Revert "Revert "Port classpath improvements""

This reverts commit a34b7b8.

Author: liufengyun

Diff for: compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala

@@ -6,7 +6,9 @@ package dotc.classpath
 
 import java.net.URL
 import scala.collection.mutable.ArrayBuffer
-import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation }
+import scala.collection.immutable.ArraySeq
+
+import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation, EfficientClassPath }
 
 /**
  * A classpath unifying multiple class- and sourcepath entries.
@@ -19,20 +21,20 @@ import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation }
 case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   override def findClassFile(className: String): Option[AbstractFile] = {
     val (pkg, _) = PackageNameUtils.separatePkgAndClassNames(className)
-    aggregatesForPackage(pkg).iterator.map(_.findClassFile(className)).collectFirst {
+    aggregatesForPackage(PackageName(pkg)).iterator.map(_.findClassFile(className)).collectFirst {
       case Some(x) => x
     }
   }
   private val packageIndex: collection.mutable.Map[String, Seq[ClassPath]] = collection.mutable.Map()
-  private def aggregatesForPackage(pkg: String): Seq[ClassPath] = packageIndex.synchronized {
-    packageIndex.getOrElseUpdate(pkg, aggregates.filter(_.hasPackage(pkg)))
+  private def aggregatesForPackage(pkg: PackageName): Seq[ClassPath] = packageIndex.synchronized {
+    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(pkg).iterator.map(_.findClass(className)).collectFirst {
+      aggregatesForPackage(PackageName(pkg)).iterator.map(_.findClass(className)).collectFirst {
         case Some(s: SourceFileEntry) if isSource => s
         case Some(s: ClassFileEntry) if !isSource => s
       }
@@ -53,31 +55,47 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
 
   override def asSourcePathString: String = ClassPath.join(aggregates map (_.asSourcePathString): _*)
 
-  override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
+  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
     val aggregatedPackages = aggregates.flatMap(_.packages(inPackage)).distinct
     aggregatedPackages
   }
 
-  override private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] =
+  override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] =
     getDistinctEntries(_.classes(inPackage))
 
-  override private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] =
+  override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] =
     getDistinctEntries(_.sources(inPackage))
 
-  override private[dotty] def hasPackage(pkg: String): Boolean = aggregates.exists(_.hasPackage(pkg))
-  override private[dotty] def list(inPackage: String): ClassPathEntries = {
-    val (packages, classesAndSources) = aggregates.map { cp =>
-      try
-        cp.list(inPackage).toTuple
-      catch {
+  override private[dotty] def hasPackage(pkg: PackageName): Boolean = aggregates.exists(_.hasPackage(pkg))
+  override private[dotty] def list(inPackage: PackageName): ClassPathEntries = {
+    val packages: java.util.HashSet[PackageEntry] = new java.util.HashSet[PackageEntry]()
+    val classesAndSourcesBuffer = collection.mutable.ArrayBuffer[ClassRepresentation]()
+    val onPackage: PackageEntry => Unit = packages.add(_)
+    val onClassesAndSources: ClassRepresentation => Unit = classesAndSourcesBuffer += _
+
+    aggregates.foreach { cp =>
+      try {
+        cp match {
+          case ecp: EfficientClassPath =>
+            ecp.list(inPackage, onPackage, onClassesAndSources)
+          case _ =>
+            val entries = cp.list(inPackage)
+            entries._1.foreach(entry => packages.add(entry))
+            classesAndSourcesBuffer ++= entries._2
+        }
+      } catch {
         case ex: java.io.IOException =>
-          val e = new FatalError(ex.getMessage)
+          val e = FatalError(ex.getMessage)
           e.initCause(ex)
           throw e
       }
-    }.unzip
-    val distinctPackages = packages.flatten.distinct
-    val distinctClassesAndSources = mergeClassesAndSources(classesAndSources: _*)
+    }
+
+    val distinctPackages: Seq[PackageEntry] = {
+      val arr = packages.toArray(new Array[PackageEntry](packages.size()))
+      ArraySeq.unsafeWrapArray(arr)
+    }
+    val distinctClassesAndSources = mergeClassesAndSources(classesAndSourcesBuffer)
     ClassPathEntries(distinctPackages, distinctClassesAndSources)
   }
 
@@ -86,19 +104,16 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
    * creates an entry containing both of them. If there would be more than one class or source
    * entries for the same class it always would use the first entry of each type found on a classpath.
    */
-  private def mergeClassesAndSources(entries: scala.collection.Seq[ClassRepresentation]*): Seq[ClassRepresentation] = {
+  private def mergeClassesAndSources(entries: scala.collection.Seq[ClassRepresentation]): Seq[ClassRepresentation] = {
     // based on the implementation from MergedClassPath
     var count = 0
-    val indices = collection.mutable.HashMap[String, Int]()
-    val mergedEntries = new ArrayBuffer[ClassRepresentation](1024)
-
+    val indices = new collection.mutable.HashMap[String, Int]()
+    val mergedEntries = new ArrayBuffer[ClassRepresentation](entries.size)
     for {
-      partOfEntries <- entries
-      entry <- partOfEntries
-    }
-    {
+      entry <- entries
+    } {
       val name = entry.name
-      if (indices contains name) {
+      if (indices.contains(name)) {
         val index = indices(name)
         val existing = mergedEntries(index)
 
@@ -113,7 +128,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
         count += 1
       }
     }
-    mergedEntries.toIndexedSeq
+    if (mergedEntries.isEmpty) Nil else mergedEntries.toIndexedSeq
   }
 
   private def getDistinctEntries[EntryType <: ClassRepresentation](getEntries: ClassPath => Seq[EntryType]): Seq[EntryType] = {

Diff for: compiler/src/dotty/tools/dotc/classpath/ClassPath.scala

@@ -10,6 +10,10 @@ case class ClassPathEntries(packages: scala.collection.Seq[PackageEntry], classe
   def toTuple: (scala.collection.Seq[PackageEntry], scala.collection.Seq[ClassRepresentation]) = (packages, classesAndSources)
 }
 
+object ClassPathEntries {
+  val empty = ClassPathEntries(Seq.empty, Seq.empty)
+}
+
 trait ClassFileEntry extends ClassRepresentation {
   def file: AbstractFile
 }
@@ -18,6 +22,21 @@ trait SourceFileEntry extends ClassRepresentation {
   def file: AbstractFile
 }
 
+case class PackageName(dottedString: String) {
+  def isRoot: Boolean = dottedString.isEmpty
+  val dirPathTrailingSlash: String = FileUtils.dirPath(dottedString) + "/"
+
+  def entryName(entry: String): String = {
+    if (isRoot) entry else {
+      val builder = new java.lang.StringBuilder(dottedString.length + 1 + entry.length)
+      builder.append(dottedString)
+      builder.append('.')
+      builder.append(entry)
+      builder.toString
+    }
+  }
+}
+
 trait PackageEntry {
   def name: String
 }
@@ -50,10 +69,10 @@ private[dotty] case class PackageEntryImpl(name: String) extends PackageEntry
 
 private[dotty] trait NoSourcePaths {
   def asSourcePathString: String = ""
-  private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] = Seq.empty
+  private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = Seq.empty
 }
 
 private[dotty] trait NoClassPaths {
   def findClassFile(className: String): Option[AbstractFile] = None
-  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = Seq.empty
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = Seq.empty
 }

Diff for: compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala

@@ -7,9 +7,11 @@ import java.io.{File => JFile}
 import java.net.URL
 import java.nio.file.{FileSystems, Files}
 
-import dotty.tools.io.{AbstractFile, PlainFile, ClassPath, ClassRepresentation}
+import dotty.tools.io.{AbstractFile, PlainFile, ClassPath, ClassRepresentation, EfficientClassPath}
 import FileUtils._
+
 import scala.collection.JavaConverters._
+import scala.collection.immutable.ArraySeq
 
 /**
  * A trait allowing to look for classpath entries in directories. It provides common logic for
@@ -18,7 +20,7 @@ import scala.collection.JavaConverters._
  * when we have a name of a package.
  * It abstracts over the file representation to work with both JFile and AbstractFile.
  */
-trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
+trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends EfficientClassPath {
   type F
 
   val dir: F
@@ -33,27 +35,24 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
   protected def createFileEntry(file: AbstractFile): FileEntryType
   protected def isMatchingFile(f: F): Boolean
 
-  private def getDirectory(forPackage: String): Option[F] =
-    if (forPackage == ClassPath.RootPackage)
+  private def getDirectory(forPackage: PackageName): Option[F] =
+    if (forPackage.isRoot)
       Some(dir)
-    else {
-      val packageDirName = FileUtils.dirPath(forPackage)
-      getSubDir(packageDirName)
-    }
+    else
+      getSubDir(forPackage.dirPathTrailingSlash)
 
-  override private[dotty] def hasPackage(pkg: String): Boolean = getDirectory(pkg).isDefined
+  override private[dotty] def hasPackage(pkg: PackageName): Boolean = getDirectory(pkg).isDefined
 
-  private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
+  private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
     val dirForPackage = getDirectory(inPackage)
     val nestedDirs: Array[F] = dirForPackage match {
       case None => emptyFiles
       case Some(directory) => listChildren(directory, Some(isPackage))
     }
-    val prefix = PackageNameUtils.packagePrefix(inPackage)
-    nestedDirs.toIndexedSeq.map(f => PackageEntryImpl(prefix + getName(f)))
+    ArraySeq.unsafeWrapArray(nestedDirs).map(f => PackageEntryImpl(inPackage.entryName(getName(f))))
   }
 
-  protected def files(inPackage: String): Seq[FileEntryType] = {
+  protected def files(inPackage: PackageName): Seq[FileEntryType] = {
     val dirForPackage = getDirectory(inPackage)
     val files: Array[F] = dirForPackage match {
       case None => emptyFiles
@@ -62,21 +61,18 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
     files.iterator.map(f => createFileEntry(toAbstractFile(f))).toSeq
   }
 
-  private[dotty] def list(inPackage: String): ClassPathEntries = {
+  override def list(inPackage: PackageName, onPackageEntry: PackageEntry => Unit, onClassesAndSources: ClassRepresentation => Unit): Unit = {
     val dirForPackage = getDirectory(inPackage)
-    val files: Array[F] = dirForPackage match {
-      case None => emptyFiles
-      case Some(directory) => listChildren(directory)
+    dirForPackage match {
+      case None =>
+      case Some(directory) =>
+        for (file <- listChildren(directory)) {
+          if (isPackage(file))
+            onPackageEntry(PackageEntryImpl(inPackage.entryName(getName(file))))
+          else if (isMatchingFile(file))
+            onClassesAndSources(createFileEntry(toAbstractFile(file)))
+        }
     }
-    val packagePrefix = PackageNameUtils.packagePrefix(inPackage)
-    val packageBuf = collection.mutable.ArrayBuffer.empty[PackageEntry]
-    val fileBuf = collection.mutable.ArrayBuffer.empty[FileEntryType]
-    for (file <- files)
-      if (isPackage(file))
-        packageBuf += PackageEntryImpl(packagePrefix + getName(file))
-      else if (isMatchingFile(file))
-        fileBuf += createFileEntry(toAbstractFile(file))
-    ClassPathEntries(packageBuf, fileBuf)
   }
 }
 
@@ -159,24 +155,25 @@ final class JrtClassPath(fs: java.nio.file.FileSystem) extends ClassPath with No
   }
 
   /** Empty string represents root package */
-  override private[dotty] def hasPackage(pkg: String): Boolean = packageToModuleBases.contains(pkg)
+  override private[dotty] def hasPackage(pkg: PackageName): Boolean = packageToModuleBases.contains(pkg.dottedString)
 
-  override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
+  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
     def matches(packageDottedName: String) =
       if (packageDottedName.contains("."))
-        packageOf(packageDottedName) == inPackage
-      else inPackage == ""
+        packageOf(packageDottedName) == inPackage.dottedString
+      else inPackage.isRoot
     packageToModuleBases.keysIterator.filter(matches).map(PackageEntryImpl(_)).toVector
   }
-  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] =
-    if (inPackage == "") Nil
+
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] =
+    if (inPackage.isRoot) Nil
     else
-      packageToModuleBases.getOrElse(inPackage, Nil).flatMap(x =>
-        Files.list(x.resolve(FileUtils.dirPath(inPackage))).iterator().asScala.filter(_.getFileName.toString.endsWith(".class"))).map(x =>
+      packageToModuleBases.getOrElse(inPackage.dottedString, Nil).flatMap(x =>
+        Files.list(x.resolve(inPackage.dirPathTrailingSlash)).iterator().asScala.filter(_.getFileName.toString.endsWith(".class"))).map(x =>
         ClassFileEntryImpl(new PlainFile(new dotty.tools.io.File(x)))).toVector
 
-  override private[dotty] def list(inPackage: String): ClassPathEntries =
-    if (inPackage == "") ClassPathEntries(packages(inPackage), Nil)
+  override private[dotty] def list(inPackage: PackageName): ClassPathEntries =
+    if (inPackage.isRoot) ClassPathEntries(packages(inPackage), Nil)
     else ClassPathEntries(packages(inPackage), classes(inPackage))
 
   def asURLs: Seq[URL] = Seq(new URL("jrt:/"))
@@ -214,7 +211,7 @@ case class DirectoryClassPath(dir: JFile) extends JFileDirectoryLookup[ClassFile
   protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)
   protected def isMatchingFile(f: JFile): Boolean = f.isClass
 
-  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = files(inPackage)
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
 }
 
 case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFileEntryImpl] with NoClassPaths {
@@ -238,5 +235,5 @@ case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFi
     }
   }
 
-  private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] = files(inPackage)
+  private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
 }

Diff for: compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala

@@ -45,7 +45,7 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
     Option(lookupPath(dir)(relativePath.split(java.io.File.separator).toIndexedSeq, directory = false))
   }
 
-  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = files(inPackage)
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
 
   protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)
   protected def isMatchingFile(f: AbstractFile): Boolean = f.isClass

Diff for: compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala

@@ -42,16 +42,16 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
 
     override def findClassFile(className: String): Option[AbstractFile] = {
       val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
-      file(pkg, simpleClassName + ".class").map(_.file)
+      file(PackageName(pkg), simpleClassName + ".class").map(_.file)
     }
 
     // This method is performance sensitive as it is used by SBT's ExtractDependencies phase.
     override def findClass(className: String): Option[ClassRepresentation] = {
       val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
-      file(pkg, simpleClassName + ".class")
+      file(PackageName(pkg), simpleClassName + ".class")
     }
 
-    override private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = files(inPackage)
+    override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
 
     override protected def createFileEntry(file: FileZipArchive#Entry): ClassFileEntryImpl = ClassFileEntryImpl(file)
     override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isClass
@@ -67,7 +67,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
   private case class ManifestResourcesClassPath(file: ManifestResources) extends ClassPath with NoSourcePaths {
     override def findClassFile(className: String): Option[AbstractFile] = {
       val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
-      classes(pkg).find(_.name == simpleClassName).map(_.file)
+      classes(PackageName(pkg)).find(_.name == simpleClassName).map(_.file)
     }
 
     override def asClassPathStrings: Seq[String] = Seq(file.path)
@@ -118,21 +118,20 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
       packages
     }
 
-    override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = cachedPackages.get(inPackage) match {
+    override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = cachedPackages.get(inPackage.dottedString) match {
       case None => Seq.empty
       case Some(PackageFileInfo(_, subpackages)) =>
-        val prefix = PackageNameUtils.packagePrefix(inPackage)
-        subpackages.map(packageFile => PackageEntryImpl(prefix + packageFile.name))
+        subpackages.map(packageFile => PackageEntryImpl(inPackage.entryName(packageFile.name)))
     }
 
-    override private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = cachedPackages.get(inPackage) match {
+    override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = cachedPackages.get(inPackage.dottedString) match {
       case None => Seq.empty
       case Some(PackageFileInfo(pkg, _)) =>
         (for (file <- pkg if file.isClass) yield ClassFileEntryImpl(file)).toSeq
     }
 
-    override private[dotty] def hasPackage(pkg: String) = cachedPackages.contains(pkg)
-    override private[dotty] def list(inPackage: String): ClassPathEntries = ClassPathEntries(packages(inPackage), classes(inPackage))
+    override private[dotty] def hasPackage(pkg: PackageName) = cachedPackages.contains(pkg.dottedString)
+    override private[dotty] def list(inPackage: PackageName): ClassPathEntries = ClassPathEntries(packages(inPackage), classes(inPackage))
   }
 
   private object ManifestResourcesClassPath {
@@ -164,7 +163,7 @@ object ZipAndJarSourcePathFactory extends ZipAndJarFileLookupFactory {
 
     override def asSourcePathString: String = asClassPathString
 
-    override private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] = files(inPackage)
+    override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
 
     override protected def createFileEntry(file: FileZipArchive#Entry): SourceFileEntryImpl = SourceFileEntryImpl(file)
     override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isScalaOrJavaSource