Keep classOf[Prim] as Constant until the back-end.

The translation of `classOf[Prim]` (e.g., `classOf[Int]`) to
`BoxedPrimClass.TYPE` (e.g., `j.l.Integer.TYPE`) is specific to the
JVM back-end, because the JVM bytecode does not have any
instruction to load them. Other back-ends have appropriate opcodes
and prefer to receive them as `Constant(Literal(primType))`, so
that they don't have to reverse-engineer the `Select`s.

Since that transformation is not harder to do in the back-end, we
move it directly to the JVM codegen. The code is actually shorter
there.

This also helps to keep the trees a bit smaller across the phases
after erasure.

Author: sjrd

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

@@ -512,9 +512,16 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
         case ClazzTag   =>
           val tp = toTypeKind(const.typeValue)
-          // classOf[Int] is transformed to Integer.TYPE by ClassOf
-          assert(!tp.isPrimitive, s"expected class type in classOf[T], found primitive type $tp")
-          mnode.visitLdcInsn(tp.toASMType)
+          if tp.isPrimitive then
+            val boxedClass = boxedClassOfPrimitive(tp.asPrimitiveBType)
+            mnode.visitFieldInsn(
+              asm.Opcodes.GETSTATIC,
+              boxedClass.internalName,
+              "TYPE", // field name
+              jlClassRef.descriptor
+            )
+          else
+            mnode.visitLdcInsn(tp.toASMType)
 
         case EnumTag   =>
           val sym       = const.symbolValue

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

@@ -124,6 +124,7 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
   lazy val jlStringBuilderRef          : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.StringBuilder])
   lazy val jlStringBufferRef           : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.StringBuffer])
   lazy val jlCharSequenceRef           : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.CharSequence])
+  lazy val jlClassRef                  : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Class[_]])
   lazy val ThrowableReference          : ClassBType = classBTypeFromSymbol(defn.ThrowableClass)
   lazy val jlCloneableReference        : ClassBType = classBTypeFromSymbol(defn.JavaCloneableClass)        // java/lang/Cloneable
   lazy val jlNPEReference              : ClassBType = classBTypeFromSymbol(defn.NullPointerExceptionClass) // java/lang/NullPointerException
@@ -248,6 +249,7 @@ final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface
   def jlStringBuilderRef          : ClassBType = _coreBTypes.jlStringBuilderRef
   def jlStringBufferRef           : ClassBType = _coreBTypes.jlStringBufferRef
   def jlCharSequenceRef           : ClassBType = _coreBTypes.jlCharSequenceRef
+  def jlClassRef                  : ClassBType = _coreBTypes.jlClassRef
   def ThrowableReference          : ClassBType = _coreBTypes.ThrowableReference
   def jlCloneableReference        : ClassBType = _coreBTypes.jlCloneableReference
   def jlNPEReference              : ClassBType = _coreBTypes.jlNPEReference

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

@@ -1157,19 +1157,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** A tree that corresponds to `Predef.classOf[$tp]` in source */
   def clsOf(tp: Type)(using 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)))
+      if tp.isRef(defn.UnitClass) then Literal(Constant(tp))
+      else Literal(Constant(TypeErasure.erasure(tp)))
     else
       Literal(Constant(tp))