Support completion from source

Author: odersky

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

@@ -18,6 +18,7 @@ import transform.TreeChecker
 import rewrite.Rewrites
 import java.io.{BufferedWriter, OutputStreamWriter}
 import printing.XprintMode
+import parsing.Parsers.Parser
 import typer.ImplicitRunInfo
 
 import scala.annotation.tailrec
@@ -169,6 +170,20 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     runPhases(runCtx)
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
   }
+  
+  /** 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 =
+    if (!files.contains(file)) {
+      val unit = new CompilationUnit(getSource(file.path))
+      enterRoots(unit)(runContext.fresh.setCompilationUnit(unit))
+    }
+
+  private def enterRoots(unit: CompilationUnit)(implicit ctx: Context): Unit = {
+    unit.untpdTree = new Parser(unit.source).parse()
+    ctx.typer.lateEnter(unit.untpdTree)
+  }
 
   private sealed trait PrintedTree
   private /*final*/ case class SomePrintedTree(phase: String, tree: String) extends PrintedTree

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

@@ -929,7 +929,7 @@ object Denotations {
         // printPeriods(current)
         this.validFor = Period(ctx.runId, targetId, current.validFor.lastPhaseId)
         if (current.validFor.firstPhaseId >= targetId)
-          insertInsteadOf(current)
+          current.replaceWith(this)
         else {
           current.validFor = Period(ctx.runId, current.validFor.firstPhaseId, targetId - 1)
           insertAfter(current)
@@ -950,7 +950,7 @@ object Denotations {
         val current1: SingleDenotation = f(current.asSymDenotation)
         if (current1 ne current) {
           current1.validFor = current.validFor
-          current1.insertInsteadOf(current)
+          current.replaceWith(current1)
         }
         hasNext = current1.nextInRun.validFor.code > current1.validFor.code
         current = current1.nextInRun
@@ -972,14 +972,14 @@ object Denotations {
      *  The code to achieve this is subtle in that it works correctly
      *  whether the replaced denotation is the only one in its cycle or not.
      */
-    private def insertInsteadOf(old: SingleDenotation): Unit = {
-      var prev = old
-      while (prev.nextInRun ne old) prev = prev.nextInRun
+    private[dotc] def replaceWith(newd: SingleDenotation): Unit = {
+      var prev = this
+      while (prev.nextInRun ne this) prev = prev.nextInRun
       // order of next two assignments is important!
-      prev.nextInRun = this
-      this.nextInRun = old.nextInRun
-      old.validFor = Nowhere
-      old.nextInRun = this
+      prev.nextInRun = newd
+      newd.nextInRun = nextInRun
+      validFor = Nowhere
+      nextInRun = newd
     }
 
     def staleSymbolError(implicit ctx: Context) =

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

@@ -1,8 +1,3 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2012 LAMP/EPFL
- * @author  Martin Odersky
- */
-
 package dotty.tools
 package dotc
 package core
@@ -199,7 +194,7 @@ class SymbolLoaders {
         !root.unforcedDecls.lookup(classRep.name.toTypeName).exists
 
       if (!root.isRoot) {
-        val classReps = classPath.classes(packageName)
+        val classReps = classPath.list(packageName).classesAndSources
 
         for (classRep <- classReps)
           if (!maybeModuleClass(classRep) && isFlatName(classRep) == flat &&
@@ -343,5 +338,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 = unsupported("doComplete")
+  def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
+    ctx.run.enterRoots(srcfile)
 }

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

@@ -205,6 +205,9 @@ class Namer { typer: Typer =>
    */
   val scope = newScope
 
+  /** We are entering symbols coming from a SourceLoader */
+  private[this] var lateCompile = false
+
   /** The symbol of the given expanded tree. */
   def symbolOfTree(tree: Tree)(implicit ctx: Context): Symbol = {
     val xtree = expanded(tree)
@@ -335,6 +338,15 @@ class Namer { typer: Typer =>
     */
   def enterSymbol(sym: Symbol)(implicit ctx: Context) = {
     if (sym.exists) {
+      if (lateCompile && sym.owner.is(Package)) {
+        val preExisting = ctx.effectiveScope.lookup(sym.name)
+        if (preExisting.exists) {
+          typr.println(i"overwriting $preExisting to late loaded $sym")
+          val old = preExisting.denot
+          old.replaceWith(sym.denot)
+          old.info = sym.info
+        }
+      }
       typr.println(s"entered: $sym in ${ctx.owner}")
       ctx.enter(sym)
     }
@@ -727,6 +739,16 @@ class Namer { typer: Typer =>
     localCtx
   }
 
+  /** Index and annotate symbols in `tree` while asserting the `lateCompile` flag.
+   *  This will cause any old top-level symbol with the same fully qualified
+   *  name as a newly created symbol to be replaced.
+   */
+  def lateEnter(tree: Tree)(implicit ctx: Context) = {
+    val saved = lateCompile
+    lateCompile = true
+    try indexAndAnnotate(tree :: Nil) finally lateCompile = saved
+  }
+
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
   class Completer(val original: Tree)(implicit ctx: Context) extends LazyType {
 

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -56,6 +56,7 @@ class CompilationTests extends ParallelTesting {
     compileFile("../tests/pos-special/utf8encoded.scala", explicitUTF8) +
     compileFile("../tests/pos-special/utf16encoded.scala", explicitUTF16) +
     compileFile("../tests/pos-special/i3589-b.scala", defaultOptions.and("-Xfatal-warnings")) +
+    compileFile("../tests/pos-special/completeFromSource/Test.scala", defaultOptions.and("-sourcepath", "../tests/pos-special")) +
     compileList(
       "compileMixed",
       List(

tests/pos-special/completeFromSource/Test.scala

@@ -0,0 +1,13 @@
+package completeFromSource
+
+class Test extends nested.A(22) {
+
+  val y: Int = this.x
+
+  val a = A(33)
+
+  println(a.x)
+
+}
+
+

tests/pos-special/completeFromSource/nested/A.scala

@@ -0,0 +1,13 @@
+package completeFromSource.nested
+
+class A(y: Int) {
+
+  val x: Int = y
+
+}
+
+object A {
+
+  def apply(x: Int) = new A(22)
+
+}