Drop RetainingType

We don't need the constructor anymore since `RetainingAnnotation` has equivalent
functionality. And we don't need the deconstructor since there is already
`CapturingOrRetainsType`.

Author: odersky

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -492,8 +492,7 @@ extension (cls: ClassSymbol)
       defn.pureBaseClasses.contains(bc)
       || bc.is(CaptureChecked)
           && bc.givenSelfType.dealiasKeepAnnots.match
-            case CapturingType(_, refs) => refs.isAlwaysEmpty
-            case RetainingType(_, refs) => refs.retainedElements.isEmpty
+            case CapturingOrRetainsType(_, refs) => refs.isAlwaysEmpty
             case selfType =>
               isCaptureChecking  // At Setup we have not processed self types yet, so
                                  // unless a self type is explicitly given, we can't tell
@@ -653,17 +652,16 @@ class PathSelectionProto(val select: Select, val pt: Type) extends typer.ProtoTy
   def selector(using Context): Symbol = select.symbol
 
 /** Drop retains annotations in the inferred type if CC is not enabled
- *  or transform them into RetainingTypes with Nothing as argument if CC is enabled
- *  (we need to do that to keep by-name status).
+ *  or transform them into retains annotations with Nothing (i.e. empty set) as
+ *   argument if CC is enabled (we need to do that to keep by-name status).
  */
 class CleanupRetains(using Context) extends TypeMap:
   def apply(tp: Type): Type = tp match
-    case AnnotatedType(parent, annot: RetainingAnnotation) =>
+    case tp @ AnnotatedType(parent, annot: RetainingAnnotation) =>
       if Feature.ccEnabled then
-        if annot.symbol == defn.RetainsAnnot || annot.symbol == defn.RetainsByNameAnnot then
-          RetainingType(parent, defn.NothingType, byName = annot.symbol == defn.RetainsByNameAnnot)
-        else mapOver(tp)
-      else apply(parent)
+        if annot.symbol == defn.RetainsCapAnnot then tp
+        else AnnotatedType(this(parent), RetainingAnnotation(annot.symbol.asClass, defn.NothingType))
+      else this(parent)
     case _ => mapOver(tp)
 
 /** A base class for extractors that match annotated types with a specific

compiler/src/dotty/tools/dotc/cc/RetainingAnnotation.scala

@@ -10,6 +10,8 @@ import config.Feature
 /** A class for annotations @retains, @retainsByName and @retainsCap */
 class RetainingAnnotation(tpe: Type) extends CompactAnnotation(tpe):
 
+  def this(cls: ClassSymbol, args: Type*)(using Context) = this(cls.typeRef.appliedTo(args.toList))
+
   /** Sanitize @retains arguments to approximate illegal types that could cause a compilation
    *  time blowup before they are dropped ot detected. This means mapping all all skolems
    *  (?n: T) to (?n: Any), and mapping all recursive captures that are not on CapSet to `^`.
@@ -20,9 +22,9 @@ class RetainingAnnotation(tpe: Type) extends CompactAnnotation(tpe):
   override protected def sanitize(tp: Type)(using Context): Type = tp match
     case SkolemType(_) =>
       SkolemType(defn.AnyType)
-    case tp @ AnnotatedType(parent, ann)
-    if ann.symbol.isRetainsLike && parent.typeSymbol != defn.Caps_CapSet =>
-      tp.derivedAnnotatedType(parent, ann.derivedClassAnnotation(defn.RetainsCapAnnot))
+    case tp @ AnnotatedType(parent, ann: RetainingAnnotation)
+    if parent.typeSymbol != defn.Caps_CapSet && ann.symbol != defn.RetainsCapAnnot =>
+      AnnotatedType(parent, RetainingAnnotation(defn.RetainsCapAnnot))
     case tp @ OrType(tp1, tp2) =>
       tp.derivedOrType(sanitize(tp1), sanitize(tp2))
     case _ =>

compiler/src/dotty/tools/dotc/cc/RetainingType.scala

@@ -813,10 +813,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    */
   private def instanceCanBeImpure(tp: Type)(using Context): Boolean = {
     tp.dealiasKeepAnnots match
-      case CapturingType(_, refs) =>
+      case CapturingOrRetainsType(_, refs) =>
         !refs.isAlwaysEmpty
-      case RetainingType(parent, refs) =>
-        !refs.retainedElements.isEmpty
       case tp: (TypeRef | AppliedType) =>
         val sym = tp.typeSymbol
         if sym.isClass
@@ -856,15 +854,10 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         needsVariable(tp.tp1) && needsVariable(tp.tp2)
       case tp: OrType =>
         needsVariable(tp.tp1) || needsVariable(tp.tp2)
-      case CapturingType(parent, refs) =>
+      case CapturingOrRetainsType(parent, refs) =>
         needsVariable(parent)
         && refs.isConst       // if refs is a variable, no need to add another
         && !refs.isUniversal  // if refs is {cap}, an added variable would not change anything
-      case RetainingType(parent, refs) =>
-        needsVariable(parent)
-        && !refs.retainedElements.exists:
-            case ref: TermRef => ref.isCapRef
-            case _ => false
       case AnnotatedType(parent, _) =>
         needsVariable(parent)
       case _ =>

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -33,9 +33,6 @@ object Annotations {
     def derivedAnnotation(tree: Tree)(using Context): Annotation =
       if (tree eq this.tree) this else Annotation(tree)
 
-    def derivedClassAnnotation(cls: ClassSymbol)(using Context) =
-      Annotation(cls, tree.span)
-
     /** All term arguments of this annotation in a single flat list */
     def arguments(using Context): List[Tree] = tpd.allTermArguments(tree)
 
@@ -140,9 +137,6 @@ object Annotations {
     override def derivedAnnotation(tree: Tree)(using Context): Annotation =
       derivedAnnotation(tree.tpe)
 
-    override def derivedClassAnnotation(cls: ClassSymbol)(using Context) =
-      derivedAnnotation(cls.typeRef)
-
     def derivedAnnotation(tp: Type)(using Context): Annotation =
       if tp eq this.tpe then this else CompactAnnotation(tp)
 

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

@@ -15,7 +15,7 @@ import Comments.{Comment, docCtx}
 import util.Spans.NoSpan
 import config.Feature
 import Symbols.requiredModuleRef
-import cc.{CaptureSet, RetainingType}
+import cc.{CaptureSet, RetainingAnnotation}
 import ast.tpd.ref
 
 import scala.annotation.tailrec
@@ -122,8 +122,9 @@ class Definitions {
           denot.info = TypeAlias(
             HKTypeLambda(argParamNames :+ "R".toTypeName, argVariances :+ Covariant)(
               tl => List.fill(arity + 1)(TypeBounds.empty),
-              tl => RetainingType(underlyingClass.typeRef.appliedTo(tl.paramRefs),
-                      captureRoot.termRef)
+              tl => AnnotatedType(
+                      underlyingClass.typeRef.appliedTo(tl.paramRefs),
+                      RetainingAnnotation(defn.RetainsCapAnnot))
             ))
         else
           val cls = denot.asClass.classSymbol
@@ -1347,8 +1348,8 @@ class Definitions {
    */
   object ByNameFunction:
     def apply(tp: Type)(using Context): Type = tp match
-      case tp @ RetainingType(tp1, refSet) if tp.annot.symbol == RetainsByNameAnnot =>
-        RetainingType(apply(tp1), refSet)
+      case tp @ AnnotatedType(tp1, ann: RetainingAnnotation) if ann.symbol == RetainsByNameAnnot =>
+        AnnotatedType(apply(tp1), RetainingAnnotation(defn.RetainsAnnot, ann.argumentTypes*))
       case _ =>
         defn.ContextFunction0.typeRef.appliedTo(tp :: Nil)
     def unapply(tp: Type)(using Context): Option[Type] = tp match

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

@@ -4227,10 +4227,8 @@ object Types extends TypeUtils {
               val parent1 = mapOver(parent)
               if ann.symbol.isRetainsLike then
                 range(
-                  AnnotatedType(parent1,
-                    RetainingAnnotation(defn.RetainsAnnot.typeRef.appliedTo(defn.NothingType))),
-                  AnnotatedType(parent1,
-                    RetainingAnnotation(defn.RetainsCapAnnot.appliedRef)))
+                  AnnotatedType(parent1, RetainingAnnotation(defn.RetainsAnnot, defn.NothingType)),
+                  AnnotatedType(parent1, RetainingAnnotation(defn.RetainsCapAnnot)))
               else
                 parent1
             case _ => mapOver(tp)

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

@@ -291,10 +291,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
             && (!parent.derivesFromStateful || refs.isReadOnly)
         then toText(parent)
         else toTextCapturing(parent, refs, boxText)
-      case tp @ RetainingType(parent, refSet) =>
-        if Feature.ccEnabledSomewhere then
-          toTextCapturing(parent, refSet.retainedElementsRaw, "") ~ Str("R").provided(printDebug)
-        else toText(parent)
       case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>
         "<error>" // do not print previously reported error message because they may try to print this error type again recursively
       case tp: ErrorType =>
@@ -335,12 +331,18 @@ class PlainPrinter(_ctx: Context) extends Printer {
           toTextGlobal(tp.resultType)
         }
       case AnnotatedType(tpe, annot) =>
-        if defn.SilentAnnots.contains(annot.symbol) && !printDebug then
-          toText(tpe)
-        else if annot.isInstanceOf[CaptureAnnotation] then
-          toTextLocal(tpe) ~ "^" ~ toText(annot)
-        else
-          toTextLocal(tpe) ~ " " ~ toText(annot)
+        annot match
+          case annot: RetainingAnnotation =>
+            if Feature.ccEnabledSomewhere then
+              toTextCapturing(tpe, annot.retainedType.retainedElementsRaw, "")
+              ~ Str("R").provided(printDebug)
+            else toText(tpe)
+          case annot: CaptureAnnotation =>
+            toTextLocal(tpe) ~ "^" ~ toText(annot)
+          case _ if defn.SilentAnnots.contains(annot.symbol) && !printDebug =>
+            toText(tpe)
+          case _ =>
+            toTextLocal(tpe) ~ " " ~ toText(annot)
       case FlexibleType(_, tpe) =>
         "(" ~ toText(tpe) ~ ")?"
       case tp: TypeVar =>