Allow symbols to be loaded from source in IDE

Various tweaks necessary so that symbols can be loaded from source.

Author: odersky

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

@@ -14,6 +14,7 @@ import util.Stats
 import Decorators._
 import scala.util.control.NonFatal
 import ast.Trees._
+import ast.tpd
 import parsing.Parsers.OutlineParser
 import reporting.trace
 
@@ -118,7 +119,9 @@ class SymbolLoaders {
       scope: Scope = EmptyScope)(implicit ctx: Context): Unit = {
 
     val completer = new SourcefileLoader(src)
-    if (ctx.settings.scansource.value) {
+    if (ctx.settings.scansource.value && ctx.run != null) {
+      System.out.print(i"scanning $src ...")
+      System.out.flush()
       if (src.exists && !src.isDirectory) {
         val filePath = owner.ownersIterator.takeWhile(!_.isRoot).map(_.name.toTermName).toList
 
@@ -160,6 +163,7 @@ class SymbolLoaders {
 
         val unit = new CompilationUnit(ctx.run.getSource(src.path))
         enterScanned(unit)(ctx.run.runContext.fresh.setCompilationUnit(unit))
+        System.out.println(" done")
       }
     }
     else enterClassAndModule(owner, name, completer, scope = scope)
@@ -338,15 +342,8 @@ abstract class SymbolLoader extends LazyType {
         postProcess(root.scalacLinkedClass.denot)
     }
   }
-}
-
-class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
-
-  override def sourceFileOrNull: AbstractFile = classfile
 
-  def description(implicit ctx: Context) = "class file " + classfile.toString
-
-  def rootDenots(rootDenot: ClassDenotation)(implicit ctx: Context): (ClassDenotation, ClassDenotation) = {
+  protected def rootDenots(rootDenot: ClassDenotation)(implicit ctx: Context): (ClassDenotation, ClassDenotation) = {
     val linkedDenot = rootDenot.scalacLinkedClass.denot match {
       case d: ClassDenotation => d
       case d =>
@@ -368,6 +365,13 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
     if (rootDenot is ModuleClass) (linkedDenot, rootDenot)
     else (rootDenot, linkedDenot)
   }
+}
+
+class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
+
+  override def sourceFileOrNull: AbstractFile = classfile
+
+  def description(implicit ctx: Context) = "class file " + classfile.toString
 
   override def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
     load(root)
@@ -393,6 +397,20 @@ 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 =
+  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)
+    }
+  }
 }

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -176,11 +176,18 @@ object Interactive {
   }
 
   /** Check if `tree` matches `sym`.
-   *  This is the case if `sym` is the symbol of `tree` or, if `includeOverriden`
-   *  is true, if `sym` is overriden by `tree`.
+   *  This is the case if one of the following is true:
+   *    (1) `sym` is the symbol of `tree`, or
+   *    (2) The two symbols have the same name and class owner, or
+   *    (3) `includeOverriden is true, and `sym` is overriden by `tree`.
+   *
+   *  The reason for (2) is that if a symbol comes from a SourcefileLoader it is
+   *  different from the symbol that was referred to, until the next run is started.
    */
   def matchSymbol(tree: Tree, sym: Symbol, includeOverriden: Boolean)(implicit ctx: Context): Boolean =
-    (sym == tree.symbol) || (includeOverriden && tree.symbol.allOverriddenSymbols.contains(sym))
+    (sym == tree.symbol) ||
+    sym.name == tree.symbol.name && sym.owner.isClass && sym.owner == tree.symbol.owner ||
+    (includeOverriden && tree.symbol.allOverriddenSymbols.contains(sym))
 
 
   /** The reverse path to the node that closest encloses position `pos`,

compiler/src/dotty/tools/dotc/interactive/SourceTree.scala

@@ -8,6 +8,7 @@ import ast.tpd
 import core._, core.Decorators.{sourcePos => _, _}
 import Contexts._, NameOps._, Symbols._
 import util._, util.Positions._
+import Interactive.matchSymbol
 
 /** A typechecked named `tree` coming from `source` */
 case class SourceTree(tree: tpd.NameTree, source: SourceFile) {
@@ -45,8 +46,9 @@ object SourceTree {
     else {
       import ast.Trees._
       def sourceTreeOfClass(tree: tpd.Tree): Option[SourceTree] = tree match {
-        case PackageDef(_, stats) => stats.flatMap(sourceTreeOfClass).headOption
-        case tree: tpd.TypeDef if tree.symbol == sym =>
+        case PackageDef(_, stats) =>
+          stats.flatMap(sourceTreeOfClass).headOption
+        case tree: tpd.TypeDef if matchSymbol(tree, sym, includeOverriden = false) =>
           val sourceFile = new SourceFile(sym.sourceFile, Codec.UTF8)
           Some(SourceTree(tree, sourceFile))
         case _ => None

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -65,8 +65,7 @@ class DottyLanguageServer extends LanguageServer
       myDrivers = new mutable.HashMap
       for (config <- configs) {
         val classpathFlags = List("-classpath", (config.classDirectory +: config.dependencyClasspath).mkString(File.pathSeparator))
-        val sourcepathFlags = List("-sourcepath", config.sourceDirectories.mkString(File.pathSeparator))
-        System.out.println(s"sourcepath = $sourcepathFlags")
+        val sourcepathFlags = List("-sourcepath", config.sourceDirectories.mkString(File.pathSeparator), "-scansource")
         val settings = defaultFlags ++ config.compilerArguments.toList ++ classpathFlags ++ sourcepathFlags
         myDrivers.put(config, new InteractiveDriver(settings))
       }