More robust scheme to re-check definitions once.

The previous scheme relied on subtle and unstated assumptions between
symbol updates and re-checking. If they were violated some definitions
could not be rechecked at all. The new scheme is more robust. We always
re-check except when the checker implementation returns true for `skipRecheck`.
And that test is based on an explicitly maintained set of completed symbols.

Author: odersky

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

@@ -1185,6 +1185,11 @@ class CheckCaptures extends Recheck, SymTransformer:
           case _ =>
         traverseChildren(t)
 
+    private val completed = new mutable.HashSet[Symbol]
+
+    override def skipRecheck(sym: Symbol)(using Context): Boolean =
+      completed.contains(sym)
+
     /** Check a ValDef or DefDef as an action performed in a completer. Since
      *  these checks can appear out of order, we need to firsty create the correct
      *  environment for checking the definition.
@@ -1205,7 +1210,8 @@ class CheckCaptures extends Recheck, SymTransformer:
             case None => Env(sym, EnvKind.Regular, localSet, restoreEnvFor(sym.owner))
         curEnv = restoreEnvFor(sym.owner)
         capt.println(i"Complete $sym in ${curEnv.outersIterator.toList.map(_.owner)}")
-        recheckDef(tree, sym)
+        try recheckDef(tree, sym)
+        finally completed += sym
       finally
         curEnv = saved
 

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

@@ -454,12 +454,16 @@ abstract class Recheck extends Phase, SymTransformer:
         case _ =>
       traverse(stats)
 
+    /** A hook to prevent rechecking a ValDef or DefDef.
+     *  Typycally used when definitions are completed on first use.
+     */
+    def skipRecheck(sym: Symbol)(using Context) = false
+
     def recheckDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type =
-      inContext(ctx.localContext(tree, sym)) {
+      inContext(ctx.localContext(tree, sym)):
         tree match
           case tree: ValDef => recheckValDef(tree, sym)
           case tree: DefDef => recheckDefDef(tree, sym)
-      }
 
     /** Recheck tree without adapting it, returning its new type.
      *  @param tree        the original tree
@@ -476,10 +480,8 @@ abstract class Recheck extends Phase, SymTransformer:
           case tree: ValOrDefDef =>
             if tree.isEmpty then NoType
             else
-              if sym.isUpdatedAfter(preRecheckPhase) then
-                sym.ensureCompleted() // in this case the symbol's completer should recheck the right hand side
-              else
-                recheckDef(tree, sym)
+              sym.ensureCompleted()
+              if !skipRecheck(sym) then recheckDef(tree, sym)
               sym.termRef
           case tree: TypeDef =>
             // TODO: Should we allow for completers as for ValDefs or DefDefs?