Represent all retains annotations as CompactAnnotations

Author: odersky

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

@@ -14,7 +14,7 @@ import Annotations.Annotation
 import CaptureSet.VarState
 import Capabilities.*
 import Mutability.isStatefulType
-import StdNames.nme
+import StdNames.{nme, tpnme}
 import config.Feature
 import NameKinds.TryOwnerName
 import typer.ProtoTypes.WildcardSelectionProto
@@ -547,11 +547,13 @@ extension (sym: Symbol)
 
   /** This symbol is one of `retains` or `retainsCap` */
   def isRetains(using Context): Boolean =
-    sym == defn.RetainsAnnot || sym == defn.RetainsCapAnnot
+    sym.name == tpnme.retains && sym == defn.RetainsAnnot
+    || sym.name == tpnme.retainsCap && sym == defn.RetainsCapAnnot
 
   /** This symbol is one of `retains`, `retainsCap`, or`retainsByName` */
   def isRetainsLike(using Context): Boolean =
-    isRetains || sym == defn.RetainsByNameAnnot
+    isRetains
+    || sym.name == tpnme.retainsByName && sym == defn.RetainsByNameAnnot
 
   /** A class is pure if:
    *   - one its base types has an explicitly declared self type with an empty capture set
@@ -658,7 +660,8 @@ 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 if CC is enabled.
+ *  or transform them into RetainingTypes with Nothing 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

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

@@ -59,7 +59,7 @@ object ccConfig:
 
   /** Not used currently. Handy for trying out new features */
   def newScheme(using ctx: Context): Boolean =
-    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.9`)
+    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
 
   def allowUse(using Context): Boolean =
     Feature.sourceVersion.stable.isAtMost(SourceVersion.`3.7`)

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

@@ -85,12 +85,8 @@ object Annotations {
             EmptyAnnotation // strip retains-like annotations unless capture checking is enabled
           else
             val mappedType = sanitize(tm(arg.tpe))
-            if mappedType `eql` arg.tpe then
-              this
-            else if cc.ccConfig.newScheme then
-              CompactAnnotation(symbol.typeRef.appliedTo(mappedType))
-            else
-              derivedAnnotation(rebuild(tree, mappedType))
+            if mappedType `eql` arg.tpe then this
+            else CompactAnnotation(symbol.typeRef.appliedTo(mappedType))
 
         case args =>
           // Checks if `tm` would result in any change by applying it to types
@@ -185,16 +181,16 @@ object Annotations {
         case _ => None
 
     override def mapWith(tm: TypeMap)(using Context): Annotation =
-      def derived(tp: Type) =
-        if tm.isRange(tp) then EmptyAnnotation else derivedAnnotation(tp)
-      def sanitizeArg(tp: Type) = tp match
-        case tp @ AppliedType(tycon, args) =>
-          tp.derivedAppliedType(tycon, args.mapConserve(sanitize))
+      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 _ =>
-          tp
-      if !symbol.isRetainsLike then derived(tm(tp))
-      else if Feature.ccEnabledSomewhere then derived(sanitizeArg(tm(tp)))
-      else EmptyAnnotation // strip retains-like annotations unless capture checking is enabled
+          EmptyAnnotation
 
     override def refersToParamOf(tl: TermLambda)(using Context): Boolean =
       refersToLambdaParam(tp, tl)
@@ -203,6 +199,12 @@ object Annotations {
     override def eql(that: Annotation) = that match
       case that: CompactAnnotation => this.tp `eql` that.tp
       case _ => false
+
+  object CompactAnnotation:
+    def apply(tree: Tree)(using Context): CompactAnnotation =
+      val argTypes = tpd.allArguments(tree).map(_.tpe)
+      apply(annotClass(tree).typeRef.appliedTo(argTypes))
+
   end CompactAnnotation
 
   /** Sanitize @retains arguments to approximate illegal types that could cause a compilation
@@ -313,7 +315,18 @@ object Annotations {
 
     def apply(tree: Tree): Annotation = tree match
       case tree: TypeTree => CompactAnnotation(tree.tpe)
-      case _ => ConcreteAnnotation(tree)
+      case _ =>
+        def assertNoRetains(t: Tree): Unit = t match
+          case Apply(fn, _) => assertNoRetains(fn)
+          case TypeApply(fn, _) => assertNoRetains(fn)
+          case Select(t, StdNames.nme.CONSTRUCTOR) => assertNoRetains(t)
+          case New(t) => assertNoRetains(t)
+          case t: RefTree =>
+            if t.name.toString == "retains" || t.name.toString == "retainsByName" then
+              new Error().printStackTrace()
+          case _ =>
+        //assertNoRetains(tree)
+        ConcreteAnnotation(tree)
 
     def apply(cls: ClassSymbol, span: Span)(using Context): Annotation =
       apply(cls, Nil, span)
@@ -328,7 +341,9 @@ object Annotations {
       apply(atp, arg :: Nil, span)
 
     def apply(atp: Type, args: List[Tree], span: Span)(using Context): Annotation =
-      apply(New(atp, args).withSpan(span))
+      if atp.typeSymbol.isRetainsLike && args.isEmpty
+      then CompactAnnotation(atp)
+      else apply(New(atp, args).withSpan(span))
 
     /** Create an annotation where the tree is computed lazily. */
     def deferred(sym: Symbol)(treeFn: Context ?=> Tree): Annotation =

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -201,8 +201,10 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       inJavaAnnot = annot.symbol.is(JavaDefined)
       if (inJavaAnnot) checkValidJavaAnnotation(annot)
       try
-        val annotCtx = if annot.hasAttachment(untpd.RetainsAnnot)
-          then ctx.addMode(Mode.InCaptureSet) else ctx
+        val annotCtx =
+          if annot.hasAttachment(untpd.RetainsAnnot)
+          then ctx.addMode(Mode.InCaptureSet)
+          else ctx
         transform(annot)(using annotCtx)
       finally inJavaAnnot = saved
     }

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

@@ -11,7 +11,7 @@ import NameOps.*
 import collection.mutable
 import reporting.*
 import Checking.{checkNoPrivateLeaks, checkNoWildcard}
-import cc.CaptureSet
+import cc.{CaptureSet, isRetainsLike}
 import util.Property
 import transform.Splicer
 
@@ -572,7 +572,10 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(using Context): Annotated = {
     assert(tree.isType) // annotating a term is done via a Typed node, can't use Annotate directly
-    tree.withType(AnnotatedType(arg.tpe, Annotation(annot)))
+    val ann =
+      if annotClass(annot).isRetainsLike then CompactAnnotation(annot)
+      else Annotation(annot)
+    tree.withType(AnnotatedType(arg.tpe, ann))
   }
 
   def assignType(tree: untpd.PackageDef, pid: Tree)(using Context): PackageDef =

tests/neg-custom-args/captures/lazyvals.check

@@ -16,7 +16,7 @@
    |                              Note that capability console is not included in capture set {x}.
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/lazyvals.scala:16:18 ----------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/lazyvals.scala:16:12 ----------------------------------------------------------
 16 |  val fun3: () ->{x} String = () => x() // error // error
-   |                  ^
-   |                  (x : () -> String) cannot be tracked since its capture set is empty
+   |            ^^^^^^^^^^^^^^^
+   |            (x : () -> String) cannot be tracked since its capture set is empty

tests/neg-custom-args/captures/spread-problem.check

@@ -7,6 +7,8 @@
 11 |  race(src1, src2) // error
    |       ^^^^^^^^^^
    |       Found:    (Source[T]^, Source[T]^)
-   |       Required: Seq[Source[T]^]
+   |       Required: Seq[Source[T]^{C}]
+   |
+   |       where:    C is a type variable with constraint >: scala.caps.CapSet and <: scala.caps.CapSet^
    |
    | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/wf-reach-1.check

@@ -1,4 +1,4 @@
--- Error: tests/neg-custom-args/captures/wf-reach-1.scala:2:17 ---------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/wf-reach-1.scala:2:9 ----------------------------------------------------------
 2 |  val y: Object^{x*} = ??? // error
-  |                 ^^
-  |                 x* cannot be tracked since its deep capture set is empty
+  |         ^^^^^^^^^^^
+  |         x* cannot be tracked since its deep capture set is empty