Remove old level checking code

Remove old level checking code and debug infra to compare old with new.

Author: odersky

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

@@ -21,34 +21,6 @@ class CCState:
    */
   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
@@ -117,17 +89,6 @@ class CCState:
 
 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.

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

@@ -16,7 +16,6 @@ import CaptureSet.VarState
 import Annotations.Annotation
 import Flags.*
 import config.Printers.capt
-import CCState.{Level, undefinedLevel}
 import annotation.constructorOnly
 import ast.tpd
 import printing.{Printer, Showable}

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

@@ -76,11 +76,6 @@ sealed abstract class CaptureSet extends Showable:
   /** Is this set provisionally solved, so that another cc run might unfreeze it? */
   def isProvisionallySolved(using Context): Boolean
 
-  /** An optional level limit, or undefinedLevel if none exists. All elements of the set
-   *  must be at levels equal or smaller than the level of the set, if it is defined.
-   */
-  def level: Level
-
   /** An optional owner, or NoSymbol if none exists. Used for diagnstics
    */
   def owner: Symbol
@@ -607,8 +602,6 @@ object CaptureSet:
 
     def withDescription(description: String): Const = Const(elems, description)
 
-    def level = undefinedLevel
-
     def owner = NoSymbol
 
     def dropEmpties()(using Context) = this
@@ -663,7 +656,7 @@ object CaptureSet:
   inline val debugTarget = 1745
 
   /** The subclass of captureset variables with given initial elements */
-  class Var(initialOwner: Symbol = NoSymbol, initialElems: Refs = emptyRefs, val level: Level = undefinedLevel, underBox: Boolean = false)(using /*@constructorOnly*/ ictx: Context) extends CaptureSet:
+  class Var(initialOwner: Symbol = NoSymbol, initialElems: Refs = emptyRefs, underBox: Boolean = false)(using /*@constructorOnly*/ ictx: Context) extends CaptureSet:
 
     override def owner = initialOwner
 
@@ -833,40 +826,7 @@ object CaptureSet:
             case _ => foldOver(b, t)
       find(false, binder)
 
-    def levelOKold(elem: Capability)(using Context): Boolean = elem match
-      case _: FreshCap =>
-        !level.isDefined
-        || ccState.symLevel(elem.ccOwner) <= level
-        || {
-          capt.println(i"LEVEL ERROR $elem cannot be included in $this of $owner")
-          false
-        }
-      case elem @ ResultCap(binder) =>
-        rootLimit == null && (this.isInstanceOf[BiMapped] || isPartOf(binder.resType))
-      case GlobalCap =>
-        rootLimit == null
-      case elem: TermRef if level.isDefined =>
-        elem.prefix match
-          case prefix: Capability =>
-            levelOK(prefix)
-          case _ =>
-            ccState.symLevel(elem.symbol) <= level
-      case elem: ThisType if level.isDefined =>
-        ccState.symLevel(elem.cls).nextInner <= level
-      case elem: ParamRef if !this.isInstanceOf[BiMapped] =>
-        isPartOf(elem.binder.resType)
-        || {
-          capt.println(
-            i"""LEVEL ERROR $elem for $this
-                |elem binder = ${elem.binder}""")
-          false
-        }
-      case elem: DerivedCapability =>
-        levelOK(elem.underlying)
-      case _ =>
-        true
-
-    def levelOKnew(elem: Capability)(using Context): Boolean = elem match
+    def levelOK(elem: Capability)(using Context): Boolean = elem match
       case elem @ ResultCap(binder) =>
         rootLimit == null && (this.isInstanceOf[BiMapped] || isPartOf(binder.resType))
       case GlobalCap =>
@@ -879,16 +839,6 @@ object CaptureSet:
           !elemVis.isProperlyContainedIn(owner)
         else true
 
-    inline val debugLevelChecking = false
-
-    def levelOK(elem: Capability)(using Context): Boolean =
-      val now = levelOKnew(elem)
-      if debugLevelChecking then
-        val was = levelOKold(elem)
-        if was != now then
-          println(i"LEVEL DIFF for $this / $getClass in ${owner.ownersIterator.toList} and elem $elem in ${elem.ccOwner}, was $was")
-      now
-
     def addDependent(cs: CaptureSet)(using Context, VarState): Boolean =
       (cs eq this)
       || cs.isUniversal
@@ -968,15 +918,9 @@ object CaptureSet:
      */
     override def optionalInfo(using Context): String =
       for vars <- ctx.property(ShownVars) do vars += this
-      val debugInfo =
-        if !ctx.settings.YccDebug.value then ""
-        else if isConst then ids ++ "(solved)"
-        else ids
-      val limitInfo =
-        if ctx.settings.YprintLevel.value && level.isDefined
-        then i"<at level ${level.toString}>"
-        else ""
-      debugInfo ++ limitInfo
+      if !ctx.settings.YccDebug.value then ""
+      else if isConst then ids ++ "(solved)"
+      else ids
 
     /** Used for diagnostics and debugging: A string that traces the creation
      *  history of a variable by following source links. Each variable on the
@@ -1378,7 +1322,7 @@ object CaptureSet:
     override def toText(printer: Printer): Text =
       inContext(printer.printerContext):
         if levelError then
-          i"($elem at wrong level for $cs at level ${cs.level.toString})"
+          i"($elem at wrong level for $cs in ${cs.owner.showLocated})"
         else
           if ctx.settings.YccDebug.value
           then i"$elem cannot be included in $trace"

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

@@ -430,7 +430,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     def capturedVars(sym: Symbol)(using Context): CaptureSet =
       myCapturedVars.getOrElseUpdate(sym,
         if sym.isTerm || !sym.owner.isStaticOwner
-        then CaptureSet.Var(sym, level = ccState.symLevel(sym))
+        then CaptureSet.Var(sym)
         else CaptureSet.empty)
 
 // ---- Record Uses with MarkFree ----------------------------------------------------
@@ -1091,14 +1091,13 @@ class CheckCaptures extends Recheck, SymTransformer:
           if ac.isEmpty then ctx
           else ctx.withProperty(CaptureSet.AssumedContains, Some(ac))
 
-        ccState.inNestedLevel: // TODO: nestedLevel needed here?
-          try checkInferredResult(super.recheckDefDef(tree, sym)(using bodyCtx), tree)
-          finally
-            if !sym.isAnonymousFunction then
-              // Anonymous functions propagate their type to the enclosing environment
-              // so it is not in general sound to interpolate their types.
-              interpolateIfInferred(tree.tpt, sym)
-            curEnv = saved
+        try checkInferredResult(super.recheckDefDef(tree, sym)(using bodyCtx), tree)
+        finally
+          if !sym.isAnonymousFunction then
+            // Anonymous functions propagate their type to the enclosing environment
+            // so it is not in general sound to interpolate their types.
+            interpolateIfInferred(tree.tpt, sym)
+          curEnv = saved
     end recheckDefDef
 
     /** If val or def definition with inferred (result) type is visible
@@ -1228,8 +1227,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case AppliedType(fn, args) =>
               markFreeTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_)))
             case _ =>
-        ccState.inNestedLevelUnless(cls.is(Module)):
-          super.recheckClassDef(tree, impl, cls)
+        super.recheckClassDef(tree, impl, cls)
       finally
         completed += cls
         curEnv = saved
@@ -1311,7 +1309,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       tree match
         case _: RefTree | closureDef(_) if pt.isBoxedCapturing =>
           curEnv = Env(curEnv.owner, EnvKind.Boxed,
-            CaptureSet.Var(curEnv.owner, level = ccState.currentLevel), curEnv)
+            CaptureSet.Var(curEnv.owner), curEnv)
         case _ =>
       val res =
         try
@@ -1577,7 +1575,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             curEnv = Env(
               curEnv.owner,
               if boxed then EnvKind.Boxed else EnvKind.NestedInOwner,
-              CaptureSet.Var(curEnv.owner, level = ccState.currentLevel),
+              CaptureSet.Var(curEnv.owner),
               if boxed then null else curEnv)
             try
               val (eargs, eres) = expected.dealias.stripCapturing match

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

@@ -520,16 +520,13 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           if isExcluded(meth) then
             return
 
-          ccState.recordLevel(meth)
-          ccState.inNestedLevel:
-            inContext(ctx.withOwner(meth)):
-              paramss.foreach(traverse)
-              transformResultType(tpt, meth)
-              traverse(tree.rhs)
+          inContext(ctx.withOwner(meth)):
+            paramss.foreach(traverse)
+            transformResultType(tpt, meth)
+            traverse(tree.rhs)
 
         case tree @ ValDef(_, tpt: TypeTree, _) =>
           val sym = tree.symbol
-          ccState.recordLevel(sym)
           val defCtx = if sym.isOneOf(TermParamOrAccessor) then ctx else ctx.withOwner(sym)
           inContext(defCtx):
             transformResultType(tpt, sym)
@@ -546,10 +543,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
         case tree: TypeDef if tree.symbol.isClass =>
           val sym = tree.symbol
-          ccState.recordLevel(sym)
-          ccState.inNestedLevelUnless(sym.is(Module)):
-            inContext(ctx.withOwner(sym))
-              traverseChildren(tree)
+          inContext(ctx.withOwner(sym))
+            traverseChildren(tree)
 
         case tree @ TypeDef(_, rhs: TypeTree) =>
           transformTT(rhs, tree.symbol, boxed = false)
@@ -670,55 +665,54 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         tree.symbol match
           case cls: ClassSymbol =>
             checkClassifiedInheritance(cls)
-            ccState.inNestedLevelUnless(cls.is(Module)):
-              val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
-
-              // Compute new self type
-              def isInnerModule = cls.is(ModuleClass) && !cls.isStatic
-              val selfInfo1 =
-                if (selfInfo ne NoType) && !isInnerModule then
-                  // if selfInfo is explicitly given then use that one, except if
-                  // self info applies to non-static modules, these still need to be inferred
-                  selfInfo
-                else if cls.isPureClass then
-                  // is cls is known to be pure, nothing needs to be added to self type
-                  selfInfo
-                else if !cls.isEffectivelySealed && !cls.baseClassHasExplicitNonUniversalSelfType then
-                  // assume {cap} for completely unconstrained self types of publicly extensible classes
-                  CapturingType(cinfo.selfType, CaptureSet.universal)
-                else
-                  // Infer the self type for the rest, which is all classes without explicit
-                  // self types (to which we also add nested module classes), provided they are
-                  // neither pure, nor are publicily extensible with an unconstrained self type.
-                  val cs = CaptureSet.Var(cls, level = ccState.currentLevel)
-                  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)
-                  CapturingType(cinfo.selfType, cs)
-
-              // Compute new parent types
-              val ps1 = inContext(ctx.withOwner(cls)):
-                ps.mapConserve(transformExplicitType(_, NoSymbol, freshen = false))
-
-              // Install new types and if it is a module class also update module object
-              if (selfInfo1 ne selfInfo) || (ps1 ne ps) then
-                val newInfo = ClassInfo(prefix, cls, ps1, decls, selfInfo1)
-                updateInfo(cls, newInfo, cls.owner)
-                capt.println(i"update class info of $cls with parents $ps selfinfo $selfInfo to $newInfo")
-                cls.thisType.asInstanceOf[ThisType].invalidateCaches()
-                if cls.is(ModuleClass) then
-                  // if it's a module, the capture set of the module reference is the capture set of the self type
-                  val modul = cls.sourceModule
-                  val selfCaptures = selfInfo1 match
-                    case CapturingType(_, refs) => refs
-                    case _ => CaptureSet.empty
-                  // Note: Can't do val selfCaptures = selfInfo1.captureSet here.
-                  // This would potentially give stackoverflows when setup is run repeatedly.
-                  // One test case is pos-custom-args/captures/checkbounds.scala under
-                  // ccConfig.alwaysRepeatRun = true.
-                  updateInfo(modul, CapturingType(modul.info, selfCaptures), modul.owner)
-                  modul.termRef.invalidateCaches()
+            val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
+
+            // Compute new self type
+            def isInnerModule = cls.is(ModuleClass) && !cls.isStatic
+            val selfInfo1 =
+              if (selfInfo ne NoType) && !isInnerModule then
+                // if selfInfo is explicitly given then use that one, except if
+                // self info applies to non-static modules, these still need to be inferred
+                selfInfo
+              else if cls.isPureClass then
+                // is cls is known to be pure, nothing needs to be added to self type
+                selfInfo
+              else if !cls.isEffectivelySealed && !cls.baseClassHasExplicitNonUniversalSelfType then
+                // assume {cap} for completely unconstrained self types of publicly extensible classes
+                CapturingType(cinfo.selfType, CaptureSet.universal)
+              else
+                // Infer the self type for the rest, which is all classes without explicit
+                // self types (to which we also add nested module classes), provided they are
+                // neither pure, nor are publicily extensible with an unconstrained self type.
+                val cs = CaptureSet.Var(cls)
+                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)
+                CapturingType(cinfo.selfType, cs)
+
+            // Compute new parent types
+            val ps1 = inContext(ctx.withOwner(cls)):
+              ps.mapConserve(transformExplicitType(_, NoSymbol, freshen = false))
+
+            // Install new types and if it is a module class also update module object
+            if (selfInfo1 ne selfInfo) || (ps1 ne ps) then
+              val newInfo = ClassInfo(prefix, cls, ps1, decls, selfInfo1)
+              updateInfo(cls, newInfo, cls.owner)
+              capt.println(i"update class info of $cls with parents $ps selfinfo $selfInfo to $newInfo")
+              cls.thisType.asInstanceOf[ThisType].invalidateCaches()
+              if cls.is(ModuleClass) then
+                // if it's a module, the capture set of the module reference is the capture set of the self type
+                val modul = cls.sourceModule
+                val selfCaptures = selfInfo1 match
+                  case CapturingType(_, refs) => refs
+                  case _ => CaptureSet.empty
+                // Note: Can't do val selfCaptures = selfInfo1.captureSet here.
+                // This would potentially give stackoverflows when setup is run repeatedly.
+                // One test case is pos-custom-args/captures/checkbounds.scala under
+                // ccConfig.alwaysRepeatRun = true.
+                updateInfo(modul, CapturingType(modul.info, selfCaptures), modul.owner)
+                modul.termRef.invalidateCaches()
           case _ =>
       case _ =>
     end postProcess
@@ -857,7 +851,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
   /** Add a capture set variable to `tp` if necessary. */
   private def addVar(tp: Type, owner: Symbol)(using Context): Type =
-    decorate(tp, CaptureSet.Var(owner, _, level = ccState.currentLevel))
+    decorate(tp, CaptureSet.Var(owner, _))
 
   /** A map that adds <fluid> capture sets at all contra- and invariant positions
    *  in a type where a capture set would be needed. This is used to make types