Remove quoted.Const.unapply

This extractor was replaced with the more versatile extractor `quoted.Expr.unapply`.
Usually, it is better to use `expr.value`/`expr.valueOrError` when it is simpler to do so.

* Remove definition of `quoted.Const.unapply`
* Replace uses of `Const` with `Expr`

**Migration**

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

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -634,15 +634,15 @@ It is possible to deconstruct or extract values out of `Expr` using pattern matc
 
 * `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 expressions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
+* `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(args @ Exprs(argValues)) =>
-    // args is of type Seq[Expr[Int]]
+  case Varargs(argExprs @ Exprs(argValues)) =>
+    // argExprs is of type Seq[Expr[Int]]
     // argValues is of type Seq[Int]
     Expr(argValues.sum) // precompute result of sum
   case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]

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

@@ -32,7 +32,7 @@ object Expr {
     Block(statements.map(Term.of), Term.of(expr)).asExpr.asInstanceOf[Expr[T]]
   }
 
-  /** Creates an expression that will construct the value `x` */
+  /** Lift a value into an expression containing the construction of that value */
   def apply[T](x: T)(using ToExpr[T])(using Quotes): Expr[T] =
     scala.Predef.summon[ToExpr[T]].apply(x)
 

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

@@ -136,8 +136,8 @@ object FromExpr {
    */
   given StringContextFromExpr: FromExpr[StringContext] with {
     def unapply(x: Expr[StringContext])(using Quotes) = x match {
-      case '{ new StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
-      case '{     StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
+      case '{ new StringContext(${Varargs(Exprs(args))}: _*) } => Some(StringContext(args: _*))
+      case '{     StringContext(${Varargs(Exprs(args))}: _*) } => Some(StringContext(args: _*))
       case _ => None
     }
   }

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

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

library/src/scala/quoted/Const.scala

@@ -1,5 +1,6 @@
 package scala.quoted
 
+/** Value expressions */
 object Exprs:
 
   /** Matches literal sequence of literal constant value expressions and return a sequence of values.
@@ -9,7 +10,6 @@ object Exprs:
    *  inline def sum(args: Int*): Int = ${ sumExpr('args) }
    *  def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match
    *    case Varargs(Exprs(args)) =>
-   *    case Varargs(Exprs(args)) =>
    *      // args: Seq[Int]
    *      ...
    *  }

library/src/scala/quoted/Consts.scala

@@ -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(Exprs(parts))}: _*) }, Varargs(Exprs(args))) =>
           res = Expr(StringContext(parts: _*).s(args: _*))
         case _ => ???
       }

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/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 @ Expr(s) <- parts)
           report.error(s, Term.of(part).pos)
     }
     '{}