Add a prefix to FreshCaps

The prefix is mapped as a normal type. It determines whether
the hidden set allows to add new elements. ThisType and NoPrefix
prefixes allow it, other prefixes forbid it.

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,12 +716,24 @@ object Capabilities:
       (this eq y)
       || this.match
         case x: FreshCap =>
+          def classifierOK =
+            if y.tryClassifyAs(x.hiddenSet.classifier) then true
+            else
+              capt.println(i"$y cannot be classified as $x")
+              false
+
+          def prefixAllowsAddHidden: Boolean = x.prefix match
+            case NoPrefix | _: ThisType => true
+            case _ if CCState.collapseFresh => true
+            case pre =>
+              capt.println(i"fresh not open $x, ${x.rootId}, $pre, ${x.ccOwner.skipWeakOwner.thisType}")
+              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 }
-              )
+              && classifierOK
               && canAddHidden
+              && prefixAllowsAddHidden
               && vs.addHidden(x.hiddenSet, y)
         case x: ResultCap =>
           val result = y match

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)

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -496,8 +496,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
       def classified =
         if c.hiddenSet.classifier == defn.AnyClass then ""
         else s" classified as ${c.hiddenSet.classifier.name.show}"
-      if ccVerbose then s"<fresh$idStr in ${c.ccOwner} hiding " ~ toTextCaptureSet(c.hiddenSet) ~ classified ~ ">"
-      else "cap"
+      def prefixTxt: Text = c.prefix match
+        case NoPrefix | _: ThisType => ""
+        case pre => pre.show ~ "."
+      def core: Text =
+        if ccVerbose then s"<fresh$idStr in ${c.ccOwner} hiding " ~ toTextCaptureSet(c.hiddenSet) ~ classified ~ ">"
+        else "cap"
+      prefixTxt ~ core
     case tp: TypeProxy =>
       homogenize(tp) match
         case tp: SingletonType => toTextRef(tp)