Support for multi-project find all references

This commit adapts the `find all references` feature so that it is able
to find references to given symbols across projects. For symbols that
come from the classpath, all the projects in the build will be
inspected. If we're able to find a source for the symbol, only the
projects that depend on the projects where we found the definition need
to be inspected.

Author: Duhemm

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

@@ -490,4 +490,32 @@ object Interactive {
     }
   }
 
+  /**
+   * Given `sym`, originating from `sourceDriver`, find its representation in
+   * `targetDriver`.
+   *
+   * @param symbol The symbol to expression in the new driver.
+   * @param sourceDriver The driver from which `symbol` originates.
+   * @param targetDriver The driver in which we want to get a representation of `symbol`.
+   * @return A representation of `symbol` in `targetDriver`.
+   */
+  def localize(symbol: Symbol, sourceDriver: InteractiveDriver, targetDriver: InteractiveDriver): Symbol = {
+
+    def in[T](driver: InteractiveDriver)(fn: Context => T): T =
+      fn(driver.currentCtx)
+
+    if (sourceDriver == targetDriver) symbol
+    else {
+      val owners = in(sourceDriver) { implicit ctx =>
+        symbol.ownersIterator.toList.reverse.map(_.name)
+      }
+      in(targetDriver) { implicit ctx =>
+        val base: Symbol = ctx.definitions.RootClass
+        owners.tail.foldLeft(base) { (prefix, symbolName) =>
+          prefix.info.member(symbolName).symbol
+        }
+      }
+    }
+  }
+
 }

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

@@ -53,61 +53,85 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   def openedTrees: Map[URI, List[SourceTree]] = myOpenedTrees
   def compilationUnits: Map[URI, CompilationUnit] = myCompilationUnits
 
+  /**
+   * The trees for all the source files in this project.
+   *
+   * This includes the trees for the buffers that are presently open in the IDE, and the trees
+   * from the target directory.
+   */
+  def sourceTrees(implicit ctx: Context): List[SourceTree] = sourceTreesContaining("")
+
+  /**
+   * The trees for all the source files in this project that contain `id`.
+   *
+   * This includes the trees for the buffers that are presently open in the IDE, and the trees
+   * from the target directory.
+   */
+  def sourceTreesContaining(id: String)(implicit ctx: Context): List[SourceTree] = {
+    val fromBuffers = openedTrees.values.flatten.toList
+    val fromCompilationOutput = {
+      val classNames = new mutable.ListBuffer[String]
+      val output = ctx.settings.outputDir.value
+      if (output.isDirectory) {
+        classesFromDir(output.jpath, classNames)
+      } else {
+        val zipFile = new ZipFile(output.file)
+        classesFromZip(zipFile, classNames)
+      }
+      classNames.flatMap { cls =>
+        val className = cls.toTypeName
+        treesFromClassName(className, id = "")
+      }
+    }
+    (fromBuffers ++ fromCompilationOutput).distinct
+  }
+
+  /**
+   * All the trees for this project.
+   *
+   * This includes the trees of the sources of this project, along with the trees that are found
+   * on this project's classpath.
+   */
   def allTrees(implicit ctx: Context): List[SourceTree] = allTreesContaining("")
 
+  /**
+   * All the trees for this project that contain `id`.
+   *
+   * This includes the trees of the sources of this project, along with the trees that are found
+   * on this project's classpath.
+   */
   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, id), tree(className.moduleClassName, id)).flatten
+      treesFromClassName(className, id)
     }
     (fromSource ++ fromClassPath).distinct
   }
 
-  private def tree(className: TypeName, id: String)(implicit ctx: Context): Option[SourceTree] = {
-    val clsd = ctx.base.staticRef(className)
-    clsd match {
-      case clsd: ClassDenotation =>
-        clsd.ensureCompleted()
-        SourceTree.fromSymbol(clsd.symbol.asClass, id)
-      case _ =>
-        None
+  /**
+   * The `SourceTree`s that define the class `className` and/or module `className`.
+   *
+   * @see SourceTree.fromSymbol
+   */
+  private def treesFromClassName(className: TypeName, id: String)(implicit ctx: Context): List[SourceTree] = {
+    def tree(className: TypeName, id: String): Option[SourceTree] = {
+      val clsd = ctx.base.staticRef(className)
+      clsd match {
+        case clsd: ClassDenotation =>
+          clsd.ensureCompleted()
+          SourceTree.fromSymbol(clsd.symbol.asClass, id)
+        case _ =>
+          None
+      }
     }
+    List(tree(className, id), tree(className.moduleClassName, id)).flatten
   }
 
   // Presence of a file with one of these suffixes indicates that the
   // corresponding class has been pickled with TASTY.
   private val tastySuffixes = List(".hasTasty", ".tasty")
 
-  private def classNames(cp: ClassPath, packageName: String): List[String] = {
-    def className(classSegments: List[String]) =
-      classSegments.mkString(".").stripSuffix(".class")
-
-    val ClassPathEntries(pkgs, classReps) = cp.list(packageName)
-
-    classReps
-      .filter((classRep: ClassRepresentation) => classRep.binary match {
-        case None =>
-          true
-        case Some(binFile) =>
-          val prefix =
-            if (binFile.name.endsWith(".class"))
-              binFile.name.stripSuffix(".class")
-            else
-              null
-          prefix != null && {
-            binFile match {
-              case pf: PlainFile =>
-                tastySuffixes.map(suffix => pf.givenPath.parent / (prefix + suffix)).exists(_.exists)
-              case _ =>
-                sys.error(s"Unhandled file type: $binFile [getClass = ${binFile.getClass}]")
-            }
-          }
-      })
-      .map(classRep => (packageName ++ (if (packageName != "") "." else "") ++ classRep.name)).toList ++
-    pkgs.flatMap(pkg => classNames(cp, pkg.name))
-  }
-
   // FIXME: All the code doing classpath handling is very fragile and ugly,
   // improving this requires changing the dotty classpath APIs to handle our usecases.
   // We also need something like sbt server-mode to be informed of changes on
@@ -128,17 +152,13 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   }
 
   // Like in `ZipArchiveFileLookup` we assume that zips are immutable
-  private val zipClassPathClasses: Seq[String] = zipClassPaths.flatMap { zipCp =>
-    val zipFile = new ZipFile(zipCp.zipFile)
-
-    try {
-      for {
-        entry <- zipFile.stream.toArray((size: Int) => new Array[ZipEntry](size))
-        name = entry.getName
-        tastySuffix <- tastySuffixes.find(name.endsWith)
-      } yield name.replace("/", ".").stripSuffix(tastySuffix)
+  private val zipClassPathClasses: Seq[String] = {
+    val names = new mutable.ListBuffer[String]
+    zipClassPaths.foreach { zipCp =>
+      val zipFile = new ZipFile(zipCp.zipFile)
+      classesFromZip(zipFile, names)
     }
-    finally zipFile.close()
+    names
   }
 
   // FIXME: classfiles in directories may change at any point, so we retraverse
@@ -148,26 +168,43 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
     val names = new mutable.ListBuffer[String]
     dirClassPaths.foreach { dirCp =>
       val root = dirCp.dir.toPath
-      try
-        Files.walkFileTree(root, new SimpleFileVisitor[Path] {
-          override def visitFile(path: Path, attrs: BasicFileAttributes) = {
-            if (!attrs.isDirectory) {
-              val name = path.getFileName.toString
-              for {
-                tastySuffix <- tastySuffixes
-                if name.endsWith(tastySuffix)
-              } {
-                names += root.relativize(path).toString.replace("/", ".").stripSuffix(tastySuffix)
-              }
+      classesFromDir(root, names)
+    }
+    names.toList
+  }
+
+  /** Adds the names of the classes that are defined in `zipFile` to `buffer`. */
+  private def classesFromZip(zipFile: ZipFile, buffer: mutable.ListBuffer[String]): Unit = {
+    try {
+      for {
+        entry <- zipFile.stream.toArray((size: Int) => new Array[ZipEntry](size))
+        name = entry.getName
+        tastySuffix <- tastySuffixes.find(name.endsWith)
+      } buffer += name.replace("/", ".").stripSuffix(tastySuffix)
+    }
+  finally zipFile.close()
+  }
+
+  /** Adds the names of the classes that are defined in `dir` to `buffer`. */
+  private def classesFromDir(dir: Path, buffer: mutable.ListBuffer[String]): Unit = {
+    try
+      Files.walkFileTree(dir, new SimpleFileVisitor[Path] {
+        override def visitFile(path: Path, attrs: BasicFileAttributes) = {
+          if (!attrs.isDirectory) {
+            val name = path.getFileName.toString
+            for {
+              tastySuffix <- tastySuffixes
+              if name.endsWith(tastySuffix)
+            } {
+              buffer += dir.relativize(path).toString.replace("/", ".").stripSuffix(tastySuffix)
             }
-            FileVisitResult.CONTINUE
           }
-        })
-      catch {
-        case _: NoSuchFileException =>
-      }
+          FileVisitResult.CONTINUE
+        }
+      })
+    catch {
+      case _: NoSuchFileException =>
     }
-    names.toList
   }
 
   private def topLevelClassTrees(topTree: Tree, source: SourceFile): List[SourceTree] = {

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

@@ -80,6 +80,7 @@ class DottyLanguageServer extends LanguageServer
         val settings =
           defaultFlags ++
           config.compilerArguments.toList
+            .update("-d", config.classDirectory.getAbsolutePath)
             .update("-classpath", (config.classDirectory +: config.dependencyClasspath).mkString(File.pathSeparator))
             .update("-sourcepath", config.sourceDirectories.mkString(File.pathSeparator)) :+
           "-scansource"
@@ -106,21 +107,37 @@ class DottyLanguageServer extends LanguageServer
   private def checkMemory() =
     if (Memory.isCritical()) CompletableFutures.computeAsync { _ => restart() }
 
-  /** The driver instance responsible for compiling `uri` */
-  def driverFor(uri: URI): InteractiveDriver = thisServer.synchronized {
-    val matchingConfig =
+  /** The configuration of the project that owns `uri`. */
+  def configFor(uri: URI): ProjectConfig = thisServer.synchronized {
+    val config =
       drivers.keys.find(config => config.sourceDirectories.exists(sourceDir =>
         new File(uri.getPath).getCanonicalPath.startsWith(sourceDir.getCanonicalPath)))
-    matchingConfig match {
-      case Some(config) =>
-        drivers(config)
-      case None =>
-        val config = drivers.keys.head
-        // println(s"No configuration contains $uri as a source file, arbitrarily choosing ${config.id}")
-        drivers(config)
+
+    config.getOrElse {
+      val config = drivers.keys.head
+      // println(s"No configuration contains $uri as a source file, arbitrarily choosing ${config.id}")
+      config
     }
   }
 
+  /** The driver instance responsible for compiling `uri` */
+  def driverFor(uri: URI): InteractiveDriver = {
+    drivers(configFor(uri))
+  }
+
+  /** The set of projects that transitively depend on `config` */
+  def transitivelyDependentProjects(config: ProjectConfig): immutable.Set[ProjectConfig] = {
+    val allProjects = drivers.keySet.toSet
+    allProjects.filter(transitiveDependencies(_).contains(config))
+  }
+
+  /** The set of transitive dependencies of `config`. */
+  def transitiveDependencies(config: ProjectConfig): immutable.Set[ProjectConfig] = {
+    val idToConfig = drivers.keys.map(k => k.id -> k).toMap
+    val dependencies = config.dependencies.map(idToConfig).toSet
+    dependencies ++ dependencies.flatMap(transitiveDependencies)
+  }
+
   def connect(client: WorksheetClient): Unit = {
     myClient = client
   }
@@ -281,22 +298,41 @@ class DottyLanguageServer extends LanguageServer
     val driver = driverFor(uri)
     implicit val ctx = driver.currentCtx
 
+    val includes = {
+      val includeDeclaration = params.getContext.isIncludeDeclaration
+      Include.references | Include.overriding | (if (includeDeclaration) Include.definitions else 0)
+    }
+
     val pos = sourcePosition(driver, uri, params.getPosition)
-    val sym = Interactive.enclosingSourceSymbol(driver.openedTrees(uri), pos)
+    val path = Interactive.pathTo(driver.openedTrees(uri), pos)
 
-    if (sym == NoSymbol) Nil.asJava
-    else {
-      // 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.allTreesContaining(sym.name.sourceModuleName.toString)
-      val includeDeclaration = params.getContext.isIncludeDeclaration
-      val includes =
-        Include.references | Include.overriding | (if (includeDeclaration) Include.definitions else 0)
-      val refs = Interactive.findTreesMatching(trees, includes, sym)
+    // Find definitions of the symbol under the cursor, so that we can determine
+    // what projects are worth exploring
+    val definitions = Interactive.findDefinitions(path, driver)
+    val projectsToInspect =
+      if (definitions.isEmpty) {
+        drivers.keySet
+      } else {
+        definitions.flatMap { definition =>
+          val config = configFor(toUri(definition.pos.source))
+          transitivelyDependentProjects(config) + config
+        }
+      }
 
-      refs.flatMap(ref => location(ref.namePos, positionMapperFor(ref.source))).asJava
-    }
+    val originalSymbol = Interactive.enclosingSourceSymbol(path)
+    val symbolName = originalSymbol.name.sourceModuleName.toString
+    val references =
+      for { config <- projectsToInspect.toList
+            remoteDriver = drivers(config)
+            ctx = remoteDriver.currentCtx
+            remoteDefinition = Interactive.localize(originalSymbol, driver, remoteDriver)
+            trees = remoteDriver.sourceTreesContaining(symbolName)(ctx)
+            reference <- Interactive.findTreesMatching(trees, includes, remoteDefinition)(ctx)
+          } yield {
+        reference
+      }
+
+      references.flatMap(ref => location(ref.namePos, positionMapperFor(ref.source))).asJava
   }
 
   override def rename(params: RenameParams) = computeAsync { cancelToken =>