Refactor split quote symbol mapping

Now, the mapping is a `SeqMap[Symbol, Symbol]` to convey its ordering
and the `Bind` is created when we are creating the tree of the quote
pattern.

Author: nicolasstucki

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

@@ -24,6 +24,7 @@ import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.Stats.record
 import dotty.tools.dotc.reporting.IllegalVariableInPatternAlternative
 import scala.collection.mutable
+import scala.collection.collection.SeqMap
 
 
 /** Type quotes `'{ ... }` and splices `${ ... }` */
@@ -190,7 +191,7 @@ trait QuotesAndSplices {
    *  will return
    *  ```
    *  (
-   *    Map(<t$giveni>: Symbol -> <t @ _>: Bind),
+   *    Map(<t$giveni>: Symbol -> <t>: Symbol),
    *    <'{
    *       @scala.internal.Quoted.patternType type t
    *       scala.internal.Quoted.patternHole[List[t]]
@@ -199,10 +200,10 @@ trait QuotesAndSplices {
    *  )
    *  ```
    */
-  private def splitQuotePattern(quoted: Tree)(using Context): (collection.Map[Symbol, Bind], Tree, List[Tree]) = {
+  private def splitQuotePattern(quoted: Tree)(using Context): (SeqMap[Symbol, Symbol], Tree, List[Tree]) = {
     val ctx0 = ctx
 
-    val bindSymMapping: collection.Map[Symbol, Bind] = unapplyBindingsMapping(quoted)
+    val bindSymMapping: SeqMap[Symbol, Symbol] = unapplyBindingsMapping(quoted)
 
     object splitter extends tpd.TreeMap {
       private var variance: Int = 1
@@ -282,7 +283,7 @@ 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 = bindSymMapping(tdef.symbol).symbol.typeRef
+        val bindingType = bindSymMapping(tdef.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)
@@ -326,10 +327,10 @@ trait QuotesAndSplices {
    *  binding that will be as type variable in the encoded `unapply` of the quote pattern.
    *
    *  @return Mapping from type variable symbols defined in the quote pattern into
-   *          type variable `Bind` definitions for the `unapply` of the quote pattern.
+   *          type variable definitions for the `unapply` of the quote pattern.
    *          This mapping retains the original type variable definition order.
    */
-  private def unapplyBindingsMapping(quoted: Tree)(using Context): collection.Map[Symbol, Bind] = {
+  private def unapplyBindingsMapping(quoted: Tree)(using Context): SeqMap[Symbol, Symbol] = {
     // Collect all existing type variable bindings and create new symbols for them.
     // The old info is used, it may contain references to the old symbols.
     val (oldBindings, newBindings) = {
@@ -367,8 +368,7 @@ trait QuotesAndSplices {
       ctx.gadtState.addToConstraint(newBindings) // This must be performed after the info has been updated
 
     // Map into Bind nodes retaining the original order
-    val newBindingBinds = newBindings.map(newSym => Bind(newSym, untpd.Ident(nme.WILDCARD).withType(newSym.info)).withSpan(quoted.span))
-    mutable.LinkedHashMap.from(oldBindings.lazyZip(newBindingBinds))
+    mutable.LinkedHashMap.from(oldBindings.lazyZip(newBindings))
   }
 
   /** Type a quote pattern `case '{ <quoted> } =>` qiven the a current prototype. Typing the pattern
@@ -434,20 +434,23 @@ trait QuotesAndSplices {
       if quoted.isType then typedType(quoted0, WildcardType)(using quoteCtx)
       else typedExpr(quoted0, WildcardType)(using quoteCtx)
 
-    val (typeBindings, shape, splices) = splitQuotePattern(quoted1)
+    val (bindSymMapping, shape, splices) = splitQuotePattern(quoted1)
 
     class ReplaceBindings extends TypeMap() {
       override def apply(tp: Type): Type = tp match {
         case tp: TypeRef =>
           val tp1 = if (tp.symbol.isTypeSplice) tp.dealias else tp
-          mapOver(typeBindings.get(tp1.typeSymbol).fold(tp)(_.symbol.typeRef))
+          mapOver(bindSymMapping.get(tp1.typeSymbol).fold(tp)(_.typeRef))
         case tp => mapOver(tp)
       }
     }
     val replaceBindings = new ReplaceBindings
     val patType = defn.tupleType(splices.tpes.map(tpe => replaceBindings(tpe.widen)))
 
-    val typeBindingsTuple = tpd.hkNestedPairsTypeTree(typeBindings.values.toList)
+    val typeBinds = bindSymMapping.values.toList.map(sym =>
+      Bind(sym, untpd.Ident(nme.WILDCARD).withType(sym.info)).withSpan(quoted.span)
+    )
+    val typeBindingsTuple = tpd.hkNestedPairsTypeTree(typeBinds)
 
     val replaceBindingsInTree = new TreeMap {
       private var bindMap = Map.empty[Symbol, Symbol]