Refactor: Move previously @sharable data to ccState

This might address the Timeout problems we were seeing.

Author: odersky

Diff for: compiler/src/dotty/tools/dotc/cc/CCState.scala

@@ -3,7 +3,7 @@ package dotc
 package cc
 
 import core.*
-import CaptureSet.{CompareResult, CompareFailure}
+import CaptureSet.{CompareResult, CompareFailure, VarState}
 import collection.mutable
 import reporting.Message
 import Contexts.Context
@@ -96,6 +96,22 @@ class CCState:
     iterCount += 1
     try op finally iterCount -= 1
 
+  // ------ Global counters -----------------------
+
+  /** Next CaptureSet.Var id */
+  var varId = 0
+
+  /** Next root id */
+  var rootId = 0
+
+  // ------ VarState singleton objects ------------
+  // See CaptureSet.VarState creation methods for documentation
+
+  object Separate extends VarState.Separating
+  object HardSeparate extends VarState.Separating
+  object Unrecorded extends VarState.Unrecorded
+  object ClosedUnrecorded extends VarState.ClosedUnrecorded
+
   // ------ Context info accessed from companion object when isCaptureCheckingOrSetup is true
 
   private var openExistentialScopes: List[MethodType] = Nil

Diff for: compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -10,11 +10,7 @@ import Decorators.*, NameOps.*
 import config.Printers.capt
 import util.Property.Key
 import tpd.*
-import StdNames.nme
-import collection.mutable
-import CCState.*
-import reporting.Message
-import CaptureSet.{VarState, CompareResult, CompareFailure}
+import CaptureSet.VarState
 
 /** Attachment key for capturing type trees */
 private val Captures: Key[CaptureSet] = Key()
@@ -501,11 +497,11 @@ extension (tp: Type)
             foldOver(x, t)
     acc(false, tp)
 
-  def level(using Context): Level =
+  def level(using Context): CCState.Level =
     tp match
     case tp: TermRef => ccState.symLevel(tp.symbol)
     case tp: ThisType => ccState.symLevel(tp.cls).nextInner
-    case _ => undefinedLevel
+    case _ => CCState.undefinedLevel
 
 extension (tp: MethodType)
   /** A method marks an existential scope unless it is the prefix of a curried method */

Diff for: compiler/src/dotty/tools/dotc/cc/CaptureRef.scala

@@ -170,7 +170,7 @@ trait CaptureRef extends TypeProxy, ValueType:
    *   Y: CapSet^c1...CapSet^c2, x subsumes (CapSet^c2)  ==>  x subsumes Y
    *   Contains[X, y]  ==>  X subsumes y
    */
-  final def subsumes(y: CaptureRef)(using ctx: Context, vs: VarState = VarState.Separate): Boolean =
+  final def subsumes(y: CaptureRef)(using ctx: Context)(using vs: VarState = VarState.Separate): Boolean =
 
     def subsumingRefs(x: Type, y: Type): Boolean = x match
       case x: CaptureRef => y match
@@ -255,7 +255,7 @@ trait CaptureRef extends TypeProxy, ValueType:
    *                       the test again with canAddHidden = true as a last effort before we
    *                       fail a comparison.
    */
-  def maxSubsumes(y: CaptureRef, canAddHidden: Boolean)(using ctx: Context, vs: VarState = VarState.Separate): Boolean =
+  def maxSubsumes(y: CaptureRef, canAddHidden: Boolean)(using ctx: Context)(using vs: VarState = VarState.Separate): Boolean =
     def yIsExistential = y.stripReadOnly match
       case root.Result(_) =>
         capt.println(i"failed existential $this >: $y")

Diff for: compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -181,7 +181,7 @@ sealed abstract class CaptureSet extends Showable:
   /** {x} <:< this   where <:< is subcapturing, but treating all variables
    *                 as frozen.
    */
-  def accountsFor(x: CaptureRef)(using ctx: Context, vs: VarState = VarState.Separate): Boolean =
+  def accountsFor(x: CaptureRef)(using ctx: Context)(using vs: VarState = VarState.Separate): Boolean =
 
     def debugInfo(using Context) = i"$this accountsFor $x, which has capture set ${x.captureSetOfInfo}"
 
@@ -210,7 +210,7 @@ sealed abstract class CaptureSet extends Showable:
   def mightAccountFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true):
       CCState.withCapAsRoot: // OK here since we opportunistically choose an alternative which gets checked later
-        elems.exists(_.subsumes(x)(using ctx, VarState.ClosedUnrecorded))
+        elems.exists(_.subsumes(x)(using ctx)(using VarState.ClosedUnrecorded))
       || !x.isRootCapability
         && {
           val elems = x.captureSetOfInfo.elems
@@ -405,8 +405,6 @@ object CaptureSet:
   type Vars = SimpleIdentitySet[Var]
   type Deps = SimpleIdentitySet[CaptureSet]
 
-  @sharable private var varId = 0
-
   /** If set to `true`, capture stack traces that tell us where sets are created */
   private final val debugSets = false
 
@@ -485,7 +483,7 @@ object CaptureSet:
   object Fluid extends Const(emptyRefs):
     override def isAlwaysEmpty(using Context) = false
     override def addThisElem(elem: CaptureRef)(using Context, VarState) = CompareResult.OK
-    override def accountsFor(x: CaptureRef)(using Context, VarState): Boolean = true
+    override def accountsFor(x: CaptureRef)(using Context)(using VarState): Boolean = true
     override def mightAccountFor(x: CaptureRef)(using Context): Boolean = true
     override def toString = "<fluid>"
   end Fluid
@@ -497,8 +495,9 @@ object CaptureSet:
 
     /** A unique identification number for diagnostics */
     val id =
-      varId += 1
-      varId
+      val ccs = ccState
+      ccs.varId += 1
+      ccs.varId
 
     //assert(id != 40)
 
@@ -1221,37 +1220,36 @@ object CaptureSet:
      *  reference `r` only if `r` is already present in the hidden set of the instance.
      *  No new references can be added.
      */
-    @sharable
-    object Separate extends Separating
+    def Separate(using Context): Separating = ccState.Separate
 
     /** Like Separate but in addition we assume that `cap` never subsumes anything else.
      *  Used in `++` to not lose track of dependencies between function parameters.
      */
-    @sharable
-    object HardSeparate extends Separating
+    def HardSeparate(using Context): Separating = ccState.HardSeparate
 
     /** A special state that turns off recording of elements. Used only
-     *  in `addSub` to prevent cycles in recordings.
+     *  in `addSub` to prevent cycles in recordings. Instantiated in ccState.Unrecorded.
      */
-    @sharable
-    private[CaptureSet] object Unrecorded extends VarState:
+    class Unrecorded extends VarState:
       override def putElems(v: Var, refs: Refs) = true
       override def putDeps(v: Var, deps: Deps) = true
       override def rollBack(): Unit = ()
       override def addHidden(hidden: HiddenSet, elem: CaptureRef)(using Context): Boolean = true
       override def toString = "unrecorded varState"
 
+    def Unrecorded(using Context): Unrecorded = ccState.Unrecorded
+
     /** A closed state that turns off recording of hidden elements (but allows
-     *  adding them). Used in `mightAccountFor`.
+     *  adding them). Used in `mightAccountFor`. Instantiated in ccState.ClosedUnrecorded.
      */
-    @sharable
-    private[CaptureSet] object ClosedUnrecorded extends Closed:
+    class ClosedUnrecorded extends Closed:
       override def addHidden(hidden: HiddenSet, elem: CaptureRef)(using Context): Boolean = true
       override def toString = "closed unrecorded varState"
 
+    def ClosedUnrecorded(using Context): ClosedUnrecorded = ccState.ClosedUnrecorded
+
   end VarState
 
-  @sharable
   /** The current VarState, as passed by the implicit context */
   def varState(using state: VarState): VarState = state
 

Diff for: compiler/src/dotty/tools/dotc/cc/root.scala

@@ -14,7 +14,7 @@ import NameOps.isImpureFunction
 import reporting.Message
 import util.{SimpleIdentitySet, EqHashMap}
 import util.Spans.NoSpan
-import annotation.internal.sharable
+import annotation.constructorOnly
 
 /** A module defining three kinds of root capabilities
  *   - `cap` of kind `Global`: This is the global root capability. Among others it is
@@ -75,15 +75,14 @@ object root:
       case Kind.Global => false
   end Kind
 
-  @sharable private var rootId = 0
-
   /** The annotation of a root instance */
-  case class Annot(kind: Kind) extends Annotation:
+  case class Annot(kind: Kind)(using @constructorOnly ictx: Context) extends Annotation:
 
     /** id printed under -uniqid, for debugging */
     val id =
-      rootId += 1
-      rootId
+      val ccs = ccState
+      ccs.rootId += 1
+      ccs.rootId
 
     override def symbol(using Context) = defn.RootCapabilityAnnot
     override def tree(using Context) = New(symbol.typeRef, Nil)