Pickle primitive classes using Reflection.TypeRepr.typeConstructorOf directly

This removes the need of some extra helper methods in the internal package.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -1603,7 +1603,9 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
         def showAnsiColored: String =
           SourceCode.showType(using QuoteContextImpl.this)(self)(SyntaxHighlight.ANSI)
 
-        def seal: scala.quoted.Type[_] =
+        def seal: scala.quoted.Type[_] = self.asType
+
+        def asType: scala.quoted.Type[?] =
           new scala.internal.quoted.Type(Inferred(self), QuoteContextImpl.this.hashCode)
 
         def =:=(that: TypeRepr): Boolean = self =:= that

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

@@ -199,10 +199,30 @@ class ReifyQuotes extends MacroTransform {
         ref(unpickleMeth).appliedToType(originalTp).appliedTo(pickledQuote)
       }
 
-      def taggedType(sym: Symbol) = ref(defn.InternalQuotedTypeModule).select(sym.name.toTermName)
+      /** Encode quote using Reflection.TypeRepr.typeConstructorOf
+       *
+       *  Generate the code
+       *  ```scala
+       *    qctx => qctx.reflect.TypeReprMethods.extension_asType(
+       *      qctx.reflect.TypeRepr.typeConstructorOf(classOf[<type>]])
+       *    ).asInstanceOf[scala.quoted.Type[<type>]]
+       *  ```
+       *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+       */
+      def taggedType() =
+        val typeType = defn.QuotedTypeClass.typeRef.appliedTo(body.tpe)
+        val classTree = TypeApply(ref(defn.Predef_classOf.termRef), body :: Nil)
+        val tpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, typeType)
+        val meth = newSymbol(ctx.owner, UniqueName.fresh(nme.ANON_FUN), Synthetic | Method, tpe)
+        def mkConst(tss: List[List[Tree]]) = {
+          val reflect = tss.head.head.select("reflect".toTermName)
+          val typeRepr = reflect.select("TypeRepr".toTermName).select("typeConstructorOf".toTermName).appliedTo(classTree)
+          reflect.select("TypeReprMethods".toTermName).select("extension_asType".toTermName).appliedTo(typeRepr).asInstance(typeType)
+        }
+        Closure(meth, mkConst).withSpan(body.span)
 
       if (isType) {
-        if (splices.isEmpty && body.symbol.isPrimitiveValueClass) taggedType(body.symbol)
+        if (splices.isEmpty && body.symbol.isPrimitiveValueClass) taggedType()
         else pickleAsTasty()
       }
       else getLiteral(body) match {

library/src-bootstrapped/scala/internal/quoted/Type.scala

@@ -41,34 +41,4 @@ object Type {
     qctx.asInstanceOf[QuoteContextInternal].typeMatch(scrutineeType, patternType).asInstanceOf[Option[Tup]]
   }
 
-
-  // TODO generalize following optimizations for all classes without parameters
-
-  def Unit: QuoteContext ?=> quoted.Type[Unit] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Unit]).seal.asInstanceOf[quoted.Type[Unit]]
-
-  def Boolean: QuoteContext ?=> quoted.Type[Boolean] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Boolean]).seal.asInstanceOf[quoted.Type[Boolean]]
-
-  def Byte: QuoteContext ?=> quoted.Type[Byte] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Byte]).seal.asInstanceOf[quoted.Type[Byte]]
-
-  def Char: QuoteContext ?=> quoted.Type[Char] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Char]).seal.asInstanceOf[quoted.Type[Char]]
-
-  def Short: QuoteContext ?=> quoted.Type[Short] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Short]).seal.asInstanceOf[quoted.Type[Short]]
-
-  def Int: QuoteContext ?=> quoted.Type[Int] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Int]).seal.asInstanceOf[quoted.Type[Int]]
-
-  def Long: QuoteContext ?=> quoted.Type[Long] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Long]).seal.asInstanceOf[quoted.Type[Long]]
-
-  def Float: QuoteContext ?=> quoted.Type[Float] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Float]).seal.asInstanceOf[quoted.Type[Float]]
-
-  def Double: QuoteContext ?=> quoted.Type[Double] =
-    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Double]).seal.asInstanceOf[quoted.Type[Double]]
-
 }

library/src/scala/tasty/Reflection.scala

@@ -1770,6 +1770,17 @@ trait Reflection { reflection =>
       /** Convert `TypeRepr` to an `quoted.Type[_]` */
       def seal: scala.quoted.Type[_]
 
+      /** Convert this `TypeRepr` to an `Type[?]`
+       *
+       *  Usage:
+       *  ```
+       *  typeRepr.asType match
+       *    case '[$t] =>
+       *      '{ val x: t = ... }
+       *  ```
+       */
+      def asType: scala.quoted.Type[?]
+
       /** Is `self` type the same as `that` type?
        *  This is the case iff `self <:< that` and `that <:< self`.
        */