Tweak deep capture set computations

Author: odersky

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

@@ -223,6 +223,20 @@ extension (tp: Type)
     case tp: SingletonCaptureRef => tp.captureSetOfInfo
     case _ => CaptureSet.ofType(tp, followResult = false)
 
+  /** The deep capture set of a type.
+   *  For singleton capabilities `x` and reach capabilities `x*`, this is `{x*}`, provided
+   *  the underlying capture set resulting from traversing the type is non-empty.
+   *  For other types this is the union of all covariant capture sets embedded
+   *  in the type, as computed by `CaptureSet.ofTypeDeeply`.
+   */
+  def deepCaptureSet(using Context): CaptureSet =
+    val dcs = CaptureSet.ofTypeDeeply(tp)
+    if dcs.isAlwaysEmpty then dcs
+    else tp match
+      case tp @ ReachCapability(_) => tp.singletonCaptureSet
+      case tp: SingletonCaptureRef => tp.reach.singletonCaptureSet
+      case _ => dcs
+
   /** A type capturing `ref` */
   def capturing(ref: CaptureRef)(using Context): Type =
     if tp.captureSet.accountsFor(ref) then tp
@@ -587,7 +601,7 @@ extension (sym: Symbol)
     }
 
   def hasTrackedParts(using Context): Boolean =
-    !CaptureSet.deepCaptureSet(sym.info).isAlwaysEmpty
+    !CaptureSet.ofTypeDeeply(sym.info).isAlwaysEmpty
 
 extension (tp: AnnotatedType)
   /** Is this a boxed capturing type? */

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

@@ -1073,7 +1073,7 @@ object CaptureSet:
             case parent: SingletonCaptureRef if parent.isTrackableRef =>
               tp.singletonCaptureSet
             case _ =>
-              CaptureSet.deepCaptureSet(parent)
+              CaptureSet.ofTypeDeeply(parent)
         case tpd @ defn.RefinedFunctionOf(rinfo: MethodType) if followResult =>
           ofType(tpd.parent, followResult = false)             // pick up capture set from parent type
           ++ (recur(rinfo.resType)                             // add capture set of result
@@ -1099,12 +1099,17 @@ object CaptureSet:
     recur(tp)
       //.showing(i"capture set of $tp = $result", captDebug)
 
-  def deepCaptureSet(tp: Type)(using Context): CaptureSet =
+  /** The deep capture set of a type is the union of all covariant occurrences of
+   *  capture sets. Nested existential sets are approximated with `cap`.
+   */
+  def ofTypeDeeply(tp: Type)(using Context): CaptureSet =
     val collect = new TypeAccumulator[CaptureSet]:
       def apply(cs: CaptureSet, t: Type) = t.dealias match
         case t @ CapturingType(p, cs1) =>
           val cs2 = apply(cs, p)
           if variance > 0 then cs2 ++ cs1 else cs2
+        case t @ Existential(_, _) =>
+          apply(cs, Existential.toCap(t))
         case _ =>
           foldOver(cs, t)
     collect(CaptureSet.empty, tp)

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

@@ -548,8 +548,8 @@ class CheckCaptures extends Recheck, SymTransformer:
     def recheckArg(arg: Tree, formal: Type)(using Context): Type =
       val argType = recheck(arg, formal)
       if unboxedArgs.contains(arg) && ccConfig.useUnboxedParams then
-        capt.println(i"charging deep capture set of $arg: ${argType} = ${CaptureSet.deepCaptureSet(argType)}")
-        markFree(CaptureSet.deepCaptureSet(argType), arg.srcPos)
+        capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
+        markFree(argType.deepCaptureSet, arg.srcPos)
       argType
 
     /** A specialized implementation of the apply rule.
@@ -579,7 +579,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val argCaptures =
         for (arg, argType) <- tree.args.lazyZip(argTypes) yield
           if unboxedArgs.remove(arg) // need to ensure the remove happens, that's why argCaptures is computed even if not needed.
-          then CaptureSet.deepCaptureSet(argType)
+          then argType.deepCaptureSet
           else argType.captureSet
       appType match
         case appType @ CapturingType(appType1, refs)