Remove quoted.Const.unapply

This extractor was replaced with the more versatil extractor `quoted.Unlifted.unapply`.

* Remove definition of `quoted.Const.unapply`
* Replace uses of `Const` with `Unlifted`
* Allow unlifting precise types for primitives
* Remove `Unlifted[Unit]`

**Migration**

* Replace `Const(x)` with `Unlifted(x)` if the type is known
* Replace `Const(x: Int)` with `'{ ${Unlifted(x)}: Int }` if type of expression must be checked at runtime
* Consider using `expr.unlift` and them match on `Option`

Author: nicolasstucki

community-build/community-projects/scalatest

@@ -14,39 +14,46 @@ trait Unliftable[T] {
 
 object Unliftable {
 
-  /** Default unliftable for Unit */
-  given UnitUnliftable as Unliftable[Unit] = new PrimitiveUnliftable
-
   /** Default unliftable for Boolean */
-  given BooleanUnliftable as Unliftable[Boolean] = new PrimitiveUnliftable
+  given BooleanUnliftable[T <: Boolean] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Byte */
-  given ByteUnliftable as Unliftable[Byte] = new PrimitiveUnliftable
+  given ByteUnliftable[T <: Byte] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Short */
-  given ShortUnliftable as Unliftable[Short] = new PrimitiveUnliftable
+  given ShortUnliftable[T <: Short] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Int */
-  given IntUnliftable as Unliftable[Int] = new PrimitiveUnliftable
+  given IntUnliftable[T <: Int] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Long */
-  given LongUnliftable as Unliftable[Long] = new PrimitiveUnliftable
+  given LongUnliftable[T <: Long] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Float */
-  given FloatUnliftable as Unliftable[Float] = new PrimitiveUnliftable
+  given FloatUnliftable[T <: Float] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Double */
-  given DoubleUnliftable as Unliftable[Double] = new PrimitiveUnliftable
+  given DoubleUnliftable[T <: Double] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Char */
-  given CharUnliftable as Unliftable[Char] = new PrimitiveUnliftable
+  given CharUnliftable[T <: Char] as Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for String */
-  given StringUnliftable as Unliftable[String] = new PrimitiveUnliftable
+  given StringUnliftable[T <: String] as Unliftable[T] = new PrimitiveUnliftable
 
-  private class PrimitiveUnliftable[T <: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Unliftable[T] {
+  private class PrimitiveUnliftable[T <: Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Unliftable[T] {
     /** Lift a quoted primitive value `'{ n }` into `n` */
-    def fromExpr(x: Expr[T]) = Const.unapply(x)
+    def fromExpr(expr: Expr[T]) = {
+      import quotes.reflect._
+      def rec(tree: Term): Option[T] = tree match {
+        case Literal(c) => Some(c.value.asInstanceOf[T])
+        case Block(Nil, e) => rec(e)
+        case Typed(e, _) => rec(e)
+        case Inlined(_, Nil, e) => rec(e)
+        case _  => None
+      }
+      rec(Term.of(expr))
+    }
   }
 
   /** Default unliftable for Option */
@@ -79,8 +86,8 @@ object Unliftable {
   /** Default unliftable for StringContext */
   given StringContextUnliftable as Unliftable[StringContext] = new {
     def fromExpr(x: Expr[StringContext]) = x match {
-      case '{ new StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
-      case '{     StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
+      case '{ new StringContext(${Varargs(Unlifted(args))}: _*) } => Some(StringContext(args: _*))
+      case '{     StringContext(${Varargs(Unlifted(args))}: _*) } => Some(StringContext(args: _*))
       case _ => None
     }
   }

community-build/community-projects/xml-interpolator

@@ -9,7 +9,7 @@ object Macro {
     var res: Expr[String] = null
     for _ <- 0 to 5_000 do
       (strCtxExpr, argsExpr) match {
-        case ('{ StringContext(${Varargs(Consts(parts))}: _*) }, Varargs(Consts(args))) =>
+        case ('{ StringContext(${Varargs(Unlifted(parts))}: _*) }, Varargs(Unlifted(args))) =>
           res = Expr(StringContext(parts: _*).s(args: _*))
         case _ => ???
       }

library/src-bootstrapped/scala/quoted/Unliftable.scala

@@ -6,7 +6,7 @@ import scala.quoted._
 object BigFloatFromDigitsImpl:
   def apply(digits: Expr[String])(using Quotes): Expr[BigFloat] =
     digits match
-      case Const(ds) =>
+      case Unlifted(ds) =>
         try
           val BigFloat(m, e) = BigFloat(ds)
           '{BigFloat(${Expr(m)}, ${Expr(e)})}

library/src/scala/quoted/Const.scala

@@ -5,7 +5,7 @@ import Even._
 
 object EvenFromDigitsImpl:
   def apply(digits: Expr[String])(using Quotes): Expr[Even] = digits match {
-    case Const(ds) =>
+    case Unlifted(ds) =>
       val ev =
         try evenFromDigits(ds)
         catch {

library/src/scala/quoted/Consts.scala

@@ -9,7 +9,7 @@ object Macro {
     import quotes.reflect._
     sc match {
       case '{ StringContext(${Varargs(parts)}: _*) } =>
-        for (part @ Const(s) <- parts)
+        for (part @ Unlifted(s) <- parts)
           report.error(s, Term.of(part).pos)
     }
     '{}

tests/bench/string-interpolation-macro/Macro.scala

@@ -9,7 +9,7 @@ object Macro {
     import quotes.reflect._
     sc match {
       case '{ StringContext(${Varargs(parts)}: _*) } =>
-        for (part @ Const(s) <- parts)
+        for (part @ Unlifted(s) <- parts)
           report.error(s, Term.of(part).pos)
     }
     '{}

tests/neg-macros/BigFloat/BigFloatFromDigitsImpl_1.scala

@@ -10,7 +10,7 @@ object E {
 
   implicit def ev1[T: Type]: Unliftable[E[T]] = new Unliftable {
     def fromExpr(x: Expr[E[T]]) = x match {
-      case '{ I(${Const(n)}) } => Some(I(n).asInstanceOf[E[T]])
+      case '{ I(${Unlifted(n)}) } => Some(I(n).asInstanceOf[E[T]])
       case '{ Plus[T](${Value(x)}, ${Value(y)})(using $op) } if op.matches('{Plus2.IPlus}) => Some(Plus(x, y)(using Plus2.IPlus.asInstanceOf[Plus2[T]]).asInstanceOf[E[T]])
       case _ => None
     }

tests/neg-macros/GenericNumLits/EvenFromDigitsImpl_1.scala

@@ -4,8 +4,8 @@ import scala.quoted._
 import Even._
 
 object EvenFromDigitsImpl:
-  def apply(digits: Expr[String])(using Quotes): Expr[Even] = digits match {
-    case Const(ds) =>
+  def apply(digits: Expr[String])(using Quotes): Expr[Even] = digits.unlift match {
+    case Some(ds) =>
       val ev =
         try evenFromDigits(ds)
         catch {

tests/neg-macros/i6432/Macro_1.scala

@@ -6,7 +6,7 @@ import scala.quoted._
 object BigFloatFromDigitsImpl:
   def apply(digits: Expr[String])(using Quotes): Expr[BigFloat] =
     digits match
-      case Const(ds) =>
+      case Unlifted(ds) =>
         try
           val BigFloat(m, e) = BigFloat(ds)
           '{BigFloat(${Expr(m)}, ${Expr(e)})}

tests/neg-macros/i6432b/Macro_1.scala

@@ -25,6 +25,6 @@ import Nat._
        case 0 => acc
        case n => inner[Succ[N]](n - 1, '{Succ($acc)})
 
-     val Const(i) = int
+     val Unlifted(i) = int
      require(i >= 0)
      inner[Zero.type](i, '{Zero})

tests/neg-macros/inline-macro-staged-interpreter/Macro_1.scala

@@ -9,7 +9,7 @@ private def stringRewriter(e: Expr[Any])(using Quotes): Expr[Any] =
 private object StringRewriter extends ExprMap {
 
   def transform[T](e: Expr[T])(using Quotes, Type[T]): Expr[T] = e match
-    case Const(s: String) =>
+    case '{ ${Unlifted(s)}: String } =>
       Expr(s.reverse) match
         case '{ $x: T } => x
         case _ => e // e had a singlton String type

tests/neg-with-compiler/GenericNumLits/EvenFromDigitsImpl_1.scala

@@ -13,22 +13,22 @@ private def rewriteMacro[T: Type](x: Expr[T])(using Quotes): Expr[T] = {
       Transformation[Int] {
         case '{ plus($x, $y) } =>
           (x, y) match {
-            case (Const(0), _) => y
-            case (Const(a), Const(b)) => Expr(a + b)
-            case (_, Const(_)) =>  '{ $y + $x }
+            case (Unlifted(0), _) => y
+            case (Unlifted(a), Unlifted(b)) => Expr(a + b)
+            case (_, Unlifted(_)) =>  '{ $y + $x }
             case _ => '{ $x + $y }
           }
         case '{ times($x, $y) } =>
           (x, y) match {
-            case (Const(0), _) => '{0}
-            case (Const(1), _) => y
-            case (Const(a), Const(b)) => Expr(a * b)
-            case (_, Const(_)) => '{ $y * $x }
+            case (Unlifted(0), _) => '{0}
+            case (Unlifted(1), _) => y
+            case (Unlifted(a), Unlifted(b)) => Expr(a * b)
+            case (_, Unlifted(_)) => '{ $y * $x }
             case _ => '{ $x * $y }
           }
-        case '{ power(${Const(x)}, ${Const(y)}) } =>
+        case '{ power(${Unlifted(x)}, ${Unlifted(y)}) } =>
           Expr(power(x, y))
-        case '{ power($x, ${Const(y)}) } =>
+        case '{ power($x, ${Unlifted(y)}) } =>
           if y == 0 then '{1}
           else '{ times($x, power($x, ${Expr(y-1)})) }
       }),

tests/run-macros/BigFloat/BigFloatFromDigitsImpl_1.scala

@@ -12,22 +12,22 @@ private def rewriteMacro[T: Type](x: Expr[T])(using Quotes): Expr[T] = {
     Transformation.safe[Int] {
       case '{ plus($x, $y) } =>
         (x, y) match {
-          case (Const(0), _) => y
-          case (Const(a), Const(b)) => Expr(a + b)
-          case (_, Const(_)) =>  '{ $y + $x }
+          case (Unlifted(0), _) => y
+          case (Unlifted(a), Unlifted(b)) => Expr(a + b)
+          case (_, Unlifted(_)) =>  '{ $y + $x }
           case _ => '{ $x + $y }
         }
       case '{ times($x, $y) } =>
         (x, y) match {
-          case (Const(0), _) => '{0}
-          case (Const(1), _) => y
-          case (Const(a), Const(b)) => Expr(a * b)
-          case (_, Const(_)) => '{ $y * $x }
+          case (Unlifted(0), _) => '{0}
+          case (Unlifted(1), _) => y
+          case (Unlifted(a), Unlifted(b)) => Expr(a * b)
+          case (_, Unlifted(_)) => '{ $y * $x }
           case _ => '{ $x * $y }
         }
-      case '{ power(${Const(x)}, ${Const(y)}) } =>
+      case '{ power(${Unlifted(x)}, ${Unlifted(y)}) } =>
         Expr(power(x, y))
-      case '{ power($x, ${Const(y)}) } =>
+      case '{ power($x, ${Unlifted(y)}) } =>
         if y == 0 then '{1}
         else '{ times($x, power($x, ${Expr(y-1)})) }
     }

tests/run-macros/enum-nat-macro/Macros_2.scala

@@ -14,7 +14,7 @@ object FileName {
   def createFileName(fileName: Expr[String])(using Quotes): Expr[FileName] =
     import quotes.reflect.report
     fileName match {
-      case e@Const(s) =>
+      case e@Unlifted(s) =>
         fileNameFromString(s) match {
             case Right(fn) =>
               '{FileName.unsafe(${Expr(fn.name)})} // Or `Expr(fn)` if there is a `Liftable[FileName]`

tests/run-macros/expr-map-1/Macro_1.scala

@@ -11,8 +11,8 @@ object E {
 
   implicit def ev1[T: Type]: Unliftable[E[T]] = new Unliftable { // TODO use type class derivation
     def fromExpr(x: Expr[E[T]]) = (x match {
-      case '{ I(${Const(n)}) } => Some(I(n))
-      case '{ D(${Const(n)}) } => Some(D(n))
+      case '{ I(${Unlifted(n)}) } => Some(I(n))
+      case '{ D(${Unlifted(n)}) } => Some(D(n))
       case '{ Plus[Int](${Value(x)}, ${Value(y)})(using $op) } => Some(Plus(x, y)(using Plus2.IPlus))
       case '{ Plus[Double](${Value(x)}, ${Value(y)})(using $op) } => Some(Plus(x, y)(using Plus2.DPlus))
       case '{ Times[Int](${Value(x)}, ${Value(y)})(using $op) } => Some(Times(x, y)(using Times2.ITimes))

tests/run-macros/flops-rewrite-2/Macro_1.scala

@@ -9,8 +9,8 @@ object Macros {
   private def impl(self: Expr[StringContext], args: Expr[Seq[String]])(using Quotes): Expr[String] = {
     (self, args) match {
       case ('{ StringContext(${Varargs(parts)}: _*) }, Varargs(args1)) =>
-        val strParts = parts.map { case Const(str) => str.reverse }
-        val strArgs = args1.map { case Const(str) => str }
+        val strParts = parts.map { case Unlifted(str) => str.reverse }
+        val strArgs = args1.map { case Unlifted(str) => str }
         Expr(StringContext(strParts: _*).s(strArgs: _*))
       case _ => ???
     }

tests/run-macros/flops-rewrite-3/Macro_1.scala

@@ -8,7 +8,7 @@ object Macros {
 
   private def impl(self: Expr[StringContext], args: Expr[Seq[String]])(using Quotes): Expr[String] = {
     self match {
-      case '{ StringContext(${Varargs(Consts(parts))}: _*) } =>
+      case '{ StringContext(${Varargs(Unlifted(parts))}: _*) } =>
         val upprerParts: List[String] = parts.toList.map(_.toUpperCase)
         val upprerPartsExpr: Expr[List[String]] = Expr.ofList(upprerParts.map(Expr(_)))
         '{ StringContext($upprerPartsExpr: _*).s($args: _*) }

tests/run-macros/i8671/Macro_1.scala

@@ -10,7 +10,7 @@ object Macros {
 
     def lift(e: Expr[DSL]): Expr[T] = e match {
 
-      case '{ LitDSL(${ Const(c) }) } =>
+      case '{ LitDSL(${ Unlifted(c) }) } =>
         '{ $sym.value(${Expr(c)}) }
 
       case '{ ($x: DSL) + ($y: DSL) } =>

tests/run-macros/inline-macro-staged-interpreter/Macro_1.scala

@@ -21,7 +21,7 @@ object Macros {
 
     def lift(e: Expr[DSL])(implicit env: Map[Int, Expr[T]]): Expr[T] = e match {
 
-      case '{ LitDSL(${Const(c)}) } => sym.value(c)
+      case '{ LitDSL(${Unlifted(c)}) } => sym.value(c)
 
       case '{ ($x: DSL) + ($y: DSL) } => sym.plus(lift(x), lift(y))
 
@@ -35,7 +35,7 @@ object Macros {
           lift(close(body1)(nEnvVar))(env + (i -> lift(value)))
         }
 
-      case '{ envVar(${Const(i)}) } => env(i)
+      case '{ envVar(${Unlifted(i)}) } => env(i)
 
       case _ =>
         import quotes.reflect._

tests/run-macros/quote-matcher-string-interpolator-2/quoted_1.scala

@@ -18,15 +18,15 @@ object Macros {
     object FromEnv {
       def unapply[T](e: Expr[Any])(using env: Env): Option[Expr[R[T]]] =
         e match
-          case '{envVar[t](${Const(id)})} =>
+          case '{envVar[t](${Unlifted(id)})} =>
             env.get(id).asInstanceOf[Option[Expr[R[T]]]] // We can only add binds that have the same type as the refs
           case _ =>
             None
     }
 
     def lift[T: Type](e: Expr[T])(using env: Env): Expr[R[T]] = ((e: Expr[Any]) match {
-      case Const(e: Int) => '{ $sym.int(${Expr(e)}).asInstanceOf[R[T]] }
-      case Const(e: Boolean) => '{ $sym.bool(${Expr(e)}).asInstanceOf[R[T]] }
+      case '{ ${Unlifted(e)}: Int } => '{ $sym.int(${Expr(e)}).asInstanceOf[R[T]] }
+      case '{ ${Unlifted(e)}: Boolean } => '{ $sym.bool(${Expr(e)}).asInstanceOf[R[T]] }
 
       case '{ ($x: Int) + ($y: Int) } =>
         '{ $sym.add(${lift(x)}, ${lift(y)}).asInstanceOf[R[T]] }

tests/run-macros/quote-matcher-string-interpolator-3/quoted_1.scala

@@ -26,11 +26,11 @@ private def sumExpr(args1: Seq[Expr[Int]])(using Quotes): Expr[Int] = {
     }
     val args2 = args1.flatMap(flatSumArgs)
     val staticSum: Int = args2.map {
-      case Const(arg) => arg
+      case Unlifted(arg) => arg
       case _ => 0
     }.sum
     val dynamicSum: Seq[Expr[Int]] = args2.filter {
-      case Const(_) => false
+      case Unlifted(_) => false
       case arg => true
     }
     dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })