Add a prefix to FreshCaps

Author: odersky

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

@@ -148,10 +148,21 @@ object Capabilities:
    *  @param origin  an indication where and why the FreshCap was created, used
    *                 for diagnostics
    */
-  case class FreshCap private (owner: Symbol, origin: Origin)(using @constructorOnly ctx: Context) extends RootCapability:
-    val hiddenSet = CaptureSet.HiddenSet(owner, this: @unchecked)
+  case class FreshCap(val prefix: Type)
+      (val owner: Symbol, val origin: Origin, origHidden: CaptureSet.HiddenSet | Null)
+      (using @constructorOnly ctx: Context)
+  extends RootCapability:
+    val hiddenSet =
+      if origHidden == null then CaptureSet.HiddenSet(owner, this: @unchecked)
+      else origHidden
       // fails initialization check without the @unchecked
 
+    def derivedFreshCap(newPrefix: Type)(using Context): FreshCap =
+      if newPrefix eq prefix then this
+      else FreshCap(newPrefix)(owner, origin, hiddenSet)
+
+    //assert(rootId != 10, i"fresh $prefix, ${ctx.owner}")
+
     /** Is this fresh cap (definitely) classified? If that's the case, the
      *  classifier cannot be changed anymore.
      *  We need to distinguish `FreshCap`s that can still be classified from
@@ -198,8 +209,10 @@ object Capabilities:
       i"a fresh root capability$classifierStr$originStr"
 
   object FreshCap:
+    def apply(prefix: Type, origin: Origin)(using Context): FreshCap =
+      new FreshCap(prefix)(ctx.owner, origin, null)
     def apply(origin: Origin)(using Context): FreshCap =
-      FreshCap(ctx.owner, origin)
+      apply(ctx.owner.skipWeakOwner.thisType, origin)
 
   /** A root capability associated with a function type. These are conceptually
    *  existentially quantified over the function's result type.
@@ -703,13 +716,23 @@ object Capabilities:
       (this eq y)
       || this.match
         case x: FreshCap =>
+          def prefixIsOpen(pre: Type): Boolean = pre match
+            case NoPrefix | _: ThisType => true
+            case pre: (TypeRef | AppliedType) if pre.typeSymbol == x.ccOwner.skipWeakOwner => true
+            case pre: TypeProxy => prefixIsOpen(pre.superType)
+            case _ => false
+
           vs.ifNotSeen(this)(x.hiddenSet.elems.exists(_.subsumes(y)))
           || x.acceptsLevelOf(y)
               && ( y.tryClassifyAs(x.hiddenSet.classifier)
                    || { capt.println(i"$y cannot be classified as $x"); false }
               )
               && canAddHidden
               && vs.addHidden(x.hiddenSet, y)
+              && (prefixIsOpen(x.prefix)
+                  /*|| { println(i"closed fresh $x, ${x.rootId}, ${x.prefix}, ${x.ccOwner.skipWeakOwner.thisType}")
+                       false
+                      }*/)
         case x: ResultCap =>
           val result = y match
             case y: ResultCap => vs.unify(x, y)

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

@@ -559,8 +559,10 @@ object CaptureSet:
   def universal(using Context): Const =
     Const(SimpleIdentitySet(GlobalCap))
 
+  def fresh(prefix: Type, origin: Origin)(using Context): Const =
+    FreshCap(prefix, origin).singletonCaptureSet
   def fresh(origin: Origin)(using Context): Const =
-    FreshCap(origin).singletonCaptureSet
+    fresh(ctx.owner.thisType, origin)
 
   /** The shared capture set `{cap.rd}` */
   def shared(using Context): Const =

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

@@ -694,7 +694,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                   if cls.derivesFrom(defn.Caps_Capability) then
                     // If cls is a capability class, we need to add a fresh readonly capability to
                     // ensure we cannot treat the class as pure.
-                    CaptureSet.fresh(Origin.InDecl(cls)).readOnly.subCaptures(cs)
+                    CaptureSet.fresh(cls.thisType, Origin.InDecl(cls)).readOnly.subCaptures(cs)
                   CapturingType(cinfo.selfType, cs)
 
               // Compute new parent types

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

@@ -6312,6 +6312,8 @@ object Types extends TypeUtils {
         null
 
     def mapCapability(c: Capability, deep: Boolean = false): Capability | (CaptureSet, Boolean) = c match
+      case c @ FreshCap(prefix) =>
+        c.derivedFreshCap(apply(prefix))
       case c: RootCapability => c
       case Reach(c1) =>
         mapCapability(c1, deep = true)