Fix scala#3947: Support lifting of java.lang.Class

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -10,6 +10,7 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types.Type
 import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
 
 import scala.quoted.Types._
@@ -33,7 +34,11 @@ object PickledQuotes {
   /** Transform the expression into its fully spliced Tree */
   def quotedExprToTree(expr: quoted.Expr[_])(implicit ctx: Context): Tree = expr match {
     case expr: TastyExpr[_] => unpickleExpr(expr)
-    case expr: LiftedExpr[_] => Literal(Constant(expr.value))
+    case expr: LiftedExpr[_] =>
+      expr.value match {
+        case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
+        case value => Literal(Constant(value))
+      }
     case expr: TreeExpr[Tree] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))
@@ -154,4 +159,25 @@ object PickledQuotes {
     }
     Block(x1 :: Nil, rec(f))
   }
+
+  private def classToType(clazz: Class[_])(implicit ctx: Context): Type = {
+    if (clazz == classOf[Boolean]) defn.BooleanType
+    else if (clazz == classOf[Byte]) defn.ByteType
+    else if (clazz == classOf[Char]) defn.CharType
+    else if (clazz == classOf[Short]) defn.ShortType
+    else if (clazz == classOf[Int]) defn.IntType
+    else if (clazz == classOf[Long]) defn.LongType
+    else if (clazz == classOf[Float]) defn.FloatType
+    else if (clazz == classOf[Double]) defn.DoubleType
+    else if (clazz == classOf[Unit]) defn.UnitType
+    else if (!clazz.isMemberClass) ctx.getClassIfDefined(clazz.getCanonicalName).typeRef
+    else {
+      val name = clazz.getSimpleName.toTypeName
+      val enclosing = classToType(clazz.getEnclosingClass)
+      if (enclosing.member(name).exists) enclosing.select(name)
+      else {
+        enclosing.classSymbol.companionModule.termRef.select(name)
+      }
+    }
+  }
 }

compiler/src/dotty/tools/dotc/quoted/Toolbox.scala

@@ -29,12 +29,16 @@ object Toolbox {
 
     def show(expr: Expr[T]): String = expr match {
       case expr: LiftedExpr[T] =>
-        implicit val ctx = new QuoteDriver().initCtx
-        if (showSettings.compilerArgs.contains("-color:never"))
-          ctx.settings.color.update("never")
-        val printer = new RefinedPrinter(ctx)
-        if (expr.value == BoxedUnit.UNIT) "()"
-        else printer.toText(Literal(Constant(expr.value))).mkString(Int.MaxValue, false)
+        expr.value match {
+          case value: Class[_] => s"classOf[${value.getCanonicalName}]"
+          case value if value == BoxedUnit.UNIT => "()"
+          case value =>
+            implicit val ctx = new QuoteDriver().initCtx
+            if (showSettings.compilerArgs.contains("-color:never"))
+              ctx.settings.color.update("never")
+            val printer = new RefinedPrinter(ctx)
+            printer.toText(Literal(Constant(value))).mkString(Int.MaxValue, false)
+        }
       case _ => new QuoteDriver().show(expr, showSettings)
     }
 

library/src/scala/quoted/Liftable.scala

@@ -25,4 +25,6 @@ object Liftable {
   implicit def DoubleIsLiftable: Liftable[Double] = (x: Double) => liftedExpr(x)
 
   implicit def StringIsLiftable: Liftable[String] = (x: String) => liftedExpr(x)
+
+  implicit def ClassIsLiftable[T]: Liftable[Class[T]] = (x: Class[T]) => liftedExpr(x)
 }

library/src/scala/runtime/quoted/Unpickler.scala

@@ -18,7 +18,7 @@ object Unpickler {
   def unpickleExpr[T](repr: Pickled, args: Seq[Any]): Expr[T] = new TastyExpr[T](repr, args)
 
   /** Lift the `value` to an `Expr` tree.
-   *  Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String or Null.
+   *  Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String, Null or Class.
    */
   def liftedExpr[T](value: T): LiftedExpr[T] = new LiftedExpr[T](value)
 

tests/run-with-compiler/i3947.check

@@ -0,0 +1,66 @@
+
+classOf[Object].getCanonicalName()
+java.lang.Object
+
+classOf[Object].getCanonicalName()
+java.lang.Object
+
+classOf[Object].getCanonicalName()
+java.lang.Object
+
+classOf[Object].getCanonicalName()
+java.lang.Object
+
+classOf[Boolean].getCanonicalName()
+boolean
+
+classOf[Byte].getCanonicalName()
+byte
+
+classOf[Char].getCanonicalName()
+char
+
+classOf[Short].getCanonicalName()
+short
+
+classOf[Int].getCanonicalName()
+int
+
+classOf[Long].getCanonicalName()
+long
+
+classOf[Float].getCanonicalName()
+float
+
+classOf[Double].getCanonicalName()
+double
+
+classOf[Unit].getCanonicalName()
+void
+
+classOf[scala.runtime.Null$].getCanonicalName()
+scala.runtime.Null$
+
+classOf[scala.runtime.Nothing$].getCanonicalName()
+scala.runtime.Nothing$
+
+classOf[String].getCanonicalName()
+java.lang.String
+
+classOf[Foo].getCanonicalName()
+Foo
+
+classOf[Foo#Bar].getCanonicalName()
+Foo.Bar
+
+classOf[Foo.Baz].getCanonicalName()
+Foo.Baz
+
+classOf[foo.Foo].getCanonicalName()
+foo.Foo
+
+classOf[foo.Foo#Bar].getCanonicalName()
+foo.Foo.Bar
+
+classOf[foo.Foo.Baz].getCanonicalName()
+foo.Foo.Baz

tests/run-with-compiler/i3947.scala

@@ -0,0 +1,64 @@
+
+import scala.quoted._
+import dotty.tools.dotc.quoted.Toolbox._
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+
+    def test[T](clazz: java.lang.Class[T]): Unit = {
+      val lclazz = clazz.toExpr
+      val name = '{ (~clazz.toExpr).getCanonicalName }
+      println()
+      println(name.show)
+      println(name.run)
+    }
+
+    // classOf[Object]
+    test(classOf[Object])
+    test(classOf[Any])
+    test(classOf[AnyRef])
+    test(classOf[AnyVal])
+
+    // primitives
+    test(classOf[Boolean])
+    test(classOf[Byte])
+    test(classOf[Char])
+    test(classOf[Short])
+    test(classOf[Int])
+    test(classOf[Long])
+    test(classOf[Float])
+    test(classOf[Double])
+    test(classOf[Unit])
+    test(classOf[Null])
+    test(classOf[Nothing])
+
+    test(classOf[String])
+
+    test(classOf[Foo])
+    test(classOf[Foo#Bar])
+    test(classOf[Foo.Baz])
+
+    test(classOf[foo.Foo])
+    test(classOf[foo.Foo#Bar])
+    test(classOf[foo.Foo.Baz])
+  }
+
+}
+
+class Foo {
+  class Bar
+}
+
+object Foo {
+  class Baz
+}
+
+package foo {
+  class Foo {
+    class Bar
+  }
+  object Foo {
+    class Baz
+  }
+}