Don't transform AnnotatedTypes to CapturingTypes

Author: odersky

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

@@ -12,7 +12,7 @@ import printing.{Showable, Printer}
 import printing.Texts.*
 import util.SimpleIdentitySet
 import util.common.alwaysTrue
-import cc.CapturingType
+import cc.*
 
 /** A class for capture sets. Capture sets can be constants or variables.
  *  Capture sets support inclusion constraints <:< where <:< is subcapturing.
@@ -158,6 +158,9 @@ sealed abstract class CaptureSet extends Showable:
     ((NoType: Type) /: elems) ((tp, ref) =>
       if tp.exists then OrType(tp, ref, soft = false) else ref)
 
+  def toRegularAnnotation(using Context): Annotation  =
+    Annotation(CaptureAnnotation(this).tree)
+
   override def toText(printer: Printer): Text =
     Str("{") ~ Text(elems.toList.map(printer.toTextCaptureRef), ", ") ~ Str("}")
 

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

@@ -38,7 +38,7 @@ import scala.util.hashing.{ MurmurHash3 => hashing }
 import config.Printers.{core, typr, matchTypes}
 import reporting.{trace, Message}
 import java.lang.ref.WeakReference
-import cc.{CapturingType, derivedCapturingType}
+import cc.{CapturingType, derivedCapturingType, retainedElems}
 import CaptureSet.CompareResult
 
 import scala.annotation.internal.sharable
@@ -3773,7 +3773,21 @@ object Types {
                   CapturingType(parent1, CaptureSet(elems1)),
                   CapturingType(parent1, CaptureSet.universal))
             case AnnotatedType(parent, ann) if ann.refersToParamOf(thisLambdaType) =>
-              mapOver(parent)
+              val parent1 = mapOver(parent)
+              if ann.symbol == defn.RetainsAnnot then
+                val elems = retainedElems(ann.tree) // ^^^ needed? or maybe just use {} as lower bound?
+                val elems1 = elems.filter { elem =>
+                  elem.tpe match
+                    case tp @ TermParamRef(`thisLambdaType`, _) => false
+                    case _ => true
+                }
+                assert(elems1.size != elems.size)
+                val lower = Annotation(defn.RetainsAnnot, repeated(elems1, TypeTree(defn.AnyType)))
+                range(
+                  AnnotatedType(parent1, lower),
+                  AnnotatedType(parent1, CaptureSet.universal.toRegularAnnotation))
+              else
+                parent1
             case _ => mapOver(tp)
           }
         }

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

@@ -146,7 +146,7 @@ class CheckCaptures extends Recheck:
         addVars(cleanType(tp))
       end reinfer
 
-      if inferred then reinfer(tp) else mapType(tp)
+      if inferred then reinfer(tp) else tp//mapType(tp)
     end transformType
 
     private var curEnv: Env = Env(NoSymbol, CaptureSet.empty, false, null)