Add flat classpath implementation for directories

There's added the flat classpath implementation for directories using
java.util.File directly. Since we work with a real directory - not
the AbstractFile - we don't need to iterate all entries of a file to
get inner entries of some package. We can just find an adequate
directory for a package.

There are added implementations for a class- and a sourcepath. Both
extend DirectoryFileLookup which provides common logic.

4 files changed, 189 insertions, 1 deletions

diff --git a/src/compiler/scala/tools/nsc/classpath/DirectoryFlatClassPath.scala b/src/compiler/scala/tools/nsc/classpath/DirectoryFlatClassPath.scala
new file mode 100644
index 0000000000..81d2f7320f
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/classpath/DirectoryFlatClassPath.scala
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.classpath
+
+import java.io.File
+import java.io.FileFilter
+import java.net.URL
+import scala.reflect.io.AbstractFile
+import scala.reflect.io.PlainFile
+import scala.tools.nsc.util.ClassRepresentation
+import FileUtils._
+
+/**
+ * A trait allowing to look for classpath entries of given type in directories.
+ * It provides common logic for classes handling class and source files.
+ * It makes use of the fact that in the case of nested directories it's easy to find a file
+ * when we have a name of a package.
+ */
+trait DirectoryFileLookup[FileEntryType <: ClassRepClassPathEntry] extends FlatClassPath {
+  val dir: File
+  assert(dir != null, "Directory file in DirectoryFileLookup cannot be null")
+
+  override def asURLs: Seq[URL] = Seq(dir.toURI.toURL)
+  override def asClassPathStrings: Seq[String] = Seq(dir.getPath)
+
+  import FlatClassPath.RootPackage
+  private def getDirectory(forPackage: String): Option[File] = {
+    if (forPackage == RootPackage) {
+      Some(dir)
+    } else {
+      val packageDirName = FileUtils.dirPath(forPackage)
+      val packageDir = new File(dir, packageDirName)
+      if (packageDir.exists && packageDir.isDirectory) {
+        Some(packageDir)
+      } else None
+    }
+  }
+
+  override private[nsc] def packages(inPackage: String): Seq[PackageEntry] = {
+    val dirForPackage = getDirectory(inPackage)
+    val nestedDirs: Array[File] = dirForPackage match {
+      case None => Array.empty
+      case Some(directory) => directory.listFiles(DirectoryFileLookup.packageDirectoryFileFilter)
+    }
+    val prefix = PackageNameUtils.packagePrefix(inPackage)
+    val entries = nestedDirs map { file =>
+      PackageEntryImpl(prefix + file.getName)
+    }
+    entries
+  }
+
+  protected def files(inPackage: String): Seq[FileEntryType] = {
+    val dirForPackage = getDirectory(inPackage)
+    val files: Array[File] = dirForPackage match {
+      case None => Array.empty
+      case Some(directory) => directory.listFiles(fileFilter)
+    }
+    val entries = files map { file =>
+      val wrappedFile = new scala.reflect.io.File(file)
+      createFileEntry(new PlainFile(wrappedFile))
+    }
+    entries
+  }
+
+  override private[nsc] def list(inPackage: String): FlatClassPathEntries = {
+    val dirForPackage = getDirectory(inPackage)
+    val files: Array[File] = dirForPackage match {
+      case None => Array.empty
+      case Some(directory) => directory.listFiles()
+    }
+    val packagePrefix = PackageNameUtils.packagePrefix(inPackage)
+    val packageBuf = collection.mutable.ArrayBuffer.empty[PackageEntry]
+    val fileBuf = collection.mutable.ArrayBuffer.empty[FileEntryType]
+    for (file <- files) {
+      if (file.isPackage) {
+        val pkgEntry = PackageEntryImpl(packagePrefix + file.getName)
+        packageBuf += pkgEntry
+      } else if (fileFilter.accept(file)) {
+        val wrappedFile = new scala.reflect.io.File(file)
+        val abstractFile = new PlainFile(wrappedFile)
+        fileBuf += createFileEntry(abstractFile)
+      }
+    }
+    FlatClassPathEntries(packageBuf, fileBuf)
+  }
+
+  protected def createFileEntry(file: AbstractFile): FileEntryType
+  protected def fileFilter: FileFilter
+}
+
+object DirectoryFileLookup {
+
+  private[classpath] object packageDirectoryFileFilter extends FileFilter {
+    override def accept(pathname: File): Boolean = pathname.isPackage
+  }
+}
+
+case class DirectoryFlatClassPath(dir: File)
+  extends DirectoryFileLookup[ClassFileEntryImpl]
+  with NoSourcePaths {
+
+  override def findClass(className: String): Option[ClassRepresentation[AbstractFile]] = findClassFile(className) map ClassFileEntryImpl
+
+  override def findClassFile(className: String): Option[AbstractFile] = {
+    val relativePath = FileUtils.dirPath(className)
+    val classFile = new File(s"$dir/$relativePath.class")
+    if (classFile.exists) {
+      val wrappedClassFile = new scala.reflect.io.File(classFile)
+      val abstractClassFile = new PlainFile(wrappedClassFile)
+      Some(abstractClassFile)
+    } else None
+  }
+
+  override protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)
+  override protected def fileFilter: FileFilter = DirectoryFlatClassPath.classFileFilter
+
+  override private[nsc] def classes(inPackage: String): Seq[ClassFileEntry] = files(inPackage)
+}
+
+object DirectoryFlatClassPath {
+
+  private val classFileFilter = new FileFilter {
+    override def accept(pathname: File): Boolean = pathname.isClass
+  }
+}
+
+case class DirectoryFlatSourcePath(dir: File)
+  extends DirectoryFileLookup[SourceFileEntryImpl]
+  with NoClassPaths {
+
+  override def asSourcePathString: String = asClassPathString
+
+  override protected def createFileEntry(file: AbstractFile): SourceFileEntryImpl = SourceFileEntryImpl(file)
+  override protected def fileFilter: FileFilter = DirectoryFlatSourcePath.sourceFileFilter
+
+  override def findClass(className: String): Option[ClassRepresentation[AbstractFile]] = {
+    findSourceFile(className) map SourceFileEntryImpl
+  }
+
+  private def findSourceFile(className: String): Option[AbstractFile] = {
+    val relativePath = FileUtils.dirPath(className)
+    val sourceFile = Stream("scala", "java")
+      .map(ext => new File(s"$dir/$relativePath.$ext"))
+      .collectFirst { case file if file.exists() => file }
+
+    sourceFile.map { file =>
+      val wrappedSourceFile = new scala.reflect.io.File(file)
+      val abstractSourceFile = new PlainFile(wrappedSourceFile)
+      abstractSourceFile
+    }
+  }
+
+  override private[nsc] def sources(inPackage: String): Seq[SourceFileEntry] = files(inPackage)
+}
+
+object DirectoryFlatSourcePath {
+
+  private val sourceFileFilter = new FileFilter {
+    override def accept(pathname: File): Boolean = endsScalaOrJava(pathname.getName)
+  }
+}
diff --git a/src/compiler/scala/tools/nsc/classpath/FileUtils.scala b/src/compiler/scala/tools/nsc/classpath/FileUtils.scala
index 0221454c04..f8f5ac3ac5 100644
--- a/src/compiler/scala/tools/nsc/classpath/FileUtils.scala
+++ b/src/compiler/scala/tools/nsc/classpath/FileUtils.scala
@@ -3,12 +3,13 @@
  */
 package scala.tools.nsc.classpath
 
+import java.io.{ File => JFile }
 import java.net.URL
 import scala.reflect.internal.FatalError
 import scala.reflect.io.AbstractFile
 
 /**
- * Common methods related to files used in the context of classpath
+ * Common methods related to Java files and abstract files used in the context of classpath
  */
 object FileUtils {
   implicit class AbstractFileOps(val file: AbstractFile) extends AnyVal {
@@ -20,12 +21,20 @@ object FileUtils {
     def toURLs(default: => Seq[URL] = Seq.empty): Seq[URL] = if (file.file == null) default else Seq(file.toURL)
   }
 
+  implicit class FileOps(val file: JFile) extends AnyVal {
+    def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.getName)
+
+    def isClass: Boolean = file.isFile && file.getName.endsWith(".class")
+  }
+
   def stripSourceExtension(fileName: String): String = {
     if (endsScala(fileName)) stripClassExtension(fileName)
     else if (endsJava(fileName)) stripJavaExtension(fileName)
     else throw new FatalError("Unexpected source file ending: " + fileName)
   }
 
+  def dirPath(forPackage: String) = forPackage.replace('.', '/')
+
   def endsClass(fileName: String): Boolean =
     fileName.length > 6 && fileName.substring(fileName.length - 6) == ".class"
 
@@ -43,4 +52,9 @@ object FileUtils {
 
   def stripJavaExtension(fileName: String): String =
     fileName.substring(0, fileName.length - 5)
+
+  // probably it should match a pattern like [a-z_]{1}[a-z0-9_]* but it cannot be changed
+  // because then some tests in partest don't pass
+  private def mayBeValidPackage(dirName: String): Boolean =
+    (dirName != "META-INF") && (dirName != "") && (dirName.charAt(0) != '.')
 }
diff --git a/src/compiler/scala/tools/nsc/classpath/FlatClassPath.scala b/src/compiler/scala/tools/nsc/classpath/FlatClassPath.scala
index bbd244b647..26b5429e23 100644
--- a/src/compiler/scala/tools/nsc/classpath/FlatClassPath.scala
+++ b/src/compiler/scala/tools/nsc/classpath/FlatClassPath.scala
@@ -89,3 +89,13 @@ private[nsc] case class ClassAndSourceFilesEntry(classFile: AbstractFile, srcFil
 }
 
 private[nsc] case class PackageEntryImpl(name: String) extends PackageEntry
+
+private[nsc] trait NoSourcePaths {
+  def asSourcePathString: String = ""
+  private[nsc] def sources(inPackage: String): Seq[SourceFileEntry] = Seq.empty
+}
+
+private[nsc] trait NoClassPaths {
+  def findClassFile(className: String): Option[AbstractFile] = None
+  private[nsc] def classes(inPackage: String): Seq[ClassFileEntry] = Seq.empty
+}
diff --git a/src/compiler/scala/tools/nsc/classpath/PackageNameUtils.scala b/src/compiler/scala/tools/nsc/classpath/PackageNameUtils.scala
index c93ce6ed27..c907d565d2 100644
--- a/src/compiler/scala/tools/nsc/classpath/PackageNameUtils.scala
+++ b/src/compiler/scala/tools/nsc/classpath/PackageNameUtils.scala
@@ -21,4 +21,6 @@ object PackageNameUtils {
     else
       (fullClassName.substring(0, lastDotIndex), fullClassName.substring(lastDotIndex + 1))
   }
+
+  def packagePrefix(inPackage: String): String = if (inPackage == RootPackage) "" else inPackage + "."
 }