Add support for pattern matching on definition identifiers

Introduces `Binding[T]` which can be used to match a check is an `Expr` is a reference to some
other binding defined in scope.

```scala
  case '{ val $x: Int = ($body: Int) } => // where x: Binding[Int]
  case '{ (`$x`: Int) => ($body: Int) } => // where x: Binding[Int]
  case Binding(b) => // where b: Binding[Int]
```

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -139,7 +139,8 @@ object desugar {
    *    def x: Int = expr
    *    def x_=($1: <TypeTree()>): Unit = ()
    */
-  def valDef(vdef: ValDef)(implicit ctx: Context): Tree = {
+  def valDef(vdef0: ValDef)(implicit ctx: Context): Tree = {
+    val vdef = transformQuotedPatternName(vdef0)
     val ValDef(name, tpt, rhs) = vdef
     val mods = vdef.mods
     val setterNeeded =
@@ -164,6 +165,14 @@ object desugar {
     else vdef
   }
 
+  def transformQuotedPatternName(vdef: ValDef)(implicit ctx: Context): ValDef = {
+    if (ctx.mode.is(Mode.QuotedPattern) && vdef.name.startsWith("$")) {
+      val name = vdef.name.toString.substring(1).toTermName
+      val mods = vdef.mods.withAddedAnnotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(vdef.span))
+      cpy.ValDef(vdef)(name).withMods(mods)
+    } else vdef
+  }
+
   def makeImplicitParameters(tpts: List[Tree], contextualFlag: FlagSet = EmptyFlags, forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
     for (tpt <- tpts) yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -722,6 +722,7 @@ class Definitions {
     def InternalQuoted_typeQuote(implicit ctx: Context): Symbol = InternalQuoted_typeQuoteR.symbol
     lazy val InternalQuoted_patternHoleR: TermRef = InternalQuotedModule.requiredMethodRef("patternHole")
     def InternalQuoted_patternHole(implicit ctx: Context): Symbol = InternalQuoted_patternHoleR.symbol
+    lazy val InternalQuoted_patternBindHoleAnnot: ClassSymbol = InternalQuotedModule.requiredClass("patternBindHole")
 
   lazy val InternalQuotedMatcherModuleRef: TermRef = ctx.requiredModuleRef("scala.internal.quoted.Matcher")
     def InternalQuotedMatcherModule(implicit ctx: Context): Symbol = InternalQuotedMatcherModuleRef.symbol
@@ -741,6 +742,9 @@ class Definitions {
   lazy val QuotedTypeModuleRef: TermRef = ctx.requiredModuleRef("scala.quoted.Type")
   def QuotedTypeModule(implicit ctx: Context): Symbol = QuotedTypeModuleRef.symbol
 
+  lazy val QuotedMatchingBindingType: TypeRef = ctx.requiredClassRef("scala.quoted.matching.Binding")
+  def QuotedMatchingBindingClass(implicit ctx: Context): ClassSymbol = QuotedMatchingBindingType.symbol.asClass
+
   def Unpickler_unpickleExpr: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
   def Unpickler_liftedExpr: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
   def Unpickler_unpickleType: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")

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

@@ -1786,6 +1786,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def Definitions_TupleClass(arity: Int): Symbol = defn.TupleType(arity).classSymbol.asClass
 
   def Definitions_InternalQuoted_patternHole: Symbol = defn.InternalQuoted_patternHole
+  def Definitions_InternalQuoted_patternBindHoleAnnot: Symbol = defn.InternalQuoted_patternBindHoleAnnot
 
   // Types
 

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1957,6 +1957,7 @@ class Typer extends Namer
   }
 
   def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (Tree, List[Tree]) = {
+    val ctx0 = ctx
     object splitter extends tpd.TreeMap {
       val patBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
@@ -1966,6 +1967,13 @@ class Typer extends Namer
         case Splice(pat) =>
           try patternHole(tree)
           finally patBuf += pat
+        case vdef: ValDef =>
+          if (vdef.symbol.annotations.exists(_.symbol == defn.InternalQuoted_patternBindHoleAnnot)) {
+            val tpe = AppliedType(defn.QuotedMatchingBindingType, vdef.tpt.tpe :: Nil)
+            val sym = ctx0.newPatternBoundSymbol(vdef.name, tpe, vdef.span)
+            patBuf += Bind(sym, untpd.Ident(nme.WILDCARD).withType(tpe)).withSpan(vdef.span)
+          }
+          super.transform(tree)
         case _ =>
           super.transform(tree)
       }

library/src-bootstrapped/scala/internal/Quoted.scala

@@ -1,5 +1,6 @@
 package scala.internal
 
+import scala.annotation.Annotation
 import scala.quoted._
 
 object Quoted {
@@ -19,4 +20,8 @@ object Quoted {
   /** A splice in a quoted pattern is desugared by the compiler into a call to this method */
   def patternHole[T]: T =
     throw new Error("Internal error: this method call should have been replaced by the compiler")
+
+  /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
+  class patternBindHole extends Annotation
+
 }

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

@@ -3,6 +3,7 @@ package scala.internal.quoted
 import scala.annotation.internal.sharable
 
 import scala.quoted._
+import scala.quoted.matching.Binding
 import scala.tasty._
 
 object Matcher {
@@ -51,6 +52,18 @@ object Matcher {
         sFlags.is(Lazy) == pFlags.is(Lazy) && sFlags.is(Mutable) == pFlags.is(Mutable)
       }
 
+      def bindingMatch(sym: Symbol) =
+        Some(Tuple1(new Binding(sym.name, sym)))
+
+      def hasBindingTypeAnnotation(tpt: TypeTree): Boolean = tpt match {
+        case Annotated(tpt2, Apply(Select(New(TypeIdent("patternBindHole")), "<init>"), Nil)) => true
+        case Annotated(tpt2, _) => hasBindingTypeAnnotation(tpt2)
+        case _ => false
+      }
+
+      def hasBindingAnnotation(sym: Symbol) =
+        sym.annots.exists { case Apply(Select(New(TypeIdent("patternBindHole")),"<init>"),List()) => true; case _ => true }
+
       def treesMatch(scrutinees: List[Tree], patterns: List[Tree]): Option[Tuple] =
         if (scrutinees.size != patterns.size) None
         else foldMatchings(scrutinees.zip(patterns).map(treeMatches): _*)
@@ -134,24 +147,30 @@ object Matcher {
           foldMatchings(treeMatches(tycon1, tycon2), treesMatch(args1, args2))
 
         case (ValDef(_, tpt1, rhs1), ValDef(_, tpt2, rhs2)) if checkValFlags() =>
+          val bindMatch =
+            if (hasBindingAnnotation(pattern.symbol) || hasBindingTypeAnnotation(tpt2)) bindingMatch(scrutinee.symbol)
+            else Some(())
           val returnTptMatch = treeMatches(tpt1, tpt2)
           val rhsEnv = env + (scrutinee.symbol -> pattern.symbol)
           val rhsMatchings = treeOptMatches(rhs1, rhs2)(rhsEnv)
-          foldMatchings(returnTptMatch, rhsMatchings)
+          foldMatchings(bindMatch, returnTptMatch, rhsMatchings)
 
         case (DefDef(_, typeParams1, paramss1, tpt1, Some(rhs1)), DefDef(_, typeParams2, paramss2, tpt2, Some(rhs2))) =>
           val typeParmasMatch = treesMatch(typeParams1, typeParams2)
           val paramssMatch =
             if (paramss1.size != paramss2.size) None
             else foldMatchings(paramss1.zip(paramss2).map { (params1, params2) => treesMatch(params1, params2) }: _*)
+          val bindMatch =
+            if (hasBindingAnnotation(pattern.symbol)) bindingMatch(scrutinee.symbol)
+            else Some(())
           val tptMatch = treeMatches(tpt1, tpt2)
           val rhsEnv =
             env + (scrutinee.symbol -> pattern.symbol) ++
-            typeParams1.zip(typeParams2).map((tparam1, tparam2) => tparam1.symbol -> tparam2.symbol) ++
-            paramss1.flatten.zip(paramss2.flatten).map((param1, param2) => param1.symbol -> param2.symbol)
+              typeParams1.zip(typeParams2).map((tparam1, tparam2) => tparam1.symbol -> tparam2.symbol) ++
+              paramss1.flatten.zip(paramss2.flatten).map((param1, param2) => param1.symbol -> param2.symbol)
           val rhsMatch = treeMatches(rhs1, rhs2)(rhsEnv)
 
-          foldMatchings(typeParmasMatch, paramssMatch, tptMatch, rhsMatch)
+          foldMatchings(bindMatch, typeParmasMatch, paramssMatch, tptMatch, rhsMatch)
 
         case (Lambda(_, tpt1), Lambda(_, tpt2)) =>
           // TODO match tpt1 with tpt2?
@@ -172,6 +191,10 @@ object Matcher {
           val finalizerMatch = treeOptMatches(finalizer1, finalizer2)
           foldMatchings(bodyMacth, casesMatch, finalizerMatch)
 
+        // Ignore type annotations
+        case (Annotated(tpt, _), _) => treeMatches(tpt, pattern)
+        case (_, Annotated(tpt, _)) => treeMatches(scrutinee, tpt)
+
         // No Match
         case _ =>
           if (debug)

library/src-non-bootstrapped/scala/internal/Quoted.scala

@@ -1,5 +1,6 @@
 package scala.internal
 
+import scala.annotation.Annotation
 import scala.quoted._
 
 object Quoted {
@@ -16,4 +17,11 @@ object Quoted {
   def typeQuote[T/* <: AnyKind */]: Type[T] =
     throw new Error("Internal error: this method call should have been replaced by the compiler")
 
+  /** A splice in a quoted pattern is desugared by the compiler into a call to this method */
+  def patternHole[T]: T =
+    throw new Error("Internal error: this method call should have been replaced by the compiler")
+
+  /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
+  class patternBindHole extends Annotation
+
 }

library/src/scala/quoted/matching/Binding.scala

@@ -0,0 +1,34 @@
+package scala.quoted
+package matching
+
+import scala.tasty.Reflection // TODO do not depend on reflection directly
+
+/** Binding of an Expr[T] used to know if some Expr[T] is a reference to the binding
+ *
+ *  @param name string name of this binding
+ *  @param id unique id used for equality
+ */
+class Binding[-T] private[scala](val name: String, private[Binding] val id: Object) { self =>
+
+  override def equals(obj: Any): Boolean = obj match {
+    case obj: Binding[_] => obj.id == id
+    case _ => false
+  }
+
+  override def hashCode(): Int = id.hashCode()
+
+}
+
+object Binding {
+
+  def unapply[T](expr: Expr[T])(implicit reflect: Reflection): Option[Binding[T]] = {
+    import reflect._
+    expr.unseal match {
+      case IsIdent(ref) =>
+        val sym = ref.symbol
+        Some(new Binding[T](sym.name, sym))
+      case _ => None
+    }
+  }
+
+}

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

@@ -1446,9 +1446,12 @@ trait Kernel {
 
   def Definitions_TupleClass(arity: Int): Symbol
 
-  /** Symbol of scala.runtime.Quoted.patternHole */
+  /** Symbol of scala.internal.Quoted.patternHole */
   def Definitions_InternalQuoted_patternHole: Symbol
 
+  /** Symbol of scala.internal.Quoted.patternBindHole */
+  def Definitions_InternalQuoted_patternBindHoleAnnot: Symbol
+
   def Definitions_UnitType: Type
   def Definitions_ByteType: Type
   def Definitions_ShortType: Type

tests/pos/quotedPatterns.scala

@@ -11,10 +11,15 @@ object Test {
     case '{g($y, $z)} => '{$y * $z}
     case '{ ((a: Int) => 3)($y) } => y
     case '{ 1 + ($y: Int)} => y
+    case '{ val a = 1 + ($y: Int); 3 } => y
       // currently gives an unreachable case warning
       // but only when used in conjunction with the others.
       // I believe this is because implicit arguments are not taken
       // into account when checking whether we have already seen an `unapply` before.
+    case '{ val $y: Int = $z; 1 } => z
+    case '{ ((`$y`: Int) => 1 + y + ($z: Int))(2) } => z
+    // TODO support syntax
+    // case '{ (($y: Int) => 1 + y + ($z: Int))(2) } => z
     case _ => '{1}
   }
 }