Compute trees from sources in compilation unit used for entering symbols

Don't parse a new tree, since this generates a new set of symbols which are
hard to correlate with the old ones.

Author: odersky

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

@@ -189,18 +189,26 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** Enter top-level definitions of classes and objects contain in Scala source file `file`.
    *  The newly added symbols replace any previously entered symbols.
    */
-  def enterRoots(file: AbstractFile)(implicit ctx: Context): Unit =
+  def enterRoots(file: AbstractFile)(implicit ctx: Context): Option[CompilationUnit] =
     if (!files.contains(file) && !lateFiles.contains(file)) {
       lateFiles += file
       val unit = new CompilationUnit(getSource(file.path))
       enterRoots(unit)(runContext.fresh.setCompilationUnit(unit))
+      Some(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

@@ -398,19 +398,15 @@ 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 = {
-    ctx.run.enterRoots(srcfile)
-    if (ctx.settings.YretainTrees.value) {
-      val (classRoot, moduleRoot) = rootDenots(root.asClass)
-      classRoot.classSymbol.treeOrProvider = treeProvider
-      moduleRoot.classSymbol.treeOrProvider = treeProvider
-    }
-  }
-  object treeProvider extends tpd.TreeProvider {
-    def computeTrees(implicit ctx: Context): List[tpd.Tree] = {
-      var units = new CompilationUnit(ctx.run.getSource(srcfile.path)) :: Nil
-      for (phase <- ctx.allPhases; if phase.isTyper)
-        units = phase.runOn(units)
-      units.map(_.tpdTree)
-    }
+    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
+      }
   }
 }