Also increase level for classes

Author: odersky

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

@@ -70,6 +70,11 @@ class CCState:
     myLevel += 1
     try op finally myLevel -=1
 
+  inline def inNestedLevelUnless[T](inline p: Boolean)(inline op: T): T =
+    val saved = myLevel
+    if !p then myLevel += 1
+    try op finally myLevel = saved
+
   /** The level of the current environment. Levels start at 0 and increase for
    *  each nested function or class. -1 means the level is undefined.
    */

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

@@ -520,14 +520,9 @@ object CaptureSet:
       if elem.isRootCapability then !noUniversal
       else elem match
         case elem: TermRef if levelLimit.exists =>
-          var sym = elem.symbol
-          val now = level == -1 || ccState.level(sym) <= level
-          val was = levelLimit.isContainedIn(elem.symbol.levelOwner)
-          if was != now then
-            println(i"Diff levelOK $sym at ${ccState.level(sym)} for $this at $level in ${directOwner}, now $now")
-          now
+          level == -1 || ccState.level(elem.symbol) <= level
         case elem: ThisType if levelLimit.exists =>
-          levelLimit.isContainedIn(elem.cls.levelOwner)
+          level == -1 || ccState.level(elem.cls) + 1 <= level
         case ReachCapability(elem1) =>
           levelOK(elem1)
         case MaybeCapability(elem1) =>

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

@@ -775,7 +775,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           checkSubset(thisSet,
             CaptureSet.empty.withDescription(i"of pure base class $pureBase"),
             selfType.srcPos, cs1description = " captured by this self type")
-        super.recheckClassDef(tree, impl, cls)
+        ccState.inNestedLevelUnless(cls.is(Module)):
+          super.recheckClassDef(tree, impl, cls)
       finally
         curEnv = saved
 

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

@@ -437,9 +437,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                 transformTT(arg, boxed = true, exact = false) // type arguments in type applications are boxed
 
         case tree: TypeDef if tree.symbol.isClass =>
-          ccState.recordLevel(tree.symbol)
-          inContext(ctx.withOwner(tree.symbol)):
-            traverseChildren(tree)
+          val sym = tree.symbol
+          ccState.recordLevel(sym)
+          ccState.inNestedLevelUnless(sym.is(Module)):
+            inContext(ctx.withOwner(sym))
+              traverseChildren(tree)
 
         case tree @ SeqLiteral(elems, tpt: TypeTree) =>
           traverse(elems)
@@ -546,36 +548,37 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case tree: TypeDef =>
         tree.symbol match
           case cls: ClassSymbol =>
-            val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
-            def innerModule = cls.is(ModuleClass) && !cls.isStatic
-            val selfInfo1 =
-              if (selfInfo ne NoType) && !innerModule 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.baseClassHasExplicitSelfType 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.
-                CapturingType(cinfo.selfType, CaptureSet.Var(cls, level = ccState.currentLevel))
-            val ps1 = inContext(ctx.withOwner(cls)):
-              ps.mapConserve(transformExplicitType(_))
-            if (selfInfo1 ne selfInfo) || (ps1 ne ps) then
-              val newInfo = ClassInfo(prefix, cls, ps1, decls, selfInfo1)
-              updateInfo(cls, newInfo)
-              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
-                updateInfo(modul, CapturingType(modul.info, selfInfo1.asInstanceOf[Type].captureSet))
-                modul.termRef.invalidateCaches()
+            ccState.inNestedLevelUnless(cls.is(Module)):
+              val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
+              def innerModule = cls.is(ModuleClass) && !cls.isStatic
+              val selfInfo1 =
+                if (selfInfo ne NoType) && !innerModule 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.baseClassHasExplicitSelfType 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.
+                  CapturingType(cinfo.selfType, CaptureSet.Var(cls, level = ccState.currentLevel))
+              val ps1 = inContext(ctx.withOwner(cls)):
+                ps.mapConserve(transformExplicitType(_))
+              if (selfInfo1 ne selfInfo) || (ps1 ne ps) then
+                val newInfo = ClassInfo(prefix, cls, ps1, decls, selfInfo1)
+                updateInfo(cls, newInfo)
+                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
+                  updateInfo(modul, CapturingType(modul.info, selfInfo1.asInstanceOf[Type].captureSet))
+                  modul.termRef.invalidateCaches()
           case _ =>
       case _ =>
     end postProcess

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

@@ -15,7 +15,7 @@ import util.SourcePosition
 import scala.util.control.NonFatal
 import scala.annotation.switch
 import config.{Config, Feature}
-import cc.{CapturingType, RetainingType, CaptureSet, ReachCapability, MaybeCapability, isBoxed, levelOwner, retainedElems, isRetainsLike}
+import cc.{CapturingType, RetainingType, CaptureSet, ReachCapability, MaybeCapability, isBoxed, retainedElems, isRetainsLike}
 
 class PlainPrinter(_ctx: Context) extends Printer {