Define Consts and Values

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -624,7 +624,7 @@ These could be used in the following way to optimize any call to `sum` that has
 ```scala
 inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
 private def sumExpr(argsExpr: Expr[Seq[Int]])(using QuoteContext): Expr[Int] = argsExpr match {
-  case Varargs(Const(args)) => // args is of type Seq[Int]
+  case Varargs(Consts(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 {

library/src-bootstrapped/dotty/internal/StringContextMacro.scala

@@ -66,7 +66,7 @@ object StringContextMacro {
     def splitParts(seq: Expr[Seq[String]]) = seq match {
       case Varargs(p1) =>
         p1 match
-          case Const(p2) => (p1.toList, p2.toList)
+          case Consts(p2) => (p1.toList, p2.toList)
           case _ => notStatic
       case _ => notStatic
     }

library/src/scala/quoted/Const.scala

@@ -26,24 +26,4 @@ object Const {
     rec(expr.unseal)
   }
 
-  /** 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]])(usingusing QuoteContext): Expr[Int] = argsExpr match
-   *    case Varargs(Const(args)) =>
-   *      // args: Seq[Int]
-   *      ...
-   *  }
-   *  ```
-   */
-  def unapply[T](exprs: Seq[Expr[T]])(using qctx: QuoteContext): Option[Seq[T]] =
-    exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
-      (elem, acc) match {
-        case (Const(value), Some(lst)) => Some(value :: lst)
-        case (_, _) => None
-      }
-    }
-
 }

library/src/scala/quoted/Consts.scala

@@ -0,0 +1,26 @@
+package scala.quoted
+
+/** MLiteral constant values */
+object Consts {
+
+  /** 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]])(usingusing QuoteContext): Expr[Int] = argsExpr match
+   *    case Varargs(Consts(args)) =>
+   *      // args: Seq[Int]
+   *      ...
+   *  }
+   *  ```
+   */
+  def unapply[T](exprs: Seq[Expr[T]])(using qctx: QuoteContext): Option[Seq[T]] =
+    exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
+      (elem, acc) match {
+        case (Const(value), Some(lst)) => Some(value :: lst)
+        case (_, _) => None
+      }
+    }
+
+}

library/src/scala/quoted/Value.scala

@@ -15,23 +15,4 @@ object Value {
   def unapply[T](expr: Expr[T])(using valueOf: ValueOfExpr[T], qxtc: QuoteContext): Option[T] =
     valueOf(expr)
 
-  /** 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 QuoteContext): Expr[Int] = argsExpr match
-   *    case Varargs(Value(args)) =>
-   *      // args: Seq[Int]
-   *      ...
-   *  }
-   *  ```
-   */
-  def unapply[T](exprs: Seq[Expr[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] =
-    exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
-      (elem, acc) match {
-        case (Value(value), Some(lst)) => Some(value :: lst)
-        case (_, _) => None
-      }
-    }
 }

library/src/scala/quoted/ValueOfExpr.scala

@@ -42,8 +42,8 @@ object ValueOfExpr {
 
   given StringContext_delegate as ValueOfExpr[StringContext] = new {
     def apply(x: Expr[StringContext])(using qctx: QuoteContext): Option[StringContext] = x match {
-      case '{ new StringContext(${Varargs(Const(args))}: _*) } => Some(StringContext(args: _*))
-      case '{     StringContext(${Varargs(Const(args))}: _*) } => Some(StringContext(args: _*))
+      case '{ new StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
+      case '{     StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
       case _ => None
     }
     override def toString(): String = "scala.quoted.ValueOfExpr.Tuple1_delegate"
@@ -270,9 +270,9 @@ object ValueOfExpr {
 
   given Seq_delegate[T](using Type[T], ValueOfExpr[T]) as ValueOfExpr[Seq[T]] = new {
     def apply(x: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] = x match {
-      case Varargs(Value(elems)) => Some(elems)
-      case '{ scala.collection.Seq[T](${Varargs(Value(elems))}: _*) } => Some(elems)
-      case '{ scala.collection.immutable.Seq[T](${Varargs(Value(elems))}: _*) } => Some(elems)
+      case Varargs(Values(elems)) => Some(elems)
+      case '{ scala.collection.Seq[T](${Varargs(Values(elems))}: _*) } => Some(elems)
+      case '{ scala.collection.immutable.Seq[T](${Varargs(Values(elems))}: _*) } => Some(elems)
       case _ => None
     }
     override def toString(): String = "scala.quoted.ValueOfExpr.Seq_delegate"

library/src/scala/quoted/Values.scala

@@ -0,0 +1,25 @@
+package scala.quoted
+
+/** Value expressions */
+object Values {
+
+  /** 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 QuoteContext): Expr[Int] = argsExpr match
+   *    case Varargs(Values(args)) =>
+   *      // args: Seq[Int]
+   *      ...
+   *  }
+   *  ```
+   */
+  def unapply[T](exprs: Seq[Expr[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] =
+    exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
+      (elem, acc) match {
+        case (Value(value), Some(lst)) => Some(value :: lst)
+        case (_, _) => None
+      }
+    }
+}

library/src/scala/quoted/matching/ConstSeq.scala

@@ -20,7 +20,7 @@ object ConstSeq {
   def unapply[T](expr: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] =
     import scala.quoted.Const
     expr match
-      case Varargs(Const(elems)) => Some(elems)
+      case Varargs(Consts(elems)) => Some(elems)
       case _ => None
 
 }

library/src/scala/quoted/matching/ValueSeq.scala

@@ -20,7 +20,7 @@ object ValueSeq {
   def unapply[T](expr: Expr[Seq[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] =
     import scala.quoted.Const
     expr match
-      case Varargs(Value(elems)) => Some(elems)
+      case Varargs(Values(elems)) => Some(elems)
       case _ => None
 
 }

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

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