Check of cyclic object initialization v3

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -57,15 +57,15 @@ class Compiler {
 
   /** Phases dealing with the transformation from pickled trees to backend trees */
   protected def transformPhases: List[List[Phase]] =
+    List(new init.Checker) ::        // Check initialization of objects
     List(new FirstTransform,         // Some transformations to put trees into a canonical form
          new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
          new ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes
          new CookComments,           // Cook the comments: expand variables, doc, etc.
          new CheckStatic,            // Check restrictions that apply to @static members
          new BetaReduce,             // Reduce closure applications
          new InlineVals,             // Check right hand-sides of an `inline val`s
-         new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
-         new init.Checker) ::        // Check initialization of objects
+         new ExpandSAMs) ::          // Expand single abstract method closures to anonymous classes
     List(new ElimRepeated,           // Rewrite vararg parameters and arguments
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods

compiler/src/dotty/tools/dotc/transform/init/Checker.scala

@@ -12,27 +12,53 @@ import Types._
 import Symbols._
 
 import dotty.tools.dotc.transform._
-import MegaPhase._
+import Phases._
 
 
 import scala.collection.mutable
 
 
-class Checker extends MiniPhase {
+class Checker extends Phase {
   import tpd._
 
   val phaseName = "initChecker"
 
   // cache of class summary
   private val cache = new Cache
 
+  private val cycleChecker = new CycleChecker(cache)
+
   override val runsAfter = Set(Pickler.name)
+  val runsBefore = Set(ExpandSAMs.name)
 
   override def isEnabled(using Context): Boolean =
     super.isEnabled && ctx.settings.YcheckInit.value
 
-  override def transformTypeDef(tree: TypeDef)(using Context): tpd.Tree = {
-    if (!tree.isClassDef) return tree
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+    cycleChecker.clean()
+    val newUnits = super.runOn(units)
+    cycleChecker.checkCyclic()
+    newUnits
+
+  val traverser = new TreeTraverser {
+    override def traverse(tree: Tree)(using Context): Unit =
+      tree match {
+        case tdef: TypeDef if tdef.isClassDef =>
+          checkClassDef(tdef)
+          cycleChecker.classesInCurrentRun += tdef.symbol
+          traverseChildren(tree)
+        case _ =>
+          traverseChildren(tree)
+      }
+  }
+
+  override def run(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    traverser.traverse(unit.tpdTree)
+  }
+
+  def checkClassDef(tree: TypeDef)(using Context): tpd.Tree = {
+    assert(tree.isClassDef)
 
     val cls = tree.symbol.asClass
     val instantiable: Boolean =
@@ -54,10 +80,14 @@ class Checker extends MiniPhase {
         fieldsInited = mutable.Set.empty,
         parentsInited = mutable.Set.empty,
         safePromoted = mutable.Set.empty,
+        dependencies = mutable.Set.empty,
+        superConstrCalled = false,
         env = Env(ctx.withOwner(cls), cache)
       )
 
       Checking.checkClassBody(tree)
+
+      cycleChecker.cacheConstructorDependencies(cls.primaryConstructor, state.dependencies.toList)
     }
 
     tree