Classify existential variables as root capabilities

Allows some simplifications in the zoo of classification methods.

Author: odersky

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

@@ -434,6 +434,13 @@ extension (tp: Type)
     && tp.membersBasedOnFlags(Mutable | Method, EmptyFlags)
       .exists(_.hasAltWith(_.symbol.isUpdateMethod))
 
+  /** Knowing that `tp` is a function type, is it an alias to a function other
+   *  than `=>`?
+   */
+  def isAliasFun(using Context) = tp match
+    case AppliedType(tycon, _) => !defn.isFunctionSymbol(tycon.typeSymbol)
+    case _ => false
+
   /** Tests whether the type derives from `caps.Capability`, which means
    *  references of this type are maximal capabilities.
    */

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

@@ -42,7 +42,7 @@ trait CaptureRef extends TypeProxy, ValueType:
    *  set of the underlying type is not always empty.
    */
   final def isTracked(using Context): Boolean =
-    this.isTrackableRef && (isMaxCapability || !captureSetOfInfo.isAlwaysEmpty)
+    this.isTrackableRef && (isRootCapability || !captureSetOfInfo.isAlwaysEmpty)
 
   /** Is this a maybe reference of the form `x?`? */
   final def isMaybe(using Context): Boolean = this ne stripMaybe
@@ -102,25 +102,16 @@ trait CaptureRef extends TypeProxy, ValueType:
 
   /** Is this reference one of the generic root capabilities `cap` or `cap.rd` ? */
   final def isRootCapability(using Context): Boolean = this match
-    case ReadOnlyCapability(tp1) => tp1.isCapOrFresh
-    case _ => isCapOrFresh
-
-  /** Is this reference a capability that does not derive from another capability?
-   *  Includes read-only versions of maximal capabilities.
-   */
-  final def isMaxCapability(using Context): Boolean = this match
-    case tp: TermRef => tp.isCap || tp.info.derivesFrom(defn.Caps_Exists)
+    case ReadOnlyCapability(tp1) => tp1.isRootCapability
     case Existential.Vble(_) => true
-    case Fresh(_) => true
-    case ReadOnlyCapability(tp1) => tp1.isMaxCapability
-    case _ => false
+    case _ => isCapOrFresh
 
   /** An exclusive capability is a capability that derives
    *  indirectly from a maximal capability without going through
    *  a read-only capability first.
    */
   final def isExclusive(using Context): Boolean =
-    !isReadOnly && (isMaxCapability || captureSetOfInfo.isExclusive)
+    !isReadOnly && (isRootCapability || captureSetOfInfo.isExclusive)
 
   // With the support of paths, we don't need to normalize the `TermRef`s anymore.
   // /** Normalize reference so that it can be compared with `eq` for equality */

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

@@ -91,22 +91,13 @@ sealed abstract class CaptureSet extends Showable:
   final def isUniversal(using Context) =
     elems.exists(_.isCap)
 
-  /** Does this capture set contain the root reference `cap` as element? */
-  final def isUniversalOrFresh(using Context) =
-    elems.exists(_.isCapOrFresh)
-
   /** Does this capture set contain a root reference `cap` or `cap.rd` as element? */
   final def containsRootCapability(using Context) =
     elems.exists(_.isRootCapability)
 
   final def containsCap(using Context) =
     elems.exists(_.stripReadOnly.isCap)
 
-  final def isUnboxable(using Context) =
-    elems.exists:
-      case Existential.Vble(_) => true
-      case elem => elem.isRootCapability
-
   final def isReadOnly(using Context): Boolean =
     elems.forall(_.isReadOnly)
 
@@ -151,7 +142,7 @@ sealed abstract class CaptureSet extends Showable:
    *  capture set.
    */
   protected final def addNewElem(elem: CaptureRef)(using ctx: Context, vs: VarState): CompareResult =
-    if elem.isMaxCapability || !vs.isOpen then
+    if elem.isRootCapability || !vs.isOpen then
       addThisElem(elem)
     else
       addThisElem(elem).orElse:
@@ -195,7 +186,7 @@ sealed abstract class CaptureSet extends Showable:
       elems.exists(_.subsumes(x))
       || // Even though subsumes already follows captureSetOfInfo, this is not enough.
          // For instance x: C^{y, z}. Then neither y nor z subsumes x but {y, z} accounts for x.
-        !x.isMaxCapability
+        !x.isRootCapability
         && !x.derivesFrom(defn.Caps_CapSet)
         && !(vs.isSeparating && x.captureSetOfInfo.containsRootCapability)
            // in VarState.Separate, don't try to widen to cap since that might succeed with {cap} <: {cap}
@@ -216,7 +207,7 @@ sealed abstract class CaptureSet extends Showable:
   def mightAccountFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true):
       elems.exists(_.subsumes(x)(using ctx, VarState.ClosedUnrecorded))
-      || !x.isMaxCapability
+      || !x.isRootCapability
         && {
           val elems = x.captureSetOfInfo.elems
           !elems.isEmpty && elems.forall(mightAccountFor)
@@ -352,7 +343,7 @@ sealed abstract class CaptureSet extends Showable:
 
   /** Invoke handler if this set has (or later aquires) the root capability `cap` */
   def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
-    if isUnboxable then handler()
+    if containsRootCapability then handler()
     this
 
   /** Invoke handler on the elements to ensure wellformedness of the capture set.
@@ -1302,7 +1293,7 @@ object CaptureSet:
     case ReadOnlyCapability(ref1) =>
       ref1.captureSetOfInfo.map(ReadOnlyMap())
     case _ =>
-      if ref.isMaxCapability then ref.singletonCaptureSet
+      if ref.isRootCapability then ref.singletonCaptureSet
       else ofType(ref.underlying, followResult = false)
 
   /** Capture set of a type
@@ -1435,7 +1426,7 @@ object CaptureSet:
     override def toAdd(using Context) =
       for CompareResult.LevelError(cs, ref) <- ccState.levelError.toList yield
         ccState.levelError = None
-        if ref.isRootCapability then
+        if ref.stripReadOnly.isCapOrFresh then
           def capStr = if ref.isReadOnly then "cap.rd" else "cap"
           i"""
             |

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

@@ -496,7 +496,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             val underlying = CaptureSet.ofTypeDeeply(c1.widen)
             capt.println(i"Widen reach $c to $underlying in ${env.owner}")
             if ccConfig.useSepChecks then
-              recur(underlying.filter(!_.isMaxCapability), env, null)
+              recur(underlying.filter(!_.isRootCapability), env, null)
                 // we don't want to disallow underlying Fresh instances, since these are typically locally created
                 // fresh capabilities. We don't need to also follow the hidden set since separation
                 // checking makes ure that locally hidden references need to go to @consume parameters.
@@ -1771,7 +1771,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                 case ref: TermParamRef
                 if !allowed.contains(ref) && !seen.contains(ref) =>
                   seen += ref
-                  if ref.isMaxCapability then
+                  if ref.isRootCapability then
                     report.error(i"escaping local reference $ref", tree.srcPos)
                   else
                     val widened = ref.captureSetOfInfo

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

@@ -250,13 +250,6 @@ object Existential:
     subst(tp)
   end toCap
 
-  /** Knowing that `tp` is a function type, is it an alias to a function other
-   *  than `=>`?
-   */
-  private def isAliasFun(tp: Type)(using Context) = tp match
-    case AppliedType(tycon, _) => !defn.isFunctionSymbol(tycon.typeSymbol)
-    case _ => false
-
   /** Replace all occurrences of `cap` (or fresh) in parts of this type by an existentially bound
    *  variable bound by `mt`.
    *  Stop at function or method types since these have been mapped before.
@@ -265,7 +258,7 @@ object Existential:
 
     abstract class CapMap extends BiTypeMap:
       override def mapOver(t: Type): Type = t match
-        case t @ FunctionOrMethod(args, res) if variance > 0 && !isAliasFun(t) =>
+        case t @ FunctionOrMethod(args, res) if variance > 0 && !t.isAliasFun =>
           t // `t` should be mapped in this case by a different call to `mapCap`.
         case t: (LazyRef | TypeVar) =>
           mapConserveSuper(t)

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

@@ -185,7 +185,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
      *   3. if `f in F` then the footprint of `f`'s info is also in `F`.
      */
     private def footprint(includeMax: Boolean = false)(using Context): Refs =
-      def retain(ref: CaptureRef) = includeMax || !ref.isMaxCapability
+      def retain(ref: CaptureRef) = includeMax || !ref.isRootCapability
       def recur(elems: Refs, newElems: List[CaptureRef]): Refs = newElems match
         case newElem :: newElems1 =>
           val superElems = newElem.captureSetOfInfo.elems.filter: superElem =>
@@ -210,7 +210,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
                   else hidden.superCaps
                 recur(seen + newElem, acc, superCaps ++ newElems)
             case _ =>
-              if newElem.isMaxCapability
+              if newElem.isRootCapability
                 //|| newElem.isInstanceOf[TypeRef | TypeParamRef]
               then recur(seen + newElem, acc, newElems1)
               else recur(seen + newElem, acc, newElem.captureSetOfInfo.elems.toList ++ newElems1)

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

@@ -926,7 +926,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     def apply(t: Type) = t match
       case t @ CapturingType(parent, refs) =>
         val parent1 = this(parent)
-        if refs.isUniversalOrFresh then t.derivedCapturingType(parent1, CaptureSet.Fluid)
+        if refs.containsRootCapability then t.derivedCapturingType(parent1, CaptureSet.Fluid)
         else t
       case _ => mapFollowingAliases(t)
 
@@ -982,7 +982,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           for
             j <- 0 until retained.length if j != i
             r <- retained(j).toCaptureRefs
-            if !r.isMaxCapability
+            if !r.isRootCapability
           yield r
         val remaining = CaptureSet(others*)
         check(remaining, remaining)