Rename extractors in quoted.matching to avoid conflicts with tasty.Reflect

library/src/scala/quoted/matching/Literal.scala → library/src/scala/quoted/matching/Const.scala

@@ -4,28 +4,28 @@ import scala.quoted.Expr
 
 import scala.tasty.Reflection // TODO do not depend on reflection directly
 
-/** Matches expressions containing literal values and extracts the value.
+/** Matches expressions containing literal constant values and extracts the value.
  *  It may match expressions of type Boolean, Byte, Short, Int, Long,
  *  Float, Double, Char, String, ClassTag, scala.Symbol, Null and Unit.
  *
  *  Usage:
  *  ```
  *  (x: Expr[B]) match {
- *    case Literal(value: B) => ...
+ *    case Const(value: B) => ...
  *  }
  *  ```
  */
-object Literal {
+object Const {
 
   def unapply[T](expr: Expr[T])(implicit reflect: Reflection): Option[T] = {
-    import reflect.{Literal => LiteralTree, _} // TODO rename reflect.Literal to avoid this clash
-    def literal(tree: Term): Option[T] = tree match {
-      case LiteralTree(c) => Some(c.value.asInstanceOf[T])
-      case Block(Nil, e) => literal(e)
-      case Inlined(_, Nil, e) => literal(e)
+    import reflect._
+    def rec(tree: Term): Option[T] = tree match {
+      case Literal(c) => Some(c.value.asInstanceOf[T])
+      case Block(Nil, e) => rec(e)
+      case Inlined(_, Nil, e) => rec(e)
       case _  => None
     }
-    literal(expr.unseal)
+    rec(expr.unseal)
   }
 
 }

library/src/scala/quoted/matching/ExprSeq.scala

@@ -0,0 +1,22 @@
+package scala.quoted.matching
+
+import scala.quoted.Expr
+
+import scala.tasty.Reflection // TODO do not depend on reflection directly
+
+/** Literal sequence of expressions */
+object ExprSeq {
+
+  /** Matches a literal sequence of expressions */
+  def unapply[T](expr: Expr[Seq[T]])(implicit reflect: Reflection): Option[Seq[Expr[T]]] = {
+    import reflect._
+    def rec(tree: Term): Option[Seq[Expr[T]]] = tree match {
+      case Typed(Repeated(elems, _), _) => Some(elems.map(x => x.seal.asInstanceOf[Expr[T]]))
+      case Block(Nil, e) => rec(e)
+      case Inlined(_, Nil, e) => rec(e)
+      case _  => None
+    }
+    rec(expr.unseal)
+  }
+
+}

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

@@ -9,9 +9,9 @@ object Macros {
 
   private def impl(self: Expr[StringContext], args: Expr[Seq[String]])(implicit reflect: Reflection): Expr[String] = {
     (self, args) match {
-      case ('{ StringContext(${Repeated(parts)}: _*) }, Repeated(args1)) =>
-        val strParts = parts.map { case Literal(str) => str.reverse }
-        val strArgs = args1.map { case Literal(str) => str }
+      case ('{ StringContext(${ExprSeq(parts)}: _*) }, ExprSeq(args1)) =>
+        val strParts = parts.map { case Const(str) => str.reverse }
+        val strArgs = args1.map { case Const(str) => str }
         StringContext(strParts: _*).s(strArgs: _*).toExpr
       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]])(implicit reflect: Reflection): Expr[String] = {
     self match {
-      case '{ StringContext(${Repeated(parts)}: _*) } =>
+      case '{ StringContext(${ExprSeq(parts)}: _*) } =>
         val parts2 = parts.map(x => '{ $x.reverse }).toList.toExprOfList
         '{ StringContext($parts2: _*).s($args: _*) }
       case _ =>

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

@@ -13,7 +13,7 @@ object Macros {
 
     def lift(e: Expr[DSL]): Expr[T] = e match {
 
-      case '{ LitDSL(${ Literal(c) }) } =>
+      case '{ LitDSL(${ Const(c) }) } =>
       // case scala.internal.quoted.Matcher.unapply[Tuple1[Expr[Int]]](Tuple1(Literal(c)))(/*implicits*/ '{ LitDSL(patternHole[Int]) }, reflect) =>
         '{ $sym.value(${c.toExpr}) }
 

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

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

tests/run-macros/tasty-extractors-constants-1/quoted_1.scala

@@ -15,12 +15,12 @@ object Macros {
     val buff = new StringBuilder
     def stagedPrintln(x: Any): Unit = buff append java.util.Objects.toString(x) append "\n"
 
-    3.toExpr match { case Literal(n) => stagedPrintln(n) }
-    '{4} match { case Literal(n) => stagedPrintln(n) }
-    '{"abc"} match { case Literal(n) => stagedPrintln(n) }
-    '{null} match { case Literal(n) => stagedPrintln(n) }
+    3.toExpr match { case Const(n) => stagedPrintln(n) }
+    '{4} match { case Const(n) => stagedPrintln(n) }
+    '{"abc"} match { case Const(n) => stagedPrintln(n) }
+    '{null} match { case Const(n) => stagedPrintln(n) }
 
-    '{new Object} match { case Literal(n) => println(n); case _ => stagedPrintln("OK") }
+    '{new Object} match { case Const(n) => println(n); case _ => stagedPrintln("OK") }
 
     '{print(${buff.result()})}
   }

tests/run-with-compiler/tasty-extractors-constants-2/quoted_1.scala

@@ -45,9 +45,9 @@ object Macros {
   }
 
   def power(n: Expr[Int], x: Expr[Double])(implicit reflect: Reflection): Expr[Double] = {
-    import quoted.matching.Literal
+    import quoted.matching.Const
     n match {
-      case Literal(n1) => powerCode(n1, x)
+      case Const(n1) => powerCode(n1, x)
       case _ => '{ dynamicPower($n, $x) }
     }
   }