Remove the findClass method from ClassPath

the method was never used, and not well defined, e.g. with branches
to search in both tasty files and class files, which could be
severely inefficient.

Author: bishabosha

compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala

@@ -33,25 +33,6 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
     packageIndex.getOrElseUpdate(pkg.dottedString, aggregates.filter(_.hasPackage(pkg)))
   }
 
-  override def findClass(className: String): Option[ClassRepresentation] = {
-    val (pkg, _) = PackageNameUtils.separatePkgAndClassNames(className)
-
-    def findEntry(isSource: Boolean): Option[ClassRepresentation] =
-      aggregatesForPackage(PackageName(pkg)).iterator.map(_.findClass(className)).collectFirst {
-        case Some(s: SourceFileEntry) if isSource => s
-        case Some(s: BinaryFileEntry) if !isSource => s
-      }
-
-    val classEntry = findEntry(isSource = false)
-    val sourceEntry = findEntry(isSource = true)
-
-    (classEntry, sourceEntry) match {
-      case (Some(c: BinaryFileEntry), Some(s: SourceFileEntry)) => Some(BinaryAndSourceFilesEntry(c, s))
-      case (c @ Some(_), _) => c
-      case (_, s) => s
-    }
-  }
-
   override def asURLs: Seq[URL] = aggregates.flatMap(_.asURLs)
 
   override def asClassPathStrings: Seq[String] = aggregates.map(_.asClassPathString).distinct

compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala

@@ -274,17 +274,12 @@ final class CtSymClassPath(ctSym: java.nio.file.Path, release: Int) extends Clas
 }
 
 case class DirectoryClassPath(dir: JFile) extends JFileDirectoryLookup[BinaryFileEntry] with NoSourcePaths {
-  override def findClass(className: String): Option[ClassRepresentation] =
-    findClassFile(className).map(BinaryFileEntry(_))
 
   def findClassFile(className: String): Option[AbstractFile] = {
     val relativePath = FileUtils.dirPath(className)
-    val tastyFile = new JFile(dir, relativePath + ".tasty")
-    if tastyFile.exists then Some(tastyFile.toPath.toPlainFile)
-    else
-      val classFile = new JFile(dir, relativePath + ".class")
-      if classFile.exists then Some(classFile.toPath.toPlainFile)
-      else None
+    val classFile = new JFile(dir, relativePath + ".class")
+    if classFile.exists then Some(classFile.toPath.toPlainFile)
+    else None
   }
 
   protected def createFileEntry(file: AbstractFile): BinaryFileEntry = BinaryFileEntry(file)
@@ -301,16 +296,5 @@ case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFi
   protected def createFileEntry(file: AbstractFile): SourceFileEntry = SourceFileEntry(file)
   protected def isMatchingFile(f: JFile): Boolean = endsScalaOrJava(f.getName)
 
-  override def findClass(className: String): Option[ClassRepresentation] = findSourceFile(className).map(SourceFileEntry(_))
-
-  private def findSourceFile(className: String): Option[AbstractFile] = {
-    val relativePath = FileUtils.dirPath(className)
-    val sourceFile = LazyList("scala", "java")
-      .map(ext => new JFile(dir, relativePath + "." + ext))
-      .collectFirst { case file if file.exists() => file }
-
-    sourceFile.map(_.toPath.toPlainFile)
-  }
-
   private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
 }

compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala

@@ -38,16 +38,12 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
   def asURLs: Seq[URL] = Seq(new URI(dir.name).toURL)
   def asClassPathStrings: Seq[String] = Seq(dir.path)
 
-  override def findClass(className: String): Option[ClassRepresentation] =
-    findClassFile(className).map(BinaryFileEntry(_))
-
   def findClassFile(className: String): Option[AbstractFile] = {
     val pathSeq = FileUtils.dirPath(className).split(java.io.File.separator)
     val parentDir = lookupPath(dir)(pathSeq.init.toSeq, directory = true)
-    if parentDir == null then return None
+    if parentDir == null then None
     else
-      Option(lookupPath(parentDir)(pathSeq.last + ".tasty" :: Nil, directory = false))
-        .orElse(Option(lookupPath(parentDir)(pathSeq.last + ".class" :: Nil, directory = false)))
+      Option(lookupPath(parentDir)(pathSeq.last + ".class" :: Nil, directory = false))
   }
 
   private[dotty] def classes(inPackage: PackageName): Seq[BinaryFileEntry] = files(inPackage)

compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala

@@ -45,14 +45,8 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
     with NoSourcePaths {
 
     override def findClassFile(className: String): Option[AbstractFile] =
-      findClass(className).map(_.file)
-
-    // This method is performance sensitive as it is used by SBT's ExtractDependencies phase.
-    override def findClass(className: String): Option[BinaryFileEntry] = {
       val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
-      val binaries = files(PackageName(pkg), simpleClassName + ".tasty", simpleClassName + ".class")
-      binaries.find(_.file.isTasty).orElse(binaries.find(_.file.isClass))
-    }
+      file(PackageName(pkg), simpleClassName + ".class").map(_.file)
 
     override private[dotty] def classes(inPackage: PackageName): Seq[BinaryFileEntry] = files(inPackage)
 

compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala

@@ -43,15 +43,6 @@ trait ZipArchiveFileLookup[FileEntryType <: ClassRepresentation] extends Efficie
     }
     yield createFileEntry(entry)
 
-  protected def files(inPackage: PackageName, names: String*): Seq[FileEntryType] =
-    for {
-      dirEntry <- findDirEntry(inPackage).toSeq
-      name <- names
-      entry <- Option(dirEntry.lookupName(name, directory = false))
-      if isRequiredFileType(entry)
-    }
-    yield createFileEntry(entry)
-
   protected def file(inPackage: PackageName, name: String): Option[FileEntryType] =
     for {
       dirEntry <- findDirEntry(inPackage)

compiler/src/dotty/tools/io/ClassPath.scala

@@ -56,32 +56,8 @@ trait ClassPath {
   private[dotty] def list(inPackage: PackageName): ClassPathEntries
 
   /**
-    * Returns the class file and / or source file for a given external name, e.g., "java.lang.String".
-    * If there is both a class file and source file, the compiler can decide whether to read the
-    * class file or compile the source file.
-    *
-    * Internally this seems to be used only by `ScriptRunner`, but only to call `.isDefined`. That
-    * could probably be implemented differently.
-    *
-    * Externally, it is used by sbt's compiler interface:
-    * https://github.com/sbt/sbt/blob/v0.13.15/compile/interface/src/main/scala/xsbt/CompilerInterface.scala#L249
-    * Jason has some improvements for that in the works (https://github.com/scala/bug/issues/10289#issuecomment-310022699)
-    */
-  def findClass(className: String): Option[ClassRepresentation] = {
-    // A default implementation which should be overridden, if we can create the more efficient
-    // solution for a given type of ClassPath
-    val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
-
-    val packageName = PackageName(pkg)
-    val foundClassFromClassFiles = classes(packageName).find(_.name == simpleClassName)
-    def findClassInSources = sources(packageName).find(_.name == simpleClassName)
-
-    foundClassFromClassFiles orElse findClassInSources
-  }
-
- /**
-   * Returns the classfile for an external name, e.g., "java.lang.String". This method does not
-   * return source files.
+   * Returns *only* the classfile for an external name, e.g., "java.lang.String". This method does not
+   * return source files, tasty files,.
    *
    * This method is used by the classfile parser. When parsing a Java class, its own inner classes
    * are entered with a `ClassfileLoader` that parses the classfile returned by this method.

compiler/test/dotty/tools/dotc/classpath/JrtClassPathTest.scala

@@ -38,7 +38,6 @@ class JrtClassPathTest {
     assertEquals("java/lang/Object", AsmUtils.readClass(jl_Object.file.toByteArray).name)
     assertTrue(cp.list("java.lang").packages.exists(_.name == "java.lang.annotation"))
     assertTrue(cp.list("java.lang").classesAndSources.exists(_.name == "Object"))
-    assertTrue(cp.findClass("java.lang.Object").isDefined)
     assertTrue(cp.findClassFile("java.lang.Object").isDefined)
   }
 }

compiler/test/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactoryTest.scala

@@ -27,7 +27,7 @@ class ZipAndJarFileLookupFactoryTest {
       createZip(f, Array(), "p2/X.class")
       createZip(f, Array(), "p3/Y.class")
       val cp1 = createCp
-      assert(cp1.findClass("p1.C").isDefined)
+      assert(cp1.findClassFile("p1.C").isDefined)
 
       // We expect get a cache hit as the underlying zip hasn't changed
       val cp2 = createCp
@@ -46,8 +46,8 @@ class ZipAndJarFileLookupFactoryTest {
       val cp3 = createCp
       assert(cp1 ne cp3, (System.identityHashCode(cp1), System.identityHashCode(cp3)))
       // And that instance should see D, not C, in package p1.
-      assert(cp3.findClass("p1.C").isEmpty)
-      assert(cp3.findClass("p1.D").isDefined)
+      assert(cp3.findClassFile("p1.C").isEmpty)
+      assert(cp3.findClassFile("p1.D").isDefined)
     } finally Files.delete(f)
   }