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.

15 files changed, 119 insertions, 197 deletions

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 <code>target</code> 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 <code>deprecation</code> 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")