Add quoted.Expr.{ofSeq, ofList}

Also
* Let `ofList` receive a `Seq`
* Remove `toExprOfSeq` and `toExprOfList`

Author: nicolasstucki

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

@@ -110,12 +110,12 @@ object Liftable {
 
   given [T: Type: Liftable] : Liftable[Seq[T]] = new Liftable[Seq[T]] {
     def toExpr(xs: Seq[T]): (given QuoteContext) => Expr[Seq[T]] =
-      xs.map(summon[Liftable[T]].toExpr).toExprOfSeq
+      Expr.ofSeq(xs.map(summon[Liftable[T]].toExpr))
   }
 
   given [T: Type: Liftable] : Liftable[List[T]] = new Liftable[List[T]] {
     def toExpr(xs: List[T]): (given QuoteContext) => Expr[List[T]] =
-      xs.map(summon[Liftable[T]].toExpr).toExprOfList
+      Expr.ofList(xs.map(summon[Liftable[T]].toExpr))
   }
 
   given [T: Type: Liftable] : Liftable[Set[T]] = new Liftable[Set[T]] {

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

@@ -9,33 +9,6 @@ package object quoted {
   implicit object ExprOps {
     def (x: T) toExpr[T: Liftable](given QuoteContext): Expr[T] = summon[Liftable[T]].toExpr(x)
 
-   /** 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(${List(1, 2, 3).toExprOfSeq}: _*) } // equvalent to '{ List(1, 2, 3) }
-    *  ```
-    */
-    def (seq: Seq[Expr[T]]) toExprOfSeq[T](given tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
-      import qctx.tasty._
-      Repeated(seq.map(_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
-    }
-
-    /** Lifts this list of expressions into an expression of a list
-     *
-     *  Transforms a list of expression
-     *    `List(e1, e2, ...)` where `ei: Expr[T]`
-     *  to an expression equivalent to
-     *    `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]`
-     */
-    def (list: List[Expr[T]]) toExprOfList[T](given Type[T], QuoteContext): Expr[List[T]] =
-      if (list.isEmpty) '{ Nil } else '{ List(${list.toExprOfSeq}: _*) }
-
     /** Lifts this sequence of expressions into an expression of a tuple
      *
      *  Transforms a sequence of expression
@@ -92,7 +65,7 @@ package object quoted {
         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(${seq.toExprOfSeq}: _*)) }
+          '{ Tuple.fromIArray(IArray(${Expr.ofSeq(seq)}: _*)) }
       }
     }
 

library/src/scala/quoted/Expr.scala

@@ -65,6 +65,34 @@ package quoted {
       Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[Expr[T]]
     }
 
+    /** 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(${Expr.ofSeq(List(1, 2, 3))}: _*) } // equvalent to '{ List(1, 2, 3) }
+     *  ```
+     */
+    def ofSeq[T](xs: Seq[Expr[T]])(given tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
+      import qctx.tasty._
+      Repeated(xs.map(_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
+    }
+
+
+    /** Lifts this list of expressions into an expression of a list
+     *
+     *  Transforms a list of expression
+     *    `List(e1, e2, ...)` where `ei: Expr[T]`
+     *  to an expression equivalent to
+     *    `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]`
+     */
+    def  ofList[T](xs: Seq[Expr[T]])(given Type[T], QuoteContext): Expr[List[T]] =
+      if (xs.isEmpty) '{ Nil } else '{ List(${ofSeq(xs)}: _*) }
+
   }
 
 }

tests/run-macros/f-interpolator-neg/Macros_1.scala

@@ -69,6 +69,6 @@ object Macro {
     }
     val parts = parts0.map { case Const(s) => s }
     dotty.internal.StringContextMacro.interpolate(parts.toList, args.toList, argsExpr, reporter) // Discard result
-    errors.result().toExprOfList
+    Expr.ofList(errors.result())
   }
 }

tests/run-macros/i6765-b/Macro_1.scala

@@ -4,6 +4,6 @@ import scala.quoted.given
 inline def foo = ${fooImpl}
 
 def fooImpl(given qctx: QuoteContext) = {
-  val res = List('{"One"}).toExprOfList
+  val res = Expr.ofList(List('{"One"}))
   res.show.toExpr
 }

tests/run-macros/i6765-c/Macro_1.scala

@@ -4,6 +4,6 @@ import scala.quoted.given
 inline def foo(inline n: Int) = ${fooImpl(n)}
 
 def fooImpl(n: Int)(given qctx: QuoteContext) = {
-  val res = List.tabulate(n)(i => ("#" + i).toExpr).toExprOfList
+  val res = Expr.ofList(List.tabulate(n)(i => ("#" + i).toExpr))
   '{ ${res.show.toExpr} + "\n" + $res.toString + "\n" }
 }

tests/run-macros/i6765/Macro_1.scala

@@ -5,6 +5,6 @@ inline def foo = ${fooImpl}
 
 def fooImpl(given qctx: QuoteContext) = {
   import qctx.tasty._
-  val res = List('{"One"}).toExprOfList
+  val res = Expr.ofList(List('{"One"}))
   res.show.toExpr
 }

tests/run-macros/i7008/macro_1.scala

@@ -14,6 +14,6 @@ def mcrProxy(expr: Expr[Boolean])(given QuoteContext): Expr[Unit] = {
 
 def mcrImpl[T](func: Expr[Seq[Box[T]] => Unit], expr: Expr[T])(given ctx: QuoteContext, tt: Type[T]): Expr[Unit] = {
   import ctx.tasty._
-  val arg = Seq('{(Box($expr))}).toExprOfSeq
+  val arg = Expr.ofSeq(Seq('{(Box($expr))}))
   func(arg)
 }

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

@@ -10,7 +10,7 @@ object Macros {
     self match {
       case '{ StringContext(${ConstSeq(parts)}: _*) } =>
         val upprerParts: List[String] = parts.toList.map(_.toUpperCase)
-        val upprerPartsExpr: Expr[List[String]] = upprerParts.map(_.toExpr).toExprOfList
+        val upprerPartsExpr: Expr[List[String]] = Expr.ofList(upprerParts.map(_.toExpr))
         '{ StringContext($upprerPartsExpr: _*).s($args: _*) }
       case _ =>
         '{

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

@@ -9,7 +9,7 @@ object Macros {
   private def impl(self: Expr[StringContext], args: Expr[Seq[String]])(given QuoteContext): Expr[String] = {
     self match {
       case '{ StringContext(${ExprSeq(parts)}: _*) } =>
-        val parts2 = parts.map(x => '{ $x.reverse }).toList.toExprOfList
+        val parts2 = Expr.ofList(parts.map(x => '{ $x.reverse }))
         '{ StringContext($parts2: _*).s($args: _*) }
       case _ =>
         '{ "ERROR" }

tests/run-macros/quote-toExprOfSeq/Macro_1.scala

@@ -4,5 +4,5 @@ import scala.quoted.given
 inline def seq = ${fooImpl}
 
 def fooImpl(given qctx: QuoteContext) = {
-  List('{1}, '{2}, '{3}).toExprOfSeq
+  Expr.ofSeq(List('{1}, '{2}, '{3}))
 }

tests/run-macros/tasty-interpolation-1/Macro.scala

@@ -15,17 +15,17 @@ object Macro {
 
 object SIntepolator extends MacroStringInterpolator[String] {
   protected def interpolate(strCtx: StringContext, args: List[Expr[Any]])(given QuoteContext): Expr[String] =
-    '{(${strCtx}).s(${args.toExprOfList}: _*)}
+    '{(${strCtx}).s(${Expr.ofList(args)}: _*)}
 }
 
 object RawIntepolator extends MacroStringInterpolator[String] {
   protected def interpolate(strCtx: StringContext, args: List[Expr[Any]])(given QuoteContext): Expr[String] =
-    '{(${strCtx}).raw(${args.toExprOfList}: _*)}
+    '{(${strCtx}).raw(${Expr.ofList(args)}: _*)}
 }
 
 object FooIntepolator extends MacroStringInterpolator[String] {
   protected def interpolate(strCtx: StringContext, args: List[Expr[Any]])(given QuoteContext): Expr[String] =
-    '{(${strCtx}).s(${args.map(_ => '{"foo"}).toExprOfList}: _*)}
+    '{(${strCtx}).s(${Expr.ofList(args.map(_ => '{"foo"}))}: _*)}
 }
 
 // TODO put this class in the stdlib or separate project?

tests/run-macros/tasty-simplified/quoted_1.scala

@@ -19,6 +19,6 @@ object Macros {
     }
 
     val tps = unpackTuple(typeOf[T])
-    tps.map(_.show.toExpr).toExprOfSeq
+    Expr.ofSeq(tps.map(_.show.toExpr))
   }
 }

tests/run-macros/tasty-string-interpolation-reporter-test/Macros_1.scala

@@ -44,7 +44,7 @@ object Macro {
           }
         }
         fooCore(parts, args, reporter) // Discard result
-        errors.result().toExprOfList
+        Expr.ofList(errors.result())
     }
 
 
@@ -58,7 +58,7 @@ object Macro {
         reporter.errorOnPart("Cannot use #", idx)
     }
 
-    '{ StringContext(${parts.toList.toExprOfList}: _*).s(${args.toList.toExprOfList}: _*) }
+    '{ StringContext(${Expr.ofList(parts)}: _*).s(${Expr.ofList(args)}: _*) }
   }
 
 

tests/run-macros/xml-interpolation-2/XmlQuote_1.scala

@@ -59,7 +59,7 @@ object XmlQuote {
     // [a0, ...]: Any*
     val args2: Expr[List[Any]] = args.unseal.underlyingArgument match {
       case Typed(Repeated(args0, _), _) => // statically known args, make list directly
-        args0.map(_.seal).toExprOfList
+        Expr.ofList(args0.map(_.seal))
       case _ =>
         '{$args.toList}