Avoid blowup of compute times for ill-formed retains

 - Completely drop all retains-like annotations if cc is not enabled somewhere.
   This is the same as in the reverted commit but now done in Annotation.mapWith

 - Strip nonsensical parts of retains-like annotations to avoid blowup.

Author: odersky

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

@@ -7,6 +7,8 @@ import ast.tpd, tpd.*
 import util.Spans.Span
 import printing.{Showable, Printer}
 import printing.Texts.Text
+import cc.isRetainsLike
+import config.Feature
 
 import scala.annotation.internal.sharable
 
@@ -53,23 +55,49 @@ object Annotations {
      *  be overridden. Returns EmptyAnnotation if type type map produces a range
      *  type, since ranges cannot be types of trees.
      */
-    def mapWith(tm: TypeMap)(using Context) =
-      val args = tpd.allArguments(tree)
-      if args.isEmpty then this
-      else
-        // Checks if `tm` would result in any change by applying it to types
-        // inside the annotations' arguments and checking if the resulting types
-        // are different.
-        val findDiff = new TreeAccumulator[Type]:
-          def apply(x: Type, tree: Tree)(using Context): Type =
-            if tm.isRange(x) then x
-            else
-              val tp1 = tm(tree.tpe)
-              foldOver(if !tp1.exists || tp1.eql(tree.tpe) then x else tp1, tree)
-        val diff = findDiff(NoType, args)
-        if tm.isRange(diff) then EmptyAnnotation
-        else if diff.exists then derivedAnnotation(tm.mapOver(tree))
-        else this
+    def mapWith(tm: TypeMap)(using Context): Annotation =
+      tpd.allArguments(tree) match
+        case Nil => this
+
+        case arg :: Nil if symbol.isRetainsLike =>
+
+          // Map all skolems (?n: T) to (?n: Any), and drop all annotations.
+          // Skolems and annotated types are not allowed in a retains annotation anyway,
+          // so the underlying type does not matter. This simplification prevents
+          // exponential blowup in some cases. See i24556.scala and i24556a.scala.
+          def sanitize(tp: Type): Type = tp match
+            case SkolemType(_) => SkolemType(defn.AnyType)
+            case AnnotatedType(parent, _) => parent
+            case tp @ OrType(tp1, tp2) => tp.derivedOrType(sanitize(tp1), sanitize(tp2))
+            case _ => tp
+
+          def rebuild(tree: Tree, mappedType: Type): Tree = tree match
+            case Apply(fn, Nil) => cpy.Apply(tree)(rebuild(fn, mappedType), Nil)
+            case TypeApply(fn, arg :: Nil) => cpy.TypeApply(tree)(fn, TypeTree(mappedType) :: Nil)
+            case Block(Nil, expr) => rebuild(expr, mappedType)
+
+          if !Feature.ccEnabledSomewhere then
+            EmptyAnnotation // strip retains-like annotations unless capture checking is enabled
+          else
+            val mappedType = sanitize(tm(arg.tpe))
+            if mappedType eq arg.tpe then this
+            else derivedAnnotation(rebuild(tree, mappedType))
+
+        case args =>
+          // Checks if `tm` would result in any change by applying it to types
+          // inside the annotations' arguments and checking if the resulting types
+          // are different.
+          val findDiff = new TreeAccumulator[Type]:
+            def apply(x: Type, tree: Tree)(using Context): Type =
+              if tm.isRange(x) then x
+              else
+                val tp1 = tm(tree.tpe)
+                foldOver(if !tp1.exists || tp1.eql(tree.tpe) then x else tp1, tree)
+          val diff = findDiff(NoType, args)
+          if tm.isRange(diff) then EmptyAnnotation
+          else if diff.exists then derivedAnnotation(tm.mapOver(tree))
+          else this
+    end mapWith
 
     /** Does this annotation refer to a parameter of `tl`? */
     def refersToParamOf(tl: TermLambda)(using Context): Boolean =
@@ -303,7 +331,7 @@ object Annotations {
         case annot @ ExperimentalAnnotation(msg) => ExperimentalAnnotation(msg, annot.tree.span)
       }
   }
-  
+
   object PreviewAnnotation {
     /** Matches and extracts the message from an instance of `@preview(msg)`
      *  Returns `Some("")` for `@preview` with no message.

tests/pos-custom-args/captures/i24556.scala

@@ -0,0 +1,35 @@
+import language.experimental.captureChecking
+
+trait Item
+
+trait ItOps[+T, +CC[_], +C]:
+  def ++[B >: T](other: It[B]^): CC[B]^{this, other}
+
+trait It[+T] extends ItOps[T, It, It[T]]
+
+trait Sq[+T] extends It[T] with ItOps[T, Seq, Seq[T]]
+
+def items: Sq[Item] = ???
+
+@main def main(): It[Item] =
+  items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items

tests/pos-custom-args/captures/i24556a.scala

@@ -0,0 +1,27 @@
+import language.experimental.captureChecking
+
+trait Item
+def items : Seq[Item] = ???
+
+@main def main() =
+  items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items
+  ++ items