Redo capture checks if necessary

Schedule another capture checking run when a provisionally solved set is later extended.

Author: odersky

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

@@ -51,6 +51,14 @@ object ccConfig:
    */
   inline val checkSkippedMaps = false
 
+  /** Always repeat a capture checking run at least once if there are no errors
+   *  yet. Used for stress-testing the logic for when a new capture checking run needs
+   *  to be scheduled because a provisionally solved capture set was later extended.
+   *  So far this happens only in very few tests. With the flag on, the logic is
+   *  tested for all tests except neg tests.
+   */
+  inline val alwaysRepeatRun = false
+
   /** If true, turn on separation checking */
   def useSepChecks(using Context): Boolean =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)

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

@@ -259,18 +259,15 @@ class CheckCaptures extends Recheck, SymTransformer:
     /** The references used at identifier or application trees */
     private val usedSet = util.EqHashMap[Tree, CaptureSet]()
 
-    /** The set of symbols that were rechecked via a completer, mapped to the completer. */
-    private val completed = new mutable.HashMap[Symbol, Type]
+    /** The set of symbols that were rechecked via a completer */
+    private val completed = new mutable.HashSet[Symbol]
 
     var needAnotherRun = false
 
     def resetIteration()(using Context): Unit =
       needAnotherRun = false
       resetNuTypes()
       todoAtPostCheck.clear()
-      for (sym, completer) <- completed do
-        sym.info = completer
-        sym.resetFlag(Touched)
       completed.clear()
 
     extension [T <: Tree](tree: T)
@@ -357,23 +354,27 @@ class CheckCaptures extends Recheck, SymTransformer:
     def checkOK(res: CompareResult, prefix: => String, added: CaptureRef | CaptureSet, target: CaptureSet, pos: SrcPos, provenance: => String = "")(using Context): Unit =
       res match
         case res: CompareFailure =>
-          def msg =
+          def msg(provisional: Boolean) =
             def toAdd: String = errorNotes(res.errorNotes).toAdd.mkString
             def descr: String =
               val d = res.blocking.description
               if d.isEmpty then provenance else ""
-            em"$prefix included in the allowed capture set ${res.blocking}$descr$toAdd"
+            def kind = if provisional then "previously estimated\n" else "allowed "
+            em"$prefix included in the ${kind}capture set ${res.blocking}$descr$toAdd"
           target match
             case target: CaptureSet.Var
             if res.blocking.isProvisionallySolved =>
-              report.error(msg.prepend(i"Another capture checking run needs to be scheduled because\n"), pos)
+              report.warning(
+                msg(provisional = true)
+                  .prepend(i"Another capture checking run needs to be scheduled because\n"),
+                pos)
               needAnotherRun = true
               added match
                 case added: CaptureRef => target.elems += added
                 case added: CaptureSet => target.elems ++= added.elems
             case _ =>
               inContext(root.printContext(added, res.blocking)):
-                report.error(msg, pos)
+                report.error(msg(provisional = false), pos)
         case _ =>
 
     /** Check subcapturing `{elem} <: cs`, report error on failure */
@@ -1107,7 +1108,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         curEnv = restoreEnvFor(sym.owner)
         capt.println(i"Complete $sym in ${curEnv.outersIterator.toList.map(_.owner)}")
         try recheckDef(tree, sym)
-        finally completed(sym) = completer
+        finally completed += sym
       finally
         curEnv = saved
 
@@ -1737,11 +1738,14 @@ class CheckCaptures extends Recheck, SymTransformer:
       withCaptureSetsExplained:
         while
           super.checkUnit(unit)
-          !ctx.reporter.errorsReported && needAnotherRun
+          !ctx.reporter.errorsReported
+          && (needAnotherRun || ccConfig.alwaysRepeatRun && ccState.iterCount == 1)
         do
           resetIteration()
+          setup.setupUnit(unit.tpdTree, this)
           ccState.iterCount += 1
-          println(s"**** capture checking run ${ccState.iterCount} started on ${ctx.source}")
+          capt.println(s"**** capture checking run ${ccState.iterCount} started on ${ctx.source}")
+
         checkOverrides.traverse(unit.tpdTree)
         postCheck(unit.tpdTree)
         checkSelfTypes(unit.tpdTree)

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

@@ -705,7 +705,14 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                 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))
+                  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.termRef.invalidateCaches()
           case _ =>
       case _ =>

tests/neg-custom-args/captures/byname.check

@@ -1,8 +1,9 @@
--- Error: tests/neg-custom-args/captures/byname.scala:5:21 -------------------------------------------------------------
-5 |  def g(x: Int) = if cap2 == cap2 then 1 else x // error
+-- Warning: tests/neg-custom-args/captures/byname.scala:5:21 -----------------------------------------------------------
+5 |  def g(x: Int) = if cap2 == cap2 then 1 else x
   |                     ^^^^
   |                     Another capture checking run needs to be scheduled because
-  |                     reference (cap2 : Cap) is not included in the allowed capture set {} of method f
+  |                     reference (cap2 : Cap) is not included in the previously estimated
+  |                     capture set {} of method f
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:10:6 ----------------------------------------
 10 |  h(f2())  // error
    |    ^^^^

tests/neg-custom-args/captures/byname.scala

@@ -2,7 +2,7 @@ class Cap extends caps.Capability
 
 def test(cap1: Cap, cap2: Cap) =
   def f() = if cap1 == cap1 then g else g
-  def g(x: Int) = if cap2 == cap2 then 1 else x // error
+  def g(x: Int) = if cap2 == cap2 then 1 else x
   def g2(x: Int) = if cap1 == cap1 then 1 else x
   def f2() = if cap1 == cap1 then g2 else g2
   def h(ff: => Int ->{cap2} Int) = ff

tests/neg-custom-args/captures/i22808.scala

@@ -6,15 +6,15 @@ def test1(io: Object^): Unit =
     val x = () =>
       foo()
     val y = Box(io)
-    println(y.m)  // error: another run needs to be scheduled
-    val _: () -> Unit = x // was error
+    println(y.m)  // warning: another run needs to be scheduled
+    val _: () -> Unit = x // error
 
 def test2(io: Object^): Unit =
   def foo(): Unit = bar()
   def bar(): Unit =
     val x = () =>
       foo()
-    val _: () -> Unit = x
+    val _: () -> Unit = x // error
     val y = Box(io)
-    println(y.m)  // error: another run needs to be scheduled
-    val _: () -> Unit = x
+    println(y.m)  // warning: another run needs to be scheduled
+    val _: () -> Unit = x // error