Merge pull request #4176 from mpociecha/flat-classpath2

The alternative, flat representation of classpath elements

10 files changed, 796 insertions, 14 deletions

diff --git a/test/files/run/t6502.scala b/test/files/run/t6502.scala
index ced1b5812d..4ce034a482 100644
--- a/test/files/run/t6502.scala
+++ b/test/files/run/t6502.scala
@@ -1,6 +1,7 @@
-import scala.tools.partest._
-import java.io.File
+import scala.tools.nsc.Settings
 import scala.tools.nsc.interpreter.ILoop
+import scala.tools.nsc.settings.ClassPathRepresentationType
+import scala.tools.partest._
 
 object Test extends StoreReporterDirectTest {
   def code = ???
@@ -10,6 +11,14 @@ object Test extends StoreReporterDirectTest {
     compileString(newCompiler("-cp", classpath, "-d", s"${testOutput.path}/$jarFileName"))(code)
   }
 
+  // TODO flat classpath doesn't support the classpath invalidation yet so we force using the recursive one
+  // it's the only test which needed such a workaround
+  override def settings = {
+    val settings = new Settings
+    settings.YclasspathImpl.value = ClassPathRepresentationType.Recursive
+    settings
+  }
+
   def app1 = """
     package test
 
@@ -41,7 +50,8 @@ object Test extends StoreReporterDirectTest {
     val jar = "test1.jar"
     compileCode(app1, jar)
 
-    val output = ILoop.run(List(s":require ${testOutput.path}/$jar", "test.Test.test()"))
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar", "test.Test.test()")
+    val output = ILoop.run(codeToRun, settings)
     val lines  = output.split("\n")
     val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
     val res2   = lines(lines.length-3).contains("testing...")
@@ -56,7 +66,8 @@ object Test extends StoreReporterDirectTest {
     val jar2 = "test2.jar"
     compileCode(app2, jar2)
 
-    val output = ILoop.run(List(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar2"))
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar2")
+    val output = ILoop.run(codeToRun, settings)
     val lines  = output.split("\n")
     val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
     val res2   = lines(lines.length-3).contains("test2.jar") && lines(lines.length-3).contains("existing classpath entries conflict")
@@ -71,7 +82,8 @@ object Test extends StoreReporterDirectTest {
     val jar3 = "test3.jar"
     compileCode(app3, jar3)
 
-    val output = ILoop.run(List(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar3", "test.Test3.test()"))
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar3", "test.Test3.test()")
+    val output = ILoop.run(codeToRun, settings)
     val lines  = output.split("\n")
     val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
     val res2   = lines(lines.length-3).contains("new object in existing package")
@@ -83,7 +95,8 @@ object Test extends StoreReporterDirectTest {
   def test4(): Unit = {
     // twice the same jar should be rejected
     val jar1   = "test1.jar"
-    val output = ILoop.run(List(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar1"))
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar1")
+    val output = ILoop.run(codeToRun, settings)
     val lines  = output.split("\n")
     val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
     val res2   = lines(lines.length-3).contains("test1.jar") && lines(lines.length-3).contains("existing classpath entries conflict")
@@ -98,4 +111,6 @@ object Test extends StoreReporterDirectTest {
     test3()
     test4()
   }
+
+  def toCodeInSeparateLines(lines: String*): String = lines.map(_ + "\n").mkString
 }
diff --git a/test/files/run/t6669.scala b/test/files/run/t6669.scala
index e18f2514a9..27c4970d60 100644
--- a/test/files/run/t6669.scala
+++ b/test/files/run/t6669.scala
@@ -1,4 +1,5 @@
 import java.io.{ByteArrayOutputStream, PrintStream}
+import scala.reflect.io.File
 
 object Test extends App {
   val baos = new ByteArrayOutputStream()
@@ -9,9 +10,11 @@ object Test extends App {
     scala.tools.scalap.Main.main(Array("-verbose", "java.lang.Object"))
   }
 
+  val currentLocationCpFragment = File.pathSeparator + "."
+
   // now make sure we saw the '.' in the classpath
   val msg1 = baos.toString()
-  assert(msg1 contains "directory classpath: .", s"Did not see '.' in the default class path. Full results were:\n$msg1")
+  assert(msg1 contains currentLocationCpFragment, s"Did not see '.' in the default class path. Full results were:\n$msg1")
 
   // then test again with a user specified classpath
   baos.reset
@@ -22,5 +25,5 @@ object Test extends App {
 
   // now make sure we did not see the '.' in the classpath
   val msg2 = baos.toString()
-  assert(!(msg2 contains "directory classpath: ."), s"Did saw '.' in the user specified class path. Full results were:\n$msg2")
+  assert(!(msg2 contains currentLocationCpFragment), s"Did saw '.' in the user specified class path. Full results were:\n$msg2")
 }
diff --git a/test/files/run/various-flat-classpath-types.check b/test/files/run/various-flat-classpath-types.check
new file mode 100644
index 0000000000..401f707d0e
--- /dev/null
+++ b/test/files/run/various-flat-classpath-types.check
@@ -0,0 +1,12 @@
+ZipBin()
+JarBin()
+DirBin()
+ZipSrc()
+JarSrc()
+DirSrc()
+NestedZipBin()
+NestedJarBin()
+NestedDirBin()
+NestedZipSrc()
+NestedJarSrc()
+NestedDirSrc()
\ No newline at end of file
diff --git a/test/files/run/various-flat-classpath-types.scala b/test/files/run/various-flat-classpath-types.scala
new file mode 100644
index 0000000000..d39019e885
--- /dev/null
+++ b/test/files/run/various-flat-classpath-types.scala
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+
+import java.io.{File => JFile, FileInputStream, FileOutputStream}
+import java.util.zip.{ZipEntry, ZipOutputStream}
+import scala.reflect.io.{Directory, File}
+import scala.tools.nsc.classpath.FlatClassPath.RootPackage
+import scala.tools.nsc.classpath.PackageNameUtils
+import scala.tools.nsc.io.Jar
+
+/**
+ * Generates directories, jars and zip files containing sources and classes
+ * (the result of a compilation which is executed here)
+ * and use them as a class- and sourcepath during compilation and running
+ * created application. At the end everything is cleaned up.
+ *
+ * It can test also current, recursive classpath. Just right now we force
+ * flat classpath to test it also when the recursive one would be set as a default.
+ */
+object Test {
+
+  private implicit class JFileOps(file: JFile) {
+
+    def createDir(newDirName: String) = {
+      val newDir = new JFile(file, newDirName)
+      newDir.mkdir()
+      newDir
+    }
+
+    def createSrcFile(newFileName: String) = createFile(newFileName + ".scala")
+
+    def createFile(fullFileName: String) = {
+      val newFile = new JFile(file, fullFileName)
+      newFile.createNewFile()
+      newFile
+    }
+
+    def writeAll(text: String): Unit = File(file) writeAll text
+
+    def moveContentToZip(zipName: String): Unit = {
+      val newZip = zipsDir createFile s"$zipName.zip"
+      val outputStream = new ZipOutputStream(new FileOutputStream(newZip))
+
+      def addFileToZip(dirPrefix: String = "")(fileToAdd: JFile): Unit =
+        if (fileToAdd.isDirectory) {
+          val dirEntryName = fileToAdd.getName + "/"
+          outputStream.putNextEntry(new ZipEntry(dirEntryName))
+          fileToAdd.listFiles() foreach addFileToZip(dirEntryName)
+        } else {
+          val inputStream = new FileInputStream(fileToAdd)
+          outputStream.putNextEntry(new ZipEntry(dirPrefix + fileToAdd.getName))
+
+          val buffer = new Array[Byte](1024)
+          var count = inputStream.read(buffer)
+          while (count > 0) {
+            outputStream.write(buffer, 0, count)
+            count = inputStream.read(buffer)
+          }
+
+          inputStream.close()
+        }
+
+      file.listFiles() foreach addFileToZip()
+      outputStream.close()
+
+      cleanDir(file)
+    }
+
+    def moveContentToJar(jarName: String): Unit = {
+      val newJar = jarsDir createFile s"$jarName.jar"
+      Jar.create(file = File(newJar), sourceDir = Directory(file), mainClass = "won't be used")
+      cleanDir(file)
+    }
+
+    def path: String = file.getAbsolutePath
+  }
+
+  private case class DirRep(name: String, nestedDirs: Seq[DirRep] = Nil, sourceFiles: Seq[String] = Nil)
+
+  private val compiler = new scala.tools.nsc.MainClass
+  private val appRunner = new scala.tools.nsc.MainGenericRunner
+  private val classPathImplFlag = "-YclasspathImpl:flat"
+  private val javaClassPath = sys.props("java.class.path")
+
+  // creates a test dir in a temporary dir containing compiled files of this test
+  // root dir will be automatically deleted after the end of test
+  private val rootDir = new JFile(sys.props("partest.output"))
+  private val testDir = rootDir createDir s"cp-tests-${System.currentTimeMillis()}"
+
+  private val jarsDir = testDir createDir "jars"
+  private val zipsDir = testDir createDir "zips"
+  private val srcDir = testDir createDir "src"
+  private val binDir = testDir createDir "bin"
+  private val outDir = testDir createDir "out"
+
+  def main(args: Array[String]): Unit = {
+    createClassesZipInZipsDir()
+    createClassesJarInJarsDir()
+    createClassesInBinDir()
+    createSourcesZipInZipsDir()
+    createSourcesJarInJarsDir()
+    createSourcesInSrcDir()
+    compileFinalApp()
+    runApp()
+    // at the end all created files will be deleted automatically
+  }
+
+  private def createClassesZipInZipsDir(): Unit = {
+    val baseFileName = "ZipBin"
+    createStandardSrcHierarchy(baseFileName)
+    compileSrc(baseFileName)
+    outDir moveContentToZip "Bin"
+    cleanDir(srcDir)
+  }
+
+  private def createClassesJarInJarsDir(): Unit = {
+    val baseFileName = "JarBin"
+    createStandardSrcHierarchy(baseFileName)
+    compileSrc(baseFileName)
+    outDir moveContentToJar "Bin"
+    cleanDir(srcDir)
+  }
+
+  private def createClassesInBinDir(): Unit = {
+    val baseFileName = "DirBin"
+    createStandardSrcHierarchy(baseFileName)
+    compileSrc(baseFileName, destination = binDir)
+    cleanDir(srcDir)
+  }
+
+  private def createSourcesZipInZipsDir(): Unit = {
+    createStandardSrcHierarchy(baseFileName = "ZipSrc")
+    srcDir moveContentToZip "Src"
+  }
+
+  private def createSourcesJarInJarsDir(): Unit = {
+    createStandardSrcHierarchy(baseFileName = "JarSrc")
+    srcDir moveContentToJar "Src"
+  }
+
+  private def createSourcesInSrcDir(): Unit = {
+    createStandardSrcHierarchy(baseFileName = "DirSrc")
+
+    val appFile = srcDir createSrcFile "Main"
+    appFile writeAll s"""import nested._
+         | object Main extends App {
+         |   println(new ZipBin)
+         |   println(new JarBin)
+         |   println(new DirBin)
+         |   println(new ZipSrc)
+         |   println(new JarSrc)
+         |   println(new DirSrc)
+         |
+         |   println(new NestedZipBin)
+         |   println(new NestedJarBin)
+         |   println(new NestedDirBin)
+         |   println(new NestedZipSrc)
+         |   println(new NestedJarSrc)
+         |   println(new NestedDirSrc)
+         | }
+       """.stripMargin
+  }
+
+  private def compileFinalApp(): Unit = {
+    val classPath = mkPath(javaClassPath, binDir.path, zipsDir.path + "/Bin.zip", jarsDir.path + "/Bin.jar")
+    val sourcePath = mkPath(srcDir.path, zipsDir.path + "/Src.zip", jarsDir.path + "/Src.jar")
+
+    compiler.process(Array(classPathImplFlag, "-cp", classPath, "-sourcepath", sourcePath,
+      "-d", outDir.path, s"${srcDir.path}/Main.scala"))
+  }
+
+  private def runApp(): Unit = {
+    val classPath = mkPath(javaClassPath, outDir.path, binDir.path, zipsDir.path + "/Bin.zip", jarsDir.path + "/Bin.jar")
+    appRunner.process(Array(classPathImplFlag, "-cp", classPath, "Main"))
+  }
+
+  private def createStandardSrcHierarchy(baseFileName: String): Unit =
+    createSources(RootPackage, srcDir,
+      DirRep("",
+        nestedDirs = Seq(DirRep("nested", sourceFiles = Seq("Nested" + baseFileName))),
+        sourceFiles = Seq(baseFileName)
+      )
+    )
+
+  private def createSources(pkg: String, dirFile: JFile, dirRep: DirRep): Unit = {
+    dirRep.nestedDirs foreach { rep =>
+      val nestedDir = dirFile createDir rep.name
+      val nestedPkg = PackageNameUtils.packagePrefix(pkg) + rep.name
+      createSources(nestedPkg, nestedDir, rep)
+    }
+
+    val pkgHeader = if (pkg == RootPackage) "" else s"package $pkg\n\n"
+    dirRep.sourceFiles foreach { srcName =>
+      val text = s"""${pkgHeader}case class $srcName(x: String = "")"""
+      val srcFile = dirFile createSrcFile srcName
+      srcFile writeAll text
+    }
+  }
+
+  private def compileSrc(baseFileName: String, destination: JFile = outDir): Unit = {
+    val srcDirPath = srcDir.path
+    compiler.process(Array(classPathImplFlag, "-cp", javaClassPath, "-d", destination.path,
+      s"$srcDirPath/$baseFileName.scala", s"$srcDirPath/nested/Nested$baseFileName.scala"))
+  }
+
+  private def cleanDir(dir: JFile): Unit =
+    dir.listFiles().foreach { file =>
+      if (file.isDirectory) cleanDir(file)
+      file.delete()
+    }
+
+  private def mkPath(pathEntries: String*) = pathEntries.mkString(File.pathSeparator)
+}
diff --git a/test/junit/scala/tools/nsc/SampleTest.scala b/test/junit/scala/tools/nsc/SampleTest.scala
index 810c88ef9d..60bb09e98f 100644
--- a/test/junit/scala/tools/nsc/SampleTest.scala
+++ b/test/junit/scala/tools/nsc/SampleTest.scala
@@ -11,6 +11,6 @@ import org.junit.runners.JUnit4
 class SampleTest {
   @Test
   def testMath: Unit = {
-    assert(2+2 == 4, "you didn't get the math right fellow")
+    assertTrue("you didn't get the math right fellow", 2 + 2 == 4)
   }
 }
diff --git a/test/junit/scala/tools/nsc/classpath/AggregateFlatClassPathTest.scala b/test/junit/scala/tools/nsc/classpath/AggregateFlatClassPathTest.scala
new file mode 100644
index 0000000000..9a004d5e0e
--- /dev/null
+++ b/test/junit/scala/tools/nsc/classpath/AggregateFlatClassPathTest.scala
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.classpath
+
+import java.net.URL
+import org.junit.Assert._
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import scala.reflect.io.VirtualFile
+import scala.tools.nsc.io.AbstractFile
+
+/**
+ * Tests whether AggregateFlatClassPath returns correct entries taken from
+ * cp instances used during creating it and whether it preserves the ordering
+ * (in the case of the repeated entry for a class or a source it returns the first one).
+ */
+@RunWith(classOf[JUnit4])
+class AggregateFlatClassPathTest {
+
+  private class TestFlatClassPath extends FlatClassPath {
+    override def packages(inPackage: String): Seq[PackageEntry] = unsupported
+    override def sources(inPackage: String): Seq[SourceFileEntry] = unsupported
+    override def classes(inPackage: String): Seq[ClassFileEntry] = unsupported
+
+    override def list(inPackage: String): FlatClassPathEntries = unsupported
+    override def findClassFile(name: String): Option[AbstractFile] = unsupported
+
+    override def asClassPathStrings: Seq[String] = unsupported
+    override def asSourcePathString: String = unsupported
+    override def asURLs: Seq[URL] = unsupported
+  }
+
+  private case class TestClassPath(virtualPath: String, classesInPackage: EntryNamesInPackage*) extends TestFlatClassPath {
+
+    override def classes(inPackage: String): Seq[ClassFileEntry] =
+      for {
+        entriesWrapper <- classesInPackage if entriesWrapper.inPackage == inPackage
+        name <- entriesWrapper.names
+      } yield classFileEntry(virtualPath, inPackage, name)
+
+    override def sources(inPackage: String): Seq[SourceFileEntry] = Nil
+
+    // we'll ignore packages
+    override def list(inPackage: String): FlatClassPathEntries = FlatClassPathEntries(Nil, classes(inPackage))
+  }
+
+  private case class TestSourcePath(virtualPath: String, sourcesInPackage: EntryNamesInPackage*) extends TestFlatClassPath {
+
+    override def sources(inPackage: String): Seq[SourceFileEntry] =
+      for {
+        entriesWrapper <- sourcesInPackage if entriesWrapper.inPackage == inPackage
+        name <- entriesWrapper.names
+      } yield sourceFileEntry(virtualPath, inPackage, name)
+
+    override def classes(inPackage: String): Seq[ClassFileEntry] = Nil
+
+    // we'll ignore packages
+    override def list(inPackage: String): FlatClassPathEntries = FlatClassPathEntries(Nil, sources(inPackage))
+  }
+
+  private case class EntryNamesInPackage(inPackage: String)(val names: String*)
+
+  private val dir1 = "./dir1"
+  private val dir2 = "./dir2"
+  private val dir3 = "./dir3"
+  private val dir4 = ""
+
+  private val pkg1 = "pkg1"
+  private val pkg2 = "pkg2"
+  private val pkg3 = "pkg1.nested"
+  private val nonexistingPkg = "nonexisting"
+
+  private def unsupported = throw new UnsupportedOperationException
+
+  private def classFileEntry(pathPrefix: String, inPackage: String, fileName: String) =
+    ClassFileEntryImpl(classFile(pathPrefix, inPackage, fileName))
+
+  private def sourceFileEntry(pathPrefix: String, inPackage: String, fileName: String) =
+    SourceFileEntryImpl(sourceFile(pathPrefix, inPackage, fileName))
+
+  private def classFile(pathPrefix: String, inPackage: String, fileName: String) =
+    virtualFile(pathPrefix, inPackage, fileName, ".class")
+
+  private def sourceFile(pathPrefix: String, inPackage: String, fileName: String) =
+    virtualFile(pathPrefix, inPackage, fileName, ".scala")
+
+  private def virtualFile(pathPrefix: String, inPackage: String, fileName: String, extension: String) = {
+    val packageDirs =
+      if (inPackage == FlatClassPath.RootPackage) ""
+      else inPackage.split('.').mkString("/", "/", "")
+    new VirtualFile(fileName + extension, s"$pathPrefix$packageDirs/$fileName$extension")
+  }
+
+  private def createDefaultTestClasspath() = {
+    val partialClassPaths = Seq(TestSourcePath(dir1, EntryNamesInPackage(pkg1)("F", "A", "G")),
+      TestClassPath(dir2, EntryNamesInPackage(pkg1)("C", "B", "A"), EntryNamesInPackage(pkg2)("D", "A", "E")),
+      TestClassPath(dir3, EntryNamesInPackage(pkg1)("A", "D", "F")),
+      TestSourcePath(dir4, EntryNamesInPackage(pkg2)("A", "H", "I"), EntryNamesInPackage(pkg1)("A")),
+      TestSourcePath(dir2, EntryNamesInPackage(pkg3)("J", "K", "L"))
+    )
+
+    AggregateFlatClassPath(partialClassPaths)
+  }
+
+  @Test
+  def testGettingPackages: Unit = {
+    case class ClassPathWithPackages(packagesInPackage: EntryNamesInPackage*) extends TestFlatClassPath {
+      override def packages(inPackage: String): Seq[PackageEntry] =
+        packagesInPackage.find(_.inPackage == inPackage).map(_.names).getOrElse(Nil) map PackageEntryImpl
+    }
+
+    val partialClassPaths = Seq(ClassPathWithPackages(EntryNamesInPackage(pkg1)("pkg1.a", "pkg1.d", "pkg1.f")),
+      ClassPathWithPackages(EntryNamesInPackage(pkg1)("pkg1.c", "pkg1.b", "pkg1.a"),
+        EntryNamesInPackage(pkg2)("pkg2.d", "pkg2.a", "pkg2.e"))
+    )
+    val cp = AggregateFlatClassPath(partialClassPaths)
+
+    val packagesInPkg1 = Seq("pkg1.a", "pkg1.d", "pkg1.f", "pkg1.c", "pkg1.b")
+    assertEquals(packagesInPkg1, cp.packages(pkg1).map(_.name))
+
+    val packagesInPkg2 = Seq("pkg2.d", "pkg2.a", "pkg2.e")
+    assertEquals(packagesInPkg2, cp.packages(pkg2).map(_.name))
+
+    assertEquals(Seq.empty, cp.packages(nonexistingPkg))
+  }
+
+  @Test
+  def testGettingClasses: Unit = {
+    val cp = createDefaultTestClasspath()
+
+    val classesInPkg1 = Seq(classFileEntry(dir2, pkg1, "C"),
+      classFileEntry(dir2, pkg1, "B"),
+      classFileEntry(dir2, pkg1, "A"),
+      classFileEntry(dir3, pkg1, "D"),
+      classFileEntry(dir3, pkg1, "F")
+    )
+    assertEquals(classesInPkg1, cp.classes(pkg1))
+
+    val classesInPkg2 = Seq(classFileEntry(dir2, pkg2, "D"),
+      classFileEntry(dir2, pkg2, "A"),
+      classFileEntry(dir2, pkg2, "E")
+    )
+    assertEquals(classesInPkg2, cp.classes(pkg2))
+
+    assertEquals(Seq.empty, cp.classes(pkg3))
+    assertEquals(Seq.empty, cp.classes(nonexistingPkg))
+  }
+
+  @Test
+  def testGettingSources: Unit = {
+    val partialClassPaths = Seq(TestClassPath(dir1, EntryNamesInPackage(pkg1)("F", "A", "G")),
+      TestSourcePath(dir2, EntryNamesInPackage(pkg1)("C", "B", "A"), EntryNamesInPackage(pkg2)("D", "A", "E")),
+      TestSourcePath(dir3, EntryNamesInPackage(pkg1)("A", "D", "F")),
+      TestClassPath(dir4, EntryNamesInPackage(pkg2)("A", "H", "I")),
+      TestClassPath(dir2, EntryNamesInPackage(pkg3)("J", "K", "L"))
+    )
+    val cp = AggregateFlatClassPath(partialClassPaths)
+
+    val sourcesInPkg1 = Seq(sourceFileEntry(dir2, pkg1, "C"),
+      sourceFileEntry(dir2, pkg1, "B"),
+      sourceFileEntry(dir2, pkg1, "A"),
+      sourceFileEntry(dir3, pkg1, "D"),
+      sourceFileEntry(dir3, pkg1, "F")
+    )
+    assertEquals(sourcesInPkg1, cp.sources(pkg1))
+
+    val sourcesInPkg2 = Seq(sourceFileEntry(dir2, pkg2, "D"),
+      sourceFileEntry(dir2, pkg2, "A"),
+      sourceFileEntry(dir2, pkg2, "E")
+    )
+    assertEquals(sourcesInPkg2, cp.sources(pkg2))
+
+    assertEquals(Seq.empty, cp.sources(pkg3))
+    assertEquals(Seq.empty, cp.sources(nonexistingPkg))
+  }
+
+  @Test
+  def testList: Unit = {
+    val cp = createDefaultTestClasspath()
+
+    val classesAndSourcesInPkg1 = Seq(
+      ClassAndSourceFilesEntry(classFile(dir3, pkg1, "F"), sourceFile(dir1, pkg1, "F")),
+      ClassAndSourceFilesEntry(classFile(dir2, pkg1, "A"), sourceFile(dir1, pkg1, "A")),
+      sourceFileEntry(dir1, pkg1, "G"),
+      classFileEntry(dir2, pkg1, "C"),
+      classFileEntry(dir2, pkg1, "B"),
+      classFileEntry(dir3, pkg1, "D")
+    )
+    assertEquals(classesAndSourcesInPkg1, cp.list(pkg1).classesAndSources)
+
+    assertEquals(FlatClassPathEntries(Nil, Nil), cp.list(nonexistingPkg))
+  }
+
+  @Test
+  def testFindClass: Unit = {
+    val cp = createDefaultTestClasspath()
+
+    assertEquals(
+      Some(ClassAndSourceFilesEntry(classFile(dir2, pkg1, "A"), sourceFile(dir1, pkg1, "A"))),
+      cp.findClass(s"$pkg1.A")
+    )
+    assertEquals(Some(classFileEntry(dir3, pkg1, "D")), cp.findClass(s"$pkg1.D"))
+    assertEquals(Some(sourceFileEntry(dir2, pkg3, "L")), cp.findClass(s"$pkg3.L"))
+    assertEquals(None, cp.findClass("Nonexisting"))
+  }
+}
diff --git a/test/junit/scala/tools/nsc/classpath/FlatClassPathResolverTest.scala b/test/junit/scala/tools/nsc/classpath/FlatClassPathResolverTest.scala
new file mode 100644
index 0000000000..a37ba31b31
--- /dev/null
+++ b/test/junit/scala/tools/nsc/classpath/FlatClassPathResolverTest.scala
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.classpath
+
+import java.io.File
+import org.junit.Assert._
+import org.junit._
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import scala.annotation.tailrec
+import scala.tools.nsc.io.AbstractFile
+import scala.tools.nsc.util.ClassPath
+import scala.tools.nsc.Settings
+import scala.tools.util.FlatClassPathResolver
+import scala.tools.util.PathResolver
+
+@RunWith(classOf[JUnit4])
+class FlatClassPathResolverTest {
+
+  val tempDir = new TemporaryFolder()
+
+  private val packagesToTest = List(FlatClassPath.RootPackage, "scala", "scala.reflect", "scala.reflect.io")
+  private val classFilesToFind = List("scala.tools.util.FlatClassPathResolver",
+    "scala.reflect.io.AbstractFile",
+    "scala.collection.immutable.List",
+    "scala.Option",
+    "scala.collection.immutable.Vector",
+    "scala.util.hashing.MurmurHash3",
+    "java.lang.Object",
+    "java.util.Date")
+
+  private val classesToFind = classFilesToFind ++ List("TestSourceInRootPackage",
+    "scala.reflect.io.TestScalaSource",
+    "scala.reflect.io.TestJavaSource")
+
+  private val settings = new Settings
+
+  @Before
+  def initTempDirAndSourcePath: Unit = {
+    // In Java TemporaryFolder in JUnit is managed automatically using @Rule.
+    // It would work also in Scala after adding and extending a class like
+    // TestWithTempFolder.java containing it. But in this case it doesn't work when running tests
+    // from the command line - java class is not compiled due to some, misterious reasons.
+    // That's why such dirs are here created and deleted manually.
+    tempDir.create()
+    tempDir.newFile("TestSourceInRootPackage.scala")
+    val ioDir = tempDir.newFolder("scala", "reflect", "io")
+    new File(ioDir, "AbstractFile.scala").createNewFile()
+    new File(ioDir, "ZipArchive.java").createNewFile()
+    new File(ioDir, "TestScalaSource.scala").createNewFile()
+    new File(ioDir, "TestJavaSource.java").createNewFile()
+
+    settings.usejavacp.value = true
+    settings.sourcepath.value = tempDir.getRoot.getAbsolutePath
+  }
+
+  @After
+  def deleteTempDir: Unit = tempDir.delete()
+
+  private def createFlatClassPath(settings: Settings) =
+    new FlatClassPathResolver(settings).result
+
+  @Test
+  def testEntriesFromListOperationAgainstSeparateMethods: Unit = {
+    val classPath = createFlatClassPath(settings)
+
+    def compareEntriesInPackage(inPackage: String): Unit = {
+      val packages = classPath.packages(inPackage)
+      val classes = classPath.classes(inPackage)
+      val sources = classPath.sources(inPackage)
+      val FlatClassPathEntries(packagesFromList, classesAndSourcesFromList) = classPath.list(inPackage)
+
+      val packageNames = packages.map(_.name).sorted
+      val packageNamesFromList = packagesFromList.map(_.name).sorted
+      assertEquals(s"Methods list and packages for package '$inPackage' should return the same packages",
+        packageNames, packageNamesFromList)
+
+      val classFileNames = classes.map(_.name).sorted
+      val classFileNamesFromList = classesAndSourcesFromList.filter(_.binary.isDefined).map(_.name).sorted
+      assertEquals(s"Methods list and classes for package '$inPackage' should return entries for the same class files",
+        classFileNames, classFileNamesFromList)
+
+      val sourceFileNames = sources.map(_.name).sorted
+      val sourceFileNamesFromList = classesAndSourcesFromList.filter(_.source.isDefined).map(_.name).sorted
+      assertEquals(s"Methods list and sources for package '$inPackage' should return entries for the same source files",
+        sourceFileNames, sourceFileNamesFromList)
+
+      val uniqueNamesOfClassAndSourceFiles = (classFileNames ++ sourceFileNames).toSet
+      assertEquals(s"Class and source entries with the same name obtained via list for package '$inPackage' should be merged into one containing both files",
+        uniqueNamesOfClassAndSourceFiles.size, classesAndSourcesFromList.length)
+    }
+
+    packagesToTest foreach compareEntriesInPackage
+  }
+
+  @Test
+  def testCreatedEntriesAgainstRecursiveClassPath: Unit = {
+    val flatClassPath = createFlatClassPath(settings)
+    val recursiveClassPath = new PathResolver(settings).result
+
+    def compareEntriesInPackage(inPackage: String): Unit = {
+
+      @tailrec
+      def traverseToPackage(packageNameParts: Seq[String], cp: ClassPath[AbstractFile]): ClassPath[AbstractFile] = {
+        packageNameParts match {
+          case Nil => cp
+          case h :: t =>
+            cp.packages.find(_.name == h) match {
+              case Some(nestedCp) => traverseToPackage(t, nestedCp)
+              case _ => throw new Exception(s"There's no package $inPackage in recursive classpath - error when searching for '$h'")
+            }
+        }
+      }
+
+      val packageNameParts = if (inPackage == FlatClassPath.RootPackage) Nil else inPackage.split('.').toList
+      val recursiveClassPathInPackage = traverseToPackage(packageNameParts, recursiveClassPath)
+
+      val flatCpPackages = flatClassPath.packages(inPackage).map(_.name)
+      val pkgPrefix = PackageNameUtils.packagePrefix(inPackage)
+      val recursiveCpPackages = recursiveClassPathInPackage.packages.map(pkgPrefix + _.name)
+      assertEquals(s"Packages in package '$inPackage' on flat cp should be the same as on the recursive cp",
+        recursiveCpPackages, flatCpPackages)
+
+      val flatCpSources = flatClassPath.sources(inPackage).map(_.name).sorted
+      val recursiveCpSources = recursiveClassPathInPackage.classes
+        .filter(_.source.nonEmpty)
+        .map(_.name).sorted
+      assertEquals(s"Source entries in package '$inPackage' on flat cp should be the same as on the recursive cp",
+        recursiveCpSources, flatCpSources)
+
+      val flatCpClasses = flatClassPath.classes(inPackage).map(_.name).sorted
+      val recursiveCpClasses = recursiveClassPathInPackage.classes
+        .filter(_.binary.nonEmpty)
+        .map(_.name).sorted
+      assertEquals(s"Class entries in package '$inPackage' on flat cp should be the same as on the recursive cp",
+        recursiveCpClasses, flatCpClasses)
+    }
+
+    packagesToTest foreach compareEntriesInPackage
+  }
+
+  @Test
+  def testFindClassFile: Unit = {
+    val classPath = createFlatClassPath(settings)
+    classFilesToFind foreach { className =>
+      assertTrue(s"File for $className should be found", classPath.findClassFile(className).isDefined)
+    }
+  }
+
+  @Test
+  def testFindClass: Unit = {
+    val classPath = createFlatClassPath(settings)
+    classesToFind foreach { className =>
+      assertTrue(s"File for $className should be found", classPath.findClass(className).isDefined)
+    }
+  }
+}
diff --git a/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala b/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala
index e4be42ac96..f0f20acf07 100644
--- a/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala
+++ b/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala
@@ -3,6 +3,9 @@ package symtab
 
 import scala.reflect.ClassTag
 import scala.reflect.internal.{Phase, NoPhase, SomePhase}
+import scala.tools.nsc.classpath.FlatClassPath
+import scala.tools.nsc.settings.ClassPathRepresentationType
+import scala.tools.util.FlatClassPathResolver
 import scala.tools.util.PathResolver
 import util.ClassPath
 import io.AbstractFile
@@ -26,13 +29,28 @@ class SymbolTableForUnitTesting extends SymbolTable {
   class LazyTreeCopier extends super.LazyTreeCopier with TreeCopier
 
   override def isCompilerUniverse: Boolean = true
-  def classPath = new PathResolver(settings).result
+
+  def classPath = platform.classPath
+  def flatClassPath: FlatClassPath = platform.flatClassPath
 
   object platform extends backend.Platform {
     val symbolTable: SymbolTableForUnitTesting.this.type = SymbolTableForUnitTesting.this
     lazy val loaders: SymbolTableForUnitTesting.this.loaders.type = SymbolTableForUnitTesting.this.loaders
+
     def platformPhases: List[SubComponent] = Nil
-    val classPath: ClassPath[AbstractFile] = new PathResolver(settings).result
+
+    lazy val classPath: ClassPath[AbstractFile] = {
+      assert(settings.YclasspathImpl.value == ClassPathRepresentationType.Recursive,
+        "It's not possible to use the recursive classpath representation, when it's not the chosen classpath scanning method")
+      new PathResolver(settings).result
+    }
+
+    private[nsc] lazy val flatClassPath: FlatClassPath = {
+      assert(settings.YclasspathImpl.value == ClassPathRepresentationType.Flat,
+        "It's not possible to use the flat classpath representation, when it's not the chosen classpath scanning method")
+      new FlatClassPathResolver(settings).result
+    }
+
     def isMaybeBoxed(sym: Symbol): Boolean = ???
     def needCompile(bin: AbstractFile, src: AbstractFile): Boolean = ???
     def externalEquals: Symbol = ???
@@ -50,7 +68,12 @@ class SymbolTableForUnitTesting extends SymbolTable {
 
   class GlobalMirror extends Roots(NoSymbol) {
     val universe: SymbolTableForUnitTesting.this.type = SymbolTableForUnitTesting.this
-    def rootLoader: LazyType = new loaders.PackageLoader(classPath)
+
+    def rootLoader: LazyType = settings.YclasspathImpl.value match {
+      case ClassPathRepresentationType.Flat => new loaders.PackageLoaderUsingFlatClassPath(FlatClassPath.RootPackage, flatClassPath)
+      case ClassPathRepresentationType.Recursive => new loaders.PackageLoader(classPath)
+    }
+
     override def toString = "compiler mirror"
   }
 
@@ -60,7 +83,7 @@ class SymbolTableForUnitTesting extends SymbolTable {
     rm.asInstanceOf[Mirror]
   }
 
-  def settings: Settings = {
+  lazy val settings: Settings = {
     val s = new Settings
     // initialize classpath using java classpath
     s.usejavacp.value = true
diff --git a/test/junit/scala/tools/nsc/util/ClassPathImplComparator.scala b/test/junit/scala/tools/nsc/util/ClassPathImplComparator.scala
new file mode 100644
index 0000000000..f2926e3e17
--- /dev/null
+++ b/test/junit/scala/tools/nsc/util/ClassPathImplComparator.scala
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.util
+
+import scala.reflect.io.AbstractFile
+import scala.tools.nsc.Settings
+import scala.tools.nsc.settings.ClassPathRepresentationType
+import scala.tools.util.PathResolverFactory
+
+/**
+ * Simple application to compare efficiency of the recursive and the flat classpath representations
+ */
+object ClassPathImplComparator {
+
+  private class TestSettings extends Settings {
+    val checkClasses = PathSetting("-checkClasses", "Specify names of classes which should be found separated with ;", "")
+    val requiredIterations = IntSetting("-requiredIterations",
+      "Repeat tests specified number of times (to check e.g. impact of caches)", 1, Some((1, Int.MaxValue)), (_: String) => None)
+    val cpCreationRepetitions = IntSetting("-cpCreationRepetitions",
+      "Repeat tests specified number of times (to check e.g. impact of caches)", 1, Some((1, Int.MaxValue)), (_: String) => None)
+    val cpLookupRepetitions = IntSetting("-cpLookupRepetitions",
+      "Repeat tests specified number of times (to check e.g. impact of caches)", 1, Some((1, Int.MaxValue)), (_: String) => None)
+  }
+
+  private class DurationStats(name: String) {
+    private var sum = 0L
+    private var iterations = 0
+
+    def noteMeasuredTime(millis: Long): Unit = {
+      sum += millis
+      iterations += 1
+    }
+
+    def printResults(): Unit = {
+      val avg = if (iterations == 0) 0 else sum.toDouble / iterations
+      println(s"$name - total duration: $sum ms; iterations: $iterations; avg: $avg ms")
+    }
+  }
+
+  private lazy val defaultClassesToFind = List(
+    "scala.collection.immutable.List",
+    "scala.Option",
+    "scala.Int",
+    "scala.collection.immutable.Vector",
+    "scala.util.hashing.MurmurHash3"
+  )
+
+  private val oldCpCreationStats = new DurationStats("Old classpath - create")
+  private val oldCpSearchingStats = new DurationStats("Old classpath - search")
+
+  private val flatCpCreationStats = new DurationStats("Flat classpath - create")
+  private val flatCpSearchingStats = new DurationStats("Flat classpath - search")
+
+  def main(args: Array[String]): Unit = {
+
+    if (args contains "-help")
+      usage()
+    else {
+      val oldCpSettings = loadSettings(args.toList, ClassPathRepresentationType.Recursive)
+      val flatCpSettings = loadSettings(args.toList, ClassPathRepresentationType.Flat)
+
+      val classesToCheck = oldCpSettings.checkClasses.value
+      val classesToFind =
+        if (classesToCheck.isEmpty) defaultClassesToFind
+        else classesToCheck.split(";").toList
+
+      def doTest(classPath: => ClassFileLookup[AbstractFile], cpCreationStats: DurationStats, cpSearchingStats: DurationStats,
+                 cpCreationRepetitions: Int, cpLookupRepetitions: Int)= {
+
+        def createClassPaths() = (1 to cpCreationRepetitions).map(_ => classPath).last
+        def testClassLookup(cp: ClassFileLookup[AbstractFile]): Boolean = (1 to cpCreationRepetitions).foldLeft(true) {
+          case (a, _) => a && checkExistenceOfClasses(classesToFind)(cp)
+        }
+
+        val cp = withMeasuredTime("Creating classpath", createClassPaths(), cpCreationStats)
+        val result = withMeasuredTime("Searching for specified classes", testClassLookup(cp), cpSearchingStats)
+        println(s"The end of the test case. All expected classes found = $result \n")
+      }
+
+      (1 to oldCpSettings.requiredIterations.value) foreach { iteration =>
+        if (oldCpSettings.requiredIterations.value > 1)
+          println(s"Iteration no $iteration")
+
+        println("Recursive (old) classpath representation:")
+        doTest(PathResolverFactory.create(oldCpSettings).result, oldCpCreationStats, oldCpSearchingStats,
+          oldCpSettings.cpCreationRepetitions.value, oldCpSettings.cpLookupRepetitions.value)
+
+        println("Flat classpath representation:")
+        doTest(PathResolverFactory.create(flatCpSettings).result, flatCpCreationStats, flatCpSearchingStats,
+          flatCpSettings.cpCreationRepetitions.value, flatCpSettings.cpLookupRepetitions.value)
+      }
+
+      if (oldCpSettings.requiredIterations.value > 1) {
+        println("\nOld classpath - summary")
+        oldCpCreationStats.printResults()
+        oldCpSearchingStats.printResults()
+
+        println("\nFlat classpath - summary")
+        flatCpCreationStats.printResults()
+        flatCpSearchingStats.printResults()
+      }
+    }
+  }
+
+  /**
+   * Prints usage information
+   */
+  private def usage(): Unit =
+    println("""Use classpath and sourcepath options like in the case of e.g. 'scala' command.
+              | There are also two additional options:
+              | -checkClasses <semicolon separated class names> Specify names of classes which should be found
+              | -requiredIterations <int value>                 Repeat tests specified count of times (to check e.g. impact of caches)
+              | Note: Option -YclasspathImpl will be set automatically for each case.
+            """.stripMargin.trim)
+
+  private def loadSettings(args: List[String], implType: String) = {
+    val settings = new TestSettings()
+    settings.processArguments(args, processAll = true)
+    settings.YclasspathImpl.value = implType
+    if (settings.classpath.isDefault)
+      settings.classpath.value = sys.props("java.class.path")
+    settings
+  }
+
+  private def withMeasuredTime[T](operationName: String, f: => T, durationStats: DurationStats): T = {
+    val startTime = System.currentTimeMillis()
+    val res = f
+    val elapsed = System.currentTimeMillis() - startTime
+    durationStats.noteMeasuredTime(elapsed)
+    println(s"$operationName - elapsed $elapsed ms")
+    res
+  }
+
+  private def checkExistenceOfClasses(classesToCheck: Seq[String])(classPath: ClassFileLookup[AbstractFile]): Boolean =
+    classesToCheck.foldLeft(true) {
+      case (res, classToCheck) =>
+        val found = classPath.findClass(classToCheck).isDefined
+        if (!found)
+          println(s"Class $classToCheck not found") // of course in this case the measured time will be affected by IO operation
+        found
+    }
+}
diff --git a/test/script-tests/README b/test/script-tests/README
index 3f5c2ce19c..7b3291c407 100755
--- a/test/script-tests/README
+++ b/test/script-tests/README
@@ -5,4 +5,9 @@ putting self-contained script tests in here to run some way that doesn't
 depend on all the platform stars aligning all the time. Feel free to
 join me.
 
--- extempore, Nov 21 2011
\ No newline at end of file
+-- extempore, Nov 21 2011
+
+But there's a problem that probably nobody would run such tests so they would become outdated quite quickly.
+And therefore they wouldn't work (and even compile) after some time - like this one existing currently.
+
+-- mpociecha, Oct 9 2014
\ No newline at end of file