Revert "Port classpath improvements"

Author: sjrd

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

@@ -6,9 +6,7 @@ package dotc.classpath
 
 import java.net.URL
 import scala.collection.mutable.ArrayBuffer
-import scala.collection.immutable.ArraySeq
-
-import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation, EfficientClassPath }
+import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation }
 
 /**
  * A classpath unifying multiple class- and sourcepath entries.
@@ -21,20 +19,20 @@ import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation, EfficientC
 case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   override def findClassFile(className: String): Option[AbstractFile] = {
     val (pkg, _) = PackageNameUtils.separatePkgAndClassNames(className)
-    aggregatesForPackage(PackageName(pkg)).iterator.map(_.findClassFile(className)).collectFirst {
+    aggregatesForPackage(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: PackageName): Seq[ClassPath] = packageIndex.synchronized {
-    packageIndex.getOrElseUpdate(pkg.dottedString, aggregates.filter(_.hasPackage(pkg)))
+  private def aggregatesForPackage(pkg: String): Seq[ClassPath] = packageIndex.synchronized {
+    packageIndex.getOrElseUpdate(pkg, 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 {
+      aggregatesForPackage(pkg).iterator.map(_.findClass(className)).collectFirst {
         case Some(s: SourceFileEntry) if isSource => s
         case Some(s: ClassFileEntry) if !isSource => s
       }
@@ -55,47 +53,31 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
 
   override def asSourcePathString: String = ClassPath.join(aggregates map (_.asSourcePathString): _*)
 
-  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+  override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
     val aggregatedPackages = aggregates.flatMap(_.packages(inPackage)).distinct
     aggregatedPackages
   }
 
-  override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] =
+  override private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] =
     getDistinctEntries(_.classes(inPackage))
 
-  override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] =
+  override private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] =
     getDistinctEntries(_.sources(inPackage))
 
-  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 {
+  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 {
         case ex: java.io.IOException =>
-          val e = FatalError(ex.getMessage)
+          val e = new FatalError(ex.getMessage)
           e.initCause(ex)
           throw e
       }
-    }
-
-    val distinctPackages: Seq[PackageEntry] = {
-      val arr = packages.toArray(new Array[PackageEntry](packages.size()))
-      ArraySeq.unsafeWrapArray(arr)
-    }
-    val distinctClassesAndSources = mergeClassesAndSources(classesAndSourcesBuffer)
+    }.unzip
+    val distinctPackages = packages.flatten.distinct
+    val distinctClassesAndSources = mergeClassesAndSources(classesAndSources: _*)
     ClassPathEntries(distinctPackages, distinctClassesAndSources)
   }
 
@@ -104,16 +86,19 @@ 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 = new collection.mutable.HashMap[String, Int]()
-    val mergedEntries = new ArrayBuffer[ClassRepresentation](entries.size)
+    val indices = collection.mutable.HashMap[String, Int]()
+    val mergedEntries = new ArrayBuffer[ClassRepresentation](1024)
+
     for {
-      entry <- entries
-    } {
+      partOfEntries <- entries
+      entry <- partOfEntries
+    }
+    {
       val name = entry.name
-      if (indices.contains(name)) {
+      if (indices contains name) {
         val index = indices(name)
         val existing = mergedEntries(index)
 
@@ -128,7 +113,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
         count += 1
       }
     }
-    if (mergedEntries.isEmpty) Nil else mergedEntries.toIndexedSeq
+    mergedEntries.toIndexedSeq
   }
 
   private def getDistinctEntries[EntryType <: ClassRepresentation](getEntries: ClassPath => Seq[EntryType]): Seq[EntryType] = {

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

@@ -10,10 +10,6 @@ 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
 }
@@ -22,21 +18,6 @@ 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
 }
@@ -69,10 +50,10 @@ private[dotty] case class PackageEntryImpl(name: String) extends PackageEntry
 
 private[dotty] trait NoSourcePaths {
   def asSourcePathString: String = ""
-  private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = Seq.empty
+  private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] = Seq.empty
 }
 
 private[dotty] trait NoClassPaths {
   def findClassFile(className: String): Option[AbstractFile] = None
-  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = Seq.empty
+  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = Seq.empty
 }

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

@@ -7,11 +7,9 @@ import java.io.{File => JFile}
 import java.net.URL
 import java.nio.file.{FileSystems, Files}
 
-import dotty.tools.io.{AbstractFile, PlainFile, ClassPath, ClassRepresentation, EfficientClassPath}
+import dotty.tools.io.{AbstractFile, PlainFile, ClassPath, ClassRepresentation}
 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
@@ -20,7 +18,7 @@ import scala.collection.immutable.ArraySeq
  * 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 EfficientClassPath {
+trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
   type F
 
   val dir: F
@@ -35,24 +33,27 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends EfficientCla
   protected def createFileEntry(file: AbstractFile): FileEntryType
   protected def isMatchingFile(f: F): Boolean
 
-  private def getDirectory(forPackage: PackageName): Option[F] =
-    if (forPackage.isRoot)
+  private def getDirectory(forPackage: String): Option[F] =
+    if (forPackage == ClassPath.RootPackage)
       Some(dir)
-    else
-      getSubDir(forPackage.dirPathTrailingSlash)
+    else {
+      val packageDirName = FileUtils.dirPath(forPackage)
+      getSubDir(packageDirName)
+    }
 
-  override private[dotty] def hasPackage(pkg: PackageName): Boolean = getDirectory(pkg).isDefined
+  override private[dotty] def hasPackage(pkg: String): Boolean = getDirectory(pkg).isDefined
 
-  private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+  private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
     val dirForPackage = getDirectory(inPackage)
     val nestedDirs: Array[F] = dirForPackage match {
       case None => emptyFiles
       case Some(directory) => listChildren(directory, Some(isPackage))
     }
-    ArraySeq.unsafeWrapArray(nestedDirs).map(f => PackageEntryImpl(inPackage.entryName(getName(f))))
+    val prefix = PackageNameUtils.packagePrefix(inPackage)
+    nestedDirs.toIndexedSeq.map(f => PackageEntryImpl(prefix + getName(f)))
   }
 
-  protected def files(inPackage: PackageName): Seq[FileEntryType] = {
+  protected def files(inPackage: String): Seq[FileEntryType] = {
     val dirForPackage = getDirectory(inPackage)
     val files: Array[F] = dirForPackage match {
       case None => emptyFiles
@@ -61,18 +62,21 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends EfficientCla
     files.iterator.map(f => createFileEntry(toAbstractFile(f))).toSeq
   }
 
-  override def list(inPackage: PackageName, onPackageEntry: PackageEntry => Unit, onClassesAndSources: ClassRepresentation => Unit): Unit = {
+  private[dotty] def list(inPackage: String): ClassPathEntries = {
     val dirForPackage = getDirectory(inPackage)
-    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 files: Array[F] = dirForPackage match {
+      case None => emptyFiles
+      case Some(directory) => listChildren(directory)
     }
+    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)
   }
 }
 
@@ -155,25 +159,24 @@ final class JrtClassPath(fs: java.nio.file.FileSystem) extends ClassPath with No
   }
 
   /** Empty string represents root package */
-  override private[dotty] def hasPackage(pkg: PackageName): Boolean = packageToModuleBases.contains(pkg.dottedString)
+  override private[dotty] def hasPackage(pkg: String): Boolean = packageToModuleBases.contains(pkg)
 
-  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+  override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
     def matches(packageDottedName: String) =
       if (packageDottedName.contains("."))
-        packageOf(packageDottedName) == inPackage.dottedString
-      else inPackage.isRoot
+        packageOf(packageDottedName) == inPackage
+      else inPackage == ""
     packageToModuleBases.keysIterator.filter(matches).map(PackageEntryImpl(_)).toVector
   }
-
-  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] =
-    if (inPackage.isRoot) Nil
+  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] =
+    if (inPackage == "") Nil
     else
-      packageToModuleBases.getOrElse(inPackage.dottedString, Nil).flatMap(x =>
-        Files.list(x.resolve(inPackage.dirPathTrailingSlash)).iterator().asScala.filter(_.getFileName.toString.endsWith(".class"))).map(x =>
+      packageToModuleBases.getOrElse(inPackage, Nil).flatMap(x =>
+        Files.list(x.resolve(FileUtils.dirPath(inPackage))).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: PackageName): ClassPathEntries =
-    if (inPackage.isRoot) ClassPathEntries(packages(inPackage), Nil)
+  override private[dotty] def list(inPackage: String): ClassPathEntries =
+    if (inPackage == "") ClassPathEntries(packages(inPackage), Nil)
     else ClassPathEntries(packages(inPackage), classes(inPackage))
 
   def asURLs: Seq[URL] = Seq(new URL("jrt:/"))
@@ -211,7 +214,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: PackageName): Seq[ClassFileEntry] = files(inPackage)
+  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = files(inPackage)
 }
 
 case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFileEntryImpl] with NoClassPaths {
@@ -235,5 +238,5 @@ case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFi
     }
   }
 
-  private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
+  private[dotty] def sources(inPackage: String): 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: PackageName): Seq[ClassFileEntry] = files(inPackage)
+  private[dotty] def classes(inPackage: String): 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(PackageName(pkg), simpleClassName + ".class").map(_.file)
+      file(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(PackageName(pkg), simpleClassName + ".class")
+      file(pkg, simpleClassName + ".class")
     }
 
-    override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
+    override private[dotty] def classes(inPackage: String): 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(PackageName(pkg)).find(_.name == simpleClassName).map(_.file)
+      classes(pkg).find(_.name == simpleClassName).map(_.file)
     }
 
     override def asClassPathStrings: Seq[String] = Seq(file.path)
@@ -118,20 +118,21 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
       packages
     }
 
-    override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = cachedPackages.get(inPackage.dottedString) match {
+    override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = cachedPackages.get(inPackage) match {
       case None => Seq.empty
       case Some(PackageFileInfo(_, subpackages)) =>
-        subpackages.map(packageFile => PackageEntryImpl(inPackage.entryName(packageFile.name)))
+        val prefix = PackageNameUtils.packagePrefix(inPackage)
+        subpackages.map(packageFile => PackageEntryImpl(prefix + packageFile.name))
     }
 
-    override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = cachedPackages.get(inPackage.dottedString) match {
+    override private[dotty] def classes(inPackage: String): Seq[ClassFileEntry] = cachedPackages.get(inPackage) 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: PackageName) = cachedPackages.contains(pkg.dottedString)
-    override private[dotty] def list(inPackage: PackageName): ClassPathEntries = ClassPathEntries(packages(inPackage), classes(inPackage))
+    override private[dotty] def hasPackage(pkg: String) = cachedPackages.contains(pkg)
+    override private[dotty] def list(inPackage: String): ClassPathEntries = ClassPathEntries(packages(inPackage), classes(inPackage))
   }
 
   private object ManifestResourcesClassPath {
@@ -163,7 +164,7 @@ object ZipAndJarSourcePathFactory extends ZipAndJarFileLookupFactory {
 
     override def asSourcePathString: String = asClassPathString
 
-    override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
+    override private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] = files(inPackage)
 
     override protected def createFileEntry(file: FileZipArchive#Entry): SourceFileEntryImpl = SourceFileEntryImpl(file)
     override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isScalaOrJavaSource