Add TASTy Reflect Pattern.WildcardPattern

Wildcard are represented with Ident but are not valid terms. The current API exposed them an the contens on a Pattern.Value which advertives them as Terms. To avoid we add Pattern.WildcardPattern and stop returning them from Pattern.Value.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -916,7 +916,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def matchPattern_Value(pattern: Pattern): Option[Value] = pattern match {
     case lit: tpd.Literal => Some(lit)
-    case ref: tpd.RefTree if ref.isTerm => Some(ref)
+    case ref: tpd.RefTree if ref.isTerm && !tpd.isWildcardArg(ref) => Some(ref)
     case ths: tpd.This => Some(ths)
     case _ => None
   }
@@ -999,6 +999,18 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest =
     tpd.cpy.Typed(original)(untpd.Ident(nme.WILDCARD).withSpan(original.span).withType(tpt.tpe), tpt)
 
+  type WildcardPattern = tpd.Ident
+
+  def matchPattern_WildcardPattern(pattern: Pattern)(implicit ctx: Context): Option[WildcardPattern] = {
+    pattern match {
+      case pattern: tpd.Ident if tpd.isWildcardArg(pattern) => Some(pattern)
+      case _ => None
+    }
+  }
+
+  def Pattern_WildcardPattern_module_apply(tpe: TypeOrBounds)(implicit ctx: Context): WildcardPattern =
+    untpd.Ident(nme.WILDCARD).withType(tpe)
+
   //
   // TYPES
   //

compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala

@@ -66,7 +66,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       }
     }
     else {
-      assert(!enclosingInlineds.nonEmpty, "unexpanded macro")
+      assert(enclosingInlineds.isEmpty, "unexpanded macro")
       assert(ctx.owner.isInlineMethod)
       if (Splicer.canBeSpliced(body)) { // level 0 inside an inline definition
         transform(body)(spliceContext) // Just check PCP

docs/docs/reference/other-new-features/tasty-reflect.md

@@ -139,6 +139,7 @@ TASTy Reflect provides the following types:
              +- Unapply
              +- Alternative
              +- TypeTest
+             +- WildcardPattern
 
 
                  +- NoPrefix

library/src-bootstrapped/scala/internal/quoted/Matcher.scala

@@ -246,6 +246,9 @@ object Matcher {
       case (Pattern.TypeTest(tpt1), Pattern.TypeTest(tpt2)) =>
         (env, treeMatches(tpt1, tpt2))
 
+      case (Pattern.WildcardPattern(), Pattern.WildcardPattern()) =>
+        (env, Some(()))
+
       case _ =>
         if (debug)
           println(

library/src/scala/tasty/reflect/Core.scala

@@ -62,6 +62,7 @@ package scala.tasty.reflect
  *               +- Unapply
  *               +- Alternatives
  *               +- TypeTest
+ *               +- WildcardPattern
  *
  *
  *                   +- NoPrefix
@@ -304,6 +305,9 @@ trait Core {
     /** Pattern representing a `x: Y` type test. */
     type TypeTest = kernel.TypeTest
 
+    /** Pattern representing a `_` pattern */
+    type WildcardPattern = kernel.WildcardPattern
+
   /** Type or bounds */
   type TypeOrBounds = kernel.TypeOrBounds
 

library/src/scala/tasty/reflect/Kernel.scala

@@ -61,6 +61,7 @@ package scala.tasty.reflect
  *               +- Unapply
  *               +- Alternatives
  *               +- TypeTest
+ *               +- WildcardPattern
  *
  *
  *                   +- NoPrefix
@@ -791,6 +792,13 @@ trait Kernel {
   def Pattern_TypeTest_module_apply(tpt: TypeTree)(implicit ctx: Context): TypeTest
   def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest
 
+  /** Pattern representing a `_` pattern */
+  type WildcardPattern <: Pattern
+
+  def matchPattern_WildcardPattern(pattern: Pattern)(implicit ctx: Context): Option[WildcardPattern]
+
+  def Pattern_WildcardPattern_module_apply(tpe: TypeOrBounds)(implicit ctx: Context): WildcardPattern
+
   //
   // TYPES
   //

library/src/scala/tasty/reflect/PatternOps.scala

@@ -105,6 +105,18 @@ trait PatternOps extends Core {
         kernel.matchPattern_TypeTest(pattern).map(_.tpt)
     }
 
+    object IsWildcardPattern {
+      def unapply(pattern: Pattern)(implicit ctx: Context): Option[WildcardPattern] =
+        kernel.matchPattern_WildcardPattern(pattern)
+    }
+
+    object WildcardPattern {
+      def apply(tpe: TypeOrBounds)(implicit ctx: Context): WildcardPattern =
+        kernel.Pattern_WildcardPattern_module_apply(tpe)
+      def unapply(pattern: Pattern)(implicit ctx: Context): Boolean =
+        kernel.matchPattern_WildcardPattern(pattern).isDefined
+    }
+
   }
 
 }

library/src/scala/tasty/reflect/Printers.scala

@@ -256,6 +256,8 @@ trait Printers
           this += "Pattern.Alternative(" ++= patterns += ")"
         case Pattern.TypeTest(tpt) =>
           this += "Pattern.TypeTest(" += tpt += ")"
+        case Pattern.WildcardPattern() =>
+          this += "Pattern.WildcardPattern()"
       }
 
       def visitConstant(x: Constant): Buffer = x match {
@@ -1293,12 +1295,12 @@ trait Printers
 
       def printPattern(pattern: Pattern): Buffer = pattern match {
         case Pattern.Value(v) =>
-          v match {
-            case Ident("_") => this += "_"
-            case _ => printTree(v)
-          }
+          printTree(v)
+
+        case Pattern.WildcardPattern() =>
+          this += "_"
 
-        case Pattern.Bind(name, Pattern.Value(Ident("_"))) =>
+        case Pattern.Bind(name, Pattern.WildcardPattern()) =>
           this += name
 
         case Pattern.Bind(name, Pattern.TypeTest(tpt)) =>

library/src/scala/tasty/reflect/TreeUtils.scala

@@ -102,6 +102,7 @@ trait TreeUtils
       case Pattern.Unapply(fun, implicits, patterns) => foldPatterns(foldTrees(foldTree(x, fun), implicits), patterns)
       case Pattern.Alternatives(patterns) => foldPatterns(x, patterns)
       case Pattern.TypeTest(tpt) => foldTree(x, tpt)
+      case Pattern.WildcardPattern() => x
     }
 
   }
@@ -243,7 +244,7 @@ trait TreeUtils
     }
 
     def transformPattern(pattern: Pattern)(implicit ctx: Context): Pattern = pattern match {
-      case Pattern.Value(_) =>
+      case Pattern.Value(_) | Pattern.WildcardPattern() =>
         pattern
       case Pattern.IsTypeTest(pattern) =>
         Pattern.TypeTest.copy(pattern)(transformTypeTree(pattern.tpt))

tests/run-custom-args/Yretain-trees/tasty-definitions-2.check

@@ -1,3 +1,3 @@
 DefDef("foo", Nil, Nil, TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(1)), "+"), List(Literal(Constant.Int(2))))))
 ValDef("bar", TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(2)), "+"), List(Literal(Constant.Int(3))))))
-Pattern.Bind("x", Pattern.Value(Ident("_")))
+Pattern.Bind("x", Pattern.WildcardPattern())