Add scala.quoted.Expr.unapply as dual of Expr.apply

`Expr.unapply` replaces `Unlifted.unapply` using the same signature that uses an `Unliftable` to perform the unlifting. The overload the works on sequences of expression is moved to `Exprs.unapply` (similar to `Consts.unapply`).

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -633,16 +633,16 @@ It is possible to deconstruct or extract values out of `Expr` using pattern matc
 
 `scala.quoted` contains objects that can help extracting values from `Expr`.
 
-* `scala.quoted.Unlifted`: matches an expression of a value (or list of values) and returns the value (or list of values).
-* `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Unlifted` but only works on primitive values.
+* `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (or list of values) and returns the value (or list of values).
+* `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Expr`/`Exprs` but only works on primitive values.
 * `scala.quoted.Varargs`: matches an explicit sequence of expresions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
 
 
 These could be used in the following way to optimize any call to `sum` that has statically known values.
 ```scala
 inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
 private def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match {
-  case Varargs(Unlifted(args)) => // args is of type Seq[Int]
+  case Varargs(Exprs(args)) => // args is of type Seq[Int]
     Expr(args.sum) // precompute result of sum
   case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
     val staticSum: Int = argExprs.map(_.unlift.getOrElse(0))

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

@@ -29,8 +29,22 @@ object Expr {
   }
 
   /** Lift a value into an expression containing the construction of that value */
-  def apply[T](x: T)(using lift: Liftable[T])(using Quotes): Expr[T] =
-    lift.toExpr(x)
+  def apply[T](x: T)(using Liftable[T])(using Quotes): Expr[T] =
+    scala.Predef.summon[Liftable[T]].toExpr(x)
+
+  /** Matches expressions containing values and extracts the value.
+   *
+   *  Usage:
+   *  ```
+   *  case '{ ... ${expr @ Expr(value)}: T ...} =>
+   *    // expr: Expr[T]
+   *    // value: T
+   *  ```
+   *
+   *  To directly unlift an expression `expr: Expr[T]` consider using `expr.unlift`/`expr.unliftOrError` insead.
+   */
+  def unapply[T](x: Expr[T])(using Unliftable[T])(using Quotes): Option[T] =
+    scala.Predef.summon[Unliftable[T]].fromExpr(x)
 
   /** Lifts this sequence of expressions into an expression of a sequence
    *

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

@@ -1,3 +1,6 @@
 package scala.quoted
 
 abstract class Expr[+T] private[scala]
+
+object Expr:
+  def unapply[T](x: Expr[T])(using Unliftable[T])(using Quotes): Option[T] = ???

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

@@ -1,29 +1,15 @@
 package scala.quoted
 
 /** Value expressions */
-object Unlifted {
-
-  /** Matches expressions containing values and extracts the value.
-   *
-   *  Usage:
-   *  ```
-   *  case '{ ... ${expr @ Unlifted(value)}: T ...} =>
-   *    // expr: Expr[T]
-   *    // value: T
-   *  ```
-   *
-   *  To directly unlift an expression `expr: Expr[T]` consider using `expr.unlift`/`expr.unliftOrError` insead.
-   */
-  def unapply[T](expr: Expr[T])(using Unliftable[T])(using Quotes): Option[T] =
-    summon[Unliftable[T]].fromExpr(expr)
+object Exprs {
 
   /** Matches literal sequence of literal constant value expressions and return a sequence of values.
    *
    *  Usage:
    *  ```scala
    *  inline def sum(args: Int*): Int = ${ sumExpr('args) }
    *  def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match
-   *    case Varargs(Unlifted(args)) =>
+   *    case Varargs(Exprs(args)) =>
    *      // args: Seq[Int]
    *      ...
    *  }
@@ -34,8 +20,8 @@ object Unlifted {
     val builder = Seq.newBuilder[T]
     val iter = exprs.iterator
     while iter.hasNext do
-      iter.next() match
-        case Unlifted(value) => builder += value
+      iter.next().unlift match
+        case Some(value) => builder += value
         case _ => return None
     Some(builder.result())
 

library/src/scala/quoted/Unlifted.scala renamed to library/src/scala/quoted/Exprs.scala

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

tests/neg-macros/i6432/Macro_1.scala

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

tests/neg-macros/i6432b/Macro_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(${Expr(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/inline-macro-staged-interpreter/Macro_1.scala

@@ -26,9 +26,9 @@ private def rewriteMacro[T: Type](x: Expr[T])(using Quotes): Expr[T] = {
             case (_, Some(_)) => '{ $y * $x }
             case _ => '{ $x * $y }
           }
-        case '{ power(${Const(x)}, ${Const(y)}) } =>
+        case '{ power(${Expr(x)}, ${Expr(y)}) } =>
           Expr(power(x, y))
-        case '{ power($x, ${Const(y)}) } =>
+        case '{ power($x, ${Expr(y)}) } =>
           if y == 0 then '{1}
           else '{ times($x, power($x, ${Expr(y-1)})) }
       }),

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

@@ -25,9 +25,9 @@ private def rewriteMacro[T: Type](x: Expr[T])(using Quotes): Expr[T] = {
           case (_, Some(_)) => '{ $y * $x }
           case _ => '{ $x * $y }
         }
-      case '{ power(${Const(x)}, ${Const(y)}) } =>
+      case '{ power(${Expr(x)}, ${Expr(y)}) } =>
         Expr(power(x, y))
-      case '{ power($x, ${Const(y)}) } =>
+      case '{ power($x, ${Expr(y)}) } =>
         if y == 0 then '{1}
         else '{ times($x, power($x, ${Expr(y-1)})) }
     }

tests/run-macros/flops-rewrite-3/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(${Expr(n)}) } => Some(I(n))
+      case '{ D(${Expr(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/inline-macro-staged-interpreter/Macro_1.scala

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

tests/run-macros/quote-matcher-symantics-1/quoted_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(${Expr(c)}) } => sym.value(c)
 
       case '{ ($x: DSL) + ($y: DSL) } => sym.plus(lift(x), lift(y))
 

tests/run-macros/quote-matcher-symantics-2/quoted_1.scala

@@ -26,7 +26,7 @@ object XmlQuote {
 
   def impl(receiver: Expr[SCOps.StringContext], args: Expr[Seq[Any]])(using Quotes): Expr[Xml] = {
     val string = receiver match {
-      case '{ SCOps(${Unlifted(sc)}) } => Expr(sc.parts.mkString("??"))
+      case '{ SCOps(${Expr(sc)}) } => Expr(sc.parts.mkString("??"))
     }
     '{new Xml(${string}, $args.toList)}
   }

tests/run-macros/xml-interpolation-5/Macros_1.scala

@@ -26,7 +26,7 @@ object XmlQuote {
 
   def impl(receiver: Expr[SCOps.StringContext], args: Expr[Seq[Any]])(using Quotes): Expr[Xml] = {
     val string = receiver match {
-      case '{ SCOps(${Unlifted(sc)}): SCOps.StringContext } => sc.parts.mkString("??")
+      case '{ SCOps(${Expr(sc)}): SCOps.StringContext } => sc.parts.mkString("??")
     }
     '{new Xml(${Expr(string)}, $args.toList)}
   }

tests/run-macros/xml-interpolation-6/Macros_1.scala

@@ -26,7 +26,7 @@ object XmlQuote {
 
   def impl(receiver: Expr[XMLOps.StringContext], args: Expr[Seq[Any]])(using Quotes): Expr[Xml] = {
     val string = receiver match {
-      case '{ XMLOps.xml(${Unlifted(sc)}) } => sc.parts.mkString("??")
+      case '{ XMLOps.xml(${Expr(sc)}) } => sc.parts.mkString("??")
     }
     '{new Xml(${Expr(string)}, $args.toList)}
   }