From 036f2602017bf04dc3a40783a531d488bbd9e12a Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Fri, 29 May 2009 13:55:01 +0000 Subject: Riffing off the removal of the cldc library, re... Riffing off the removal of the cldc library, removed forCLDC and its special cases. Not as much fun as removing inIDE, but still fun. --- src/compiler/scala/tools/ant/Scalac.scala | 2 +- src/compiler/scala/tools/nsc/Global.scala | 1 - .../scala/tools/nsc/backend/ScalaPrimitives.scala | 127 ++++++++++----------- .../scala/tools/nsc/backend/icode/GenICode.scala | 9 +- .../scala/tools/nsc/backend/icode/TypeKinds.scala | 6 +- .../scala/tools/nsc/backend/jvm/GenJVM.scala | 38 +++--- src/compiler/scala/tools/nsc/doc/ModelFrames.scala | 6 +- .../scala/tools/nsc/symtab/Definitions.scala | 64 +++++------ src/compiler/scala/tools/nsc/symtab/StdNames.scala | 15 +-- .../scala/tools/nsc/symtab/SymbolTable.scala | 3 - src/compiler/scala/tools/nsc/symtab/Symbols.scala | 19 --- .../scala/tools/nsc/transform/CleanUp.scala | 20 +--- .../scala/tools/nsc/typechecker/RefChecks.scala | 2 +- .../tools/nsc/typechecker/SyntheticMethods.scala | 2 +- .../scala/tools/nsc/typechecker/Typers.scala | 2 +- src/manual/scala/man1/scalac.scala | 2 +- src/scala-lang.iml | 1 - 17 files changed, 120 insertions(+), 199 deletions(-) (limited to 'src') diff --git a/src/compiler/scala/tools/ant/Scalac.scala b/src/compiler/scala/tools/ant/Scalac.scala index 9fb6d09f56..f5ccf236a1 100644 --- a/src/compiler/scala/tools/ant/Scalac.scala +++ b/src/compiler/scala/tools/ant/Scalac.scala @@ -99,7 +99,7 @@ class Scalac extends MatchingTask { /** Defines valid values for the target property. */ object Target extends PermissibleValue { - val values = List("jvm-1.5", "msil", "cldc") + val values = List("jvm-1.5", "msil") } /** Defines valid values for the deprecation and diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 269c1f4e2d..77e8ec4869 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -946,7 +946,6 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable }) } - def forCLDC: Boolean = settings.target.value == "cldc" def forJVM : Boolean = settings.target.value startsWith "jvm" def forMSIL: Boolean = settings.target.value == "msil" def onlyPresentation = false diff --git a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala index dde81541a2..f89b576d8b 100644 --- a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala +++ b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala @@ -276,10 +276,8 @@ abstract class ScalaPrimitives { addPrimitives(ByteClass, nme.UNARY_-, NEG) addPrimitives(ByteClass, nme.UNARY_~, NOT) - if (!forCLDC) { - addPrimitives(ByteClass, nme.toFloat, B2F) - addPrimitives(ByteClass, nme.toDouble, B2D) - } + addPrimitives(ByteClass, nme.toFloat, B2F) + addPrimitives(ByteClass, nme.toDouble, B2D) // scala.Short addPrimitives(ShortClass, nme.EQ, EQ) @@ -310,10 +308,8 @@ abstract class ScalaPrimitives { addPrimitives(ShortClass, nme.UNARY_-, NEG) addPrimitives(ShortClass, nme.UNARY_~, NOT) - if (!forCLDC) { - addPrimitives(ShortClass, nme.toFloat, S2F) - addPrimitives(ShortClass, nme.toDouble, S2D) - } + addPrimitives(ShortClass, nme.toFloat, S2F) + addPrimitives(ShortClass, nme.toDouble, S2D) // scala.Char addPrimitives(CharClass, nme.EQ, EQ) @@ -343,10 +339,8 @@ abstract class ScalaPrimitives { addPrimitives(CharClass, nme.UNARY_+, POS) addPrimitives(CharClass, nme.UNARY_-, NEG) addPrimitives(CharClass, nme.UNARY_~, NOT) - if (!forCLDC) { - addPrimitives(CharClass, nme.toFloat, C2F) - addPrimitives(CharClass, nme.toDouble, C2D) - } + addPrimitives(CharClass, nme.toFloat, C2F) + addPrimitives(CharClass, nme.toDouble, C2D) // scala.Int addPrimitives(IntClass, nme.EQ, EQ) @@ -376,10 +370,8 @@ abstract class ScalaPrimitives { addPrimitives(IntClass, nme.UNARY_+, POS) addPrimitives(IntClass, nme.UNARY_-, NEG) addPrimitives(IntClass, nme.UNARY_~, NOT) - if (!forCLDC) { - addPrimitives(IntClass, nme.toFloat, I2F) - addPrimitives(IntClass, nme.toDouble, I2D) - } + addPrimitives(IntClass, nme.toFloat, I2F) + addPrimitives(IntClass, nme.toDouble, I2D) // scala.Long addPrimitives(LongClass, nme.EQ, EQ) @@ -409,60 +401,57 @@ abstract class ScalaPrimitives { addPrimitives(LongClass, nme.UNARY_+, POS) addPrimitives(LongClass, nme.UNARY_-, NEG) addPrimitives(LongClass, nme.UNARY_~, NOT) - if (!forCLDC) { - addPrimitives(LongClass, nme.toFloat, L2F) - addPrimitives(LongClass, nme.toDouble, L2D) - } + addPrimitives(LongClass, nme.toFloat, L2F) + addPrimitives(LongClass, nme.toDouble, L2D) + + // scala.Float + addPrimitives(FloatClass, nme.EQ, EQ) + addPrimitives(FloatClass, nme.NE, NE) + addPrimitives(FloatClass, nme.ADD, ADD) + addPrimitives(FloatClass, nme.SUB, SUB) + addPrimitives(FloatClass, nme.MUL, MUL) + addPrimitives(FloatClass, nme.DIV, DIV) + addPrimitives(FloatClass, nme.MOD, MOD) + addPrimitives(FloatClass, nme.LT, LT) + addPrimitives(FloatClass, nme.LE, LE) + addPrimitives(FloatClass, nme.GT, GT) + addPrimitives(FloatClass, nme.GE, GE) + // conversions + addPrimitives(FloatClass, nme.toByte, F2B) + addPrimitives(FloatClass, nme.toShort, F2S) + addPrimitives(FloatClass, nme.toChar, F2C) + addPrimitives(FloatClass, nme.toInt, F2I) + addPrimitives(FloatClass, nme.toLong, F2L) + addPrimitives(FloatClass, nme.toFloat, F2F) + addPrimitives(FloatClass, nme.toDouble, F2D) + // unary methods + addPrimitives(FloatClass, nme.UNARY_+, POS) + addPrimitives(FloatClass, nme.UNARY_-, NEG) + + // scala.Double + addPrimitives(DoubleClass, nme.EQ, EQ) + addPrimitives(DoubleClass, nme.NE, NE) + addPrimitives(DoubleClass, nme.ADD, ADD) + addPrimitives(DoubleClass, nme.SUB, SUB) + addPrimitives(DoubleClass, nme.MUL, MUL) + addPrimitives(DoubleClass, nme.DIV, DIV) + addPrimitives(DoubleClass, nme.MOD, MOD) + addPrimitives(DoubleClass, nme.LT, LT) + addPrimitives(DoubleClass, nme.LE, LE) + addPrimitives(DoubleClass, nme.GT, GT) + addPrimitives(DoubleClass, nme.GE, GE) + // conversions + addPrimitives(DoubleClass, nme.toByte, D2B) + addPrimitives(DoubleClass, nme.toShort, D2S) + addPrimitives(DoubleClass, nme.toChar, D2C) + addPrimitives(DoubleClass, nme.toInt, D2I) + addPrimitives(DoubleClass, nme.toLong, D2L) + addPrimitives(DoubleClass, nme.toFloat, D2F) + addPrimitives(DoubleClass, nme.toDouble, D2D) + // unary methods + addPrimitives(DoubleClass, nme.UNARY_+, POS) + addPrimitives(DoubleClass, nme.UNARY_-, NEG) - if (!forCLDC) { - // scala.Float - addPrimitives(FloatClass, nme.EQ, EQ) - addPrimitives(FloatClass, nme.NE, NE) - addPrimitives(FloatClass, nme.ADD, ADD) - addPrimitives(FloatClass, nme.SUB, SUB) - addPrimitives(FloatClass, nme.MUL, MUL) - addPrimitives(FloatClass, nme.DIV, DIV) - addPrimitives(FloatClass, nme.MOD, MOD) - addPrimitives(FloatClass, nme.LT, LT) - addPrimitives(FloatClass, nme.LE, LE) - addPrimitives(FloatClass, nme.GT, GT) - addPrimitives(FloatClass, nme.GE, GE) - // conversions - addPrimitives(FloatClass, nme.toByte, F2B) - addPrimitives(FloatClass, nme.toShort, F2S) - addPrimitives(FloatClass, nme.toChar, F2C) - addPrimitives(FloatClass, nme.toInt, F2I) - addPrimitives(FloatClass, nme.toLong, F2L) - addPrimitives(FloatClass, nme.toFloat, F2F) - addPrimitives(FloatClass, nme.toDouble, F2D) - // unary methods - addPrimitives(FloatClass, nme.UNARY_+, POS) - addPrimitives(FloatClass, nme.UNARY_-, NEG) - - // scala.Double - addPrimitives(DoubleClass, nme.EQ, EQ) - addPrimitives(DoubleClass, nme.NE, NE) - addPrimitives(DoubleClass, nme.ADD, ADD) - addPrimitives(DoubleClass, nme.SUB, SUB) - addPrimitives(DoubleClass, nme.MUL, MUL) - addPrimitives(DoubleClass, nme.DIV, DIV) - addPrimitives(DoubleClass, nme.MOD, MOD) - addPrimitives(DoubleClass, nme.LT, LT) - addPrimitives(DoubleClass, nme.LE, LE) - addPrimitives(DoubleClass, nme.GT, GT) - addPrimitives(DoubleClass, nme.GE, GE) - // conversions - addPrimitives(DoubleClass, nme.toByte, D2B) - addPrimitives(DoubleClass, nme.toShort, D2S) - addPrimitives(DoubleClass, nme.toChar, D2C) - addPrimitives(DoubleClass, nme.toInt, D2I) - addPrimitives(DoubleClass, nme.toLong, D2L) - addPrimitives(DoubleClass, nme.toFloat, D2F) - addPrimitives(DoubleClass, nme.toDouble, D2D) - // unary methods - addPrimitives(DoubleClass, nme.UNARY_+, POS) - addPrimitives(DoubleClass, nme.UNARY_-, NEG) - } // and the type map! initPrimitiveTypeMap } diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 2a0acc053b..b7bdf1de9d 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -1439,14 +1439,7 @@ abstract class GenICode extends SubComponent { * not using the rich equality is possible (their own equals method will do ok.)*/ def mustUseAnyComparator: Boolean = { def isBoxed(sym: Symbol): Boolean = - if (forCLDC) { - (sym isNonBottomSubClass definitions.ByteClass) || - (sym isNonBottomSubClass definitions.ShortClass) || - (sym isNonBottomSubClass definitions.CharClass) || - (sym isNonBottomSubClass definitions.IntClass) || - (sym isNonBottomSubClass definitions.LongClass) - } - else ((sym isNonBottomSubClass definitions.BoxedNumberClass) || + ((sym isNonBottomSubClass definitions.BoxedNumberClass) || (!forMSIL && (sym isNonBottomSubClass definitions.BoxedCharacterClass))) val lsym = l.tpe.typeSymbol diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala index ed57ff06e0..a9fc518272 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala @@ -481,10 +481,8 @@ trait TypeKinds { self: ICodes => primitiveTypeMap += (definitions.CharClass -> CHAR) primitiveTypeMap += (definitions.IntClass -> INT) primitiveTypeMap += (definitions.LongClass -> LONG) - if (!forCLDC) { - primitiveTypeMap += (definitions.FloatClass -> FLOAT) - primitiveTypeMap += (definitions.DoubleClass -> DOUBLE) - } + primitiveTypeMap += (definitions.FloatClass -> FLOAT) + primitiveTypeMap += (definitions.DoubleClass -> DOUBLE) // primitiveTypeMap += (definitions.StringClass -> STRING) } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index ec58e71a50..bcadd07137 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -157,19 +157,18 @@ abstract class GenJVM extends SubComponent { if (parents.isEmpty) parents = definitions.ObjectClass.tpe :: parents; - if (!forCLDC) - for (attr <- c.symbol.attributes) attr match { - case AnnotationInfo(tp, _, _) if tp.typeSymbol == SerializableAttr => - parents = parents ::: List(definitions.SerializableClass.tpe) - case AnnotationInfo(tp, _, _) if tp.typeSymbol == CloneableAttr => - parents = parents ::: List(CloneableClass.tpe) - case AnnotationInfo(tp, value :: _, _) if tp.typeSymbol == SerialVersionUID => - serialVUID = Some(value.constant.get.longValue) - case AnnotationInfo(tp, _, _) if tp.typeSymbol == RemoteAttr => - parents = parents ::: List(RemoteInterface.tpe) - remoteClass = true - case _ => () - } + for (attr <- c.symbol.attributes) attr match { + case AnnotationInfo(tp, _, _) if tp.typeSymbol == SerializableAttr => + parents = parents ::: List(definitions.SerializableClass.tpe) + case AnnotationInfo(tp, _, _) if tp.typeSymbol == CloneableAttr => + parents = parents ::: List(CloneableClass.tpe) + case AnnotationInfo(tp, value :: _, _) if tp.typeSymbol == SerialVersionUID => + serialVUID = Some(value.constant.get.longValue) + case AnnotationInfo(tp, _, _) if tp.typeSymbol == RemoteAttr => + parents = parents ::: List(RemoteInterface.tpe) + remoteClass = true + case _ => () + } parents = parents.removeDuplicates @@ -614,15 +613,12 @@ abstract class GenJVM extends SubComponent { case _ => false } - if (remoteClass || - (meth.hasAttribute(RemoteAttr) - && jmethod.isPublic() - && !forCLDC)) { - val ainfo = AnnotationInfo(ThrowsAttr.tpe, List(new AnnotationArgument(Constant(RemoteException))), List()) - if (!meth.attributes.exists(isRemoteThrows)) { - meth.attributes = ainfo :: meth.attributes; - } + if (remoteClass || (meth.hasAttribute(RemoteAttr) && jmethod.isPublic())) { + val ainfo = AnnotationInfo(ThrowsAttr.tpe, List(new AnnotationArgument(Constant(RemoteException))), List()) + if (!meth.attributes.exists(isRemoteThrows)) { + meth.attributes = ainfo :: meth.attributes; } + } } diff --git a/src/compiler/scala/tools/nsc/doc/ModelFrames.scala b/src/compiler/scala/tools/nsc/doc/ModelFrames.scala index 8475502737..bd6c816ea8 100644 --- a/src/compiler/scala/tools/nsc/doc/ModelFrames.scala +++ b/src/compiler/scala/tools/nsc/doc/ModelFrames.scala @@ -28,10 +28,8 @@ trait ModelFrames extends ModelExtractor { SyntheticClasses ++= List( NothingClass, NullClass, AnyClass, AnyRefClass, AnyValClass, //value classes - BooleanClass, ByteClass, CharClass, IntClass, LongClass, ShortClass, UnitClass) - - if (!global.forCLDC) - SyntheticClasses ++= List(FloatClass, DoubleClass) + BooleanClass, ByteClass, CharClass, IntClass, LongClass, ShortClass, + FloatClass, DoubleClass, UnitClass) } val outdir = settings.outdir.value diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index 03783d054c..fdad54ffcb 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -533,10 +533,10 @@ trait Definitions { val longtype = LongClass.typeConstructor val longparam = List(longtype) - val floattype = if (forCLDC) null else FloatClass.typeConstructor - val floatparam = if (forCLDC) null else List(floattype) - val doubletype = if (forCLDC) null else DoubleClass.typeConstructor - val doubleparam = if (forCLDC) null else List(doubletype) + val floattype = FloatClass.typeConstructor + val floatparam = List(floattype) + val doubletype = DoubleClass.typeConstructor + val doubleparam = List(doubletype) val stringtype = StringClass.typeConstructor @@ -579,10 +579,8 @@ trait Definitions { newParameterlessMethod(clazz, nme.toInt, inttype) newParameterlessMethod(clazz, nme.toLong, longtype) - if (!forCLDC) { - newParameterlessMethod(clazz, nme.toFloat, floattype) - newParameterlessMethod(clazz, nme.toDouble, doubletype) - } + newParameterlessMethod(clazz, nme.toFloat, floattype) + newParameterlessMethod(clazz, nme.toDouble, doubletype) // def +(s: String): String newMethod(clazz, nme.ADD, List(stringtype), stringtype) @@ -619,11 +617,10 @@ trait Definitions { addBinops(charparam, restype, isCardinal) addBinops(intparam, restype, isCardinal) addBinops(longparam, restype2, isCardinal) - if (!forCLDC) { - val restype3 = if (clazz eq DoubleClass) doubletype else floattype - addBinops(floatparam, restype3, false) - addBinops(doubleparam, doubletype, false) - } + + val restype3 = if (clazz eq DoubleClass) doubletype else floattype + addBinops(floatparam, restype3, false) + addBinops(doubleparam, doubletype, false) } initValueClass(ByteClass, true) @@ -631,10 +628,9 @@ trait Definitions { initValueClass(CharClass, true) initValueClass(IntClass, true) initValueClass(LongClass, true) - if (!forCLDC) { - initValueClass(FloatClass, false) - initValueClass(DoubleClass, false) - } + initValueClass(FloatClass, false) + initValueClass(DoubleClass, false) + def addModuleMethod(clazz: Symbol, name: Name, value: Any) { val owner = clazz.linkedClassOfClass newParameterlessMethod(owner, name, mkConstantType(Constant(value))) @@ -650,21 +646,19 @@ trait Definitions { addModuleMethod(LongClass, "MinValue", java.lang.Long.MIN_VALUE) addModuleMethod(LongClass, "MaxValue", java.lang.Long.MAX_VALUE) - if (!forCLDC) { - addModuleMethod(FloatClass, "MinValue", -java.lang.Float.MAX_VALUE) - addModuleMethod(FloatClass, "MaxValue", java.lang.Float.MAX_VALUE) - addModuleMethod(FloatClass, "Epsilon", java.lang.Float.MIN_VALUE) - addModuleMethod(FloatClass, "NaN", java.lang.Float.NaN) - addModuleMethod(FloatClass, "PositiveInfinity", java.lang.Float.POSITIVE_INFINITY) - addModuleMethod(FloatClass, "NegativeInfinity", java.lang.Float.NEGATIVE_INFINITY) - - addModuleMethod(DoubleClass, "MinValue", -java.lang.Double.MAX_VALUE) - addModuleMethod(DoubleClass, "MaxValue", java.lang.Double.MAX_VALUE) - addModuleMethod(DoubleClass, "Epsilon", java.lang.Double.MIN_VALUE) - addModuleMethod(DoubleClass, "NaN", java.lang.Double.NaN) - addModuleMethod(DoubleClass, "PositiveInfinity", java.lang.Double.POSITIVE_INFINITY) - addModuleMethod(DoubleClass, "NegativeInfinity", java.lang.Double.NEGATIVE_INFINITY) - } + addModuleMethod(FloatClass, "MinValue", -java.lang.Float.MAX_VALUE) + addModuleMethod(FloatClass, "MaxValue", java.lang.Float.MAX_VALUE) + addModuleMethod(FloatClass, "Epsilon", java.lang.Float.MIN_VALUE) + addModuleMethod(FloatClass, "NaN", java.lang.Float.NaN) + addModuleMethod(FloatClass, "PositiveInfinity", java.lang.Float.POSITIVE_INFINITY) + addModuleMethod(FloatClass, "NegativeInfinity", java.lang.Float.NEGATIVE_INFINITY) + + addModuleMethod(DoubleClass, "MinValue", -java.lang.Double.MAX_VALUE) + addModuleMethod(DoubleClass, "MaxValue", java.lang.Double.MAX_VALUE) + addModuleMethod(DoubleClass, "Epsilon", java.lang.Double.MIN_VALUE) + addModuleMethod(DoubleClass, "NaN", java.lang.Double.NaN) + addModuleMethod(DoubleClass, "PositiveInfinity", java.lang.Double.POSITIVE_INFINITY) + addModuleMethod(DoubleClass, "NegativeInfinity", java.lang.Double.NEGATIVE_INFINITY) } /** Is symbol a value class? */ @@ -740,10 +734,8 @@ trait Definitions { CharClass = newValueClass(nme.Char, 'C') IntClass = newValueClass(nme.Int, 'I') LongClass = newValueClass(nme.Long, 'L') - if (!forCLDC) { - FloatClass = newValueClass(nme.Float, 'F') - DoubleClass = newValueClass(nme.Double, 'D') - } + FloatClass = newValueClass(nme.Float, 'F') + DoubleClass = newValueClass(nme.Double, 'D') CodeClass = getClass(sn.Code) CodeModule = getModule(sn.Code) diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index f19a8e5138..a0b559885a 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -485,18 +485,7 @@ trait StdNames { final val Code = newTermName("scala.reflect.Code") } - private class CLDCNames extends JavaNames { - final val Serializable = nme.NOSYMBOL - final val BeanProperty = nme.NOSYMBOL - final val Code = nme.NOSYMBOL - final val Method = nme.NOSYMBOL - } - - private var sn0 : SymbolNames = _ - def sn: SymbolNames = { - if (sn0 == null) sn0 = if (forMSIL) new MSILNames - else if (forCLDC) new CLDCNames + lazy val sn: SymbolNames = + if (forMSIL) new MSILNames else new J2SENames - sn0 - } } diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala b/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala index 9fd93ab6ff..50cccd0f05 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolTable.scala @@ -26,9 +26,6 @@ abstract class SymbolTable extends Names def rootLoader: LazyType def log(msg: AnyRef) - /** Are we compiling for the J2ME CLDC platform ? */ - def forCLDC: Boolean - /** Are we compiling for Java SE ? */ def forJVM: Boolean diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index 23a5d858e9..f9bd2ea831 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -1446,12 +1446,6 @@ trait Symbols { extends Symbol(initOwner, initPos, initName) { override def isTerm = true -/* - val marker = initName.toString match { - case "forCLDC" => new MarkForCLDC - case _ => null - } -*/ privateWithin = NoSymbol protected var referenced: Symbol = NoSymbol @@ -1798,17 +1792,4 @@ trait Symbols { override def toString() = "TypeHistory(" + phaseOf(validFrom)+":"+runId(validFrom) + "," + info + "," + prev + ")" } -/* - var occs = 0 - -class MarkForCLDC { - val atRun: Int = currentRunId - occs += 1 - println("new "+getClass+" at "+atRun+" ("+occs+" total)") - override def finalize() { - occs -=1 - println("drop "+getClass+" from "+atRun+" ("+occs+" total)") - } -} -*/ } diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index 5339bef080..d99518c6cf 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -39,11 +39,9 @@ abstract class CleanUp extends Transform { javaBoxClassModule(IntClass) = getModule("java.lang.Integer") javaBoxClassModule(CharClass) = getModule("java.lang.Character") javaBoxClassModule(LongClass) = getModule("java.lang.Long") - if (!forCLDC) { - javaBoxClassModule(FloatClass) = getModule("java.lang.Float") - javaBoxClassModule(DoubleClass) = getModule("java.lang.Double") - javaBoxClassModule(UnitClass) = getModule("java.lang.Void") - } + javaBoxClassModule(FloatClass) = getModule("java.lang.Float") + javaBoxClassModule(DoubleClass) = getModule("java.lang.Double") + javaBoxClassModule(UnitClass) = getModule("java.lang.Void") } private var localTyper: analyzer.Typer = null @@ -351,14 +349,7 @@ abstract class CleanUp extends Transform { def mayRequirePrimitiveReplacement: Boolean = { def isBoxed(sym: Symbol): Boolean = - if (forCLDC) { - (sym isNonBottomSubClass ByteClass) || - (sym isNonBottomSubClass ShortClass) || - (sym isNonBottomSubClass CharClass) || - (sym isNonBottomSubClass IntClass) || - (sym isNonBottomSubClass LongClass) - } - else ((sym isNonBottomSubClass BoxedNumberClass) || + ((sym isNonBottomSubClass BoxedNumberClass) || (!forMSIL && (sym isNonBottomSubClass BoxedCharacterClass))) val sym = qual.tpe.typeSymbol @@ -719,8 +710,7 @@ abstract class CleanUp extends Transform { val tpe = c.typeValue atPos(tree.pos) { localTyper.typed { - if ((isValueClass(tpe.typeSymbol) || tpe.typeSymbol == definitions.UnitClass) - && !forCLDC) + if (isValueClass(tpe.typeSymbol) || tpe.typeSymbol == definitions.UnitClass) Select(gen.mkAttributedRef(javaBoxClassModule(tpe.typeSymbol)), "TYPE") else tree } diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index d4e9136b1a..686824a7f5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -612,7 +612,7 @@ abstract class RefChecks extends InfoTransform { nonSensible("", false) else if (isNumericValueClass(receiver) && !isNumericValueClass(actual) && - !(forMSIL || forCLDC|| (actual isSubClass BoxedNumberClass)) && + !(forMSIL || (actual isSubClass BoxedNumberClass)) && !(receiver isSubClass actual)) nonSensible("", false) else if ((receiver hasFlag FINAL) && hasObjectEquals && !isValueClass(receiver) && diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 22ad123aae..00468abc8e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -323,7 +323,7 @@ trait SyntheticMethods { self: Analyzer => // only for those that carry a @serializable annotation? if (!hasImplementation(nme.readResolve)) ts += readResolveMethod } - if (!forCLDC && !forMSIL) + if (!forMSIL) for (sym <- clazz.info.decls.toList) if (!sym.getAttributes(BeanPropertyAttr).isEmpty) if (sym.isGetter) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index d43d09f79f..915786597c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1572,7 +1572,7 @@ trait Typers { self: Analyzer => * @return ... */ def typedFunction(fun: Function, mode: Int, pt: Type): Tree = { - val codeExpected = !forCLDC && !forMSIL && (pt.typeSymbol isNonBottomSubClass CodeClass) + val codeExpected = !forMSIL && (pt.typeSymbol isNonBottomSubClass CodeClass) if (fun.vparams.length > definitions.MaxFunctionArity) return errorTree(fun, "implementation restricts functions to " + definitions.MaxFunctionArity + " parameters") diff --git a/src/manual/scala/man1/scalac.scala b/src/manual/scala/man1/scalac.scala index 421df1b745..330ea4fd82 100644 --- a/src/manual/scala/man1/scalac.scala +++ b/src/manual/scala/man1/scalac.scala @@ -126,7 +126,7 @@ object scalac extends Command { CmdOption("target:", Argument("target")), SeqPara( "Specify which backend to use (" & Mono("jvm-1.5," & - "msil,cldc") & ").", + "msil") & ").", "The default value is " & Mono("\"jvm-1.5\"") & " (was " & Mono("\"jvm-1.4\"") & " up to Scala version 2.6.1).")), Definition( diff --git a/src/scala-lang.iml b/src/scala-lang.iml index dec0e11a53..d860a9ce0f 100644 --- a/src/scala-lang.iml +++ b/src/scala-lang.iml @@ -20,7 +20,6 @@ - -- cgit v1.2.3