A more robust scheme for resetting denotations after Recheck

The new scheme works also for arbitrary denotation changes in PreRecheck.

Furthermore, recheck denot transformers are not run after Recheck has ended. This
means that effectivly only symbols touched by the Rechecker are transformed and
reset again afterwards.

Author: odersky

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

@@ -34,14 +34,17 @@ object CheckCaptures:
   	/**  - Reset `private` flags of parameter accessors so that we can refine them
      *     in Setup if they have non-empty capture sets.
      *   - Special handling of some symbols defined for case classes.
+     *  Enabled only until recheck is finished, and provided some compilation unit
+     *  is CC-enabled.
      */
     def transformSym(sym: SymDenotation)(using Context): SymDenotation =
-      if sym.isAllOf(PrivateParamAccessor) && !sym.hasAnnotation(defn.ConstructorOnlyAnnot) then
-        sym.copySymDenotation(initFlags = sym.flags &~ Private | Recheck.ResetPrivate)
-      else if Synthetics.needsTransform(sym) then
-        Synthetics.transform(sym, toCC = true)
-      else
-        sym
+      if !pastRecheck && Feature.ccEnabledSomewhere then
+        if sym.isAllOf(PrivateParamAccessor) && !sym.hasAnnotation(defn.ConstructorOnlyAnnot) then
+          sym.copySymDenotation(initFlags = sym.flags &~ Private | Recheck.ResetPrivate)
+        else if Synthetics.needsTransform(sym) then
+          Synthetics.transform(sym, toCC = true)
+        else sym
+      else sym
   end Pre
 
   enum EnvKind:

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

@@ -306,7 +306,7 @@ extends tpd.TreeTraverser:
 
   /** Update info of `sym` for CheckCaptures phase only */
   private def updateInfo(sym: Symbol, info: Type)(using Context) =
-    sym.updateInfoBetween(preRecheckPhase, thisPhase, info, newOwnerFor(sym))
+    sym.updateInfo(preRecheckPhase, info, newOwnerFor(sym))
     sym.namedType match
       case ref: CaptureRef => ref.invalidateCaches()
       case _ =>

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

@@ -14,6 +14,8 @@ abstract class PreRecheck extends Phase, DenotTransformer:
 
   override def changesBaseTypes: Boolean = true
 
+  var pastRecheck = false
+
   def run(using Context): Unit = ()
 
   override def isCheckable = false

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

@@ -48,26 +48,19 @@ object Recheck:
 
   extension (sym: Symbol)
 
-    /** Update symbol's info to newInfo from prevPhase.next to lastPhase.
+    /** Update symbol's info to newInfo after `prevPhase`.
      *  Also update owner to newOwnerOrNull if it is not null.
-     *  Reset to previous info and owner for phases after lastPhase.
+     *  The update is valid until after Recheck. After that the symbol's denotation
+     *  is reset to what it was before PreRecheck.
      */
-    def updateInfoBetween(prevPhase: DenotTransformer, lastPhase: DenotTransformer, newInfo: Type, newOwnerOrNull: Symbol | Null = null)(using Context): Unit =
+    def updateInfo(prevPhase: DenotTransformer, newInfo: Type, newOwnerOrNull: Symbol | Null = null)(using Context): Unit =
       val newOwner = if newOwnerOrNull == null then sym.owner else newOwnerOrNull
       if (sym.info ne newInfo) || (sym.owner ne newOwner)  then
         val flags = sym.flags
-        sym.copySymDenotation(
-            initFlags =
-              if flags.isAllOf(ResetPrivateParamAccessor)
-              then flags &~ ResetPrivate | Private
-              else flags
-          ).installAfter(lastPhase) // reset
         sym.copySymDenotation(
             owner = newOwner,
             info = newInfo,
-            initFlags =
-              if newInfo.isInstanceOf[LazyType] then flags &~ Touched
-              else flags
+            initFlags = if newInfo.isInstanceOf[LazyType] then flags &~ Touched else flags
           ).installAfter(prevPhase)
 
     /** Does symbol have a new denotation valid from phase.next that is different
@@ -158,16 +151,20 @@ abstract class Recheck extends Phase, SymTransformer:
     // One failing test is pos/i583a.scala
 
   /** Change any `ResetPrivate` flags back to `Private` */
-  def transformSym(sym: SymDenotation)(using Context): SymDenotation =
-    if sym.isAllOf(Recheck.ResetPrivateParamAccessor) then
-      sym.copySymDenotation(initFlags = sym.flags &~ Recheck.ResetPrivate | Private)
-    else sym
+  def transformSym(symd: SymDenotation)(using Context): SymDenotation =
+    val sym = symd.symbol
+    if sym.isUpdatedAfter(preRecheckPhase) then atPhase(preRecheckPhase)(sym.denot)
+    else symd
 
   def run(using Context): Unit =
     val rechecker = newRechecker()
     rechecker.checkUnit(ctx.compilationUnit)
     rechecker.reset()
 
+  override def runOn(units: List[CompilationUnit])(using runCtx: Context): List[CompilationUnit] =
+    try super.runOn(units)
+    finally preRecheckPhase.pastRecheck = true
+
   def newRechecker()(using Context): Rechecker
 
   /** The typechecker pass */
@@ -197,6 +194,7 @@ abstract class Recheck extends Phase, SymTransformer:
     def reset()(using Context): Unit =
       for (ref, mbr) <- prevSelDenots.iterator do
         ref.withDenot(mbr)
+      preRecheckPhase
 
     /** Constant-folded rechecked type `tp` of tree `tree` */
     protected def constFold(tree: Tree, tp: Type)(using Context): Type =