Use TermRef to distinguish distinct Type[T] instances

We used the symbol before, but this ignored the specific path to the
instance of Type[T].

Fixes #16959

Author: nicolasstucki

compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala

@@ -27,10 +27,10 @@ object QuoteTypeTags {
 class QuoteTypeTags(span: Span)(using Context) {
   import tpd.*
 
-  private val tags = collection.mutable.LinkedHashMap.empty[Symbol, TypeDef]
+  private val tags = collection.mutable.LinkedHashMap.empty[TermRef, TypeDef]
 
   def getTagRef(spliced: TermRef): TypeRef = {
-    val typeDef = tags.getOrElseUpdate(spliced.symbol, mkTagSymbolAndAssignType(spliced))
+    val typeDef = tags.getOrElseUpdate(spliced, mkTagSymbolAndAssignType(spliced))
     typeDef.symbol.typeRef
   }
 
@@ -42,7 +42,7 @@ class QuoteTypeTags(span: Span)(using Context) {
     val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs, EmptyTree)
     val local = newSymbol(
       owner = ctx.owner,
-      name = UniqueName.fresh((splicedTree.symbol.name.toString + "$_").toTermName).toTypeName,
+      name = UniqueName.fresh(rhs.tpe.dealias.typeSymbol.name.toTypeName),
       flags = Synthetic,
       info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
       coord = span).asType

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

@@ -108,8 +108,8 @@ class Splicing extends MacroTransform:
     /** Number of holes created in this quote. Used for indexing holes. */
     private var numHoles = 0
 
-    /** Mapping from the term symbol of a `Type[T]` to it's hole. Used to deduplicate type holes. */
-    private val typeHoles = mutable.Map.empty[Symbol, Hole]
+    /** Mapping from the term of a `Type[T]` to it's hole. Used to deduplicate type holes. */
+    private val typeHoles = mutable.Map.empty[TermRef, Hole]
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
@@ -127,13 +127,13 @@ class Splicing extends MacroTransform:
         case tree: TypeDef if tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
           val tp @ TypeRef(qual: TermRef, _) = tree.rhs.tpe.hiBound: @unchecked
           quotedDefs += tree.symbol
-          val hole = typeHoles.get(qual.symbol) match
+          val hole = typeHoles.get(qual) match
             case Some (hole) => cpy.Hole(hole)(content = EmptyTree)
             case None =>
               val holeIdx = numHoles
               numHoles += 1
               val hole = tpd.Hole(false, holeIdx, Nil, ref(qual), TypeTree(tp))
-              typeHoles.put(qual.symbol, hole)
+              typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
         case Apply(Select(Apply(TypeApply(fn,_), List(code)),nme.apply),List(quotes))

tests/pos-macros/i16959/Macro_1.scala

@@ -0,0 +1,17 @@
+import scala.quoted.*
+
+inline def test = ${ testImpl }
+
+def testImpl(using Quotes) =
+  import quotes.reflect.*
+
+  val int = PackedType[Int]
+  val string = PackedType[String]
+
+  assert(Type.show[(int.U, string.U, string.U)] == "scala.Tuple3[scala.Int, java.lang.String, java.lang.String]")
+
+  '{ () }
+
+final class PackedType[T](using t: Type[T]):
+  opaque type U = T
+  given tpe: Type[U] = t

tests/pos-macros/i16959/Test_2.scala

@@ -0,0 +1 @@
+def app = test