Two fixes to handling of abstract types with cap bounds

 1. Strip implied cap.rd sets from Capability types in extends and bounds

    I.e. We do not add an implicit cap.rd in

       class C extends Capability
       type T <: C

 2. Don't map CapSet^ to CapSet^{fresh}. Assume `^` is root in some comparisons
    with CapSet.

Author: odersky

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

@@ -1341,7 +1341,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         else if !owner.exists then false
         else isPure(owner.info) && isPureContext(owner.owner, limit)
 
-      // Augment expeced capture set `erefs` by all references in actual capture
+      // Augment expected capture set `erefs` by all references in actual capture
       // set `arefs` that are outside some `C.this.type` reference in `erefs` for an enclosing
       // class `C`. If an added reference is not a ThisType itself, add it to the capture set
       // (i.e. use set) of the `C`. This makes sure that any outer reference implicitly subsumed

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

@@ -336,6 +336,20 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     def fail(msg: Message) =
       if !tptToCheck.isEmpty then report.error(msg, tptToCheck.srcPos)
 
+    /** If C derives from Capability and we have a C^cs in source, we leave it as is
+     *  instead of expanding it to C^{cap.rd}^cs. We do this by stripping capability-generated
+     *  universal capture sets from the parent of a CapturingType.
+     */
+    def stripImpliedCaptureSet(tp: Type): Type = tp match
+      case tp @ CapturingType(parent, refs)
+      if (refs eq CaptureSet.universalImpliedByCapability) && !tp.isBoxedCapturing =>
+        parent
+      case tp: AliasingBounds =>
+        tp.derivedAlias(stripImpliedCaptureSet(tp.alias))
+      case tp: RealTypeBounds =>
+        tp.derivedTypeBounds(stripImpliedCaptureSet(tp.lo), stripImpliedCaptureSet(tp.hi))
+      case _ => tp
+
     object toCapturing extends DeepTypeMap, SetupTypeMap:
       override def toString = "transformExplicitType"
 
@@ -367,16 +381,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           CapturingType(fntpe, cs, boxed = false)
         else fntpe
 
-      /** If C derives from Capability and we have a C^cs in source, we leave it as is
-       *  instead of expanding it to C^{cap.rd}^cs. We do this by stripping capability-generated
-       *  universal capture sets from the parent of a CapturingType.
-       */
-      def stripImpliedCaptureSet(tp: Type): Type = tp match
-        case tp @ CapturingType(parent, refs)
-        if (refs eq CaptureSet.universalImpliedByCapability) && !tp.isBoxedCapturing =>
-          parent
-        case _ => tp
-
       /** Check that types extending SharedCapability don't have a `cap` in their capture set.
        *  TODO This is not enough.
        *  We need to also track that we cannot get exclusive capabilities in paths
@@ -456,8 +460,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         toCapturing.keepFunAliases = false
         transform(tp1)
       else tp1
-    if freshen then root.capToFresh(tp2).tap(addOwnerAsHidden(_, sym))
-    else tp2
+    val tp3 =
+      if sym.isType then stripImpliedCaptureSet(tp2)
+      else tp2
+    if freshen then root.capToFresh(tp3).tap(addOwnerAsHidden(_, sym))
+    else tp3
   end transformExplicitType
 
   /** Substitute parameter symbols in `from` to paramRefs in corresponding

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

@@ -162,7 +162,9 @@ object root:
     case _ if root.isCap => Some(Kind.Global)
     case _ => None
 
-  /** Map each occurrence of cap to a different Sep.Cap instance */
+  /** Map each occurrence of cap to a different Fresh instance
+   *  Exception: CapSet^ stays as it is.
+   */
   class CapToFresh(owner: Symbol)(using Context) extends BiTypeMap, FollowAliasesMap:
     thisMap =>
 
@@ -171,6 +173,8 @@ object root:
       else t match
         case t: CaptureRef if t.isCap =>
           Fresh.withOwner(owner)
+        case t @ CapturingType(parent: TypeRef, _) if parent.symbol == defn.Caps_CapSet =>
+          t
         case t @ CapturingType(_, _) =>
           mapOver(t)
         case t @ AnnotatedType(parent, ann) =>

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

@@ -426,7 +426,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             if (tp1.prefix.isStable) return tryLiftedToThis1
           case _ =>
             if isCaptureVarComparison then
-              return subCaptures(tp1.captureSet, tp2.captureSet).isOK
+              return CCState.withCapAsRoot:
+                subCaptures(tp1.captureSet, tp2.captureSet).isOK
             if (tp1 eq NothingType) || isBottom(tp1) then
               return true
         }
@@ -575,7 +576,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           && (isBottom(tp1) || GADTusage(tp2.symbol))
 
         if isCaptureVarComparison then
-          return subCaptures(tp1.captureSet, tp2.captureSet).isOK
+          return CCState.withCapAsRoot:
+            subCaptures(tp1.captureSet, tp2.captureSet).isOK
 
         isSubApproxHi(tp1, info2.lo) && (trustBounds || isSubApproxHi(tp1, info2.hi))
         || compareGADT

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

@@ -8,7 +8,7 @@ import NameKinds.DefaultGetterName
 import NullOpsDecorator.*
 import collection.immutable.BitSet
 import scala.annotation.tailrec
-import cc.isCaptureChecking
+import cc.{isCaptureChecking, CCState}
 
 import scala.compiletime.uninitialized
 
@@ -215,14 +215,15 @@ object OverridingPairs:
     if member.isType then // intersection of bounds to refined types must be nonempty
       memberTp.bounds.hi.hasSameKindAs(otherTp.bounds.hi)
       && (
-        (memberTp frozen_<:< otherTp)
-        || !member.owner.derivesFrom(other.owner)
-            && {
-              // if member and other come from independent classes or traits, their
-              // bounds must have non-empty-intersection
-              val jointBounds = (memberTp.bounds & otherTp.bounds).bounds
-              jointBounds.lo frozen_<:< jointBounds.hi
-            }
+        CCState.withCapAsRoot: // If upper bound is CapSet^ any capture set of lower bound is OK
+          (memberTp frozen_<:< otherTp)
+          || !member.owner.derivesFrom(other.owner)
+              && {
+                // if member and other come from independent classes or traits, their
+                // bounds must have non-empty-intersection
+                val jointBounds = (memberTp.bounds & otherTp.bounds).bounds
+                jointBounds.lo frozen_<:< jointBounds.hi
+              }
       )
     else
       member.name.is(DefaultGetterName) // default getters are not checked for compatibility

tests/pos-custom-args/captures/check-override-typebounds.scala

@@ -0,0 +1,16 @@
+import language.experimental.captureChecking
+
+trait A:
+  type T <: caps.Capability
+
+class B extends A:
+  type T = C
+
+class C extends caps.Capability
+
+
+trait A2:
+  type T[Cap^]
+
+  def takesCap[Cap^](t: T[Cap]): Unit
+