Fix #5449: Index class definitions before unpickling parents

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -649,7 +649,8 @@ object TastyFormat {
     case VALDEF | DEFDEF | TYPEDEF | OBJECTDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
          SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | HOLE => 1
     case RENAMED | PARAMtype => 2
-    case POLYtype | METHODtype | TYPELAMBDAtype => -1
+    case POLYtype | METHODtype | IMPLICITMETHODtype | ERASEDMETHODtype | ERASEDIMPLICITMETHODtype |
+         TYPELAMBDAtype => -1
     case _ => 0
   }
 }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -869,6 +869,14 @@ class TreeUnpickler(reader: TastyReader,
       val end = readEnd()
       val tparams = readIndexedParams[TypeDef](TYPEPARAM)
       val vparams = readIndexedParams[ValDef](PARAM)
+      // It's important to index the class definitions before unpickling the parents
+      // (see the parents-cycle test for examples where this matter)
+      val bodyFlags = {
+        val bodyIndexer = fork
+        // The first DEFDEF corresponds to the primary constructor
+        while (bodyIndexer.reader.nextByte != DEFDEF) bodyIndexer.skipTree()
+        bodyIndexer.indexStats(end)
+      }
       val parents = collectWhile(nextByte != SELFDEF && nextByte != DEFDEF) {
         nextUnsharedTag match {
           case APPLY | TYPEAPPLY | BLOCK => readTerm()(parentCtx)
@@ -884,7 +892,7 @@ class TreeUnpickler(reader: TastyReader,
         else EmptyValDef
       cls.info = ClassInfo(cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,
         if (self.isEmpty) NoType else self.tpt.tpe)
-      cls.setNoInitsFlags(parentsKind(parents), fork.indexStats(end))
+      cls.setNoInitsFlags(parentsKind(parents), bodyFlags)
       val constr = readIndexedDef().asInstanceOf[DefDef]
       val mappedParents = parents.map(_.changeOwner(localDummy, constr.symbol))
 

tests/pos-separate-compilation/parents-cycle/Def_1.scala

@@ -0,0 +1,15 @@
+class A[T]
+// Unpickling the parents of B1 will lead to unpickling a call to B1.<init>
+class B1 extends A[C1]
+class C1 extends B1
+
+// Unpickling the parents of B2 will lead to unpickling a call to the secondary B2.<init>
+class B2 extends A[C2] {
+  def this(x: Int) = this()
+}
+class C2 extends B2(1)
+
+// Unpickling the parents of B3 will lead to unpickling a call to B3#Hi
+class B3 extends A[B3#Hi[Int]] {
+  type Hi[X] = X
+}

tests/pos-separate-compilation/parents-cycle/Use_2.scala

@@ -0,0 +1,5 @@
+object Use {
+  val b1 = new B1
+  val b2 = new B2
+  val b3 = new B3
+}