Pickle '{} and '{null} directly as Literal

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

Also add `asExpr` to have a variant of `asExprOf[Any]` that does not need the extra type test at runtime.

Author: nicolasstucki

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

@@ -70,15 +70,18 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
                 case _: MethodType | _: PolyType => false
                 case _ => true
             case _ => false
+        def asExpr: scala.quoted.Expr[Any] =
+          if tree.isExpr then
+            new scala.internal.quoted.Expr(self, QuoteContextImpl.this.hashCode)
+          else self match
+            case TermTypeTest(self) => throw new Exception("Expected an expression. This is a partially applied Term. Try eta-expanding the term first.")
+            case _ => throw new Exception("Expected a Term but was: " + self)
       end extension
 
-      extension [T](tree: Tree)
+      extension [T](self: Tree)
         def asExprOf(using scala.quoted.Type[T])(using QuoteContext): scala.quoted.Expr[T] =
-          if tree.isExpr then
-            new scala.internal.quoted.Expr(tree, QuoteContextImpl.this.hashCode).asExprOf[T]
-          else tree match
-            case TermTypeTest(tree) => throw new Exception("Expected an expression. This is a partially applied Term. Try eta-expanding the term first.")
-            case _ => throw new Exception("Expected a Term but was: " + tree)
+          self.asExpr.asExprOf[T]
+      end extension
 
     end TreeMethodsImpl
 

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

@@ -143,12 +143,41 @@ class ReifyQuotes extends MacroTransform {
     }
 
     private def pickledQuote(body: Tree, splices: List[Tree], originalTp: Type, isType: Boolean)(using Context) = {
+      /** Encode quote using Reflection.Literal
+       *
+       *  Generate the code
+       *  ```scala
+       *    qctx => qctx.reflect.TreeMethods.extension_asExpr(
+       *      qctx.reflect.Literal.apply(x$1.reflect.Constant.<typeName>.apply(<literalValue>))
+       *    ).asInstanceOf[scala.quoted.Expr[<body.type>]]
+       *  ```
+       *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+       */
       def pickleAsLiteral(lit: Literal) = {
+        val exprType = defn.QuotedExprClass.typeRef.appliedTo(body.tpe)
+        val tpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, exprType)
+        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 typeName = body.tpe.typeSymbol.name
+          val literalValue =
+            if lit.const.tag == Constants.NullTag || lit.const.tag == Constants.UnitTag then Nil
+            else List(body)
+          val constant = reflect.select("Constant".toTermName).select(typeName.toTermName).select(nme.apply).appliedToArgs(literalValue)
+          val literal = reflect.select("Literal".toTermName).select(nme.apply).appliedTo(constant)
+          reflect.select("TreeMethods".toTermName).select("extension_asExpr".toTermName).appliedTo(literal).asInstance(exprType)
+        }
+        Closure(meth, mkConst).withSpan(body.span)
+      }
+
+      def pickleAsValue(lit: Literal) = {
+        // TODO should all constants be pickled as Literals?
+        // Should examime the generated bytecode size to decide and performance
         def liftedValue(lifter: Symbol) =
           ref(lifter).appliedToType(originalTp).select(nme.toExpr).appliedTo(lit)
         lit.const.tag match {
-          case Constants.NullTag => ref(defn.InternalQuotedExpr_null)
-          case Constants.UnitTag => ref(defn.InternalQuotedExpr_unit)
+          case Constants.NullTag => pickleAsLiteral(lit)
+          case Constants.UnitTag => pickleAsLiteral(lit)
           case Constants.BooleanTag => liftedValue(defn.LiftableModule_BooleanLiftable)
           case Constants.ByteTag => liftedValue(defn.LiftableModule_ByteLiftable)
           case Constants.ShortTag => liftedValue(defn.LiftableModule_ShortLiftable)
@@ -177,7 +206,7 @@ class ReifyQuotes extends MacroTransform {
         else pickleAsTasty()
       }
       else getLiteral(body) match {
-        case Some(lit) => pickleAsLiteral(lit)
+        case Some(lit) => pickleAsValue(lit)
         case _ => pickleAsTasty()
       }
     }

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

@@ -58,16 +58,4 @@ object Expr {
     qctx.asInstanceOf[QuoteContextInternal].exprMatch(scrutineeExpr, patternExpr).asInstanceOf[Option[Tup]]
   }
 
-  /** Returns a null expresssion equivalent to `'{null}` */
-  def `null`: QuoteContext ?=> quoted.Expr[Null] = (using qctx) => {
-    import qctx.reflect._
-    Literal(Constant.Null()).seal.asInstanceOf[quoted.Expr[Null]]
-  }
-
-  /** Returns a unit expresssion equivalent to `'{}` or `'{()}` */
-  def Unit: QuoteContext ?=> quoted.Expr[Unit] = (using qctx) => {
-    import qctx.reflect._
-    Literal(Constant.Unit()).seal.asInstanceOf[quoted.Expr[Unit]]
-  }
-
 }

library/src/scala/tasty/Reflection.scala

@@ -158,10 +158,15 @@ trait Reflection { reflection =>
 
       /** Does this tree represent a valid expression? */
       def isExpr: Boolean
+
+      /** Convert this tree to an `quoted.Expr[Any]` if the tree is a valid expression or throws */
+      def asExpr: scala.quoted.Expr[Any]
     end extension
 
     /** Convert this tree to an `quoted.Expr[T]` if the tree is a valid expression or throws */
     extension [T](self: Tree)
+      // FIXME: remove QuoteContext from parameters
+      // TODO: Move Reflection inside QuoteContext as it can never be instantiated outside a QuoteContext
       def asExprOf(using scala.quoted.Type[T])(using QuoteContext): scala.quoted.Expr[T]
   }