Change ConstantExpr to ValueExpr and add documentation

Author: nicolasstucki

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: ConstantExpr[_] => Literal(Constant(expr.value))
+    case expr: ValueExpr[_] => Literal(Constant(expr.value))
     case expr: RawExpr[Tree] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))

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

@@ -7,7 +7,7 @@ import dotty.tools.dotc.printing.RefinedPrinter
 
 import scala.quoted.Expr
 import scala.runtime.BoxedUnit
-import scala.quoted.Exprs.ConstantExpr
+import scala.quoted.Exprs.ValueExpr
 import scala.runtime.quoted._
 
 /** Default runners for quoted expressions */
@@ -31,20 +31,20 @@ object Runners {
         case _ => None
       }
       expr match {
-        case expr: ConstantExpr[T] => Some(expr.value)
+        case expr: ValueExpr[T] => Some(expr.value)
         case _ => new QuoteDriver().withTree(expr, (tree, _) => toConstantOpt(tree), Settings.run())
       }
     }
 
   }
 
   def run[T](expr: Expr[T], settings: Settings[Run]): T = expr match {
-    case expr: ConstantExpr[T] => expr.value
+    case expr: ValueExpr[T] => expr.value
     case _ => new QuoteDriver().run(expr, settings)
   }
 
   def show[T](expr: Expr[T], settings: Settings[Show]): String = expr match {
-    case expr: ConstantExpr[T] =>
+    case expr: ValueExpr[T] =>
       implicit val ctx = new QuoteDriver().initCtx
       if (settings.compilerArgs.contains("-color:never"))
         ctx.settings.color.update("never")

library/src/scala/quoted/Expr.scala

@@ -26,8 +26,10 @@ object Exprs {
     override def toString(): String = s"Expr(<pickled>)"
   }
 
-  /** An Expr backed by a value */
-  final class ConstantExpr[T](val value: T) extends Expr[T] {
+  /** An Expr backed by a 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] {
     override def toString: String = s"Expr($value)"
   }
 

library/src/scala/quoted/Liftable.scala

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