Join literal sequence Expr logic into Exprs

Currently we have `Expr.ofSeq` and `ExprSeq.unapply` to handle such cases.
Instead we provide a single `Exprs` that contains an `apply` and `unapply`.

Furthermore having both `Expr.ofSeq` and `Expr.ofList` has lead to confusions on which one to use for varargs.
This will help guide users to the correct logic to use for varargs.

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -618,7 +618,7 @@ It is possible to deconstruct or extract values out of `Expr` using pattern matc
 
 * `scala.quoted.Const`: matches an expression of a literal value and returns the value.
 * `scala.quoted.Value`: matches an expression of a value and returns the value.
-* `scala.quoted.ExprSeq`: 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]]`.
+* `scala.quoted.Exprs`: 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]]`.
 * `scala.quoted.ConstSeq`:  matches an explicit sequence of literal values and returns them.
 * `scala.quoted.ValueSeq`:  matches an explicit sequence of values and returns them.
 
@@ -628,7 +628,7 @@ inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
 private def sumExpr(argsExpr: Expr[Seq[Int]])(using QuoteContext): Expr[Int] = argsExpr match {
   case ConstSeq(args) => // args is of type Seq[Int]
     Expr(args.sum) // precompute result of sum
-  case ExprSeq(argExprs) => // argExprs is of type Seq[Expr[Int]]
+  case Exprs(argExprs) => // argExprs is of type Seq[Expr[Int]]
     val staticSum: Int = argExprs.map {
       case Const(arg) => arg
       case _ => 0
@@ -664,12 +664,12 @@ private def optimizeExpr(body: Expr[Int])(using QuoteContext): Expr[Int] = body
   // Match a call to sum with an argument $n of type Int. n will be the Expr[Int] representing the argument.
   case '{ sum($n) } => n
   // Match a call to sum and extracts all its args in an `Expr[Seq[Int]]`
-  case '{ sum(${ExprSeq(args)}: _*) } => sumExpr(args)
+  case '{ sum(${Exprs(args)}: _*) } => sumExpr(args)
   case body => body
 }
 private def sumExpr(args1: Seq[Expr[Int]])(using QuoteContext): Expr[Int] = {
     def flatSumArgs(arg: Expr[Int]): Seq[Expr[Int]] = arg match {
-      case '{ sum(${ExprSeq(subArgs)}: _*) } => subArgs.flatMap(flatSumArgs)
+      case '{ sum(${Exprs(subArgs)}: _*) } => subArgs.flatMap(flatSumArgs)
       case arg => Seq(arg)
     }
     val args2 = args1.flatMap(flatSumArgs)
@@ -707,7 +707,7 @@ inline def (sc: StringContext).showMe(inline args: Any*): String = ${ showMeExpr
 
 private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using qctx: QuoteContext): Expr[String] = {
   argsExpr match {
-    case ExprSeq(argExprs) =>
+    case Exprs(argExprs) =>
       val argShowedExprs = argExprs.map {
         case '{ $arg: $tp } =>
           val showTp = '[Show[$tp]]

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

@@ -64,7 +64,7 @@ object StringContextMacro {
     def notStatic =
       qctx.throwError("Expected statically known String Context", strCtxExpr)
     def splitParts(seq: Expr[Seq[String]]) = (seq, seq) match {
-      case (ExprSeq(p1), ConstSeq(p2)) => (p1.toList, p2.toList)
+      case (Exprs(p1), ConstSeq(p2)) => (p1.toList, p2.toList)
       case (_, _) => notStatic
     }
     val (partsExpr, parts) = strCtxExpr match {
@@ -74,7 +74,7 @@ object StringContextMacro {
     }
 
     val args = argsExpr match {
-      case ExprSeq(args) => args
+      case Exprs(args) => args
       case _ => qctx.throwError("Expected statically known argument list", argsExpr)
     }
 

library/src/scala/quoted/ConstSeq.scala

@@ -16,7 +16,7 @@ object ConstSeq {
    *  ```
    */
   def unapply[T](expr: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] = expr match {
-    case ExprSeq(elems) =>
+    case Exprs(elems) =>
       elems.foldRight(Option(List.empty[T])) { (elem, acc) =>
         (elem, acc) match {
           case (Const(value), Some(lst)) => Some(value :: lst)

library/src/scala/quoted/Expr.scala

@@ -108,17 +108,9 @@ object Expr {
    *    `Seq(e1, e2, ...)` where `ei: Expr[T]`
    *  to an expression equivalent to
    *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
-   *
-   *  Usage:
-   *  ```scala
-   *  '{ List(${Expr.ofSeq(List(1, 2, 3))}: _*) } // equvalent to '{ List(1, 2, 3) }
    *  ```
    */
-  def ofSeq[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
-    import qctx.tasty.{_, given _}
-    Repeated(xs.map[Term](_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
-  }
-
+  def ofSeq[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = Exprs(xs)
 
   /** Lifts this list of expressions into an expression of a list
    *
@@ -128,7 +120,7 @@ object Expr {
    *    `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]`
    */
   def  ofList[T](xs: Seq[Expr[T]])(using Type[T], QuoteContext): Expr[List[T]] =
-    if (xs.isEmpty) '{ Nil } else '{ List(${ofSeq(xs)}: _*) }
+    if (xs.isEmpty) '{ Nil } else '{ List(${Exprs(xs)}: _*) }
 
   /** Lifts this sequence of expressions into an expression of a tuple
    *
@@ -186,7 +178,7 @@ object Expr {
       case Seq('{ $x1: $t1 }, '{ $x2: $t2 }, '{ $x3: $t3 }, '{ $x4: $t4 }, '{ $x5: $t5 }, '{ $x6: $t6 }, '{ $x7: $t7 }, '{ $x8: $t8 }, '{ $x9: $t9 }, '{ $x10: $t10 }, '{ $x11: $t11 }, '{ $x12: $t12 }, '{ $x13: $t13 }, '{ $x14: $t14 }, '{ $x15: $t15 }, '{ $x16: $t16 }, '{ $x17: $t17 }, '{ $x18: $t18 }, '{ $x19: $t19 }, '{ $x20: $t20 }, '{ $x21: $t21 }, '{ $x22: $t22 }) =>
         '{ Tuple22($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19, $x20, $x21, $x22) }
       case _ =>
-        '{ Tuple.fromIArray(IArray(${ofSeq(seq)}: _*)) }
+        '{ Tuple.fromIArray(IArray(${Exprs(seq)}: _*)) }
     }
   }
 

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

@@ -1,15 +1,32 @@
 package scala.quoted
 
 /** Literal sequence of expressions */
-object ExprSeq {
+object Exprs {
+
+  /** Lifts this sequence of expressions into an expression of a sequence
+   *
+   *  Transforms a sequence of expression
+   *    `Seq(e1, e2, ...)` where `ei: Expr[T]`
+   *  to an expression equivalent to
+   *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
+   *
+   *  Usage:
+   *  ```scala
+   *  '{ List(${Exprs(List(1, 2, 3))}: _*) } // equvalent to '{ List(1, 2, 3) }
+   *  ```
+   */
+  def apply[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
+    import qctx.tasty.{_, given _}
+    Repeated(xs.map[Term](_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
+  }
 
   /** Matches a literal sequence of expressions and return a sequence of expressions.
    *
    *  Usage:
    *  ```scala
    *  inline def sum(args: Int*): Int = ${ sumExpr('args) }
    *  def sumExpr(argsExpr: Expr[Seq[Int]])(using QuoteContext): Expr[Int] = argsExpr match
-   *    case ExprSeq(argExprs) =>
+   *    case Exprs(argExprs) =>
    *      // argExprs: Seq[Expr[Int]]
    *      ...
    *  }

library/src/scala/quoted/ValueSeq.scala

@@ -16,7 +16,7 @@ object ValueSeq {
    *  ```
    */
   def unapply[T](expr: Expr[Seq[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] = expr match {
-    case ExprSeq(elems) =>
+    case Exprs(elems) =>
       elems.foldRight(Option(List.empty[T])) { (elem, acc) =>
         (elem, acc) match {
           case (Value(value), Some(lst)) => Some(value :: lst)

library/src/scala/quoted/matching/package.scala

@@ -20,8 +20,8 @@ package object matching {
   @deprecated("use scala.quoted.ConstSeq instead", "0.23.0")
   val ConstSeq: quoted.ConstSeq.type = quoted.ConstSeq
 
-  @deprecated("use scala.quoted.ExprSeq instead", "0.23.0")
-  val ExprSeq: quoted.ExprSeq.type = quoted.ExprSeq
+  @deprecated("use scala.quoted.Exprs instead", "0.23.0")
+  val ExprSeq: quoted.Exprs.type = quoted.Exprs
 
   @deprecated("use scala.quoted.Lambda instead", "0.23.0")
   val Lambda: quoted.Lambda.type = quoted.Lambda

tests/neg-macros/i6432/Macro_1.scala

@@ -9,7 +9,7 @@ object Macro {
   def impl(sc: Expr[StringContext])(using qctx: QuoteContext) : Expr[Unit] = {
     import qctx.tasty._
     sc match {
-      case '{ StringContext(${ExprSeq(parts)}: _*) } =>
+      case '{ StringContext(${Exprs(parts)}: _*) } =>
         for (part @ Const(s) <- parts)
           error(s, part.unseal.pos)
     }

tests/neg-macros/i6432b/Macro_1.scala

@@ -9,7 +9,7 @@ object Macro {
   def impl(sc: Expr[StringContext])(using qctx: QuoteContext) : Expr[Unit] = {
     import qctx.tasty._
     sc match {
-      case '{ StringContext(${ExprSeq(parts)}: _*) } =>
+      case '{ StringContext(${Exprs(parts)}: _*) } =>
         for (part @ Const(s) <- parts)
           error(s, part.unseal.pos)
     }

tests/neg/i6436.check

@@ -1,5 +1,5 @@
 -- Error: tests/neg/i6436.scala:5:9 ------------------------------------------------------------------------------------
-5 |    case '{ StringContext(${ExprSeq(parts)}: _*) } => // error
+5 |    case '{ StringContext(${Exprs(parts)}: _*) } => // error
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |         no implicit argument of type scala.quoted.QuoteContext was found
 -- [E006] Unbound Identifier Error: tests/neg/i6436.scala:6:34 ---------------------------------------------------------