Integrate flat classpath with the compiler

This commit integrates with the compiler the whole flat classpath
representation build next to the recursive one as an alternative.

From now flat classpath really works and can be turned on. There's
added flag -YclasspathImpl with two options: recursive (the default
one) and flat.

It was needed to make the dynamic dispatch to the particular
classpath representation according to the chosen type of a classpath
representation.

There's added PathResolverFactory which is used instead of a concrete
implementation of a path resolver. It turned out that only a small
subset of path resolvers methods is used outside this class in Scala
sources. Therefore, PathResolverFactory returns an instance of a base
interface PathResolverResult providing only these used methods.

PathResolverFactory in combination with matches in some other places
ensures that in all places using classpath we create/get the proper
representation.

Also the classPath method in Global is modified to use the dynamic
dispatch. This is very important change as a return type changed to
the base ClassFileLookup providing subset of old ClassPath public
methods. It can be problematic if someone was using in his project
the explicit ClassPath type or public methods which are not provided
via ClassFileLookup. I tested flat classpath with sbt and Scala IDE
and there were no problems. Also was looking at sources of some other
projects like e.g. Scala plugin for IntelliJ and there shouldn't be
problems, I think, but it would be better to check these changes
using the community build.

Scalap's Main.scala is changed to be able to use both implementations
and also to use flags related to the classpath implementation.

The classpath invalidation is modified to work properly with the old
(recursive) classpath representation after changes made in a Global.
In the case of the attempt to use the invalidation for the flat cp it
just throws exception with a message that the flat one currently
doesn't support the invalidation. And also that's why the partest's
test for the invalidation has been changed to use (always) the old
implementation. There's added an adequate comment with TODO to this
file.

There's added partest test generating various dependencies
(directories, zips and jars with sources and class files) and testing
whether the compilation and further running an application works
correctly, when there are these various types of entries specified as
-classpath and -sourcepath. It should be a good approximation of real
use cases.

1 files changed, 32 insertions, 7 deletions

diff --git a/src/scalap/scala/tools/scalap/Main.scala b/src/scalap/scala/tools/scalap/Main.scala
index dc3bf64060..0e0970db1f 100644
--- a/src/scalap/scala/tools/scalap/Main.scala
+++ b/src/scalap/scala/tools/scalap/Main.scala
@@ -10,11 +10,15 @@ package tools.scalap
 
 import java.io.{ PrintStream, OutputStreamWriter, ByteArrayOutputStream }
 import scala.reflect.NameTransformer
+import scala.tools.nsc.Settings
+import scala.tools.nsc.classpath.AggregateFlatClassPath
+import scala.tools.nsc.classpath.FlatClassPathFactory
 import scala.tools.nsc.io.AbstractFile
+import scala.tools.nsc.settings.ClassPathRepresentationType
 import scala.tools.nsc.util.ClassFileLookup
-import scala.tools.nsc.util.JavaClassPath
 import scala.tools.nsc.util.ClassPath.DefaultJavaContext
-import scala.tools.util.PathResolver
+import scala.tools.nsc.util.JavaClassPath
+import scala.tools.util.PathResolverFactory
 import scalax.rules.scalasig._
 
 /**The main object used to execute scalap on the command-line.
@@ -139,6 +143,9 @@ object Main extends Main {
     val showPrivateDefs = "-private"
     val verbose = "-verbose"
     val version = "-version"
+
+    val classPathImplType = "-YclasspathImpl"
+    val logClassPath = "-Ylog-classpath"
   }
 
   /** Prints usage information for scalap. */
@@ -170,11 +177,14 @@ object Main extends Main {
       verbose = arguments contains opts.verbose
       printPrivates = arguments contains opts.showPrivateDefs
       // construct a custom class path
-      val cpArg = List(opts.classpath, opts.cp) map (arguments getArgument _) reduceLeft (_ orElse _)
-      val path = cpArg match {
-        case Some(cp) => new JavaClassPath(DefaultJavaContext.classesInExpandedPath(cp), DefaultJavaContext)
-        case _        => PathResolver.fromPathString(".") // include '.' in the default classpath SI-6669
-      }
+      val cpArg = List(opts.classpath, opts.cp) map (arguments getArgument) reduceLeft (_ orElse _)
+
+      val settings = new Settings()
+
+      arguments getArgument opts.classPathImplType foreach settings.YclasspathImpl.tryToSetFromPropertyValue
+      settings.Ylogcp.value = arguments contains opts.logClassPath
+
+      val path = createClassPath(cpArg, settings)
 
       // print the classpath if output is verbose
       if (verbose)
@@ -192,5 +202,20 @@ object Main extends Main {
       .withOption(opts.help)
       .withOptionalArg(opts.classpath)
       .withOptionalArg(opts.cp)
+      // TODO two temporary, hidden options to be able to test different classpath representations
+      .withOptionalArg(opts.classPathImplType)
+      .withOption(opts.logClassPath)
       .parse(args)
+
+  private def createClassPath(cpArg: Option[String], settings: Settings) = cpArg match {
+    case Some(cp) => settings.YclasspathImpl.value match {
+      case ClassPathRepresentationType.Flat =>
+        AggregateFlatClassPath(new FlatClassPathFactory(settings).classesInExpandedPath(cp))
+      case ClassPathRepresentationType.Recursive =>
+        new JavaClassPath(DefaultJavaContext.classesInExpandedPath(cp), DefaultJavaContext)
+    }
+    case _ =>
+      settings.classpath.value = "." // include '.' in the default classpath SI-6669
+      PathResolverFactory.create(settings).result
+  }
 }