Make findReferences more robust and faster

 - Don't fail if a class file is not found
 - Consult name tables of Tasty info for a possible match
   before loading tree.
 - Do the same for rename

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -889,6 +889,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     /** Get first tree defined by this provider, or EmptyTree if none exists */
     def tree(implicit ctx: Context): Tree =
       trees.headOption.getOrElse(EmptyTree)
+
+    /** Is it possible that the tree to load contains a definition of or reference to `id`? */
+    def mightContain(id: String)(implicit ctx: Context) = true
   }
 
   // convert a numeric with a toXXX method

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

@@ -625,16 +625,27 @@ object Symbols {
       * then return the TypeDef tree (possibly wrapped inside PackageDefs) for this class, otherwise EmptyTree.
       * This will force the info of the class.
       */
-    def tree(implicit ctx: Context): Tree = denot.infoOrCompleter match {
+    def tree(implicit ctx: Context): Tree = treeContaining("")
+
+    /** Same as `tree` but load only Tasty tree if the name table of the unpickler
+     *  contains `id`.
+     */
+    def treeContaining(id: String)(implicit ctx: Context): Tree = denot.infoOrCompleter match {
       case _: NoCompleter =>
         tpd.EmptyTree
       case _ =>
         denot.ensureCompleted()
         myTree match {
-          case fn: TreeProvider => myTree = fn.tree
-          case _ =>
+          case fn: TreeProvider =>
+            if (id.isEmpty || fn.mightContain(id)) {
+              val tree = fn.tree
+              myTree = tree
+              tree
+            }
+            else tpd.EmptyTree
+          case tree: Tree @ unchecked =>
+            tree
         }
-        myTree.asInstanceOf[Tree]
     }
 
     def treeOrProvider: TreeOrProvider = myTree
@@ -658,7 +669,7 @@ object Symbols {
     denot = underlying.denot
   }
 
-  @sharable val NoSymbol = new Symbol(NoCoord, 0) {
+  @sharable val NoSymbol: Symbol = new Symbol(NoCoord, 0) {
     override def associatedFile(implicit ctx: Context): AbstractFile = NoSource.file
     override def recomputeDenot(lastd: SymDenotation)(implicit ctx: Context): SymDenotation = NoDenotation
   }

compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala

@@ -51,4 +51,11 @@ class DottyUnpickler(bytes: Array[Byte]) extends ClassfileParser.Embedded with t
   }
 
   protected def computeTrees(implicit ctx: Context) = treeUnpickler.unpickle()
+
+  private[this] var ids: Array[String] = null
+
+  override def mightContain(id: String)(implicit ctx: Context): Boolean = {
+    if (ids == null) ids = unpickler.nameAtRef.contents.toArray.map(_.toString).sorted
+    java.util.Arrays.binarySearch(ids.asInstanceOf[Array[Object]], id) >= 0
+  }
 }

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

@@ -53,22 +53,26 @@ class InteractiveDriver(settings: List[String]) extends Driver {
   def openedFiles: Map[URI, SourceFile] = myOpenedFiles
   def openedTrees: Map[URI, List[SourceTree]] = myOpenedTrees
 
-  def allTrees(implicit ctx: Context): List[SourceTree] = {
+  def allTrees(implicit ctx: Context): List[SourceTree] = allTreesContaining("")
+
+  def allTreesContaining(id: String)(implicit ctx: Context): List[SourceTree] = {
     val fromSource = openedTrees.values.flatten.toList
     val fromClassPath = (dirClassPathClasses ++ zipClassPathClasses).flatMap { cls =>
       val className = cls.toTypeName
-      List(tree(className), tree(className.moduleClassName)).flatten
+      List(tree(className, id), tree(className.moduleClassName, id)).flatten
     }
     (fromSource ++ fromClassPath).distinct
   }
 
-  private def tree(className: TypeName)(implicit ctx: Context): Option[SourceTree] = {
+  private def tree(className: TypeName, id: String)(implicit ctx: Context): Option[SourceTree] = {
     val clsd = ctx.base.staticRef(className)
     clsd match {
       case clsd: ClassDenotation =>
-        SourceTree.fromSymbol(clsd.symbol.asClass)
+        clsd.ensureCompleted()
+        SourceTree.fromSymbol(clsd.symbol.asClass, id)
       case _ =>
-        sys.error(s"class not found: $className")
+        //sys.error(s"class not found: $className")
+        None
     }
   }
 

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

@@ -39,7 +39,7 @@ case class SourceTree(tree: tpd.NameTree, source: SourceFile) {
   }
 }
 object SourceTree {
-  def fromSymbol(sym: ClassSymbol)(implicit ctx: Context): Option[SourceTree] = {
+  def fromSymbol(sym: ClassSymbol, id: String = "")(implicit ctx: Context): Option[SourceTree] = {
     if (sym == defn.SourceFileAnnot || // FIXME: No SourceFile annotation on SourceFile itself
         sym.sourceFile == null) // FIXME: We cannot deal with external projects yet
       None
@@ -53,7 +53,7 @@ object SourceTree {
           Some(SourceTree(tree, sourceFile))
         case _ => None
       }
-      sourceTreeOfClass(sym.tree)
+      sourceTreeOfClass(sym.treeContaining(id))
     }
   }
 }

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

@@ -243,7 +243,7 @@ class DottyLanguageServer extends LanguageServer
       // FIXME: this will search for references in all trees on the classpath, but we really
       // only need to look for trees in the target directory if the symbol is defined in the
       // current project
-      val trees = driver.allTrees
+      val trees = driver.allTreesContaining(sym.name.toString)
       val refs = Interactive.namedTrees(trees, includeReferences = true, (tree: tpd.NameTree) =>
         (includeDeclaration || !Interactive.isDefinition(tree))
           && Interactive.matchSymbol(tree, sym, includeOverriden = true))
@@ -262,7 +262,7 @@ class DottyLanguageServer extends LanguageServer
 
     if (sym == NoSymbol) new WorkspaceEdit()
     else {
-      val trees = driver.allTrees
+      val trees = driver.allTreesContaining(sym.name.toString)
       val linkedSym = sym.linkedClass
       val newName = params.getNewName