Add Wildcard in reflection

This allows the creation of wildcard trees `_` in the refection API

Author: nicolasstucki

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -448,6 +448,20 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       end extension
     end IdentMethods
 
+    type Wildcard = tpd.Ident
+
+    object WildcardTypeTest extends TypeTest[Tree, Wildcard]:
+      def unapply(x: Tree): Option[Wildcard & x.type] = x match
+        case x: (tpd.Ident & x.type) if x.name == nme.WILDCARD => Some(x)
+        case _ => None
+    end WildcardTypeTest
+
+    object Wildcard extends WildcardModule:
+      def apply(): Wildcard =
+        withDefaultPos(untpd.Ident(nme.WILDCARD).withType(dotc.core.Symbols.defn.AnyType))
+      def unapply(pattern: Wildcard): true = true
+    end Wildcard
+
     type Select = tpd.Select
 
     object SelectTypeTest extends TypeTest[Tree, Select]:

library/src/scala/quoted/Quotes.scala

@@ -123,7 +123,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
    *           |             |               +- DefDef
    *           |             |               +- ValDef
    *           |             |
-   *           |             +- Term --------+- Ref -+- Ident
+   *           |             +- Term --------+- Ref -+- Ident -+- Wildcard
    *           |                             |       +- Select
    *           |                             |
    *           |                             +- Literal
@@ -784,6 +784,23 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       end extension
     end IdentMethods
 
+    /** Pattern representing a `_` wildcard. */
+    type Wildcard <: Ident
+
+    /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Wildcard` */
+    given WildcardTypeTest: TypeTest[Tree, Wildcard]
+
+    /** Module object of `type Wildcard`  */
+    val Wildcard: WildcardModule
+
+    /** Methods of the module object `val Wildcard` */
+    trait WildcardModule { this: Wildcard.type =>
+      /** Create a tree representing a `_` wildcard. */
+      def apply(): Wildcard
+      /** Match a tree representing a `_` wildcard. */
+      def unapply(wildcard: Wildcard): true
+    }
+
     /** Tree representing a selection of definition with a given name on a given prefix */
     type Select <: Ref
 

tests/pos-macros/i12188b/Macro_1.scala

@@ -0,0 +1,13 @@
+import scala.quoted.*
+
+object MatchTest {
+  inline def test[T](inline obj: Any): Unit = ${testImpl('obj)}
+
+  def testImpl[T](objExpr: Expr[T])(using Quotes): Expr[Unit] = {
+    import quotes.reflect.*
+    // test that the extractors work
+    val Inlined(None, Nil, Block(Nil, Match(param @ Ident("a"), List(CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))), CaseDef(Wildcard(), None, Block(Nil, Literal(UnitConstant()))))))) = objExpr.asTerm
+    // test that the constructors work
+    Block(Nil, Match(param, List(CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))), CaseDef(Wildcard(), None, Block(Nil, Literal(UnitConstant())))))).asExprOf[Unit]
+  }
+}

tests/pos-macros/i12188b/Test_2.scala

@@ -0,0 +1,5 @@
+def test(a: Int) = MatchTest.test {
+  a match
+    case 1 =>
+    case _ =>
+}

tests/pos-macros/i12188c/Macro_1.scala

@@ -0,0 +1,14 @@
+import scala.quoted.*
+
+object MatchTest {
+  inline def test(a: Int): Unit = ${testImpl('a)}
+
+  def testImpl(a: Expr[Any])(using Quotes): Expr[Unit] = {
+    import quotes.reflect.*
+    val matchTree = Match(a.asTerm, List(
+      CaseDef(Literal(IntConstant(1)), None, Block(Nil, Literal(UnitConstant()))),
+      CaseDef(Alternatives(List(Literal(IntConstant(2)), Literal(IntConstant(3)), Literal(IntConstant(4)))), None, Block(Nil, Literal(UnitConstant()))),
+      CaseDef(Typed(Wildcard(), TypeIdent(defn.IntClass)), None, Block(Nil, Literal(UnitConstant())))))
+    matchTree.asExprOf[Unit]
+  }
+}

tests/pos-macros/i12188c/Test_2.scala

@@ -0,0 +1 @@
+def test(a: Int) = MatchTest.test(a)

tests/run-macros/i12188/Macro_1.scala

@@ -0,0 +1,23 @@
+import scala.quoted.*
+
+object MatchTest {
+  inline def test[T](inline obj: T): String = ${testImpl('obj)}
+
+  def testImpl[T](objExpr: Expr[T])(using qctx: Quotes, t: Type[T]): Expr[String] = {
+    import qctx.reflect.*
+
+    val obj = objExpr.asTerm
+    val cases = obj.tpe.typeSymbol.children.map { child =>
+      val subtype = TypeIdent(child)
+      val bind = Symbol.newBind(Symbol.spliceOwner, "c", Flags.EmptyFlags, subtype.tpe)
+      CaseDef(Bind(bind, Typed(Ref(bind), subtype)), None, Literal(StringConstant(subtype.show)))
+    } ::: {
+      CaseDef(Wildcard(), None, Literal(StringConstant("default")))
+    } :: Nil
+    val bind = Symbol.newBind(Symbol.spliceOwner, "o", Flags.EmptyFlags, obj.tpe)
+    val result = Match(obj, cases)
+    val code = result.show(using Printer.TreeAnsiCode)
+    // println(code)
+    result.asExprOf[String]
+  }
+}

tests/run-macros/i12188/Test_2.scala

@@ -0,0 +1,8 @@
+sealed trait P
+case class PC1(a: String) extends P
+case class PC2(b: Int) extends P
+
+@main def Test =
+  println(MatchTest.test(PC1("ab"): P))
+  println(MatchTest.test(PC2(10): P))
+  println(MatchTest.test(null: P))