Fix binding bounds

Author: nicolasstucki

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

@@ -810,10 +810,17 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   /** The variables defined by a pattern, in reverse order of their appearance. */
   def patVars(tree: Tree)(using Context): List[Symbol] = {
-    val acc = new TreeAccumulator[List[Symbol]] {
+    val acc = new TreeAccumulator[List[Symbol]] { outer =>
       def apply(syms: List[Symbol], tree: Tree)(using Context) = tree match {
         case Bind(_, body) => apply(tree.symbol :: syms, body)
         case Annotated(tree, id @ Ident(tpnme.BOUNDTYPE_ANNOT)) => apply(id.symbol :: syms, tree)
+        case QuotePattern(bindings, body, _) =>
+          new TreeAccumulator[List[Symbol]] {
+            def apply(syms: List[Symbol], tree: Tree)(using Context) = tree match {
+              case SplicePattern(pat, _) => outer.apply(syms, pat)
+              case _ => foldOver(syms, tree)
+            }
+          }.apply(bindings.map(_.symbol) ::: syms, body)
         case _ => foldOver(syms, tree)
       }
     }

compiler/src/dotty/tools/dotc/quoted/QuotePatterns.scala

@@ -64,18 +64,21 @@ object QuotePatterns:
     val shape1 =
       if quotePattern.bindings.isEmpty then shape0
       else
-        val patternTypes = quotePattern.bindings.map { binding =>
+        val oldBindings = quotePattern.bindings.map(_.symbol)
+        val newBindings = quotePattern.bindings.map { binding =>
           val sym = binding.symbol
           val typeSym = newSymbol(ctx.owner, sym.name ++ "$inPattern" /* TODO remove $inPattern */, EmptyFlags, sym.info, NoSymbol, binding.span)
           typeSym.addAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot)
           for fromAbove <- sym.getAnnotation(defn.QuotedRuntimePatterns_fromAboveAnnot) do
             typeSym.addAnnotation(fromAbove)
-          TypeDef(typeSym.asType).withSpan(binding.span)
+          typeSym.asType
         }
-        new TreeTypeMap(
-          substFrom = quotePattern.bindings.map(_.symbol),
-          substTo = patternTypes.map(_.symbol)
-        ).transform(Block(patternTypes, shape0))
+        var newBindingsRefs = newBindings.map(_.typeRef)
+        for newBinding <- newBindings do
+          newBinding.info = newBinding.info.subst(oldBindings, newBindingsRefs)
+
+        val patternTypes = newBindings.map(sym => TypeDef(sym).withSpan(sym.span))
+        Block(patternTypes, shape0.subst(oldBindings, newBindings))
 
 
     val quotedShape =

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

@@ -206,13 +206,7 @@ trait QuotesAndSplices {
   private def splitQuotePattern(quoted: Tree)(using Context): (collection.Map[Symbol, Bind], Tree, List[Tree]) = {
     val ctx0 = ctx
 
-    val typeBindings: mutable.Map[Symbol, Bind] = mutable.LinkedHashMap.empty
-    def getBinding(sym: Symbol): Bind =
-      typeBindings.getOrElseUpdate(sym, {
-        val bindingBounds = sym.info
-        val bsym = newPatternBoundSymbol(sym.name.toString.stripPrefix("$").toTypeName, bindingBounds, quoted.span)
-        Bind(bsym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(quoted.span)
-      })
+    val bindSymMapping: collection.Map[Symbol, Bind] = unapplyBindingsMapping(quoted)
 
     object splitter extends tpd.TreeMap {
       private var variance: Int = 1
@@ -292,13 +286,14 @@ trait QuotesAndSplices {
           report.error(IllegalVariableInPatternAlternative(tdef.symbol.name), tdef.srcPos)
         if variance == -1 then
           tdef.symbol.addAnnotation(Annotation(New(ref(defn.QuotedRuntimePatterns_fromAboveAnnot.typeRef)).withSpan(tdef.span)))
-        val bindingType = getBinding(tdef.symbol).symbol.typeRef
+        val bindingType = bindSymMapping(tdef.symbol).symbol.typeRef
         val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
         val sym = newPatternBoundSymbol(nameOfSyntheticGiven, bindingTypeTpe, tdef.span, flags = ImplicitVal)(using ctx0)
         buff += Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingTypeTpe)).withSpan(tdef.span)
         super.transform(tdef)
       }
     }
+
     val shape0 = splitter.transform(quoted)
     val patterns = (splitter.typePatBuf.iterator ++ splitter.freshTypePatBuf.iterator ++ splitter.patBuf.iterator).toList
     val freshTypeBindings = splitter.freshTypeBindingsBuff.result()
@@ -329,7 +324,42 @@ trait QuotesAndSplices {
         new TreeTypeMap(typeMap = typeMap).transform(shape1)
       }
 
-    (typeBindings, shape2, patterns)
+    (bindSymMapping, shape2, patterns)
+  }
+
+  private def unapplyBindingsMapping(quoted: Tree)(using Context): collection.Map[Symbol, Bind] = {
+    val mapping = mutable.LinkedHashMap.empty[Symbol, Symbol]
+    new tpd.TreeTraverser {
+      def traverse(tree: Tree)(using Context): Unit = tree match {
+        case _: SplicePattern =>
+        case Select(pat: Bind, _) if tree.symbol.isTypeSplice =>
+          val sym = tree.tpe.dealias.typeSymbol
+          if sym.exists then registerNewBindSym(sym)
+        case tdef: TypeDef  =>
+          if tdef.symbol.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot) then
+            registerNewBindSym(tdef.symbol)
+          traverseChildren(tdef)
+        case _ =>
+          traverseChildren(tree)
+      }
+      private def registerNewBindSym(sym: Symbol): Unit =
+        if !mapping.contains(sym) then
+          mapping(sym) = newSymbol(ctx.owner, sym.name.toString.stripPrefix("$").toTypeName, Case | sym.flags, sym.info, coord = quoted.span)
+    }.traverse(quoted)
+
+    // Replace symbols in `mapping` in the infos of the new symbol and register GADT bounds.
+    // GADT bounds need to be added after the info is updated to avoid references to the old symbols.
+    var oldBindings: List[Symbol] = mapping.keys.toList
+    var newBindingsRefs: List[Type] = mapping.values.toList.map(_.typeRef)
+    for newBindings <- mapping.values do
+      newBindings.info = newBindings.info.subst(oldBindings, newBindingsRefs)
+      ctx.gadtState.addToConstraint(newBindings)
+
+    // Map into Bind nodes retaining the original order
+    val mapping2: mutable.Map[Symbol, Bind] = mutable.LinkedHashMap.empty
+    for (oldSym, newSym)  <- mapping do
+      mapping2(oldSym) = Bind(newSym, untpd.Ident(nme.WILDCARD).withType(newSym.info)).withSpan(quoted.span)
+    mapping2
   }
 
   /** Type a quote pattern `case '{ <quoted> } =>` qiven the a current prototype. Typing the pattern
@@ -451,6 +481,11 @@ trait QuotesAndSplices {
 
     val decoded = QuotePatterns.decode(patternUnapply)
     decoded.foreach(QuotePatterns.checkPattern)
+    // val encoded = QuotePatterns.encode(decoded.get)
+    // println(patternUnapply.show)
+    // println(encoded.show)
+    // println(decoded.get.show)
+
     decoded.getOrElse(patternUnapply)
   }
 }

tests/pos-macros/quote-pattern-type-variable-bounds.scala

@@ -0,0 +1,12 @@
+import quoted.*
+
+def foo(using Quotes)(x: Expr[Int]) =
+  x match
+    case '{ type t; type u <: `t`; f[`t`, `u`] } =>
+    case '{ type u <: `t`; type t; f[`t`, `u`] } =>
+    case '{ type t; type u <: `t`; g[F[`t`, `u`]] } =>
+    case '{ type u <: `t`; type t; g[F[`t`, `u`]] } =>
+
+def f[T, U <: T] = ???
+def g[T] = ???
+type F[T, U <: T]