Refine class refinements

 - Use a uniform criterion when to add them
 - Don't add them for @constructorOnly or @cc.untrackedCaptures arguments

@untrackedCaptures is a new annotation

Author: odersky

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

@@ -467,41 +467,17 @@ extension (sym: Symbol)
     && !sym.allowsRootCapture
     && sym != defn.Caps_unsafeBox
     && sym != defn.Caps_unsafeUnbox
-
-  /** Does this symbol define a level where we do not want to let local variables
-   *  escape into outer capture sets?
-   */
-  def isLevelOwner(using Context): Boolean =
-    sym.isClass
-    || sym.is(Method, butNot = Accessor)
-
-  /** The owner of the current level. Qualifying owners are
-   *   - methods, other than accessors
-   *   - classes, if they are not staticOwners
-   *   - _root_
-   */
-  def levelOwner(using Context): Symbol =
-    def recur(sym: Symbol): Symbol =
-      if !sym.exists || sym.isRoot || sym.isStaticOwner then defn.RootClass
-      else if sym.isLevelOwner then sym
-      else recur(sym.owner)
-    recur(sym)
-
-  /** The outermost symbol owned by both `sym` and `other`. if none exists
-   *  since the owning scopes of `sym` and `other` are not nested, invoke
-   *  `onConflict` to return a symbol.
-   */
-  def maxNested(other: Symbol, onConflict: (Symbol, Symbol) => Context ?=> Symbol)(using Context): Symbol =
-    if !sym.exists || other.isContainedIn(sym) then other
-    else if !other.exists || sym.isContainedIn(other) then sym
-    else onConflict(sym, other)
-
-  /** The innermost symbol owning both `sym` and `other`.
-   */
-  def minNested(other: Symbol)(using Context): Symbol =
-    if !other.exists || other.isContainedIn(sym) then sym
-    else if !sym.exists || sym.isContainedIn(other) then other
-    else sym.owner.minNested(other.owner)
+    && !defn.isPolymorphicAfterErasure(sym)
+
+  def isRefiningParamAccessor(using Context): Boolean =
+    sym.is(ParamAccessor)
+    && {
+      val param = sym.owner.primaryConstructor.paramSymss
+        .nestedFind(_.name == sym.name)
+        .getOrElse(NoSymbol)
+      !param.hasAnnotation(defn.ConstructorOnlyAnnot)
+      && !param.hasAnnotation(defn.UntrackedCapturesAnnot)
+    }
 
 extension (tp: AnnotatedType)
   /** Is this a boxed capturing type? */

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

@@ -550,8 +550,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           var allCaptures: CaptureSet =
             if core.derivesFromCapability then CaptureSet.universal else initCs
           for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
-            val getter = cls.info.member(getterName).suchThat(_.is(ParamAccessor)).symbol
-            if getter.termRef.isTracked && !getter.is(Private) then
+            val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
+            if !getter.is(Private) && getter.termRef.isTracked then
               refined = RefinedType(refined, getterName, argType)
               allCaptures ++= argType.captureSet
           (refined, allCaptures)
@@ -764,7 +764,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         val thisSet = cls.classInfo.selfType.captureSet.withDescription(i"of the self type of $cls")
         checkSubset(localSet, thisSet, tree.srcPos) // (2)
         for param <- cls.paramGetters do
-          if !param.hasAnnotation(defn.ConstructorOnlyAnnot) then
+          if !param.hasAnnotation(defn.ConstructorOnlyAnnot)
+            && !param.hasAnnotation(defn.UntrackedCapturesAnnot) then
             checkSubset(param.termRef.captureSet, thisSet, param.srcPos) // (3)
         for pureBase <- cls.pureBaseClass do // (4)
           def selfType = impl.body

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

@@ -69,9 +69,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case _ => foldOver(x, tp)
       def apply(tp: Type): Boolean = apply(false, tp)
 
-    if symd.isAllOf(PrivateParamAccessor)
+    if symd.symbol.isRefiningParamAccessor
+        && symd.is(Private)
         && symd.owner.is(CaptureChecked)
-        && !symd.hasAnnotation(defn.ConstructorOnlyAnnot)
         && containsCovarRetains(symd.symbol.originDenotation.info)
     then symd.flags &~ Private
     else symd.flags
@@ -186,6 +186,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             if !defn.isFunctionClass(cls) && cls.is(CaptureChecked) =>
               cls.paramGetters.foldLeft(tp) { (core, getter) =>
                 if atPhase(thisPhase.next)(getter.termRef.isTracked)
+                    && getter.isRefiningParamAccessor
                     && !getter.is(Tracked)
                 then
                   val getterType =

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

@@ -1053,6 +1053,7 @@ class Definitions {
   @tu lazy val UncheckedStableAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
   @tu lazy val UncheckedVarianceAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedVariance")
   @tu lazy val UncheckedCapturesAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedCaptures")
+  @tu lazy val UntrackedCapturesAnnot: ClassSymbol = requiredClass("scala.caps.untrackedCaptures")
   @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
   @tu lazy val BeanGetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanGetter")
   @tu lazy val BeanSetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanSetter")

library/src/scala/caps.scala

@@ -28,6 +28,11 @@ import annotation.experimental
    */
   sealed trait Exists extends Capability
 
+  /** This should go into annotations. For now it is here, so that we
+   *  can experiment with it quickly between minor releases
+   */
+  final class untrackedCaptures extends annotation.StaticAnnotation
+
   object unsafe:
 
     extension [T](x: T)