Address review comments

Author: Duhemm

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

@@ -512,7 +512,8 @@ object Interactive {
       in(targetDriver) { implicit ctx =>
         val base: Symbol = ctx.definitions.RootClass
         owners.tail.foldLeft(base) { (prefix, symbolName) =>
-          prefix.info.member(symbolName).symbol
+          if (prefix.exists) prefix.info.member(symbolName).symbol
+          else NoSymbol
         }
       }
     }

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

@@ -77,8 +77,8 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   }
 
   // Like in `ZipArchiveFileLookup` we assume that zips are immutable
-  private val zipClassPathClasses: Seq[String] = {
-    val names = new mutable.ListBuffer[String]
+  private val zipClassPathClasses: Seq[TypeName] = {
+    val names = new mutable.ListBuffer[TypeName]
     zipClassPaths.foreach { zipCp =>
       val zipFile = new ZipFile(zipCp.zipFile)
       classesFromZip(zipFile, names)
@@ -105,7 +105,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   def sourceTreesContaining(id: String)(implicit ctx: Context): List[SourceTree] = {
     val fromBuffers = openedTrees.values.flatten.toList
     val fromCompilationOutput = {
-      val classNames = new mutable.ListBuffer[String]
+      val classNames = new mutable.ListBuffer[TypeName]
       val output = ctx.settings.outputDir.value
       if (output.isDirectory) {
         classesFromDir(output.jpath, classNames)
@@ -114,8 +114,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
         classesFromZip(zipFile, classNames)
       }
       classNames.flatMap { cls =>
-        val className = cls.toTypeName
-        treesFromClassName(className, id = "")
+        treesFromClassName(cls, id)
       }
     }
     (fromBuffers ++ fromCompilationOutput).distinct
@@ -138,8 +137,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   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
-      treesFromClassName(className, id)
+      treesFromClassName(cls, id)
     }
     (fromSource ++ fromClassPath).distinct
   }
@@ -205,8 +203,8 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   // FIXME: classfiles in directories may change at any point, so we retraverse
   // the directories each time, if we knew when classfiles changed (sbt
   // server-mode might help here), we could do cache invalidation instead.
-  private def dirClassPathClasses: Seq[String] = {
-    val names = new mutable.ListBuffer[String]
+  private def dirClassPathClasses: Seq[TypeName] = {
+    val names = new mutable.ListBuffer[TypeName]
     dirClassPaths.foreach { dirCp =>
       val root = dirCp.dir.toPath
       classesFromDir(root, names)
@@ -215,19 +213,19 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   }
 
   /** Adds the names of the classes that are defined in `zipFile` to `buffer`. */
-  private def classesFromZip(zipFile: ZipFile, buffer: mutable.ListBuffer[String]): Unit = {
+  private def classesFromZip(zipFile: ZipFile, buffer: mutable.ListBuffer[TypeName]): 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)
+      } buffer += name.replace("/", ".").stripSuffix(tastySuffix).toTypeName
     }
   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 = {
+  private def classesFromDir(dir: Path, buffer: mutable.ListBuffer[TypeName]): Unit = {
     try
       Files.walkFileTree(dir, new SimpleFileVisitor[Path] {
         override def visitFile(path: Path, attrs: BasicFileAttributes) = {
@@ -237,7 +235,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
               tastySuffix <- tastySuffixes
               if name.endsWith(tastySuffix)
             } {
-              buffer += dir.relativize(path).toString.replace("/", ".").stripSuffix(tastySuffix)
+              buffer += dir.relativize(path).toString.replace("/", ".").stripSuffix(tastySuffix).toTypeName
             }
           }
           FileVisitResult.CONTINUE

sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala

@@ -374,16 +374,16 @@ object DottyIDEPlugin extends AutoPlugin {
   /**
    * Detect the eligible configuration dependencies from a given configuration.
    *
-   * A configuration is elibile if the project defines it and `bloopGenerate`
+   * A configuration is eligible if the project defines it and `compile`
    * exists for it. Otherwise, the configuration dependency is ignored.
    *
    * This is required to prevent transitive configurations like `Runtime` from
-   * generating useless bloop configuration files and possibly incorrect project
+   * generating useless IDE configuration files and possibly incorrect project
    * dependencies. For example, if we didn't do this then the dependencies of
-   * `IntegrationTest` would be `projectName-runtime` and `projectName-compile`,
+   * `IntegrationTest` would be `projectName/runtime` and `projectName/compile`,
    * whereas the following logic will return only the configuration `Compile`
    * so that the use site of this function can create the project dep
-   * `projectName-compile`.
+   * `projectName/compile`.
    */
   private def eligibleDepsFromConfig(config: Configuration): Def.Initialize[Task[List[Configuration]]] = {
     Def.task {