Rename reflection Class[?] to Type conversion

compiler/src/dotty/tools/dotc/quoted/reflect/ReflectionCompilerInterface.scala

@@ -1128,7 +1128,7 @@ class ReflectionCompilerInterface(val rootContext: Context) extends CompilerInte
       case _ => None
   }
 
-  def Type_apply(clazz: Class[?])(using Context): Type =
+  def Type_ofErasedClass(clazz: Class[?])(using Context): Type =
     if (clazz.isPrimitive)
       if (clazz == classOf[Boolean]) defn.BooleanType
       else if (clazz == classOf[Byte]) defn.ByteType
@@ -1140,10 +1140,10 @@ class ReflectionCompilerInterface(val rootContext: Context) extends CompilerInte
       else if (clazz == classOf[Double]) defn.DoubleType
       else defn.UnitType
     else if (clazz.isArray)
-      defn.ArrayType.appliedTo(Type_apply(clazz.getComponentType))
+      defn.ArrayType.appliedTo(Type_ofErasedClass(clazz.getComponentType))
     else if (clazz.isMemberClass) {
       val name = clazz.getSimpleName.toTypeName
-      val enclosing = Type_apply(clazz.getEnclosingClass)
+      val enclosing = Type_ofErasedClass(clazz.getEnclosingClass)
       if (enclosing.member(name).exists) enclosing.select(name)
       else
         enclosing.classSymbol.companionModule.termRef.select(name)

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -58,9 +58,11 @@ object Liftable {
 
   /** Default liftable for Class[T] */
   given ClassLiftable[T] as Liftable[Class[T]] = new Liftable[Class[T]] {
-    def toExpr(x: Class[T]) = qctx ?=> {
-      import qctx.tasty._
-      Ref(defn.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
+    def toExpr(x: Class[T]) = {
+      val qctx1 = scala.internal.tasty.CompilerInterface.quoteContextWithCompilerInterface(qctx)
+      import qctx1.tasty._
+      val tpe = qctx1.tasty.Type_ofErasedClass(x)
+      Ref(defn.Predef_classOf).appliedToType(tpe).seal.asInstanceOf[Expr[Class[T]]]
     }
   }
 

library/src/scala/internal/tasty/CompilerInterface.scala

@@ -512,7 +512,11 @@ trait CompilerInterface extends scala.tasty.reflect.Types {
 
   def Type_TypeTest(using ctx: Context): TypeTest[Type, Type]
 
-  def Type_apply(clazz: Class[_])(using ctx: Context): Type
+   /** Returns the type of the runtime class. This type is the erased representation
+    *  that of the type that is used by arrays.
+    *
+    */
+  def Type_ofErasedClass(clazz: Class[_])(using ctx: Context): Type
 
   /** Is `self` type the same as `that` type?
    *  This is the case iff `Type_isSubType(self, that)` and `Type_isSubType(that, self)`.

library/src/scala/tasty/Reflection.scala

@@ -1353,8 +1353,6 @@ trait Reflection extends reflect.Types { reflectSelf: CompilerInterface =>
     def of[T <: AnyKind](using qtype: scala.quoted.Type[T], ctx: Context): Type =
       qtype.asInstanceOf[scala.internal.quoted.Type[TypeTree]].typeTree.tpe
 
-    def apply(clazz: Class[_])(using ctx: Context): Type =
-      reflectSelf.Type_apply(clazz)
   end Type
 
   given TypeOps as AnyRef: