Handle CapsOf in more places

Author: noti0na1

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

@@ -198,7 +198,7 @@ extension (tp: Type)
       || tp.isRootCapability
       ) && !tp.symbol.isOneOf(UnstableValueFlags)
     case tp: TypeRef =>
-      tp.symbol.isAbstractOrParamType && tp.derivesFrom(defn.Caps_CapSet)
+      tp.symbol.isType && tp.derivesFrom(defn.Caps_CapSet)
     case tp: TypeParamRef =>
       tp.derivesFrom(defn.Caps_CapSet)
     case AnnotatedType(parent, annot) =>

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

@@ -140,6 +140,8 @@ trait CaptureRef extends TypeProxy, ValueType:
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
         case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TermParamRef => subsumesExistentially(x, y)
+        case x: TypeRef if x.symbol.info.derivesFrom(defn.Caps_CapSet) =>
+          x.captureSetOfInfo.elems.exists(_.subsumes(y))
         case x: TypeRef => assumedContainsOf(x).contains(y)
         case _ => false
   end subsumes

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

@@ -132,7 +132,7 @@ object CheckCaptures:
       elem match
         case CapsOfApply(arg) =>
           def isLegalCapsOfArg =
-            arg.symbol.isAbstractOrParamType && arg.symbol.info.derivesFrom(defn.Caps_CapSet)
+            arg.symbol.isType && arg.symbol.info.derivesFrom(defn.Caps_CapSet)
           if !isLegalCapsOfArg then
             report.error(
               em"""$arg is not a legal prefix for `^` here,

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

@@ -4007,7 +4007,7 @@ object Types extends TypeUtils {
                 (compute(status, parent, theAcc) /: refs.elems) {
                   (s, ref) => ref.stripReach match
                     case tp: TermParamRef if tp.binder eq thisLambdaType => combine(s, CaptureDeps)
-                    case _ => s
+                    case tp => combine(s, compute(status, tp, theAcc))
                 }
               case _ =>
                 if tp.annot.refersToParamOf(thisLambdaType) then TrueDeps
@@ -6077,6 +6077,8 @@ object Types extends TypeUtils {
         case tp: CaptureRef =>
           if tp.isTrackableRef then tp
           else ensureTrackable(tp.underlying)
+        case tp: TypeAlias =>
+          ensureTrackable(tp.alias)
         case _ =>
           assert(false, i"not a trackable captureRef ref: $result, ${result.underlyingIterator.toList}")
       ensureTrackable(result)

tests/neg-custom-args/captures/capture-poly.scala

@@ -0,0 +1,25 @@
+import caps.*
+
+trait Foo extends Capability
+
+trait CaptureSet:
+  type C <: CapSet^
+
+def capturePoly[C^](a: Foo^{C^}): Foo^{C^} = a
+def capturePoly2(c: CaptureSet)(a: Foo^{c.C^}): Foo^{c.C^} = a
+
+def test =
+  val x: Foo^ = ???
+  val y: Foo^ = ???
+
+  object X extends CaptureSet:
+    type C = CapSet^{x}
+
+  val z1: Foo^{X.C^} = x
+  val z2: Foo^{X.C^} = y // error
+
+  val z3: Foo^{x} = capturePoly(x)
+  val z4: Foo^{x} = capturePoly(y) // error
+
+  val z5: Foo^{x} = capturePoly2(X)(x)
+  val z6: Foo^{x} = capturePoly2(X)(y) // error