Merge pull request #677 from alexander-myltsev/am-579-implement_class_of

Closes #579 Implement mini-phase for classOf[T]

Author: DarkDimius

src/dotty/tools/dotc/Compiler.scala

@@ -46,7 +46,8 @@ class Compiler {
            new NormalizeFlags,
            new ExtensionMethods,
            new ExpandSAMs,
-           new TailRec),
+           new TailRec,
+           new ClassOf),
       List(new PatternMatcher,
            new ExplicitOuter,
            new Splitter),

src/dotty/tools/dotc/core/Definitions.scala

@@ -271,6 +271,16 @@ class Definitions {
   lazy val BoxedFloatClass = ctx.requiredClass("java.lang.Float")
   lazy val BoxedDoubleClass = ctx.requiredClass("java.lang.Double")
 
+  lazy val BoxedBooleanModule = ctx.requiredModule("java.lang.Boolean")
+  lazy val BoxedByteModule    = ctx.requiredModule("java.lang.Byte")
+  lazy val BoxedShortModule   = ctx.requiredModule("java.lang.Short")
+  lazy val BoxedCharModule    = ctx.requiredModule("java.lang.Character")
+  lazy val BoxedIntModule     = ctx.requiredModule("java.lang.Integer")
+  lazy val BoxedLongModule    = ctx.requiredModule("java.lang.Long")
+  lazy val BoxedFloatModule   = ctx.requiredModule("java.lang.Float")
+  lazy val BoxedDoubleModule  = ctx.requiredModule("java.lang.Double")
+  lazy val BoxedVoidModule    = ctx.requiredModule("java.lang.Void")
+
   lazy val ByNameParamClass2x     = specialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, AnyType)
   lazy val EqualsPatternClass     = specialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, AnyType)
 

src/dotty/tools/dotc/transform/ClassOf.scala

@@ -0,0 +1,54 @@
+package dotty.tools.dotc
+package transform
+
+import ast.tpd
+import core.Constants.Constant
+import core.Contexts.Context
+import core.StdNames.nme
+import core.Symbols.TermSymbol
+import core.TypeErasure
+import TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
+
+/** Performs rewritings as follows for `classOf` calls:
+ * classOf[CustomValueClass] ~> CustomValueClass class
+ * classOf[ValueClass]       ~> ValueClass class, where ValueClass is Boolean, Byte, Short, etc.
+ * classOf[AnyOtherClass]    ~> erasure(AnyOtherClass)
+ */
+class ClassOf extends MiniPhaseTransform {
+  import tpd._
+
+  override def phaseName: String = "classOf"
+
+  private var classOfMethod: TermSymbol = _
+
+  override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = {
+    val predefModule = ctx.definitions.ScalaPredefModule
+    classOfMethod = ctx.requiredMethod(predefModule.moduleClass.asClass, nme.classOf)
+    this
+  }
+
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    if (tree.symbol eq classOfMethod) {
+      val tp = tree.args.head.tpe
+      val defn = ctx.definitions
+      val claz = tp.classSymbol
+      if (ValueClasses.isDerivedValueClass(claz)) {
+        Literal(Constant(ref(claz).tpe))
+      } else {
+        def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_).ensureConforms(tree.tpe)
+        claz match {
+          case defn.BooleanClass => TYPE(defn.BoxedBooleanModule)
+          case defn.ByteClass    => TYPE(defn.BoxedByteModule)
+          case defn.ShortClass   => TYPE(defn.BoxedShortModule)
+          case defn.CharClass    => TYPE(defn.BoxedCharModule)
+          case defn.IntClass     => TYPE(defn.BoxedIntModule)
+          case defn.LongClass    => TYPE(defn.BoxedLongModule)
+          case defn.FloatClass   => TYPE(defn.BoxedFloatModule)
+          case defn.DoubleClass  => TYPE(defn.BoxedDoubleModule)
+          case defn.UnitClass    => TYPE(defn.BoxedVoidModule)
+          case _                 => Literal(Constant(TypeErasure.erasure(tp)))
+        }
+      }
+    } else tree
+  }
+}

tests/pending/run/classof.check renamed to tests/run/classof.check

@@ -10,6 +10,7 @@ float
 double
 Class types
 class SomeClass
+class ValueClass
 class scala.collection.immutable.List
 class scala.Tuple2
 Arrays:

tests/pending/run/classof.scala renamed to tests/run/classof.scala

@@ -1,8 +1,12 @@
+class ValueClass(val i: Integer) extends AnyVal
 class SomeClass
 
 object Test {
   def main(args: Array[String]): Unit = {
     val cls: Predef.Class[SomeClass] = classOf[SomeClass]
+    val valCls: Predef.Class[ValueClass] = classOf[ValueClass]
+    val iCls: Class[Int] = classOf[Int]
+
     println("Value types:")
     println(classOf[Unit])
     println(classOf[Boolean])
@@ -16,6 +20,7 @@ object Test {
 
     println("Class types")
     println(classOf[SomeClass])
+    println(classOf[ValueClass])
     println(classOf[List[Array[Float]]])
     println(classOf[(String, Map[Int, String])])