Redo scheme for typing late-loaded units

We got into problems when the symbols were entered in one run and
the tree was demanded in a subsequent run. In that case we'd need
to time-travel back which the framework does not really support.

The new scheme makes sure the typechecking is done at the same run
as when the symbols were entered. It either immediately typechecks
them, or if called during a compile, waits until the end of the
compile. The latter twist is done so that we do not cause new cycles.

Author: odersky

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

@@ -61,6 +61,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     (start.setRun(this) /: defn.RootImportFns)(addImport)
   }
 
+  private[this] var compiling = false
+
   private[this] var myCtx = rootContext(ictx)
 
   /** The context created for this run */
@@ -96,6 +98,9 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** The source files of all late entered symbols, as a set */
   private[this] var lateFiles = mutable.Set[AbstractFile]()
 
+  /** Actions that need to be performed at the end of the current compilation run */
+  private[this] var finalizeActions = mutable.ListBuffer[() => Unit]()
+
   def getSource(fileName: String): SourceFile = {
     val f = new PlainFile(io.Path(fileName))
     if (f.isDirectory) {
@@ -143,6 +148,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   protected def compileUnits()(implicit ctx: Context) = Stats.maybeMonitored {
     ctx.checkSingleThreaded()
+    compiling = true
 
     // If testing pickler, make sure to stop after pickling phase:
     val stopAfter =
@@ -184,31 +190,32 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     ctx.phases.foreach(_.initContext(runCtx))
     runPhases(runCtx)
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
+    while (finalizeActions.nonEmpty) {
+      val action = finalizeActions.remove(0)
+      action()
+    }
+    compiling = false
   }
 
   /** Enter top-level definitions of classes and objects contain in Scala source file `file`.
    *  The newly added symbols replace any previously entered symbols.
+   *  If `typeCheck = true`, also run typer on the compilation unit.
    */
-  def enterRoots(file: AbstractFile)(implicit ctx: Context): Option[CompilationUnit] =
+  def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit =
     if (!files.contains(file) && !lateFiles.contains(file)) {
       lateFiles += file
       val unit = new CompilationUnit(getSource(file.path))
-      enterRoots(unit)(runContext.fresh.setCompilationUnit(unit))
-      Some(unit)
+      def process()(implicit ctx: Context) = {
+        unit.untpdTree = new Parser(unit.source).parse()
+        ctx.typer.lateEnter(unit.untpdTree)
+        def typeCheckUnit() = unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
+        if (typeCheck)
+          if (compiling) finalizeActions += (() => typeCheckUnit()) else typeCheckUnit()
+      }
+      process()(runContext.fresh.setCompilationUnit(unit))
     }
     else None
 
-  private def enterRoots(unit: CompilationUnit)(implicit ctx: Context): Unit = {
-    unit.untpdTree = new Parser(unit.source).parse()
-    ctx.typer.lateEnter(unit.untpdTree)
-  }
-
-  def typedTree(unit: CompilationUnit)(implicit ctx: Context) = {
-    def typeCheck(implicit ctx: Context) = ctx.typer.typedExpr(unit.untpdTree)
-    if (unit.tpdTree.isEmpty) unit.tpdTree = typeCheck(runContext.fresh.setCompilationUnit(unit))
-    unit.tpdTree
-  }
-
   private sealed trait PrintedTree
   private /*final*/ case class SomePrintedTree(phase: String, tree: String) extends PrintedTree
   private object NoPrintedTree extends PrintedTree

compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -397,16 +397,6 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
 class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader {
   def description(implicit ctx: Context) = "source file " + srcfile.toString
   override def sourceFileOrNull = srcfile
-  def doComplete(root: SymDenotation)(implicit ctx: Context): Unit = {
-    for (unit <- ctx.run.enterRoots(srcfile))
-      if (ctx.settings.YretainTrees.value) {
-        val (classRoot, moduleRoot) = rootDenots(root.asClass)
-        val treeProvider = new tpd.TreeProvider {
-          def computeTrees(implicit ctx: Context): List[tpd.Tree] =
-            ctx.run.typedTree(unit) :: Nil
-        }
-        classRoot.classSymbol.treeOrProvider = treeProvider
-        moduleRoot.classSymbol.treeOrProvider = treeProvider
-      }
-  }
+  def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
+    ctx.run.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
 }