Charge a lazy val if its initialization is impure

Author: bracevac

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

@@ -655,11 +655,26 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     override def recheckIdent(tree: Ident, pt: Type)(using Context): Type =
       val sym = tree.symbol
-      if sym.is(Method) || sym.is(Lazy) then
-        // If ident refers to a parameterless method or lazy val, charge its cv to the environment.
-        // Lazy vals are like parameterless methods: accessing them may trigger initialization
-        // that uses captured references.
+      if sym.is(Method) then
+        // If ident refers to a parameterless method, charge its cv to the environment.
         includeCallCaptures(sym, sym.info, tree)
+      else if sym.is(Lazy) then
+        // For lazy vals: when the declared type is pure but captures capabilities,
+        // charge the captured vars instead of the lazy val itself. This makes
+        // {x} work through its captured vars rather than being independent.
+        val declaredCs = sym.info.captureSet
+        val capturedCs = capturedVars(sym)
+        if declaredCs.isAlwaysEmpty && !capturedCs.isAlwaysEmpty then
+          // Pure type but captures: charge the captured vars directly
+          def isRetained(ref: Capability): Boolean = ref.pathRoot match
+            case root: ThisType => ctx.owner.isContainedIn(root.cls)
+            case _ => true
+          if curEnv.kind != EnvKind.Boxed then
+            markFree(capturedCs.filter(isRetained), tree)
+        else
+          // Otherwise treat like a regular val
+          if !sym.isStatic then
+            markPathFree(sym.termRef, pt, tree)
       else if sym.exists && !sym.isStatic then
         markPathFree(sym.termRef, pt, tree)
       mapResultRoots(super.recheckIdent(tree, pt), tree.symbol)
@@ -1113,7 +1128,30 @@ class CheckCaptures extends Recheck, SymTransformer:
           else if runInConstructor then
             pushConstructorEnv()
 
-          checkInferredResult(super.recheckValDef(tree, sym), tree)
+          val resType = checkInferredResult(super.recheckValDef(tree, sym), tree)
+
+          // For lazy vals, if the declared type is pure but the initialization captures
+          // capabilities, we need to make the lazy val trackable by adding its captured
+          // vars to the result type. This allows subcapturing to work: {x} can subcapture
+          // {console} if x's type includes console in its capture set.
+          if sym.is(Lazy) then
+            val declaredCs = tree.tpt.nuType.captureSet
+            val capturedCs = capturedVars(sym)
+            if declaredCs.isAlwaysEmpty && !capturedCs.isAlwaysEmpty then
+              // The declared type is pure, but we captured capabilities.
+              // Augment the type to make it trackable.
+              val augmentedType = resType.capturing(capturedCs)
+              capt.println(i"lazy val $sym: augmenting pure type $resType with $capturedCs -> $augmentedType")
+              tree.setNuType(augmentedType)
+              // Also update the symbol's info so that TermRefs to this lazy val
+              // will have the augmented type
+              sym.info = augmentedType
+              capt.println(i"lazy val $sym: sym.info = ${sym.info}, termRef.captureSet = ${sym.termRef.captureSet}")
+              augmentedType
+            else
+              resType
+          else
+            resType
       finally
         if !sym.is(Param) then
           // Parameters with inferred types belong to anonymous methods. We need to wait