Add BackquotedDefDef to keep track of backquotes in def names

Author: nicolasstucki

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

@@ -206,7 +206,9 @@ object desugar {
    *  ==>
    *      inline def f(x: Boolean): Any = (if (x) 1 else ""): Any
    */
-  private def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = {
+  private def defDef(meth0: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = {
+    val meth = transformQuotedPatternName(meth0)
+
     val DefDef(_, tparams, vparamss, tpt, rhs) = meth
     val methName = normalizeName(meth, tpt).asTermName
     val mods = meth.mods
@@ -281,6 +283,14 @@ object desugar {
     }
   }
 
+  def transformQuotedPatternName(ddef: DefDef)(implicit ctx: Context): DefDef = {
+    if (ctx.mode.is(Mode.QuotedPattern) && !ddef.isBackquoted && ddef.name != nme.ANON_FUN && ddef.name.startsWith("$")) {
+      val name = ddef.name.toString.substring(1).toTermName
+      val mods = ddef.mods.withAddedAnnotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(ddef.span))
+      cpy.DefDef(ddef)(name).withMods(mods)
+    } else ddef
+  }
+
   // Add all evidence parameters in `params` as implicit parameters to `meth` */
   private def addEvidenceParams(meth: DefDef, params: List[ValDef])(implicit ctx: Context): DefDef =
     params match {

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

@@ -361,6 +361,9 @@ object Trees {
     def tpt: Tree[T]
     def unforcedRhs: LazyTree = unforced
     def rhs(implicit ctx: Context): Tree[T] = forceIfLazy
+
+    /** Is this a `BackquotedValDef` or `BackquotedDefDef` ? */
+    def isBackquoted: Boolean = false
   }
 
   // ----------- Tree case classes ------------------------------------
@@ -704,9 +707,6 @@ object Trees {
     assert(isEmpty || tpt != genericEmptyTree)
     def unforced: LazyTree = preRhs
     protected def force(x: AnyRef): Unit = preRhs = x
-
-    /** Is this a `BackquotedValDef` ? */
-    def isBackquoted: Boolean = false
   }
 
   class BackquotedValDef[-T >: Untyped] private[ast] (name: TermName, tpt: Tree[T], preRhs: LazyTree)(implicit @constructorOnly src: SourceFile)
@@ -725,6 +725,13 @@ object Trees {
     protected def force(x: AnyRef): Unit = preRhs = x
   }
 
+  class BackquotedDefDef[-T >: Untyped] private[ast] (name: TermName, tparams: List[TypeDef[T]],
+      vparamss: List[List[ValDef[T]]], tpt: Tree[T], preRhs: LazyTree)(implicit @constructorOnly src: SourceFile)
+    extends DefDef[T](name, tparams, vparamss, tpt, preRhs) {
+    override def isBackquoted: Boolean = true
+    override def productPrefix: String = "BackquotedDefDef"
+  }
+
   /** mods class name template     or
    *  mods trait name template     or
    *  mods type name = rhs   or
@@ -943,6 +950,7 @@ object Trees {
     type ValDef = Trees.ValDef[T]
     type BackquotedValDef = Trees.BackquotedValDef[T]
     type DefDef = Trees.DefDef[T]
+    type BackquotedDefDef = Trees.BackquotedDefDef[T]
     type TypeDef = Trees.TypeDef[T]
     type Template = Trees.Template[T]
     type Import = Trees.Import[T]
@@ -1142,6 +1150,9 @@ object Trees {
         case _ => finalize(tree, untpd.ValDef(name, tpt, rhs)(sourceFile(tree)))
       }
       def DefDef(tree: Tree)(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit ctx: Context): DefDef = tree match {
+        case tree: BackquotedDefDef =>
+          if ((name == tree.name) && (tparams eq tree.tparams) && (vparamss eq tree.vparamss) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs)) tree
+          else finalize(tree, untpd.BackquotedDefDef(name, tparams, vparamss, tpt, rhs)(sourceFile(tree)))
         case tree: DefDef if (name == tree.name) && (tparams eq tree.tparams) && (vparamss eq tree.vparamss) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
         case _ => finalize(tree, untpd.DefDef(name, tparams, vparamss, tpt, rhs)(sourceFile(tree)))
       }

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

@@ -323,6 +323,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def ValDef(name: TermName, tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): ValDef = new ValDef(name, tpt, rhs)
   def BackquotedValDef(name: TermName, tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): ValDef = new BackquotedValDef(name, tpt, rhs)
   def DefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs)
+  def BackquotedDefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): DefDef = new BackquotedDefDef(name, tparams, vparamss, tpt, rhs)
   def TypeDef(name: TypeName, rhs: Tree)(implicit src: SourceFile): TypeDef = new TypeDef(name, rhs)
   def Template(constr: DefDef, parents: List[Tree], derived: List[Tree], self: ValDef, body: LazyTreeList)(implicit src: SourceFile): Template =
     if (derived.isEmpty) new Template(constr, parents, self, body)

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2415,10 +2415,10 @@ object Parsers {
           else
             (Nil, Method)
         val mods1 = addFlag(mods, flags)
-        val name = ident()
+        val ident = termIdent()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
         val vparamss = paramClauses() match {
-          case rparams :: rparamss if leadingParamss.nonEmpty && !isLeftAssoc(name) =>
+          case rparams :: rparamss if leadingParamss.nonEmpty && !isLeftAssoc(ident.name) =>
             rparams :: leadingParamss ::: rparamss
           case rparamss =>
             leadingParamss ::: rparamss
@@ -2448,7 +2448,9 @@ object Parsers {
             accept(EQUALS)
             expr()
           }
-        finalizeDef(DefDef(name, tparams, vparamss, tpt, rhs), mods1, start)
+
+        if (ident.isBackquoted) finalizeDef(BackquotedDefDef(ident.name.asTermName, tparams, vparamss, tpt, rhs), mods1, start)
+        else finalizeDef(DefDef(ident.name.asTermName, tparams, vparamss, tpt, rhs), mods1, start)
       }
     }
 

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

@@ -1975,11 +1975,17 @@ class Typer extends Namer
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        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)
+        case ddef: ValOrDefDef =>
+          if (ddef.symbol.annotations.exists(_.symbol == defn.InternalQuoted_patternBindHoleAnnot)) {
+            val tpe = ddef.symbol.info match {
+              case t: ExprType => t.resType
+              case t: PolyType => t.resultType.toFunctionType()
+              case t: MethodType => t.toFunctionType()
+              case t => t
+            }
+            val exprTpe = AppliedType(defn.QuotedMatchingBindingType, tpe :: Nil)
+            val sym = ctx0.newPatternBoundSymbol(ddef.name, exprTpe, ddef.span)
+            patBuf += Bind(sym, untpd.Ident(nme.WILDCARD).withType(exprTpe)).withSpan(ddef.span)
           }
           super.transform(tree)
         case _ =>

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

@@ -8,7 +8,7 @@ import scala.tasty.Reflection // TODO do not depend on reflection directly
  *  @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 =>
+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

tests/neg/quotedPatterns-3.scala

@@ -4,6 +4,8 @@ object Test {
       y // error: Not found: y
     case '{ ((`$y`: Int) => 3); 2 } =>
       y // error: Not found: y
+    case '{ def `$f`: Int = 8; 2 } =>
+      f // error: Not found: f
     case _ =>
   }
 }

tests/pos/quotedPatterns.scala

@@ -22,6 +22,19 @@ object Test {
     case '{ (($y: Int) => 1 + y + ($z: Int))(2) } =>
       val a: quoted.matching.Binding[Int] = y
       z
+    case '{ def $ff: Int = $z; ff } =>
+      val a: quoted.matching.Binding[Int] = ff
+      z
+    case '{ def $ff(i: Int): Int = $z; 2 } =>
+      val a: quoted.matching.Binding[Int => Int] = ff
+      z
+    case '{ def $ff(i: Int)(j: Int): Int = $z; 2 } =>
+      val a: quoted.matching.Binding[Int => Int => Int] = ff
+      z
+    // FIXME
+//    case '{ def `$ff`[T](i: T): Int = $z; 2 } =>
+//      val a: quoted.matching.Binding[[T] => T => Int] = ff // TODO make Binding any-kinded
+//      z
     case _ => '{1}
   }
 }