Rename ValueExpr to LiftedExpr

Author: nicolasstucki

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

@@ -628,9 +628,6 @@ class Definitions {
   lazy val QuotedExprsModule = ctx.requiredModule("scala.quoted.Exprs")
   def QuotedExprsClass(implicit ctx: Context) = QuotedExprsModule.symbol.asClass
 
-    lazy val QuotedExprs_valueExprR = QuotedExprsModule.requiredMethod("valueExpr")
-    def QuotedExprs_valueExpr(implicit ctx: Context) = QuotedExprs_valueExprR.symbol
-
   lazy val QuotedTypeType = ctx.requiredClassRef("scala.quoted.Type")
   def QuotedTypeClass(implicit ctx: Context) = QuotedTypeType.symbol.asClass
 
@@ -642,6 +639,7 @@ class Definitions {
     def QuotedType_apply(implicit ctx: Context) = QuotedType_applyR.symbol
 
   def Unpickler_unpickleExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
+  def Unpickler_liftedExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
   def Unpickler_unpickleType = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
 
   lazy val EqType = ctx.requiredClassRef("scala.Eq")

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

@@ -33,7 +33,7 @@ object PickledQuotes {
   /** Transform the expression into its fully spliced Tree */
   def quotedExprToTree(expr: quoted.Expr[_])(implicit ctx: Context): Tree = expr match {
     case expr: TastyExpr[_] => unpickleExpr(expr)
-    case expr: ValueExpr[_] => Literal(Constant(expr.value))
+    case expr: LiftedExpr[_] => Literal(Constant(expr.value))
     case expr: TreeExpr[Tree] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))

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

@@ -4,11 +4,10 @@ import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Constants._
 import dotty.tools.dotc.printing.RefinedPrinter
-import dotty.tools.dotc.transform.ReifyQuotes
 
 import scala.quoted.Expr
 import scala.runtime.BoxedUnit
-import scala.quoted.Exprs.ValueExpr
+import scala.quoted.Exprs.LiftedExpr
 import scala.runtime.quoted._
 
 /** Default runners for quoted expressions */
@@ -24,12 +23,12 @@ object Toolbox {
     ): Toolbox[T] = new Toolbox[T] {
 
     def run(expr: Expr[T]): T = expr match {
-      case expr: ValueExpr[T] => expr.value
+      case expr: LiftedExpr[T] => expr.value
       case _ => new QuoteDriver().run(expr, runSettings)
     }
 
     def show(expr: Expr[T]): String = expr match {
-      case expr: ValueExpr[T] =>
+      case expr: LiftedExpr[T] =>
         implicit val ctx = new QuoteDriver().initCtx
         if (showSettings.compilerArgs.contains("-color:never"))
           ctx.settings.color.update("never")
@@ -47,7 +46,7 @@ object Toolbox {
         case _ => None
       }
       expr match {
-        case expr: ValueExpr[T] => Some(expr.value)
+        case expr: LiftedExpr[T] => Some(expr.value)
         case _ => new QuoteDriver().withTree(expr, (tree, _) => toConstantOpt(tree), Settings.run())
       }
     }

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

@@ -297,7 +297,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
 
     private def pickledQuote(body: Tree, splices: List[Tree], isType: Boolean)(implicit ctx: Context) = {
       def pickleAsValue[T](value: T) =
-        ref(defn.QuotedExprs_valueExpr).appliedToType(body.tpe.widen).appliedTo(Literal(Constant(value)))
+        ref(defn.Unpickler_liftedExpr).appliedToType(body.tpe.widen).appliedTo(Literal(Constant(value)))
       def pickleAsTasty() = {
         val meth =
           if (isType) ref(defn.Unpickler_unpickleType).appliedToType(body.tpe)

library/src/scala/quoted/Expr.scala

@@ -28,15 +28,13 @@ object Exprs {
     override def toString(): String = s"Expr(<pickled>)"
   }
 
-  /** An Expr backed by a value.
+  /** 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 ValueExpr[T](val value: T) extends Expr[T] {
+  final class LiftedExpr[T](val value: T) extends Expr[T] {
     override def toString: String = s"Expr($value)"
   }
 
-  def valueExpr[T](value: T): ValueExpr[T] = new ValueExpr[T](value)
-
   /** An Expr backed by a tree. Only the current compiler trees are allowed. */
   final class TreeExpr[Tree](val tree: Tree) extends quoted.Expr[Any] {
     override def toString: String = s"Expr(<raw>)"

library/src/scala/quoted/Liftable.scala

@@ -1,6 +1,6 @@
 package scala.quoted
 
-import scala.quoted.Exprs.ValueExpr
+import scala.runtime.quoted.Unpickler.liftedExpr
 
 /** A typeclass for types that can be turned to `quoted.Expr[T]`
  *  without going through an explicit `'(...)` operation.
@@ -20,14 +20,14 @@ object Liftable {
     def toExpr(implicit liftable: Liftable[T]): Expr[T] = liftable.toExpr(x)
   }
 
-  implicit def BooleanIsLiftable: Liftable[Boolean] = (x: Boolean) => new ValueExpr(x)
-  implicit def ByteLiftable: Liftable[Byte] = (x: Byte) => new ValueExpr(x)
-  implicit def CharIsLiftable: Liftable[Char] = (x: Char) => new ValueExpr(x)
-  implicit def ShortIsLiftable: Liftable[Short] = (x: Short) => new ValueExpr(x)
-  implicit def IntIsLiftable: Liftable[Int] = (x: Int) => new ValueExpr(x)
-  implicit def LongIsLiftable: Liftable[Long] = (x: Long) => new ValueExpr(x)
-  implicit def FloatIsLiftable: Liftable[Float] = (x: Float) => new ValueExpr(x)
-  implicit def DoubleIsLiftable: Liftable[Double] = (x: Double) => new ValueExpr(x)
+  implicit def BooleanIsLiftable: Liftable[Boolean] = (x: Boolean) => liftedExpr(x)
+  implicit def ByteLiftable: Liftable[Byte] = (x: Byte) => liftedExpr(x)
+  implicit def CharIsLiftable: Liftable[Char] = (x: Char) => liftedExpr(x)
+  implicit def ShortIsLiftable: Liftable[Short] = (x: Short) => liftedExpr(x)
+  implicit def IntIsLiftable: Liftable[Int] = (x: Int) => liftedExpr(x)
+  implicit def LongIsLiftable: Liftable[Long] = (x: Long) => liftedExpr(x)
+  implicit def FloatIsLiftable: Liftable[Float] = (x: Float) => liftedExpr(x)
+  implicit def DoubleIsLiftable: Liftable[Double] = (x: Double) => liftedExpr(x)
 
-  implicit def StringIsLiftable: Liftable[String] = (x: String) => new ValueExpr(x)
+  implicit def StringIsLiftable: Liftable[String] = (x: String) => liftedExpr(x)
 }

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

@@ -1,7 +1,7 @@
 package scala.runtime.quoted
 
 import scala.quoted.Types.TastyType
-import scala.quoted.Exprs.TastyExpr
+import scala.quoted.Exprs.{LiftedExpr, TastyExpr}
 import scala.quoted.{Expr, Type}
 
 /** Provides methods to unpickle `Expr` and `Type` trees. */
@@ -17,6 +17,11 @@ 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 or Null.
+   */
+  def liftedExpr[T](value: T): LiftedExpr[T] = new LiftedExpr[T](value)
+
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `args`
    */

tests/run/quote-compile-constants.check

@@ -1,15 +1,15 @@
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
-class scala.quoted.Exprs$ValueExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr
+class scala.quoted.Exprs$LiftedExpr