An alternative way to refer to * with no -Ycc set

Author: odersky

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

@@ -690,7 +690,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       /** Destruct a capturing type `tp` to a tuple (cs, tp0, boxed),
        *  where `tp0` is not a capturing type.
-       * 
+       *
        *  If `tp` is a nested capturing type, the return tuple always represents
        *  the innermost capturing type. The outer capture annotations can be
        *  reconstructed with the returned function.

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

@@ -1023,6 +1023,7 @@ class Definitions {
   @tu lazy val RequiresCapabilityAnnot: ClassSymbol = requiredClass("scala.annotation.internal.requiresCapability")
   @tu lazy val RetainsAnnot: ClassSymbol = requiredClass("scala.annotation.retains")
   @tu lazy val RetainsByNameAnnot: ClassSymbol = requiredClass("scala.annotation.retainsByName")
+  @tu lazy val RetainsUniversalAnnot: ClassSymbol = requiredClass("scala.annotation.retainsUniversal")
 
   @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
 

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

@@ -2669,9 +2669,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   end typedPackageDef
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree = {
-    val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
-    if Annotations.annotClass(annot1) == defn.NowarnAnnot then
+    var annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
+    val annotCls = Annotations.annotClass(annot1)
+    if annotCls == defn.NowarnAnnot then
       registerNowarn(annot1, tree)
+    else if annotCls == defn.RetainsUniversalAnnot then
+      annot1 = typedExpr(
+        untpd.New(
+          untpd.TypeTree(defn.RetainsAnnot.typeRef),
+          (untpd.ref(defn.captureRoot) :: Nil) :: Nil).withSpan(tree.annot.span),
+        defn.AnnotationClass.typeRef)
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type) {
       val cls = annot1.symbol.maybeOwner

library/src/scala/annotation/retains.scala

@@ -14,3 +14,5 @@ package scala.annotation
 // @experimental // suppressed so we can use in compiler
 class retains(xs: Any*) extends annotation.StaticAnnotation
 
+// @experimental // suppressed so we can use in compiler
+class retainsUniversal extends annotation.StaticAnnotation

tests/pos-custom-args/captures/caps-universal.scala

@@ -0,0 +1,7 @@
+import annotation.retainsUniversal
+
+val foo: Int => Int = x => x
+val bar: (Int -> Int) @retainsUniversal = foo
+val baz: {*} Int -> Int = bar
+
+