WIP Remove scala.internal.quoted.LiftedExpr

Replace by reflection using the QuoteContext

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -797,7 +797,6 @@ class Definitions {
   def QuotedMatchingBindingClass(implicit ctx: Context): ClassSymbol = QuotedMatchingBindingType.symbol.asClass
 
   def Unpickler_unpickleExpr: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
-  def Unpickler_liftedExpr: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
   def Unpickler_unpickleType: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
 
   @threadUnsafe lazy val TastyReflectionType: TypeRef = ctx.requiredClassRef("scala.tasty.Reflection")

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -43,11 +43,6 @@ object PickledQuotes {
         }
       }
       forceAndCleanArtefacts.transform(unpickled)
-    case expr: LiftedExpr[T] =>
-      expr.value match {
-        case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
-        case value => Literal(Constant(value))
-      }
     case expr: TastyTreeExpr[Tree] @unchecked => healOwner(expr.tree)
     case expr: FunctionAppliedTo[_] =>
       functionAppliedTo(quotedExprToTree(expr.f), expr.args.map(arg => quotedExprToTree(arg)).toList)

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

@@ -49,7 +49,6 @@ class QuoteCompiler extends Compiler {
   class QuotedFrontend extends Phase {
     import tpd._
 
-
     def phaseName: String = "quotedFrontend"
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
@@ -83,8 +82,8 @@ class QuoteCompiler extends Compiler {
     }
 
     private def checkValidRunExpr(expr: Expr[_]): Expr[_] = expr match {
-      case expr: scala.internal.quoted.TastyTreeExpr[Tree] @unchecked =>
-        throw new Exception("Cannot call `Expr.run` on an `Expr` that comes from a macro argument.")
+//      case expr: scala.internal.quoted.TastyTreeExpr[Tree] @unchecked =>
+//        throw new Exception("Cannot call `Expr.run` on an `Expr` that comes from a macro argument.")
       case _ => expr
     }
 

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -1445,6 +1445,8 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def matchConstant_ClassTag(x: Constant): Option[Type] =
     if (x.tag == Constants.ClazzTag) Some(x.typeValue) else None
 
+  def Constant_apply(x: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Class[_]): Constant =
+    Constants.Constant(x)
   def Constant_Unit_apply(): Constant = Constants.Constant(())
   def Constant_Null_apply(): Constant = Constants.Constant(null)
   def Constant_Boolean_apply(x: Boolean): Constant = Constants.Constant(x)

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

@@ -199,8 +199,9 @@ class ReifyQuotes extends MacroTransform {
     }
 
     private def pickledQuote(body: Tree, splices: List[Tree], originalTp: Type, isType: Boolean)(implicit ctx: Context) = {
-      def pickleAsValue[T](value: T) =
-        ref(defn.Unpickler_liftedExpr).appliedToType(originalTp.widen).appliedTo(Literal(Constant(value)))
+      // FIXME use Liftable.XYZ
+//      def pickleAsValue[T](value: T) =
+//        ref(defn.Unpickler_liftedExpr).appliedToType(originalTp.widen).appliedTo(Literal(Constant(value)))
       def pickleAsTasty() = {
         val meth =
           if (isType) ref(defn.Unpickler_unpickleType).appliedToType(originalTp)
@@ -216,7 +217,7 @@ class ReifyQuotes extends MacroTransform {
         else pickleAsTasty()
       }
       else toValue(body) match {
-        case Some(value) => pickleAsValue(value)
+//        case Some(value) => pickleAsValue(value)
         case _ => pickleAsTasty()
       }
     }

library/src-3.x/scala/quoted/Expr.scala

@@ -67,13 +67,6 @@ package internal {
       override def toString: String = s"Expr(<pickled tasty>)"
     }
 
-    /** An Expr backed by a lifted value.
-     *  Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String or Null.
-     */
-    final class LiftedExpr[+T](val value: T) extends Expr[T] {
-      override def toString: String = s"Expr($value)"
-    }
-
     /** An Expr backed by a tree. Only the current compiler trees are allowed.
      *
      *  These expressions are used for arguments of macros. They contain and actual tree

library/src-3.x/scala/quoted/Liftable.scala

@@ -1,7 +1,5 @@
 package scala.quoted
 
-import scala.runtime.quoted.Unpickler.liftedExpr
-
 /** A typeclass for types that can be turned to `quoted.Expr[T]`
  *  without going through an explicit `'{...}` operation.
  */
@@ -24,10 +22,16 @@ object Liftable {
   implicit val Liftable_Double_delegate: Liftable[Double] = new PrimitiveLiftable
   implicit val Liftable_Char_delegate: Liftable[Char] = new PrimitiveLiftable
   implicit val Liftable_String_delegate: Liftable[String] = new PrimitiveLiftable
-  implicit def ClassIsLiftable[T]: Liftable[Class[T]] = new PrimitiveLiftable
+  implicit def ClassIsLiftable[T]: Liftable[Class[T]] = new PrimitiveLiftable[Class[T]]
 
-  private class PrimitiveLiftable[T] extends Liftable[T] {
-    override def toExpr(x: T) given QuoteContext: Expr[T] = liftedExpr(x)
+  private class PrimitiveLiftable[T <: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Class[_]] extends Liftable[T] {
+    override def toExpr(x: T) given (qctx: QuoteContext): Expr[T] = {
+      import qctx.tasty._
+      x match {
+//        case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
+        case x => Literal(Constant(x)).seal.asInstanceOf[Expr[T]]
+      }
+    }
   }
 
 }

library/src/scala/runtime/quoted/Unpickler.scala

@@ -1,6 +1,6 @@
 package scala.runtime.quoted
 
-import scala.internal.quoted.{LiftedExpr, TastyExpr, TastyType}
+import scala.internal.quoted.{TastyExpr, TastyType}
 import scala.quoted.{Expr, Type}
 
 /** Provides methods to unpickle `Expr` and `Type` trees. */
@@ -19,7 +19,7 @@ object Unpickler {
   /** Lift the `value` to an `Expr` tree.
    *  Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String, Null or Class.
    */
-  def liftedExpr[T](value: T): Expr[T] = new LiftedExpr[T](value)
+  def liftedExpr[T](value: T): Expr[T] = ??? // deprecated
 
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `args`

library/src/scala/tasty/reflect/ConstantOps.scala

@@ -10,6 +10,9 @@ trait ConstantOps extends Core {
   /** Module of Constant literals */
   object Constant {
 
+    def apply(x: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Class[_]): Constant =
+      kernel.Constant_apply(x)
+
     /** Module of Null literals */
     object Unit {
       /** Unit `()` literal */

library/src/scala/tasty/reflect/Kernel.scala

@@ -1185,6 +1185,7 @@ trait Kernel {
   def matchConstant_String(constant: Constant): Option[String]
   def matchConstant_ClassTag(constant: Constant): Option[Type]
 
+  def Constant_apply(x: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Class[_]): Constant
   def Constant_Unit_apply(): Constant
   def Constant_Null_apply(): Constant
   def Constant_Boolean_apply(x: Boolean): Constant

tests/run-with-compiler/quote-compile-constants.check

@@ -0,0 +1,16 @@
+Inlined(Ident(Test$),List(),Literal(Constant(true)))
+Inlined(Ident(Test$),List(),Literal(Constant(a)))
+Inlined(Ident(Test$),List(),Literal(Constant(
+)))
+Inlined(Ident(Test$),List(),Literal(Constant(")))
+Inlined(Ident(Test$),List(),Literal(Constant(')))
+Inlined(Ident(Test$),List(),Literal(Constant(\)))
+Inlined(Ident(Test$),List(),Literal(Constant(1)))
+Inlined(Ident(Test$),List(),Block(List(),Block(List(),Literal(Constant(2)))))
+Inlined(Ident(Test$),List(),Literal(Constant(3)))
+Inlined(Ident(Test$),List(),Literal(Constant(4.0)))
+Inlined(Ident(Test$),List(),Literal(Constant(5.0)))
+Inlined(Ident(Test$),List(),Literal(Constant(xyz)))
+Inlined(Ident(Test$),List(),Block(List(),Literal(Constant(()))))
+Inlined(Ident(Test$),List(),Literal(Constant(())))
+Inlined(Ident(Test$),List(),Block(List(),Literal(Constant(()))))

tests/run-with-compiler/quote-compile-constants.scala

@@ -0,0 +1,30 @@
+import scala.quoted._
+
+object Test {
+
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+
+  def main(args: Array[String]): Unit = withQuoteContext {
+    val qctx = the[QuoteContext]
+    def check[T](expr: Expr[T]): Unit = {
+      import qctx.tasty._
+      println(expr.unseal)
+    }
+
+    check('{true})
+    check('{ 'a' })
+    check('{ '\n' })
+    check('{ '"' })
+    check('{ '\'' })
+    check('{ '\\' })
+    check('{1})
+    check('{ { { 2 } } })
+    check('{3L})
+    check('{4.0f})
+    check('{5.0d})
+    check('{"xyz"})
+    check('{})
+    check('{()})
+    check('{{()}})
+  }
+}