implicitly pass classloader, might make code easier

and prepares for allowing `run` and `runFlat` at
Dependency instead of Build level

5 files changed, 62 insertions, 59 deletions

diff --git a/stage1/MavenRepository.scala b/stage1/MavenRepository.scala
index a8c9b51..6be537b 100644
--- a/stage1/MavenRepository.scala
+++ b/stage1/MavenRepository.scala
@@ -4,7 +4,7 @@ import java.net._
 case class MavenResolver(
   cbtLastModified: Long, mavenCache: File, urls: URL*
 )(
-  implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]
+  implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache
 ){
   def bind( dependencies: MavenDependency* ): Seq[BoundMavenDependency]
     = dependencies.map( BoundMavenDependency(cbtLastModified,mavenCache,_,urls.to) ).to
diff --git a/stage1/Stage1.scala b/stage1/Stage1.scala
index bf6a3d4..60f0ad9 100644
--- a/stage1/Stage1.scala
+++ b/stage1/Stage1.scala
@@ -36,17 +36,16 @@ abstract class Stage2Base{
   def run( context: Stage2Args ): ExitCode
 }
 
-case class Stage2Args(
-  cwd: File,
-  args: Seq[String],
-  stage2LastModified: Long,
-  logger: Logger,
-  classLoaderCache: ClassLoaderCache,
-  cache: File,
-  cbtHome: File,
-  compatibilityTarget: File
+class Stage2Args(
+  val cwd: File,
+  val args: Seq[String],
+  val stage2LastModified: Long,
+  val logger: Logger,
+  val cache: File,
+  val cbtHome: File,
+  val compatibilityTarget: File
 )(
-  implicit val transientCache: java.util.Map[AnyRef,AnyRef]
+  implicit val transientCache: java.util.Map[AnyRef,AnyRef], val classLoaderCache: ClassLoaderCache
 ){
   val persistentCache = classLoaderCache.hashMap
 }
@@ -61,11 +60,10 @@ object Stage1{
     val logger = new Logger( context.enabledLoggers, buildStage1.start )
     val (cbtLastModified, classLoader) = buildStage2(
       buildStage1,
-      new ClassLoaderCache( context.persistentCache ),
       context.cbtHome,
       context.cache,
       logger
-    )(context.transientCache)
+    )(context.transientCache, new ClassLoaderCache( context.persistentCache ))
 
     classLoader
       .loadClass("cbt.Stage2")
@@ -79,8 +77,8 @@ object Stage1{
   }
 
   def buildStage2(
-    buildStage1: BuildStage1Result, classLoaderCache: ClassLoaderCache, cbtHome: File, cache: File, logger: Logger
-  )(implicit transientCache: java.util.Map[AnyRef,AnyRef]): (Long, ClassLoader) = {
+    buildStage1: BuildStage1Result, cbtHome: File, cache: File, logger: Logger
+  )(implicit transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache): (Long, ClassLoader) = {
 
     import buildStage1._
 
@@ -106,9 +104,9 @@ object Stage1{
       stage2sourceFiles, stage2Target, stage2StatusFile,
       cbtDependencies.stage2Dependency.dependencies,
       mavenCache,
-      Seq("-deprecation","-feature","-unchecked"), classLoaderCache,
+      Seq("-deprecation","-feature","-unchecked"),
       zincVersion = constants.zincVersion, scalaVersion = constants.scalaVersion
-    )(transientCache)
+    )
 
     logger.stage1(s"calling CbtDependency.classLoader")
 
@@ -129,19 +127,19 @@ object Stage1{
       "cbt unchanged, expected stage1 classloader to be cached"
     )
 
-    val stage2ClassLoader = cbtDependencies.stage2Dependency.classLoader(classLoaderCache)
+    val stage2ClassLoader = cbtDependencies.stage2Dependency.classLoader
 
     {
       // a few classloader sanity checks
       val compatibilityClassLoader =
-        cbtDependencies.compatibilityDependency.classLoader(classLoaderCache)
+        cbtDependencies.compatibilityDependency.classLoader
       assert(
         classOf[BuildInterface].getClassLoader == compatibilityClassLoader,
         classOf[BuildInterface].getClassLoader.toString ++ "\n\nis not the same as\n\n" ++ compatibilityClassLoader.toString
       )
       //-------------
       val stage1ClassLoader =
-        cbtDependencies.stage1Dependency.classLoader(classLoaderCache)
+        cbtDependencies.stage1Dependency.classLoader
       assert(
         classOf[Stage1ArgsParser].getClassLoader == stage1ClassLoader,
         classOf[Stage1ArgsParser].getClassLoader.toString ++ "\n\nis not the same as\n\n" ++ stage1ClassLoader.toString
@@ -165,20 +163,19 @@ object Stage1{
   ): Int = {
     val args = Stage1ArgsParser(_args.toVector)
     val logger = new Logger(args.enabledLoggers, buildStage1.start)
-    implicit val transientCache: java.util.Map[AnyRef,AnyRef] = new java.util.HashMap
     logger.stage1(s"Stage1 start")
 
-    val classLoaderCache = new ClassLoaderCache( persistentCache )
+    implicit val transientCache: java.util.Map[AnyRef,AnyRef] = new java.util.HashMap
+    implicit val classLoaderCache = new ClassLoaderCache( persistentCache )
 
-    val (stage2LastModified, classLoader) = buildStage2( buildStage1, classLoaderCache, cbtHome, cache, logger )
+    val (stage2LastModified, classLoader) = buildStage2( buildStage1, cbtHome, cache, logger )
 
-    val stage2Args = Stage2Args(
+    val stage2Args = new Stage2Args(
       new File( args.args(0) ),
       args.args.drop(1).dropWhile(_ == "direct").toVector,
       // launcher changes cause entire nailgun restart, so no need for them here
       stage2LastModified = stage2LastModified,
       logger = logger,
-      classLoaderCache = classLoaderCache,
       cache,
       cbtHome,
       new File(buildStage1.compatibilityClasspath)
diff --git a/stage1/Stage1Lib.scala b/stage1/Stage1Lib.scala
index 5a2f05d..67c1f4e 100644
--- a/stage1/Stage1Lib.scala
+++ b/stage1/Stage1Lib.scala
@@ -192,11 +192,10 @@ class Stage1Lib( logger: Logger ) extends BaseLib{
     dependencies: Seq[Dependency],
     mavenCache: File,
     scalacOptions: Seq[String] = Seq(),
-    classLoaderCache: ClassLoaderCache,
     zincVersion: String,
     scalaVersion: String
   )(
-    implicit transientCache: java.util.Map[AnyRef, AnyRef]
+    implicit transientCache: java.util.Map[AnyRef, AnyRef], classLoaderCache: ClassLoaderCache
   ): Option[Long] = {
     val d = Dependencies(dependencies)
     val classpath = d.classpath
@@ -259,7 +258,7 @@ class Stage1Lib( logger: Logger ) extends BaseLib{
                 dualArgs ++ singleArgs ++ (
                   if(cp.isEmpty) Nil else Seq("-cp", cp)
                 ) ++ sourceFiles.map(_.toString),
-                zinc.classLoader(classLoaderCache)
+                zinc.classLoader
               )
             } catch {
               case scala.util.control.NonFatal(e) =>
@@ -413,20 +412,20 @@ ${sourceFiles.sorted.mkString(" \\\n")}
     case d => d
   }
 
-  def classLoaderRecursion( dependency: Dependency, latest: Map[(String,String),Dependency], cache: ClassLoaderCache)(implicit transientCache: java.util.Map[AnyRef,AnyRef] ): ClassLoader = {
+  def classLoaderRecursion( dependency: Dependency, latest: Map[(String,String),Dependency])(implicit transientCache: java.util.Map[AnyRef,AnyRef], cache: ClassLoaderCache): ClassLoader = {
     // FIXME: shouldn't we be using KeyLockedLazyCache instead of hashmap directly here?
     val dependencies = dependency.dependencies
     val dependencyClassLoader: ClassLoader = {
       if( dependency.dependencies.isEmpty ){
         NailgunLauncher.jdkClassLoader
       } else if( dependencies.size == 1 ){
-        classLoaderRecursion( dependencies.head, latest, cache )
+        classLoaderRecursion( dependencies.head, latest )
       } else{
         val lastModified = dependencies.map( _.lastModified ).max
         val cp = dependency.dependencyClasspath.string
         val cl =
           new MultiClassLoader(
-            dependencies.map( classLoaderRecursion(_, latest, cache) )
+            dependencies.map( classLoaderRecursion(_, latest) )
           )
         if(dependency.isInstanceOf[BuildInterface])
           cl // Don't cache builds right now. We need to fix invalidation first.
diff --git a/stage1/cbt.scala b/stage1/cbt.scala
index 54f3159..f88ef16 100644
--- a/stage1/cbt.scala
+++ b/stage1/cbt.scala
@@ -52,10 +52,10 @@ object `package`{
   }
   implicit class DependencyExtensions(subject: Dependency){
     import subject._
-    def dependencyClasspath(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]): ClassPath
+    def dependencyClasspath(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache): ClassPath
       = Dependencies(dependenciesArray.to).classpath
     def exportedClasspath: ClassPath = ClassPath(exportedClasspathArray.to)
-    def classpath(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) = exportedClasspath ++ dependencyClasspath
+    def classpath(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache) = exportedClasspath ++ dependencyClasspath
     def dependencies: Seq[Dependency] = dependenciesArray.to
   }
   implicit class ContextExtensions(subject: Context){
@@ -66,7 +66,7 @@ object `package`{
     def classLoaderCache: ClassLoaderCache = new ClassLoaderCache( persistentCache )
     def cbtDependencies = {
       import paths._
-      new CbtDependencies(mavenCache, nailgunTarget, stage1Target, stage2Target, compatibilityTarget)(logger, transientCache)
+      new CbtDependencies(mavenCache, nailgunTarget, stage1Target, stage2Target, compatibilityTarget)(logger, transientCache, classLoaderCache)
     }
     val cbtDependency = cbtDependencies.stage2Dependency
 
diff --git a/stage1/resolver.scala b/stage1/resolver.scala
index 97cd36a..4731b0c 100644
--- a/stage1/resolver.scala
+++ b/stage1/resolver.scala
@@ -9,6 +9,7 @@ trait DependencyImplementation extends Dependency{
   implicit protected def logger: Logger
   protected def lib = new Stage1Lib(logger)
   implicit protected def transientCache: java.util.Map[AnyRef,AnyRef]
+  implicit protected def classLoaderCache: ClassLoaderCache
 
   /** key used by taskCache to identify different objects that represent the same logical module */
   protected def moduleKey: String
@@ -78,23 +79,29 @@ trait DependencyImplementation extends Dependency{
   }
   */
 
-  def classLoader( cache: ClassLoaderCache ): ClassLoader = {
-    /*
-    if( concurrencyEnabled ){
-      // trigger concurrent building / downloading dependencies
-      exportClasspathConcurrently
+  def flatClassLoader: Boolean = false
+
+  def classLoader: ClassLoader = {
+    if( flatClassLoader ){
+      new java.net.URLClassLoader(classpath.strings.map(f => new URL("file://" ++ f)).toArray)
+    } else {
+      /*
+      if( concurrencyEnabled ){
+        // trigger concurrent building / downloading dependencies
+        exportClasspathConcurrently
+      }
+      */
+      lib.classLoaderRecursion(
+        this,
+        (this +: transitiveDependencies).collect{
+          case d: ArtifactInfo => d 
+        }.groupBy(
+          d => (d.groupId,d.artifactId)
+        ).mapValues(_.head)
+      )
     }
-    */
-    lib.classLoaderRecursion(
-      this,
-      (this +: transitiveDependencies).collect{
-        case d: ArtifactInfo => d 
-      }.groupBy(
-        d => (d.groupId,d.artifactId)
-      ).mapValues(_.head),
-      cache // FIXME
-    )
   }
+
   // FIXME: these probably need to update outdated as well
   def classpath           : ClassPath = exportedClasspath ++ dependencyClasspath
   def dependencyClasspath : ClassPath = ClassPath(
@@ -116,11 +123,11 @@ trait DependencyImplementation extends Dependency{
 }
 
 // TODO: all this hard codes the scala version, needs more flexibility
-class ScalaCompilerDependency(cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BoundMavenDependency(cbtLastModified, mavenCache, MavenDependency("org.scala-lang","scala-compiler",version, Classifier.none), Seq(mavenCentral))
-class ScalaLibraryDependency (cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BoundMavenDependency(cbtLastModified, mavenCache, MavenDependency("org.scala-lang","scala-library",version, Classifier.none), Seq(mavenCentral))
-class ScalaReflectDependency (cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BoundMavenDependency(cbtLastModified, mavenCache, MavenDependency("org.scala-lang","scala-reflect",version, Classifier.none), Seq(mavenCentral))
+class ScalaCompilerDependency(cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache) extends BoundMavenDependency(cbtLastModified, mavenCache, MavenDependency("org.scala-lang","scala-compiler",version, Classifier.none), Seq(mavenCentral))
+class ScalaLibraryDependency (cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache) extends BoundMavenDependency(cbtLastModified, mavenCache, MavenDependency("org.scala-lang","scala-library",version, Classifier.none), Seq(mavenCentral))
+class ScalaReflectDependency (cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache) extends BoundMavenDependency(cbtLastModified, mavenCache, MavenDependency("org.scala-lang","scala-reflect",version, Classifier.none), Seq(mavenCentral))
 
-class ScalaDependencies(cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends Dependencies(
+class ScalaDependencies(cbtLastModified: Long, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache) extends Dependencies(
   Seq(
     new ScalaCompilerDependency(cbtLastModified, mavenCache, version),
     new ScalaLibraryDependency(cbtLastModified, mavenCache, version),
@@ -128,7 +135,7 @@ class ScalaDependencies(cbtLastModified: Long, mavenCache: File, version: String
   )
 )
 
-case class BinaryDependency( paths: Seq[File], dependencies: Seq[Dependency] )(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]) extends DependencyImplementation{
+case class BinaryDependency( paths: Seq[File], dependencies: Seq[Dependency] )(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef], val classLoaderCache: ClassLoaderCache) extends DependencyImplementation{
   assert(paths.nonEmpty)
   def exportedClasspath = ClassPath(paths)
   override def lastModified = paths.map(_.lastModified).maxOption.getOrElse(0) // FIXME: cache this
@@ -137,7 +144,7 @@ case class BinaryDependency( paths: Seq[File], dependencies: Seq[Dependency] )(i
 }
 
 /** Allows to easily assemble a bunch of dependencies */
-case class Dependencies( dependencies: Seq[Dependency] )(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]) extends DependencyImplementation{
+case class Dependencies( dependencies: Seq[Dependency] )(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef], val classLoaderCache: ClassLoaderCache) extends DependencyImplementation{
   override def lastModified = dependencies.map(_.lastModified).maxOption.getOrElse(0)
   def moduleKey = this.getClass.getName ++ "(" ++ dependencies.map(_.moduleKey).mkString(", ") ++ ")"
   def targetClasspath = ClassPath() 
@@ -145,14 +152,14 @@ case class Dependencies( dependencies: Seq[Dependency] )(implicit val logger: Lo
   override def show: String = this.getClass.getSimpleName + "( " + dependencies.map(_.show).mkString(", ") + " )"
 }
 
-case class PostBuildDependency(target: File, _dependencies: Seq[DependencyImplementation])(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]) extends DependencyImplementation{
+case class PostBuildDependency(target: File, _dependencies: Seq[DependencyImplementation])(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef], val classLoaderCache: ClassLoaderCache) extends DependencyImplementation{
   override final lazy val lastModified = (target++".last-success").lastModified
   def moduleKey = target.string
   override def targetClasspath = exportedClasspath
   override def exportedClasspath = ClassPath( Seq(target) )
   override def dependencies = _dependencies
 }
-case class CbtDependencies(mavenCache: File, nailgunTarget: File, stage1Target: File, stage2Target: File, compatibilityTarget: File)(implicit logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]){
+case class CbtDependencies(mavenCache: File, nailgunTarget: File, stage1Target: File, stage2Target: File, compatibilityTarget: File)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache){
   val compatibilityDependency = PostBuildDependency(compatibilityTarget, Nil)
   val cbtLastModified = (stage2Target++".last-success").lastModified
   val stage1Dependency = PostBuildDependency(
@@ -188,7 +195,7 @@ abstract class DependenciesProxy{
 class BoundMavenDependencies(
   cbtLastModified: Long, mavenCache: File, urls: Seq[URL], mavenDependencies: Seq[MavenDependency]
 )(
-  implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]
+  implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef], classLoaderCache: ClassLoaderCache
 ) extends Dependencies(
   mavenDependencies.map( BoundMavenDependency(cbtLastModified,mavenCache,_,urls) )
 )
@@ -206,7 +213,7 @@ object MavenDependency{
 case class BoundMavenDependency(
   cbtLastModified: Long, mavenCache: File, mavenDependency: MavenDependency, repositories: Seq[URL]
 )(
-  implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]
+  implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef], val classLoaderCache: ClassLoaderCache
 ) extends ArtifactInfo with DependencyImplementation{
   def moduleKey = this.getClass.getName ++ "(" ++ mavenDependency.serialize ++ ")"
   val MavenDependency( groupId, artifactId, version, classifier ) = mavenDependency