Handle constant-folding applied getClass

Any#getClass is a polymorphic nilary method, handle this properly in
ConstFold instead of folding just the selection, this could not be done
when the constant-folding of getClass was first introduced two commits
ago due to the weird overloading of getClass, but that has been take
care of by the previous commit.

Author: smarter

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -513,6 +513,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *
    *     { pre; v }
    *
+   *  (3) An expression `pre.getClass[..]()` that has a constant type `ConstantType(v)` but where
+   *  `pre` has side-effects is translated to:
+   *
+   *     { pre; v }
+   *
    *  This avoids the situation where we have a Select node that does not have a symbol.
    */
   def constToLiteral(tree: Tree)(implicit ctx: Context): Tree = {
@@ -524,12 +529,19 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
         tree1
       case ConstantType(value) =>
         if (isIdempotentExpr(tree1)) Literal(value).withSpan(tree.span)
-        else tree1 match {
-          case Select(qual, _) if tree1.tpe.isInstanceOf[ConstantType] =>
-            // it's a primitive unary operator; Simplify `pre.op` to `{ pre; v }` where `v` is the value of `pre.op`
-            Block(qual :: Nil, Literal(value)).withSpan(tree.span)
-          case _ =>
-            tree1
+        else {
+          def keepPrefix(pre: Tree) =
+            Block(pre :: Nil, Literal(value)).withSpan(tree.span)
+
+          tree1 match {
+            case Select(pre, _) if tree1.tpe.isInstanceOf[ConstantType] =>
+              // it's a primitive unary operator; Simplify `pre.op` to `{ pre; v }` where `v` is the value of `pre.op`
+              keepPrefix(pre)
+            case Apply(TypeApply(Select(pre, nme.getClass_), _), Nil) =>
+              keepPrefix(pre)
+            case _ =>
+              tree1
+          }
         }
       case _ => tree1
     }

compiler/src/dotty/tools/dotc/typer/ConstFold.scala

@@ -29,15 +29,15 @@ object ConstFold {
               case _ => null
           case _ => null
       case Select(xt, op) =>
-        if (op eq nme.getClass_) && xt.tpe.widen.isPrimitiveValueType then
-          Constant(xt.tpe.widen)
-        else
-          xt.tpe.widenTermRefExpr match {
-            case ConstantType(x) => foldUnop(op, x)
-            case _ => null
-          }
+        xt.tpe.widenTermRefExpr match {
+          case ConstantType(x) => foldUnop(op, x)
+          case _ => null
+        }
       case TypeApply(_, List(targ)) if tree.symbol eq defn.Predef_classOf =>
         Constant(targ.tpe)
+      case Apply(TypeApply(Select(qual, nme.getClass_), _), Nil)
+          if qual.tpe.widen.isPrimitiveValueType =>
+        Constant(qual.tpe.widen)
       case _ => null
     }
   }

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala

@@ -827,20 +827,25 @@ class TestBCode extends DottyBytecodeTest {
     val source = """
                  |class Foo {
                  |  def sideEffect(): Int = { println("hi"); 1 }
-                 |  def before: Class[Int] = sideEffect().getClass
+                 |  def before1: Class[Int] = sideEffect().getClass
+                 |  def before2: Class[Int] = sideEffect().getClass[Int]
                  |  def after: Class[Int] = { sideEffect(); classOf[Int] }
                  |}
                  """.stripMargin
 
     checkBCode(source) { dir =>
       val clsIn      = dir.lookupName("Foo.class", directory = false).input
       val clsNode    = loadClassNode(clsIn)
-      val before     = instructionsFromMethod(getMethod(clsNode, "before"))
+      val before1    = instructionsFromMethod(getMethod(clsNode, "before1"))
+      val before2    = instructionsFromMethod(getMethod(clsNode, "before2"))
       val after      = instructionsFromMethod(getMethod(clsNode, "after"))
 
-      assert(before == after,
+      assert(before1 == after,
         "`before1` was not translated to the same bytecode as `after`\n" +
-        diffInstructions(before, after))
+        diffInstructions(before1, after))
+      assert(before2 == after,
+        "`before2` was not translated to the same bytecode as `after`\n" +
+        diffInstructions(before2, after))
     }
   }
 

tests/run/t5568.check

@@ -1,7 +1,13 @@
 void
+void
+int
 int
 class scala.runtime.BoxedUnit
 class scala.runtime.BoxedUnit
+class scala.runtime.BoxedUnit
+class scala.runtime.BoxedUnit
+class java.lang.Integer
+class java.lang.Integer
 class java.lang.Integer
 class java.lang.Integer
 5

tests/run/t5568.scala

@@ -2,12 +2,18 @@ object Test {
   def main(args: Array[String]): Unit = {
     // these should give unboxed results
     println(().getClass)
+    println(().getClass[Unit])
     println(5.getClass)
-  	// these should give boxed results
+    println(5.getClass[Int])
+    // these should give boxed results
     println(().asInstanceOf[AnyRef with Unit].getClass)
+    println(().asInstanceOf[AnyRef with Unit].getClass[Any])
     println(().asInstanceOf[Unit with AnyRef].getClass)
+    println(().asInstanceOf[Unit with AnyRef].getClass[Any])
     println(5.asInstanceOf[AnyRef with Int].getClass)
+    println(5.asInstanceOf[AnyRef with Int].getClass[Any])
     println(5.asInstanceOf[Int with AnyRef].getClass)
+    println(5.asInstanceOf[Int with AnyRef].getClass[Any])
     //make sure ## wasn't broken
     println(5.##)
     println((5.asInstanceOf[AnyRef]).##)