Avoiding cyclic references involving module vals and imports.

Previousely, compiling all of dotc/core caused a cyclic reference. The cyclic reference was caused by evaluating a module val, which caused it to evaluate its type, which caused the evaluation of all preceding imports, which led via some hops back to the same module val. We now break the cycle by computing the signature of a module val without going through its type.

1 files changed, 13 insertions, 1 deletions

diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala
index 317827129..c0e39c44c 100644
--- a/src/dotty/tools/dotc/typer/Namer.scala
+++ b/src/dotty/tools/dotc/typer/Namer.scala
@@ -327,7 +327,8 @@ class Namer { typer: Typer =>
 
     private def typeSig(sym: Symbol): Type = original match {
       case original: ValDef =>
-        valOrDefDefSig(original, sym, Nil, identity)(localContext(sym).withNewScope)
+        if (sym is Module) moduleValSig(sym)
+        else valOrDefDefSig(original, sym, Nil, identity)(localContext(sym).withNewScope)
       case original: DefDef =>
         val typer1 = new Typer
         nestedTyper(sym) = typer1
@@ -420,6 +421,17 @@ class Namer { typer: Typer =>
     for (param <- params) typedAheadExpr(param)
   }
 
+  /** The signature of a module valdef.
+   *  This will compute the corresponding module class TypeRef immediately
+   *  without going through the defined type of the ValDef. This is necessary
+   *  to avoid cyclic references involving imports and module val defs.
+   */
+  def moduleValSig(sym: Symbol)(implicit ctx: Context): Type = {
+    val clsName = sym.name.moduleClassName
+    val cls = ctx.denotNamed(clsName) suchThat (_ is ModuleClass)
+    ctx.owner.thisType select (clsName, cls)
+  }
+
   /** The type signature of a ValDef or DefDef
    *  @param mdef     The definition
    *  @param sym      Its symbol