When typing a DerivedFromParamTree, only complete constructors

Parameter accessors have a derived rhs based on the corresponding class
constructor parameter. Before this commit, typing such a derived tree
would involve completing the enclosing class, which requires typing the
class parents, which might end up requiring the info of the original
parameter accessor. This doesn't always cause cyclic reference since
`Namer#typeDefSig` sets temporary empty bounds when completing a type
definition, but it can lead to puzzling compilation errors. In
particular, after the changes related to completions in this PR, it
broke the bootstrap.

We fix this by making `DerivedFromParamTree#ensureCompletions` force
less: we only really need to force the constructors, this requires some
refactoring in `ClassCompleter` to allow such partial completions.

Author: smarter

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -7,7 +7,7 @@ import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags
 import Symbols._, StdNames._, Trees._
 import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
-import typer.FrontEnd
+import typer.{FrontEnd, Namer}
 import util.{Property, SourceFile, SourcePosition}
 import util.NameTransformer.avoidIllegalChars
 import collection.mutable.ListBuffer
@@ -75,21 +75,27 @@ object desugar {
   }
 
   /** A type tree that computes its type from an existing parameter. */
-  class DerivedFromParamTree(implicit @constructorOnly src: SourceFile) extends DerivedTypeTree {
+  class DerivedFromParamTree()(implicit @constructorOnly src: SourceFile) extends DerivedTypeTree {
 
-    /** Make sure that for all enclosing module classes their companion classes
-     *  are completed. Reason: We need the constructor of such companion classes to
-     *  be completed so that OriginalSymbol attachments are pushed to DerivedTypeTrees
-     *  in apply/unapply methods.
+    /** Complete the appropriate constructors so that OriginalSymbol attachments are
+     *  pushed to DerivedTypeTrees.
      */
-    override def ensureCompletions(implicit ctx: Context): Unit =
+    override def ensureCompletions(implicit ctx: Context): Unit = {
+      def completeConstructor(sym: Symbol) =
+        sym.infoOrCompleter match {
+          case completer: Namer#ClassCompleter =>
+            completer.completeConstructor(sym)
+          case _ =>
+        }
+
       if (!ctx.owner.is(Package))
         if (ctx.owner.isClass) {
-          ctx.owner.ensureCompleted()
+          completeConstructor(ctx.owner)
           if (ctx.owner.is(ModuleClass))
-            ctx.owner.linkedClass.ensureCompleted()
+            completeConstructor(ctx.owner.linkedClass)
         }
         else ensureCompletions(ctx.outer)
+    }
 
     /** Return info of original symbol, where all references to siblings of the
      *  original symbol (i.e. sibling and original symbol have the same owner)

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -913,6 +913,10 @@ class Namer { typer: Typer =>
 
     protected implicit val ctx: Context = localContext(cls).setMode(ictx.mode &~ Mode.InSuperCall)
 
+    private[this] var localCtx: Context = _
+    /** info to be used temporarily while completing the class, to avoid cyclic references. */
+    private[this] var tempInfo: TempClassInfo = _
+
     val TypeDef(name, impl @ Template(constr, _, self, _)) = original
 
     private val (params, rest): (List[Tree], List[Tree]) = impl.body.span {
@@ -1040,6 +1044,42 @@ class Namer { typer: Typer =>
       forwarderss.foreach(_.foreach(fwdr => fwdr.symbol.entered))
     }
 
+    /** Ensure constructor is completed so that any parameter accessors
+     *  which have type trees deriving from its parameters can be
+     *  completed in turn. Note that parent types access such parameter
+     *  accessors, that's why the constructor needs to be completed before
+     *  the parent types are elaborated.
+     */
+    def completeConstructor(denot: SymDenotation): Unit = {
+      if (tempInfo != null) // Constructor has been completed already
+        return
+
+      addAnnotations(denot.symbol)
+
+      val selfInfo: TypeOrSymbol =
+        if (self.isEmpty) NoType
+        else if (cls.is(Module)) {
+          val moduleType = cls.owner.thisType select sourceModule
+          if (self.name == nme.WILDCARD) moduleType
+          else recordSym(
+            ctx.newSymbol(cls, self.name, self.mods.flags, moduleType, coord = self.span),
+            self)
+        }
+        else createSymbol(self)
+
+      val savedInfo = denot.infoOrCompleter
+      tempInfo = new TempClassInfo(cls.owner.thisType, cls, decls, selfInfo)
+      denot.info = tempInfo
+
+      localCtx = ctx.inClassContext(selfInfo)
+
+      index(constr)
+      index(rest)(localCtx)
+      symbolOfTree(constr).ensureCompleted()
+
+      denot.info = savedInfo
+    }
+
     /** The type signature of a ClassDef with given symbol */
     override def completeInCreationContext(denot: SymDenotation): Unit = {
       val parents = impl.parents
@@ -1102,34 +1142,11 @@ class Namer { typer: Typer =>
         }
       }
 
-      addAnnotations(denot.symbol)
+      if (tempInfo == null) // Constructor has not been completed yet
+        completeConstructor(denot)
 
-      val selfInfo: TypeOrSymbol =
-        if (self.isEmpty) NoType
-        else if (cls.is(Module)) {
-          val moduleType = cls.owner.thisType select sourceModule
-          if (self.name == nme.WILDCARD) moduleType
-          else recordSym(
-            ctx.newSymbol(cls, self.name, self.mods.flags, moduleType, coord = self.span),
-            self)
-        }
-        else createSymbol(self)
-
-      // pre-set info, so that parent types can refer to type params
-      val tempInfo = new TempClassInfo(cls.owner.thisType, cls, decls, selfInfo)
       denot.info = tempInfo
 
-      val localCtx = ctx.inClassContext(selfInfo)
-
-      // Ensure constructor is completed so that any parameter accessors
-      // which have type trees deriving from its parameters can be
-      // completed in turn. Note that parent types access such parameter
-      // accessors, that's why the constructor needs to be completed before
-      // the parent types are elaborated.
-      index(constr)
-      index(rest)(localCtx)
-      symbolOfTree(constr).ensureCompleted()
-
       val parentTypes = defn.adjustForTuple(cls, cls.typeParams,
         ensureFirstIsClass(parents.map(checkedParentType(_)), cls.span))
       typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")
@@ -1145,6 +1162,8 @@ class Namer { typer: Typer =>
       }
 
       tempInfo.finalize(denot, parentTypes)
+      // The temporary info can now be garbage-collected
+      tempInfo = null
 
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)