Fix Reflection wildcard abstraction

Currently we are missing in the API the Wilcard concept for `case _ =>` patterns.
These are encoded as term `Ident` with name `_`. Currently this tree can be inconsitently
 matched by `Ident` or `WildcardTypeTree`. There is also no way to create an `Ident(_)`.
`TypeIdent` is the only one that works as expected.

Changes
* `Ident` does not match `Ident(_)`
* `WildcardTypeTree` does not match `Ident(_)` if it is a term
* Add `Wildcard` type that matches a term `Ident(_)`

Fixes scala#12188

Author: nicolasstucki

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

@@ -422,7 +422,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object IdentTypeTest extends TypeTest[Tree, Ident]:
       def unapply(x: Tree): Option[Ident & x.type] = x match
-        case x: (tpd.Ident & x.type) if x.isTerm => Some(x)
+        case x: (tpd.Ident & x.type) if x.isTerm && x.name != nme.WILDCARD => Some(x)
         case _ => None
     end IdentTypeTest
 
@@ -1021,7 +1021,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object TypeIdentTypeTest extends TypeTest[Tree, TypeIdent]:
       def unapply(x: Tree): Option[TypeIdent & x.type] = x match
-        case tpt: (tpd.Ident & x.type) if tpt.isType => Some(tpt)
+        case tpt: (tpd.Ident & x.type) if tpt.isType && tpt.name != nme.WILDCARD => Some(tpt)
         case _ => None
     end TypeIdentTypeTest
 
@@ -1335,7 +1335,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object WildcardTypeTreeTypeTest extends TypeTest[Tree, WildcardTypeTree]:
       def unapply(x: Tree): Option[WildcardTypeTree & x.type] = x match
-        case x: (tpd.Ident & x.type) if x.name == nme.WILDCARD => Some(x)
+        case x: (tpd.Ident & x.type) if x.isType && x.name == nme.WILDCARD => Some(x)
         case _ => None
     end WildcardTypeTreeTypeTest
 
@@ -1399,6 +1399,21 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       end extension
     end TypeCaseDefMethods
 
+
+    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 Bind = tpd.Bind
 
     object BindTypeTest extends TypeTest[Tree, Bind]:

compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala

@@ -165,6 +165,8 @@ object Extractors {
         this += "CaseDef(" += pat += ", " += guard += ", " += body += ")"
       case TypeCaseDef(pat, body) =>
         this += "TypeCaseDef(" += pat += ", " += body += ")"
+      case Wildcard() =>
+        this += "Wildcard()"
       case Bind(name, body) =>
         this += "Bind(\"" += name += "\", " += body += ")"
       case Unapply(fun, implicits, patterns) =>

compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala

@@ -530,6 +530,9 @@ object SourceCode {
       case Closure(meth, _) =>
         printTree(meth)
 
+      case Wildcard() =>
+        this += "_"
+
       case _ =>
         throw new MatchError(tree.show(using Printer.TreeStructure))
 

library/src/scala/quoted/Quotes.scala

@@ -157,6 +157,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
    *           +- CaseDef
    *           |
    *           +- TypeCaseDef
+   *           +- Wildcard
    *           +- Bind
    *           +- Unapply
    *           +- Alternatives
@@ -2020,6 +2021,21 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
     // ----- Patterns ------------------------------------------------
 
+    /** Pattern representing a `_` wildcard. */
+    type Wildcard <: Tree
+
+    /** `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 =>
+      def apply(): Wildcard
+      def unapply(pattern: Wildcard): true
+    }
+
     /** Pattern representing a `_ @ _` binding. */
     type Bind <: Tree
 

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,6 @@
+
+def test(a: Int) = MatchTest.test {
+  a match
+    case 1 =>
+    case _ =>
+}

tests/run-macros/i12188.check

@@ -0,0 +1,3 @@
+PC1
+PC2
+default

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))