Remove scala.internal.quoted.LiftedExpr

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

@@ -758,13 +758,16 @@ class Definitions {
 
   @threadUnsafe lazy val QuotedExprType: TypeRef = ctx.requiredClassRef("scala.quoted.Expr")
   def QuotedExprClass(implicit ctx: Context): ClassSymbol = QuotedExprType.symbol.asClass
+  def QuotedExprModule(implicit ctx: Context): Symbol = QuotedExprClass.companionModule
 
   @threadUnsafe lazy val QuoteContextType: TypeRef = ctx.requiredClassRef("scala.quoted.QuoteContext")
   def QuoteContextClass(implicit ctx: Context): ClassSymbol = QuoteContextType.symbol.asClass
 
   @threadUnsafe lazy val QuoteContextModule: TermSymbol = ctx.requiredModule("scala.quoted.QuoteContext")
     @threadUnsafe lazy val QuoteContext_macroContext: TermSymbol = QuoteContextModule.requiredMethod("macroContext")
 
+  @threadUnsafe lazy val LiftableModule: TermSymbol = ctx.requiredModule("scala.quoted.Liftable")
+
   @threadUnsafe lazy val InternalQuotedModuleRef: TermRef = ctx.requiredModuleRef("scala.internal.Quoted")
   def InternalQuotedModule: Symbol = InternalQuotedModuleRef.symbol
     @threadUnsafe lazy val InternalQuoted_exprQuoteR: TermRef = InternalQuotedModule.requiredMethodRef("exprQuote")
@@ -797,7 +800,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

@@ -45,11 +45,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)
@@ -174,29 +169,6 @@ object PickledQuotes {
     seq(argVals.flatten, rec(fn))
   }
 
-  private def classToType(clazz: Class[_])(implicit ctx: Context): Type = {
-    if (clazz.isPrimitive) {
-      if (clazz == classOf[Boolean]) defn.BooleanType
-      else if (clazz == classOf[Byte]) defn.ByteType
-      else if (clazz == classOf[Char]) defn.CharType
-      else if (clazz == classOf[Short]) defn.ShortType
-      else if (clazz == classOf[Int]) defn.IntType
-      else if (clazz == classOf[Long]) defn.LongType
-      else if (clazz == classOf[Float]) defn.FloatType
-      else if (clazz == classOf[Double]) defn.DoubleType
-      else defn.UnitType
-    } else if (clazz.isArray) {
-      defn.ArrayType.appliedTo(classToType(clazz.getComponentType))
-    } else if (clazz.isMemberClass) {
-      val name = clazz.getSimpleName.toTypeName
-      val enclosing = classToType(clazz.getEnclosingClass)
-      if (enclosing.member(name).exists) enclosing.select(name)
-      else {
-        enclosing.classSymbol.companionModule.termRef.select(name)
-      }
-    } else ctx.getClassIfDefined(clazz.getCanonicalName).typeRef
-  }
-
   /** Make sure that the owner of this tree is `ctx.owner` */
   private def healOwner(tree: Tree)(implicit ctx: Context): Tree = {
     val getCurrentOwner = new TreeAccumulator[Option[Symbol]] {

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] = {
@@ -65,7 +64,7 @@ class QuoteCompiler extends Compiler {
           cls.enter(ctx.newDefaultConstructor(cls), EmptyScope)
           val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
 
-          val quoted = PickledQuotes.quotedExprToTree(checkValidRunExpr(exprUnit.exprBuilder.apply(new QuoteContext(ReflectionImpl(ctx)))))(ctx.withOwner(meth))
+          val quoted = PickledQuotes.quotedExprToTree(exprUnit.exprBuilder.apply(new QuoteContext(ReflectionImpl(ctx))))(ctx.withOwner(meth))
 
           getLiteral(quoted) match {
             case Some(value) =>
@@ -82,12 +81,6 @@ 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
-    }
-
     /** Get the literal value if this tree only contains a literal tree */
     @tailrec private def getLiteral(tree: Tree): Option[Any] = tree match {
       case Literal(lit) => Some(lit.value)

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

@@ -1055,6 +1055,29 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
     case _ => Some(x)
   }
 
+  def Type_apply(clazz: Class[_])(implicit ctx: Context): Type = {
+    if (clazz.isPrimitive) {
+      if (clazz == classOf[Boolean]) defn.BooleanType
+      else if (clazz == classOf[Byte]) defn.ByteType
+      else if (clazz == classOf[Char]) defn.CharType
+      else if (clazz == classOf[Short]) defn.ShortType
+      else if (clazz == classOf[Int]) defn.IntType
+      else if (clazz == classOf[Long]) defn.LongType
+      else if (clazz == classOf[Float]) defn.FloatType
+      else if (clazz == classOf[Double]) defn.DoubleType
+      else defn.UnitType
+    } else if (clazz.isArray) {
+      defn.ArrayType.appliedTo(Type_apply(clazz.getComponentType))
+    } else if (clazz.isMemberClass) {
+      val name = clazz.getSimpleName.toTypeName
+      val enclosing = Type_apply(clazz.getEnclosingClass)
+      if (enclosing.member(name).exists) enclosing.select(name)
+      else {
+        enclosing.classSymbol.companionModule.termRef.select(name)
+      }
+    } else ctx.getClassIfDefined(clazz.getCanonicalName).typeRef
+  }
+
   def `Type_=:=`(self: Type)(that: Type)(implicit ctx: Context): Boolean = self =:= that
 
   def `Type_<:<`(self: Type)(that: Type)(implicit ctx: Context): Boolean = self <:< that
@@ -1431,6 +1454,9 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def Constant_value(const: Constant): Any = const.value
 
+  def matchConstant(constant: Constant): Option[Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Type] =
+    Some(constant.asInstanceOf[Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Type])
+
   def matchConstant_Unit(x: Constant): Boolean = x.tag == Constants.UnitTag
   def matchConstant_Null(x: Constant): Boolean = x.tag == Constants.NullTag
   def matchConstant_Boolean(x: Constant): Option[Boolean] =
@@ -1454,6 +1480,9 @@ 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 | Type): 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)
@@ -1809,6 +1838,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def Definitions_ClassClass: Symbol = defn.ClassClass
   def Definitions_ArrayClass: Symbol = defn.ArrayClass
   def Definitions_PredefModule: Symbol = defn.ScalaPredefModule.asTerm
+  def Definitions_Predef_classOf: Symbol = defn.Predef_classOf.asTerm
 
   def Definitions_JavaLangPackage: Symbol = defn.JavaLangPackageVal
 

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

@@ -20,6 +20,7 @@ import typer.Implicits.SearchFailureType
 
 import scala.collection.mutable
 import dotty.tools.dotc.core.Annotations.Annotation
+import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.transform.TreeMapWithStages._
@@ -71,6 +72,8 @@ class ReifyQuotes extends MacroTransform {
 
   override def phaseName: String = ReifyQuotes.name
 
+  override def allowsImplicitSearch: Boolean = true
+
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
       case tree: RefTree if !ctx.inInlineMethod =>
@@ -199,8 +202,29 @@ 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)))
+
+      def liftedValue[T](value: T, name: TermName, qctx: Tree) =
+        ref(defn.LiftableModule).select(name).select("toExpr".toTermName).appliedTo(Literal(Constant(value))).appliedTo(qctx)
+
+      def pickleAsValue[T](value: T) = {
+        val qctx = ctx.typer.inferImplicitArg(defn.QuoteContextType, body.span)
+        if (qctx.tpe.isInstanceOf[SearchFailureType])
+          ctx.error(ctx.typer.missingArgMsg(qctx, defn.QuoteContextType, ""), ctx.source.atSpan(body.span))
+        value match {
+          case null => ref(defn.QuotedExprModule).select("nullExpr".toTermName).appliedTo(qctx)
+          case _: Unit => ref(defn.QuotedExprModule).select("unitExpr".toTermName).appliedTo(qctx)
+          case _: Boolean => liftedValue(value, "Liftable_Boolean_delegate".toTermName, qctx)
+          case _: Byte => liftedValue(value, "Liftable_Byte_delegate".toTermName, qctx)
+          case _: Short => liftedValue(value, "Liftable_Short_delegate".toTermName, qctx)
+          case _: Int => liftedValue(value, "Liftable_Int_delegate".toTermName, qctx)
+          case _: Long => liftedValue(value, "Liftable_Long_delegate".toTermName, qctx)
+          case _: Float => liftedValue(value, "Liftable_Float_delegate".toTermName, qctx)
+          case _: Double => liftedValue(value, "Liftable_Double_delegate".toTermName, qctx)
+          case _: Char => liftedValue(value, "Liftable_Char_delegate".toTermName, qctx)
+          case _: String => liftedValue(value, "Liftable_String_delegate".toTermName, qctx)
+        }
+      }
+
       def pickleAsTasty() = {
         val meth =
           if (isType) ref(defn.Unpickler_unpickleType).appliedToType(originalTp)

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

@@ -44,7 +44,19 @@ package quoted {
         tg.untupled(args => new FunctionAppliedTo[R](f, args.toArray.map(_.asInstanceOf[Expr[_]])))
     }
 
-    /** Returns A expression containing a block with the given statements and ending with the expresion
+    /** Returns a null expresssion equivalent to `'{null}` */
+    def nullExpr given (qctx: QuoteContext): Expr[Null] = {
+      import qctx.tasty._
+      Literal(Constant(null)).seal.asInstanceOf[Expr[Null]]
+    }
+
+    /** Returns a unit expresssion equivalent to `'{}` or `'{()}` */
+    def unitExpr given (qctx: QuoteContext): Expr[Unit] = {
+      import qctx.tasty._
+      Literal(Constant(())).seal.asInstanceOf[Expr[Unit]]
+    }
+
+    /** Returns an expression containing a block with the given statements and ending with the expresion
      *  Given list of statements `s1 :: s2 :: ... :: Nil` and an expression `e` the resulting expression
      *  will be equivalent to `'{ $s1; $s2; ...; $e }`.
      */
@@ -67,13 +79,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,12 +1,13 @@
 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.
  */
-abstract class Liftable[T] {
+trait Liftable[T] {
+
+  /** Lift a value into an expression containing the construction of that value */
   def toExpr(x: T) given QuoteContext: Expr[T]
+
 }
 
 /** Some liftable base types. To be completed with at least all types
@@ -17,17 +18,29 @@ abstract class Liftable[T] {
 object Liftable {
 
   implicit val Liftable_Boolean_delegate: Liftable[Boolean] = new PrimitiveLiftable
+  implicit val Liftable_Byte_delegate: Liftable[Byte] = new PrimitiveLiftable
   implicit val Liftable_Short_delegate: Liftable[Short] = new PrimitiveLiftable
   implicit val Liftable_Int_delegate: Liftable[Int] = new PrimitiveLiftable
   implicit val Liftable_Long_delegate: Liftable[Long] = new PrimitiveLiftable
   implicit val Liftable_Float_delegate: Liftable[Float] = new PrimitiveLiftable
   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
 
-  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] extends Liftable[T] {
+    /** Lift a primitive value `n` into `'{ n }` */
+    def toExpr(x: T) given (qctx: QuoteContext): Expr[T] = {
+      import qctx.tasty._
+      Literal(Constant(x)).seal.asInstanceOf[Expr[T]]
+    }
+  }
+
+  implicit def ClassIsLiftable[T]: Liftable[Class[T]] = new Liftable[Class[T]] {
+    /** Lift a `Class[T]` into `'{ classOf[T] }` */
+    def toExpr(x: Class[T]) given (qctx: QuoteContext): Expr[Class[T]] = {
+      import qctx.tasty._
+      Ref(definitions.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
+    }
   }
 
 }

library/src-non-bootstrapped/scala/quoted/package.scala

@@ -0,0 +1,11 @@
+package scala
+
+package object quoted {
+
+  def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T =
+    throw new Exception("Non bootsrapped library")
+
+  def withQuoteContext[T](thunk: given QuoteContext => T) given (toolbox: Toolbox): T =
+    throw new Exception("Non bootsrapped library")
+
+}

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. */
@@ -16,11 +16,6 @@ object Unpickler {
    */
   def unpickleExpr[T](repr: Pickled, args: Seq[Any]): Expr[T] = new TastyExpr[T](repr, args)
 
-  /** 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)
-
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `args`
    */

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

@@ -10,6 +10,14 @@ 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 | Type): Constant =
+      kernel.Constant_apply(x)
+
+    def unapply(constant: Constant): Option[Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Type] =
+      kernel.matchConstant(constant)
+
+    // TODO remove all extractors bellow and use only use the two above
+
     /** Module of Null literals */
     object Unit {
       /** Unit `()` literal */

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

@@ -829,6 +829,8 @@ trait Kernel {
 
   def matchType(x: TypeOrBounds)(implicit ctx: Context): Option[Type]
 
+  def Type_apply(clazz: Class[_])(implicit ctx: Context): Type
+
   def `Type_=:=`(self: Type)(that: Type)(implicit ctx: Context): Boolean
   def `Type_<:<`(self: Type)(that: Type)(implicit ctx: Context): Boolean
 
@@ -1176,6 +1178,7 @@ trait Kernel {
 
   def Constant_value(const: Constant): Any
 
+  def matchConstant(constant: Constant): Option[Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Type]
   def matchConstant_Unit(constant: Constant): Boolean
   def matchConstant_Null(constant: Constant): Boolean
   def matchConstant_Boolean(constant: Constant): Option[Boolean]
@@ -1189,6 +1192,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 | Type): Constant
   def Constant_Unit_apply(): Constant
   def Constant_Null_apply(): Constant
   def Constant_Boolean_apply(x: Boolean): Constant
@@ -1470,6 +1474,7 @@ trait Kernel {
   def Definitions_ClassClass: Symbol
   def Definitions_ArrayClass: Symbol
   def Definitions_PredefModule: Symbol
+  def Definitions_Predef_classOf: Symbol
 
   def Definitions_JavaLangPackage: Symbol
 

library/src/scala/tasty/reflect/StandardDefinitions.scala

@@ -85,6 +85,9 @@ trait StandardDefinitions extends Core {
     /** The module symbol of module `scala.Predef`. */
     def PredefModule: Symbol = kernel.Definitions_PredefModule
 
+    /** The method symbol of method `scala.Predef.classOf`. */
+    def Predef_classOf: Symbol = kernel.Definitions_Predef_classOf
+
     /** The module symbol of package `java.lang`. */
     def JavaLangPackage: Symbol = kernel.Definitions_JavaLangPackage
 

library/src/scala/tasty/reflect/TypeOrBoundsOps.scala

@@ -64,6 +64,8 @@ trait TypeOrBoundsOps extends Core {
 
   object Type {
 
+    def apply(clazz: Class[_])(implicit ctx: Context): Type = kernel.Type_apply(clazz)
+
     object IsConstantType {
       /** Matches any ConstantType and returns it */
       def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[ConstantType] =