Special class for RetainingAnnotations

Author: odersky

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

@@ -0,0 +1,38 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Types.*, Symbols.*, Contexts.*
+import Annotations.{Annotation, CompactAnnotation, EmptyAnnotation}
+import config.Feature
+
+/** A class for annotations @retains, @retainsByName and @retainsCap */
+class RetainingAnnotation(tpe: Type) extends CompactAnnotation(tpe):
+
+    /** 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 `^`.
+     *  Skolems and capturing types on types other than CapSet are not allowed in a
+     *  @retains annotation anyway, so the underlying type does not matter as long as it is also
+     *  illegal. See i24556.scala and i24556a.scala.
+     */
+    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 @ OrType(tp1, tp2) =>
+        tp.derivedOrType(sanitize(tp1), sanitize(tp2))
+      case _ =>
+        tp
+
+    override def mapWith(tm: TypeMap)(using Context): Annotation =
+      if Feature.ccEnabledSomewhere then mapWithCtd(tm) else EmptyAnnotation
+
+/*
+    def toCaptureSet(using Context): CaptureSet =
+      CaptureSet(argumentType(0).retainedElements*)
+*/
+end RetainingAnnotation

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

@@ -4,9 +4,6 @@ package cc
 
 import core.*
 import Types.*, Symbols.*, Contexts.*
-import ast.tpd.*
-import Annotations.CompactAnnotation
-import Decorators.i
 
 /** A builder and extractor for annotated types with @retains or @retainsByName annotations
  *  excluding CapturingTypes.
@@ -15,7 +12,7 @@ object RetainingType:
 
   def apply(tp: Type, typeElems: Type, byName: Boolean = false)(using Context): Type =
     val annotCls = if byName then defn.RetainsByNameAnnot else defn.RetainsAnnot
-    AnnotatedType(tp, CompactAnnotation(annotCls.typeRef.appliedTo(typeElems)))
+    AnnotatedType(tp, RetainingAnnotation(annotCls.typeRef.appliedTo(typeElems)))
 
   def unapply(tp: AnnotatedType)(using Context): Option[(Type, Type)] =
     val sym = tp.annot.symbol

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

@@ -7,7 +7,7 @@ import ast.tpd, tpd.*
 import util.Spans.Span
 import printing.{Showable, Printer}
 import printing.Texts.Text
-import cc.isRetainsLike
+import cc.{isRetainsLike, RetainingAnnotation}
 import config.Feature
 import Decorators.*
 
@@ -130,12 +130,12 @@ object Annotations {
   case class ConcreteAnnotation(t: Tree) extends Annotation:
     def tree(using Context): Tree = t
 
-  case class CompactAnnotation(tp: Type) extends Annotation:
-    assert(tp.isInstanceOf[AppliedType | TypeRef], tp)
+  class CompactAnnotation(val tpe: Type) extends Annotation:
+    assert(tpe.isInstanceOf[AppliedType | TypeRef], tpe)
 
-    def tree(using Context) = TypeTree(tp)
+    def tree(using Context) = TypeTree(tpe)
 
-    override def symbol(using Context) = tp.typeSymbol
+    override def symbol(using Context) = tpe.typeSymbol
 
     override def derivedAnnotation(tree: Tree)(using Context): Annotation =
       derivedAnnotation(tree.tpe)
@@ -144,12 +144,12 @@ object Annotations {
       derivedAnnotation(cls.typeRef)
 
     def derivedAnnotation(tp: Type)(using Context): Annotation =
-      if tp eq this.tp then this else CompactAnnotation(tp)
+      if tp eq this.tpe then this else CompactAnnotation(tp)
 
     override def arguments(using Context): List[Tree] =
       argumentTypes.map(TypeTree(_))
 
-    override def argumentTypes(using Context): List[Type] = tp.argTypes
+    override def argumentTypes(using Context): List[Type] = tpe.argTypes
 
     def argumentType(i: Int)(using Context): Type =
       val args = argumentTypes
@@ -160,49 +160,39 @@ object Annotations {
         case ConstantType(c) => Some(c)
         case _ => None
 
-    /** 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 `^`.
-     *  Skolems and capturing types on types other than CapSet are not allowed in a
-     *  @retains annotation anyway, so the underlying type does not matter as long as it is also
-     *  illegal. See i24556.scala and i24556a.scala.
+    /** A hook to transform the type argument of a mapped annotation. Overridden in
+     *  RetainingAnnotation to avoid compilation time blowups for annotations that
+     *  are not valid capture annotations.
      */
-    private 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 @ OrType(tp1, tp2) =>
-        tp.derivedOrType(sanitize(tp1), sanitize(tp2))
+    protected def sanitize(tp: Type)(using Context): Type = tp
+
+    protected def mapWithCtd(tm: TypeMap)(using Context): Annotation = tm(tpe) match
+      case tp1 @ AppliedType(tycon, args) =>
+        derivedAnnotation(tp1.derivedAppliedType(tycon, args.mapConserve(sanitize)))
+      case tp1: TypeRef =>
+        derivedAnnotation(tp1)
       case _ =>
-        tp
+        EmptyAnnotation
 
     override def mapWith(tm: TypeMap)(using Context): Annotation =
-      val isRetains = symbol.isRetainsLike
-      if isRetains && !Feature.ccEnabledSomewhere then EmptyAnnotation
-      else tm(tp) match
-        case tp1 @ AppliedType(tycon, args) =>
-          val args1 = if isRetains then args.mapConserve(sanitize) else args
-          derivedAnnotation(tp1.derivedAppliedType(tycon, args1))
-        case tp1: TypeRef =>
-          derivedAnnotation(tp1)
-        case _ =>
-          EmptyAnnotation
+      assert(!symbol.isRetainsLike)
+      mapWithCtd(tm)
 
     override def refersToParamOf(tl: TermLambda)(using Context): Boolean =
-      refersToLambdaParam(tp, tl)
+      refersToLambdaParam(tpe, tl)
 
-    override def hash: Int = tp.hash
+    override def hash: Int = tpe.hash
     override def eql(that: Annotation) = that match
-      case that: CompactAnnotation => this.tp `eql` that.tp
+      case that: CompactAnnotation => this.tpe `eql` that.tpe
       case _ => false
 
   object CompactAnnotation:
+    def apply(tp: Type)(using Context): CompactAnnotation =
+      if tp.typeSymbol.isRetainsLike then RetainingAnnotation(tp)
+      else new CompactAnnotation(tp)
     def apply(tree: Tree)(using Context): CompactAnnotation =
       val argTypes = tpd.allArguments(tree).map(_.tpe)
       apply(annotClass(tree).typeRef.appliedTo(argTypes))
-
   end CompactAnnotation
 
   private def isLambdaParam(t: Type, tl: TermLambda): Boolean = t match
@@ -314,7 +304,7 @@ object Annotations {
 
     def apply(atp: Type, args: List[Tree], span: Span)(using Context): Annotation =
       if atp.typeSymbol.isRetainsLike && args.isEmpty
-      then CompactAnnotation(atp)
+      then RetainingAnnotation(atp)
       else apply(New(atp, args).withSpan(span))
 
     /** Create an annotation where the tree is computed lazily. */

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

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

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -286,10 +286,10 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
       withLength:
         pickleType(tpe.parent, richTypes)
         tpe.annot match
-          case CompactAnnotation(tp) => pickleType(tp)
-          case _ =>
-            pickleTree(tpe.annot.tree)
-            annotatedTypeTrees += tpe.annot.tree
+          case ann: CompactAnnotation => pickleType(ann.tpe)
+          case ann =>
+            pickleTree(ann.tree)
+            annotatedTypeTrees += ann.tree
     case tpe: AndType =>
       writeByte(ANDtype)
       withLength { pickleType(tpe.tp1, richTypes); pickleType(tpe.tp2, richTypes) }