Rewrite getClass handling

Previously, getClass was implemented as a miniphase, but that miniphase
completely neglected to preserve potential side-effects in the prefix of
the call. Instead of doing this manually in the miniphase, we extend our
constant folding logic to recognize getClass calls, this simplifies
things since constant folding already knows how to deal with side-effects.

Author: smarter

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -108,8 +108,7 @@ class Compiler {
     List(new Constructors,           // Collect initialization code in primary constructors
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
-         new Instrumentation,        // Count closure allocations under -Yinstrument-closures
-         new GetClass) ::            // Rewrites getClass calls on primitive types.
+         new Instrumentation) ::     // Count closure allocations under -Yinstrument-closures
     List(new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to
          new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments
                                      // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here

compiler/src/dotty/tools/dotc/transform/GetClass.scala

@@ -12,6 +12,7 @@ import Constants._
 import Names._
 import StdNames._
 import Contexts._
+import transform.TypeUtils._
 
 object ConstFold {
 
@@ -28,10 +29,13 @@ object ConstFold {
               case _ => null
           case _ => null
       case Select(xt, op) =>
-        xt.tpe.widenTermRefExpr match {
-          case ConstantType(x) => foldUnop(op, x)
-          case _ => null
-        }
+        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
+          }
       case TypeApply(_, List(targ)) if tree.symbol eq defn.Predef_classOf =>
         Constant(targ.tpe)
       case _ => null

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

@@ -822,6 +822,28 @@ class TestBCode extends DottyBytecodeTest {
     }
   }
 
+  @Test
+  def getClazz: Unit = {
+    val source = """
+                 |class Foo {
+                 |  def sideEffect(): Int = { println("hi"); 1 }
+                 |  def before: Class[Int] = sideEffect().getClass
+                 |  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 after      = instructionsFromMethod(getMethod(clsNode, "after"))
+
+      assert(before == after,
+        "`before1` was not translated to the same bytecode as `after`\n" +
+        diffInstructions(before, after))
+    }
+  }
+
   @Test
   def invocationReceivers(): Unit = {
     import Opcodes._