Handle QualifiedAnnotation in TypeAccumulator

Author: mbovel

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

@@ -4983,6 +4983,7 @@ object Types extends TypeUtils {
 
     private var myRepr: Name | Null = null
     def repr(using Context): Name = {
+      //if (myRepr == null) myRepr = s"?$id".toString.toTermName
       if (myRepr == null) myRepr = SkolemName.fresh()
       myRepr.nn
     }
@@ -6914,7 +6915,10 @@ object Types extends TypeUtils {
 
     def apply(x: T, tp: Type): T
 
-    protected def applyToAnnot(x: T, annot: Annotation): T = x // don't go into annotations
+    protected def applyToAnnot(x: T, annot: Annotation): T =
+      annot match
+        case annot: QualifiedAnnotation => annot.foldOverTypes(x, this)
+        case _ => x // don't go into other annotations
 
     /** A prefix is never contravariant. Even if say `p.A` is used in a contravariant
      *  context, we cannot assume contravariance for `p` because `p`'s lower

compiler/src/dotty/tools/dotc/qualified_types/ENode.scala

@@ -249,15 +249,16 @@ enum ENode extends Showable:
         body.foreachType(f)
 
   def normalizeTypes()(using Context): ENode =
-    mapTypes(NormalizeMap())
+    trace(i"normalizeTypes($this)", Printers.qualifiedTypes):
+      mapTypes(NormalizeMap())
 
   private class NormalizeMap(using Context) extends TypeMap:
     def apply(tp: Type): Type =
       tp match
         case tp: TypeVar if tp.isPermanentlyInstantiated =>
           apply(tp.permanentInst)
         case tp: NamedType =>
-          val dealiased = tp.dealias
+          val dealiased = tp.dealiasKeepAnnotsAndOpaques
           if dealiased ne tp then
             apply(dealiased)
           else if tp.symbol.isStatic then
@@ -547,7 +548,7 @@ object ENode:
   def assumptions(node: ENode)(using Context): List[ENode] =
     trace(i"assumptions($node)", Printers.qualifiedTypes):
       node match
-        case Atom(tp: SingletonType) => termAssumptions(tp) ++ typeAssumptions(tp)
+        case n: Atom => termAssumptions(n.tp) ++ typeAssumptions(n.tp)
         case n: Constructor => Nil
         case n: Select => assumptions(n.qual)
         case n: Apply => assumptions(n.fn) ++ n.args.flatMap(assumptions)
@@ -560,7 +561,6 @@ object ENode:
       tp match
         case tp: TermRef =>
           tp.symbol.info match
-            case QualifiedType(_, _) => Nil
             case _ =>
               tp.symbol.defTree match
                 case valDef: tpd.ValDef if !valDef.rhs.isEmpty && !valDef.symbol.is(Flags.Lazy) =>

compiler/src/dotty/tools/dotc/qualified_types/QualifiedAnnotation.scala

@@ -37,3 +37,9 @@ case class QualifiedAnnotation(qualifier: ENode.Lambda) extends Annotation:
         case TermParamRef(tl1, _) if tl eq tl1 => res = true
         case _ => ()
     res
+
+  def foldOverTypes[A](z: A, f: (A, Type) => A)(using Context): A =
+    var acc = z
+    qualifier.foreachType: tp =>
+      acc = f(acc, tp)
+    acc