Refactor: Move CCState to separate file and make it more class based

odersky · odersky · commit 053341dd4c73 · 2025-04-06T13:05:11.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/cc/CCState.scala b/compiler/src/dotty/tools/dotc/cc/CCState.scala
@@ -0,0 +1,149 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import CaptureSet.{CompareResult, CompareFailure}
+import collection.mutable
+import reporting.Message
+import Contexts.Context
+import Types.MethodType
+import Symbols.Symbol
+
+/** Capture checking state, which is known to other capture checking components */
+class CCState:
+  import CCState.*
+
+  // ------ Error diagnostics -----------------------------
+
+  /** Error reprting notes produces since the last call to `test` */
+  var notes: List[ErrorNote] = Nil
+
+  def addNote(note: ErrorNote): Unit =
+    if !notes.exists(_.getClass == note.getClass) then
+      notes = note :: notes
+
+  def test(op: => CompareResult): CompareResult =
+    val saved = notes
+    notes = Nil
+    try op match
+      case res: CompareFailure => res.withNotes(notes)
+      case res => res
+    finally notes = saved
+
+  def testOK(op: => Boolean): CompareResult =
+    test(if op then CompareResult.OK else CompareResult.Fail(Nil))
+
+  /** Warnings relating to upper approximations of capture sets with
+   *  existentially bound variables.
+   */
+  val approxWarnings: mutable.ListBuffer[Message] = mutable.ListBuffer()
+
+  // ------ Level handling ---------------------------
+
+  private var curLevel: Level = outermostLevel
+
+  /** The level of the current environment. Levels start at 0 and increase for
+   *  each nested function or class. -1 means the level is undefined.
+   */
+  def currentLevel(using Context): Level = curLevel
+
+  /** Perform `op` in the next inner level */
+  inline def inNestedLevel[T](inline op: T)(using Context): T =
+    val saved = curLevel
+    curLevel = curLevel.nextInner
+    try op finally curLevel = saved
+
+  /** Perform `op` in the next inner level unless `p` holds. */
+  inline def inNestedLevelUnless[T](inline p: Boolean)(inline op: T)(using Context): T =
+    val saved = curLevel
+    if !p then curLevel = curLevel.nextInner
+    try op finally curLevel = saved
+
+  /** A map recording the level of a symbol */
+  private val mySymLevel: mutable.Map[Symbol, Level] = mutable.Map()
+
+  def symLevel(sym: Symbol): Level = mySymLevel.getOrElse(sym, undefinedLevel)
+
+  def recordLevel(sym: Symbol)(using Context): Unit = mySymLevel(sym) = curLevel
+
+  // ------ BiTypeMap adjustment -----------------------
+
+  private var myMapFutureElems = true
+
+  /** When mapping a capture set with a BiTypeMap, should we create a BiMapped set
+   *  so that future elements can also be mapped, and elements added to the BiMapped
+   *  are back-propagated? Turned off when creating capture set variables for the
+   *  first time, since we then do not want to change the binder to the original type
+   *  without capture sets when back propagating. Error case where this shows:
+   *  pos-customargs/captures/lists.scala, method m2c.
+   */
+  def mapFutureElems(using Context) = myMapFutureElems
+
+  /** Don't map future elements in this `op` */
+  inline def withoutMappedFutureElems[T](op: => T)(using Context): T =
+    val saved = mapFutureElems
+    myMapFutureElems = false
+    try op finally myMapFutureElems = saved
+
+  // ------ Iteration count of capture checking run
+
+  private var iterCount = 1
+
+  def iterationId = iterCount
+
+  def nextIteration[T](op: => T): T =
+    iterCount += 1
+    try op finally iterCount -= 1
+
+  // ------ Context info accessed from companion object when isCaptureCheckingOrSetup is true
+
+  private var openExistentialScopes: List[MethodType] = Nil
+
+  private var capIsRoot: Boolean = false
+
+object CCState:
+
+  opaque type Level = Int
+
+  val undefinedLevel: Level = -1
+
+  val outermostLevel: Level = 0
+
+  extension (x: Level)
+    def isDefined: Boolean = x >= 0
+    def <= (y: Level) = (x: Int) <= y
+    def nextInner: Level = if isDefined then x + 1 else x
+
+  /** If we are currently in capture checking or setup, and `mt` is a method
+   *  type that is not a prefix of a curried method, perform `op` assuming
+   *  a fresh enclosing existential scope `mt`, otherwise perform `op` directly.
+   */
+  inline def inNewExistentialScope[T](mt: MethodType)(op: => T)(using Context): T =
+    if isCaptureCheckingOrSetup then
+      val ccs = ccState
+      val saved = ccs.openExistentialScopes
+      if mt.marksExistentialScope then ccs.openExistentialScopes = mt :: ccs.openExistentialScopes
+      try op finally ccs.openExistentialScopes = saved
+    else
+      op
+
+  /** The currently opened existential scopes */
+  def openExistentialScopes(using Context): List[MethodType] = ccState.openExistentialScopes
+
+  /** Run `op` under the assumption that `cap` can subsume all other capabilties
+   *  except Result capabilities. Every use of this method should be scrutinized
+   *  for whether it introduces an unsoundness hole.
+   */
+  inline def withCapAsRoot[T](op: => T)(using Context): T =
+    if isCaptureCheckingOrSetup then
+      val ccs = ccState
+      val saved = ccs.capIsRoot
+      ccs.capIsRoot = true
+      try op finally ccs.capIsRoot = saved
+    else op
+
+  /** Is `caps.cap` a root capability that is allowed to subsume other capabilities? */
+  def capIsRoot(using Context): Boolean = ccState.capIsRoot
+
+end CCState
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -48,134 +48,6 @@ class IllegalCaptureRef(tpe: Type)(using Context) extends Exception(tpe.show)
 /** A base trait for data producing addenda to error messages */
 trait ErrorNote
 
-/** Capture checking state, which is known to other capture checking components */
-class CCState:
-
-  /** Error reprting notes produces since the last call to `test` */
-  var notes: List[ErrorNote] = Nil
-
-  def addNote(note: ErrorNote): Unit =
-    if !notes.exists(_.getClass == note.getClass) then
-      notes = note :: notes
-
-  def test(op: => CompareResult): CompareResult =
-    val saved = notes
-    notes = Nil
-    try op match
-      case res: CompareFailure => res.withNotes(notes)
-      case res => res
-    finally notes = saved
-
-  def testOK(op: => Boolean): CompareResult =
-    test(if op then CompareResult.OK else CompareResult.Fail(Nil))
-
-  /** Warnings relating to upper approximations of capture sets with
-   *  existentially bound variables.
-   */
-  val approxWarnings: mutable.ListBuffer[Message] = mutable.ListBuffer()
-
-  private var curLevel: Level = outermostLevel
-  private val symLevel: mutable.Map[Symbol, Int] = mutable.Map()
-
-  private var openExistentialScopes: List[MethodType] = Nil
-
-  private var capIsRoot: Boolean = false
-
-  /** If true, apply a BiTypeMap also to elements added to the set in the future
-   *  (and use its inverse when back-progating).
-   */
-  private var mapFutureElems = true
-
-  var iterCount = 1
-
-object CCState:
-
-  opaque type Level = Int
-
-  val undefinedLevel: Level = -1
-
-  val outermostLevel: Level = 0
-
-  /** The level of the current environment. Levels start at 0 and increase for
-   *  each nested function or class. -1 means the level is undefined.
-   */
-  def currentLevel(using Context): Level = ccState.curLevel
-
-  /** Perform `op` in the next inner level
-   *  @pre We are currently in capture checking or setup
-   */
-  inline def inNestedLevel[T](inline op: T)(using Context): T =
-    val ccs = ccState
-    val saved = ccs.curLevel
-    ccs.curLevel = ccs.curLevel.nextInner
-    try op finally ccs.curLevel = saved
-
-  /** Perform `op` in the next inner level unless `p` holds.
-   *  @pre We are currently in capture checking or setup
-   */
-  inline def inNestedLevelUnless[T](inline p: Boolean)(inline op: T)(using Context): T =
-    val ccs = ccState
-    val saved = ccs.curLevel
-    if !p then ccs.curLevel = ccs.curLevel.nextInner
-    try op finally ccs.curLevel = saved
-
-  /** If we are currently in capture checking or setup, and `mt` is a method
-   *  type that is not a prefix of a curried method, perform `op` assuming
-   *  a fresh enclosing existential scope `mt`, otherwise perform `op` directly.
-   */
-  inline def inNewExistentialScope[T](mt: MethodType)(op: => T)(using Context): T =
-    if isCaptureCheckingOrSetup then
-      val ccs = ccState
-      val saved = ccs.openExistentialScopes
-      if mt.marksExistentialScope then ccs.openExistentialScopes = mt :: ccs.openExistentialScopes
-      try op finally ccs.openExistentialScopes = saved
-    else
-      op
-
-  /** Run `op` under the assumption that `cap` can subsume all other capabilties
-   *  except Result capabilities. Every use of this method should be scrutinized
-   *  for whether it introduces an unsoundness hole.
-   */
-  inline def withCapAsRoot[T](op: => T)(using Context): T =
-    if isCaptureCheckingOrSetup then
-      val ccs = ccState
-      val saved = ccs.capIsRoot
-      ccs.capIsRoot = true
-      try op finally ccs.capIsRoot = saved
-    else op
-
-  /** Don't map future elements in this `op` */
-  inline def withoutMappedFutureElems[T](op: => T)(using Context): T =
-    val ccs = ccState
-    val saved = ccs.mapFutureElems
-    ccs.mapFutureElems = false
-    try op finally ccs.mapFutureElems = saved
-
-  /** Is `caps.cap` a root capability that is allowed to subsume other capabilities? */
-  def capIsRoot(using Context): Boolean = ccState.capIsRoot
-
-  /** When mapping a capture set with a BiTypeMap, should we create a BiMapped set
-   *  so that future elements can also be mapped, and elements added to the BiMapped
-   *  are back-propagated? Turned off when creating capture set variables for the
-   *  first time, since we then do not want to change the binder to the original type
-   *  without capture sets when back propagating. Error case where this shows:
-   *  pos-customargs/captures/lists.scala, method m2c.
-   */
-  def mapFutureElems(using Context) = ccState.mapFutureElems
-
-  /** The currently opened existential scopes */
-  def openExistentialScopes(using Context): List[MethodType] = ccState.openExistentialScopes
-
-  extension (x: Level)
-    def isDefined: Boolean = x >= 0
-    def <= (y: Level) = (x: Int) <= y
-    def nextInner: Level = if isDefined then x + 1 else x
-
-  extension (sym: Symbol)(using Context)
-    def ccLevel: Level = ccState.symLevel.getOrElse(sym, -1)
-    def recordLevel() = ccState.symLevel(sym) = currentLevel
-end CCState
-
 /** The currently valid CCState */
 def ccState(using Context): CCState =
   Phases.checkCapturesPhase.asInstanceOf[CheckCaptures].ccState1
@@ -631,8 +503,8 @@ extension (tp: Type)
 
   def level(using Context): Level =
     tp match
-    case tp: TermRef => tp.symbol.ccLevel
-    case tp: ThisType => tp.cls.ccLevel.nextInner
+    case tp: TermRef => ccState.symLevel(tp.symbol)
+    case tp: ThisType => ccState.symLevel(tp.cls).nextInner
     case _ => undefinedLevel
 
 extension (tp: MethodType)
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -20,7 +20,7 @@ object CaptureRef:
   opaque type Validity = Int
   def validId(runId: Int, iterId: Int): Validity =
     runId + (iterId << RunWidth)
-  def currentId(using Context): Validity = validId(ctx.runId, ccState.iterCount)
+  def currentId(using Context): Validity = validId(ctx.runId, ccState.iterationId)
   val invalid: Validity = validId(NoRunId, 0)
 
 /** A trait for references in CaptureSets. These can be NamedTypes, ThisTypes or ParamRefs,
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -322,7 +322,7 @@ sealed abstract class CaptureSet extends Showable:
         if isConst then
           if mappedElems == elems then this
           else Const(mappedElems)
-        else if CCState.mapFutureElems then
+        else if ccState.mapFutureElems then
           def unfused = BiMapped(asVar, tm, mappedElems)
           this match
             case self: BiMapped => self.bimap.fuse(tm) match
@@ -521,7 +521,7 @@ object CaptureSet:
      */
     var deps: Deps = SimpleIdentitySet.empty
 
-    def isConst(using Context) = solved >= ccState.iterCount
+    def isConst(using Context) = solved >= ccState.iterationId
     def isAlwaysEmpty(using Context) = isConst && elems.isEmpty
     def isProvisionallySolved(using Context): Boolean = solved > 0 && solved != Int.MaxValue
 
@@ -613,9 +613,9 @@ object CaptureSet:
             case prefix: CaptureRef =>
               levelOK(prefix)
             case _ =>
-              elem.symbol.ccLevel <= level
+              ccState.symLevel(elem.symbol) <= level
         case elem: ThisType if level.isDefined =>
-          elem.cls.ccLevel.nextInner <= level
+          ccState.symLevel(elem.cls).nextInner <= level
         case elem: ParamRef if !this.isInstanceOf[BiMapped] =>
           isPartOf(elem.binder.resType)
           || {
@@ -700,7 +700,7 @@ object CaptureSet:
 
     /** Mark set as solved and propagate this info to all dependent sets */
     def markSolved(provisional: Boolean)(using Context): Unit =
-      solved = if provisional then ccState.iterCount else Int.MaxValue
+      solved = if provisional then ccState.iterationId else Int.MaxValue
       deps.foreach(_.propagateSolved(provisional))
 
     var skippedMaps: Set[TypeMap] = Set.empty
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
