Under 3.8 solve all capture sets in types of vals and defs

Author: odersky

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

@@ -51,12 +51,15 @@ sealed abstract class CaptureSet extends Showable:
   /** Is this capture set constant (i.e. not an unsolved capture variable)?
    *  Solved capture variables count as constant.
    */
-  def isConst: Boolean
+  def isConst(using Context): Boolean
 
   /** Is this capture set always empty? For unsolved capture veriables, returns
    *  always false.
    */
-  def isAlwaysEmpty: Boolean
+  def isAlwaysEmpty(using Context): Boolean
+
+  /** 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.
@@ -71,14 +74,14 @@ sealed abstract class CaptureSet extends Showable:
   final def isNotEmpty: Boolean = !elems.isEmpty
 
   /** Convert to Const. @pre: isConst */
-  def asConst: Const = this match
+  def asConst(using Context): Const = this match
     case c: Const => c
     case v: Var =>
       assert(v.isConst)
       Const(v.elems)
 
   /** Cast to variable. @pre: !isConst */
-  def asVar: Var =
+  def asVar(using Context): Var =
     assert(!isConst)
     asInstanceOf[Var]
 
@@ -316,23 +319,29 @@ sealed abstract class CaptureSet extends Showable:
    *  `OtherMapped` provides some approximation to a solution, but it is neither
    *  sound nor complete.
    */
-  def map(tm: TypeMap)(using Context): CaptureSet = tm match
-    case tm: BiTypeMap =>
-      val mappedElems = elems.map(tm.forward)
-      if isConst then
-        if mappedElems == elems then this
-        else Const(mappedElems)
-      else BiMapped(asVar, tm, mappedElems)
-    case tm: IdentityCaptRefMap =>
-      this
-    case tm: AvoidMap if this.isInstanceOf[HiddenSet] =>
-      this
-    case _ =>
-      val mapped = mapRefs(elems, tm, tm.variance)
-      if isConst then
-        if mapped.isConst && mapped.elems == elems && !mapped.keepAlways then this
-        else mapped
-      else Mapped(asVar, tm, tm.variance, mapped)
+  def map(tm: TypeMap)(using Context): CaptureSet =
+    def freeze() = this match
+      case self: Var if !isConst && ccConfig.newScheme =>
+        if tm.variance < 0 then self.solve()
+        else self.markSolved(provisional = true)
+      case _ =>
+    tm match
+      case tm: BiTypeMap =>
+        val mappedElems = elems.map(tm.forward)
+        if isConst then
+          if mappedElems == elems then this
+          else Const(mappedElems)
+        else BiMapped(asVar, tm, mappedElems)
+      case tm: IdentityCaptRefMap =>
+        this
+      case tm: AvoidMap if this.isInstanceOf[HiddenSet] =>
+        this
+      case _ =>
+        val mapped = mapRefs(elems, tm, tm.variance)
+        if isConst then
+          if mapped.isConst && mapped.elems == elems && !mapped.keepAlways then this
+          else mapped
+        else Mapped(asVar, tm, tm.variance, mapped)
 
   /** A mapping resulting from substituting parameters of a BindingType to a list of types */
   def substParams(tl: BindingType, to: List[Type])(using Context) =
@@ -368,7 +377,7 @@ sealed abstract class CaptureSet extends Showable:
    *  to this set. This might result in the set being solved to be constant
    *  itself.
    */
-  protected def propagateSolved()(using Context): Unit = ()
+  protected def propagateSolved(provisional: Boolean)(using Context): Unit = ()
 
   /** This capture set with a description that tells where it comes from */
   def withDescription(description: String): CaptureSet
@@ -438,8 +447,9 @@ object CaptureSet:
 
   /** The subclass of constant capture sets with given elements `elems` */
   class Const private[CaptureSet] (val elems: Refs, val description: String = "") extends CaptureSet:
-    def isConst = true
-    def isAlwaysEmpty = elems.isEmpty
+    def isConst(using Context) = true
+    def isAlwaysEmpty(using Context) = elems.isEmpty
+    def isProvisionallySolved(using Context) = false
 
     def addThisElem(elem: CaptureRef)(using Context, VarState): CompareResult =
       addIfHiddenOrFail(elem)
@@ -470,7 +480,7 @@ object CaptureSet:
    *  were not yet compiled with capture checking on.
    */
   object Fluid extends Const(emptyRefs):
-    override def isAlwaysEmpty = false
+    override def isAlwaysEmpty(using Context) = false
     override def addThisElem(elem: CaptureRef)(using Context, VarState) = CompareResult.OK
     override def accountsFor(x: CaptureRef)(using Context, VarState): Boolean = true
     override def mightAccountFor(x: CaptureRef)(using Context): Boolean = true
@@ -489,8 +499,13 @@ object CaptureSet:
 
     //assert(id != 40)
 
-    /** A variable is solved if it is aproximated to a from-then-on constant set. */
-    private var isSolved: Boolean = false
+    /** A variable is solved if it is aproximated to a from-then-on constant set.
+     *  Interpretation:
+     *    0              not solved
+     *    Int.MaxValue   definitively solved
+     *    n > 0          provisionally solved in iteration n
+     */
+    private var solved: Int = 0
 
     /** The elements currently known to be in the set */
     protected var myElems: Refs = initialElems
@@ -503,8 +518,9 @@ object CaptureSet:
      */
     var deps: Deps = SimpleIdentitySet.empty
 
-    def isConst = isSolved
-    def isAlwaysEmpty = isSolved && elems.isEmpty
+    def isConst(using Context) = solved >= ccState.iterCount
+    def isAlwaysEmpty(using Context) = isConst && elems.isEmpty
+    def isProvisionallySolved(using Context): Boolean = solved > 0 && solved != Int.MaxValue
 
     def isMaybeSet = false // overridden in BiMapped
 
@@ -656,21 +672,20 @@ object CaptureSet:
      *  in the results of defs and vals.
      */
     def solve()(using Context): Unit =
-      if !isConst then
-        CCState.withCapAsRoot: // // OK here since we infer parameter types that get checked later
-          val approx = upperApprox(empty)
-            .map(root.CapToFresh(NoSymbol).inverse)    // Fresh --> cap
-            .showing(i"solve $this = $result", capt)
-          //println(i"solving var $this $approx ${approx.isConst} deps = ${deps.toList}")
-          val newElems = approx.elems -- elems
-          given VarState()
-          if tryInclude(newElems, empty).isOK then
-            markSolved()
+      CCState.withCapAsRoot: // // OK here since we infer parameter types that get checked later
+        val approx = upperApprox(empty)
+          .map(root.CapToFresh(NoSymbol).inverse)    // Fresh --> cap
+          .showing(i"solve $this = $result", capt)
+        //println(i"solving var $this $approx ${approx.isConst} deps = ${deps.toList}")
+        val newElems = approx.elems -- elems
+        given VarState()
+        if tryInclude(newElems, empty).isOK then
+          markSolved(provisional = false)
 
     /** Mark set as solved and propagate this info to all dependent sets */
-    def markSolved()(using Context): Unit =
-      isSolved = true
-      deps.foreach(_.propagateSolved())
+    def markSolved(provisional: Boolean)(using Context): Unit =
+      solved = if provisional then ccState.iterCount else Int.MaxValue
+      deps.foreach(_.propagateSolved(provisional))
 
     def withDescription(description: String): this.type =
       this.description = this.description.join(" and ", description)
@@ -728,8 +743,8 @@ object CaptureSet:
 
     addAsDependentTo(source)
 
-    override def propagateSolved()(using Context) =
-      if source.isConst && !isConst then markSolved()
+    override def propagateSolved(provisional: Boolean)(using Context) =
+      if source.isConst && !isConst then markSolved(provisional)
   end DerivedVar
 
   /** A variable that changes when `source` changes, where all additional new elements are mapped
@@ -823,8 +838,8 @@ object CaptureSet:
       else
         source.upperApprox(this).map(tm)
 
-    override def propagateSolved()(using Context) =
-      if initial.isConst then super.propagateSolved()
+    override def propagateSolved(provisional: Boolean)(using Context) =
+      if initial.isConst then super.propagateSolved(provisional)
 
     override def toString = s"Mapped$id($source, elems = $elems)"
   end Mapped
@@ -914,8 +929,8 @@ object CaptureSet:
           else res
         else res
 
-    override def propagateSolved()(using Context) =
-      if cs1.isConst && cs2.isConst && !isConst then markSolved()
+    override def propagateSolved(provisional: Boolean)(using Context) =
+      if cs1.isConst && cs2.isConst && !isConst then markSolved(provisional)
   end Union
 
   class Intersection(cs1: CaptureSet, cs2: CaptureSet)(using Context)
@@ -941,8 +956,8 @@ object CaptureSet:
       else
         CaptureSet(elemIntersection(cs1.upperApprox(this), cs2.upperApprox(this)))
 
-    override def propagateSolved()(using Context) =
-      if cs1.isConst && cs2.isConst && !isConst then markSolved()
+    override def propagateSolved(provisional: Boolean)(using Context) =
+      if cs1.isConst && cs2.isConst && !isConst then markSolved(provisional)
   end Intersection
 
   def elemIntersection(cs1: CaptureSet, cs2: CaptureSet)(using Context): Refs =

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

@@ -59,7 +59,7 @@ object CheckCaptures:
     def isOutermost = outer0 == null
 
     /** If an environment is open it tracks free references */
-    def isOpen = !captured.isAlwaysEmpty && kind != EnvKind.Boxed
+    def isOpen(using Context) = !captured.isAlwaysEmpty && kind != EnvKind.Boxed
 
     def outersIterator: Iterator[Env] = new:
       private var cur = Env.this
@@ -220,7 +220,7 @@ object CheckCaptures:
 
   trait CheckerAPI:
     /** Complete symbol info of a val or a def */
-    def completeDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type
+    def completeDef(tree: ValOrDefDef, sym: Symbol, newInfo: Type)(using Context): Type
 
     extension [T <: Tree](tree: T)
 
@@ -271,6 +271,8 @@ class CheckCaptures extends Recheck, SymTransformer:
 
   class CaptureChecker(ictx: Context) extends Rechecker(ictx), CheckerAPI:
 
+    // println(i"checking ${ictx.source}"(using ictx))
+
     /** The current environment */
     private val rootEnv: Env = inContext(ictx):
       Env(defn.RootClass, EnvKind.Regular, CaptureSet.empty, null)
@@ -292,8 +294,21 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     private val sepCheckFormals = util.EqHashMap[Tree, Type]()
 
+    /** 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]
+
+    var needAnotherRun = false
+
+    def resetIteration()(using Context): Unit =
+      needAnotherRun = false
+      resetNuTypes()
+      todoAtPostCheck.clear()
+      for (sym, completer) <- completed do sym.info = completer
+      completed.clear()
+
     extension [T <: Tree](tree: T)
       def needsSepCheck: Boolean = sepCheckFormals.contains(tree)
       def formalType: Type = sepCheckFormals.getOrElse(tree, NoType)
@@ -307,7 +322,9 @@ class CheckCaptures extends Recheck, SymTransformer:
       override def traverse(t: Type) = t match
         case t @ CapturingType(parent, refs) =>
           refs match
-            case refs: CaptureSet.Var if variance < 0 => refs.solve()
+            case refs: CaptureSet.Var if !refs.isConst =>
+              if variance < 0 then refs.solve()
+              else if ccConfig.newScheme then refs.markSolved(provisional = true)
             case _ =>
           traverse(parent)
         case t @ defn.RefinedFunctionOf(rinfo) =>
@@ -340,7 +357,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     private def interpolateVarsIn(tpt: Tree, sym: Symbol)(using Context): Unit =
       if tpt.isInstanceOf[InferredTypeTree] then
         interpolator().traverse(tpt.nuType)
-          .showing(i"solved vars in ${tpt.nuType}", capt)
+          .showing(i"solved vars for $sym in ${tpt.nuType}", capt)
         anchorCaps(sym).traverse(tpt.nuType)
       for msg <- ccState.approxWarnings do
         report.warning(msg, tpt.srcPos)
@@ -351,23 +368,33 @@ class CheckCaptures extends Recheck, SymTransformer:
       assert(cs1.subCaptures(cs2).isOK, i"$cs1 is not a subset of $cs2")
 
     /** If `res` is not CompareResult.OK, report an error */
-    def checkOK(res: CompareResult, prefix: => String, added: CaptureRef | CaptureSet, pos: SrcPos, provenance: => String = "")(using Context): Unit =
+    def checkOK(res: CompareResult, prefix: => String, added: CaptureRef | CaptureSet, target: CaptureSet, pos: SrcPos, provenance: => String = "")(using Context): Unit =
       res match
         case res: CompareFailure =>
-          inContext(root.printContext(added, res.blocking)):
+          def msg =
             def toAdd: String = errorNotes(res.errorNotes).toAdd.mkString
             def descr: String =
               val d = res.blocking.description
               if d.isEmpty then provenance else ""
-            report.error(em"$prefix included in the allowed capture set ${res.blocking}$descr$toAdd", pos)
+            em"$prefix included in the allowed capture set ${res.blocking}$descr$toAdd"
+          target match
+            case target: CaptureSet.Var if res.blocking.isProvisionallySolved =>
+              report.warning(msg.prepend(i"Another capture checking run needs to be scheduled because:"), 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)
         case _ =>
 
     /** Check subcapturing `{elem} <: cs`, report error on failure */
     def checkElem(elem: CaptureRef, cs: CaptureSet, pos: SrcPos, provenance: => String = "")(using Context) =
       checkOK(
           ccState.test(elem.singletonCaptureSet.subCaptures(cs)),
           i"$elem cannot be referenced here; it is not",
-          elem, pos, provenance)
+          elem, cs, pos, provenance)
 
     /** Check subcapturing `cs1 <: cs2`, report error on failure */
     def checkSubset(cs1: CaptureSet, cs2: CaptureSet, pos: SrcPos,
@@ -376,7 +403,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           ccState.test(cs1.subCaptures(cs2)),
           if cs1.elems.size == 1 then i"reference ${cs1.elems.toList.head}$cs1description is not"
           else i"references $cs1$cs1description are not all",
-          cs1, pos, provenance)
+          cs1, cs2, pos, provenance)
 
     /** If `sym` is a class or method nested inside a term, a capture set variable representing
      *  the captured variables of the environment associated with `sym`.
@@ -1051,9 +1078,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       tp
     end checkInferredResult
 
-    /** The set of symbols that were rechecked via a completer */
-    private val completed = new mutable.HashSet[Symbol]
-
     /** The normal rechecking if `sym` was already completed before */
     override def skipRecheck(sym: Symbol)(using Context): Boolean =
       completed.contains(sym)
@@ -1062,7 +1086,9 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  these checks can appear out of order, we need to first create the correct
      *  environment for checking the definition.
      */
-    def completeDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type =
+    def completeDef(tree: ValOrDefDef, sym: Symbol, newInfo: Type)(using Context): Type =
+      val completer = sym.infoOrCompleter
+      sym.info = newInfo
       val saved = curEnv
       try
         // Setup environment to reflect the new owner.
@@ -1079,7 +1105,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
+        finally completed(sym) = completer
       finally
         curEnv = saved
 
@@ -1704,7 +1730,13 @@ class CheckCaptures extends Recheck, SymTransformer:
         report.echo(s"$echoHeader\n$treeString\n")
 
       withCaptureSetsExplained:
-        super.checkUnit(unit)
+        while
+          super.checkUnit(unit)
+          !ctx.reporter.errorsReported && needAnotherRun
+        do
+          resetIteration()
+          ccState.iterCount += 1
+          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

@@ -728,8 +728,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                   assert(ctx.phase == thisPhase.next, i"$sym")
                   capt.println(i"forcing $sym, printing = ${ctx.mode.is(Mode.Printing)}")
                   //if ctx.mode.is(Mode.Printing) then new Error().printStackTrace()
-                  denot.info = newInfo
-                  completeDef(tree, sym)
+                  completeDef(tree, sym, newInfo)
             updateInfo(sym, updatedInfo)
 
       case tree: Bind =>

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -189,6 +189,9 @@ abstract class Recheck extends Phase, SymTransformer:
     def keepNuTypes(using Context): Boolean =
       ctx.settings.Xprint.value.containsPhase(thisPhase)
 
+    def resetNuTypes()(using Context): Unit =
+      nuTypes.clear(resetToInitial = false)
+
     /** A map from NamedTypes to the denotations they had before this phase.
      *  Needed so that we can `reset` them after this phase.
      */