Rewrite classOf handling

So far, a miniphase took care of rewriting Predef.classOf to a class
constant, but this means that `classOf` could survive in annotations
(since they're not transformed) and needed to be handled by the backend.
To simplify things, we take advantage of the constant folding done in
the typer to directly replace `classOf` calls by a constant.

Author: smarter

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -368,14 +368,12 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
             case StringTag =>
               assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
               av.visit(name, const.stringValue) // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag
-            case ClazzTag => av.visit(name, typeToTypeKind(const.typeValue)(bcodeStore)(innerClasesStore).toASMType)
+            case ClazzTag => av.visit(name, typeToTypeKind(TypeErasure.erasure(const.typeValue))(bcodeStore)(innerClasesStore).toASMType)
             case EnumTag =>
               val edesc = innerClasesStore.typeDescriptor(const.tpe) // the class descriptor of the enumeration class.
               val evalue = const.symbolValue.javaSimpleName // value the actual enumeration value.
               av.visitEnum(name, edesc, evalue)
           }
-        case t: TypeApply if (t.fun.symbol == defn.Predef_classOf) =>
-          av.visit(name, typeToTypeKind(t.args.head.tpe.classSymbol.denot.info)(bcodeStore)(innerClasesStore).toASMType)
         case Ident(nme.WILDCARD) =>
           // An underscore argument indicates that we want to use the default value for this parameter, so do not emit anything
         case t: tpd.RefTree if t.symbol.denot.owner.isAllOf(JavaEnumTrait) =>

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

@@ -68,7 +68,6 @@ class Compiler {
          new CacheAliasImplicits,    // Cache RHS of parameterless alias implicits
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
-         new ClassOf,                // Expand `Predef.classOf` calls.
          new RefChecks) ::           // Various checks mostly related to abstract members and overriding
     List(new ElimOpaque,             // Turn opaque into normal aliases
          new TryCatchPatterns,       // Compile cases in try/catch

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

@@ -9,6 +9,7 @@ import typer.ConstFold
 import reporting.trace
 import dotty.tools.dotc.transform.SymUtils._
 import Decorators._
+import Constants.Constant
 
 import scala.annotation.tailrec
 
@@ -396,7 +397,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case New(_) | Closure(_, _, _) =>
       Pure
     case TypeApply(fn, _) =>
-      if (fn.symbol.is(Erased) || fn.symbol == defn.InternalQuoted_typeQuote) Pure else exprPurity(fn)
+      if (fn.symbol.is(Erased) || fn.symbol == defn.InternalQuoted_typeQuote || fn.symbol == defn.Predef_classOf) Pure else exprPurity(fn)
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass
@@ -517,6 +518,10 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def constToLiteral(tree: Tree)(implicit ctx: Context): Tree = {
     val tree1 = ConstFold(tree)
     tree1.tpe.widenTermRefExpr.dealias.normalized match {
+      case ConstantType(Constant(_: Type)) if tree.isInstanceOf[Block] =>
+        // We can't rewrite `{ class A; classOf[A] }` to `classOf[A]`, so we leave
+        // blocks returning a class literal alone, even if they're idempotent.
+        tree1
       case ConstantType(value) =>
         if (isIdempotentExpr(tree1)) Literal(value).withSpan(tree.span)
         else tree1 match {

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

@@ -1154,25 +1154,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  /** A tree that represents the class of the erasure of type `tp`. */
-  def clsOf(tp: Type)(implicit ctx: Context): Tree = {
-    def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_)
-    defn.scalaClassName(tp) match {
-      case tpnme.Boolean => TYPE(defn.BoxedBooleanModule)
-      case tpnme.Byte => TYPE(defn.BoxedByteModule)
-      case tpnme.Short => TYPE(defn.BoxedShortModule)
-      case tpnme.Char => TYPE(defn.BoxedCharModule)
-      case tpnme.Int => TYPE(defn.BoxedIntModule)
-      case tpnme.Long => TYPE(defn.BoxedLongModule)
-      case tpnme.Float => TYPE(defn.BoxedFloatModule)
-      case tpnme.Double => TYPE(defn.BoxedDoubleModule)
-      case tpnme.Unit => TYPE(defn.BoxedUnitModule)
-      case _ =>
-        if (ctx.erasedTypes || !tp.derivesFrom(defn.ArrayClass))
+  /** A tree that corresponds to `Predef.classOf[$tp]` in source */
+  def clsOf(tp: Type)(implicit ctx: Context): Tree =
+    if ctx.erasedTypes then
+      def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_)
+      defn.scalaClassName(tp) match
+        case tpnme.Boolean => TYPE(defn.BoxedBooleanModule)
+        case tpnme.Byte => TYPE(defn.BoxedByteModule)
+        case tpnme.Short => TYPE(defn.BoxedShortModule)
+        case tpnme.Char => TYPE(defn.BoxedCharModule)
+        case tpnme.Int => TYPE(defn.BoxedIntModule)
+        case tpnme.Long => TYPE(defn.BoxedLongModule)
+        case tpnme.Float => TYPE(defn.BoxedFloatModule)
+        case tpnme.Double => TYPE(defn.BoxedDoubleModule)
+        case tpnme.Unit => TYPE(defn.BoxedUnitModule)
+        case _ =>
           Literal(Constant(TypeErasure.erasure(tp)))
-        else Literal(Constant(tp))
-    }
-  }
+    else
+      Literal(Constant(tp))
 
   @tailrec
   def sameTypes(trees: List[tpd.Tree], trees1: List[tpd.Tree]): Boolean =

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

@@ -601,7 +601,7 @@ object Erasure {
       if (tree.typeOpt.isRef(defn.UnitClass))
         tree.withType(tree.typeOpt)
       else if (tree.const.tag == Constants.ClazzTag)
-        Literal(Constant(erasure(tree.const.typeValue)))
+        clsOf(tree.const.typeValue)
       else
         super.typedLiteral(tree)
 

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

@@ -6,6 +6,7 @@ import java.lang.ArithmeticException
 import ast._
 import Trees._
 import core._
+import Symbols._
 import Types._
 import Constants._
 import Names._
@@ -31,6 +32,8 @@ object ConstFold {
           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

@@ -315,7 +315,7 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(using Context): TypeApply = {
     def fail = tree.withType(errorType(err.takesNoParamsStr(fn, "type "), tree.sourcePos))
-    fn.tpe.widen match {
+    ConstFold(fn.tpe.widen match {
       case pt: TypeLambda =>
         tree.withType {
           val paramNames = pt.paramNames
@@ -381,7 +381,7 @@ trait TypeAssigner {
       case _ =>
         //println(i"bad type: $fn: ${fn.symbol} / ${fn.symbol.isType} / ${fn.symbol.info}") // DEBUG
         fail
-    }
+    })
   }
 
   def assignType(tree: untpd.Typed, tpt: Tree)(using Context): Typed =

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

@@ -26,7 +26,7 @@ object Test/*<-advanced::Test.*/ {
   val s2/*<-advanced::Test.s2.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/
   val s2x/*<-advanced::Test.s2x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*//*->scala::Selectable#selectDynamic().*/.x
   val s3/*<-advanced::Test.s3.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/
-  val s3x/*<-advanced::Test.s3x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*//*->scala::Selectable#applyDynamic().*/.m/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/(???/*->scala::Predef.`???`().*/)
+  val s3x/*<-advanced::Test.s3x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*//*->scala::Selectable#applyDynamic().*/.m/*->scala::reflect::ClassTag.apply().*/(???/*->scala::Predef.`???`().*/)
 
   val e/*<-advanced::Test.e.*/ = new Wildcards/*->advanced::Wildcards#*/
   val e1/*<-advanced::Test.e1.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/

tests/semanticdb/expect/Advanced.expect.scala

@@ -7,5 +7,5 @@ object Example/*<-example::Example.*/ { self/*<-local0*/ =>
   def main/*<-example::Example.main().*/(args/*<-example::Example.main().(args)*/: Array/*->scala::Array#*/[String/*->scala::Predef.String#*/]): Unit/*->scala::Unit#*/ = {
     println/*->scala::Predef.println(+1).*/(1)
   }
-  val x/*<-example::Example.x.*/ = scala.reflect.classTag/*->scala::reflect::package.classTag().*/[Int/*->scala::Int#*/]/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/
+  val x/*<-example::Example.x.*/ = scala.reflect.classTag/*->scala::reflect::package.classTag().*/[Int/*->scala::Int#*/]/*->scala::reflect::ClassTag.apply().*/
 }