memoize task results across classes within a single run

8 files changed, 114 insertions, 90 deletions

diff --git a/stage1/Cache.scala b/stage1/Cache.scala
deleted file mode 100644
index a8036e5..0000000
--- a/stage1/Cache.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-package cbt
-/**
-Caches exactly one value.
-Is there a less boiler-platy way to achieve this, that doesn't
-require creating an instance for each thing you want to cache?
-*/
-class Cache[T]{
-  private var value: Option[T] = None
-  def apply(value: => T) = this.synchronized{
-    if(!this.value.isDefined)
-      this.value = Some(value)
-    this.value.get
-  }
-}
diff --git a/stage1/ContextImplementation.scala b/stage1/ContextImplementation.scala
index 3b610c0..30db597 100644
--- a/stage1/ContextImplementation.scala
+++ b/stage1/ContextImplementation.scala
@@ -2,19 +2,19 @@ package cbt
 import java.io._
 import java.lang._
 
-case class ContextImplementation(
-  projectDirectory: File,
-  cwd: File,
-  argsArray: Array[String],
-  enabledLoggersArray: Array[String],
-  startCompat: Long,
-  cbtHasChangedCompat: Boolean,
-  scalaVersionOrNull: String,
-  persistentCache: java.util.Map[AnyRef,AnyRef],
-  transientCache: java.util.Map[AnyRef,AnyRef],
-  cache: File,
-  cbtHome: File,
-  cbtRootHome: File,
-  compatibilityTarget: File,
-  parentBuildOrNull: BuildInterface
-) extends Context
\ No newline at end of file
+class ContextImplementation(
+  val projectDirectory: File,
+  val cwd: File,
+  val argsArray: Array[String],
+  val enabledLoggersArray: Array[String],
+  val startCompat: Long,
+  val cbtHasChangedCompat: Boolean,
+  val scalaVersionOrNull: String,
+  val persistentCache: java.util.Map[AnyRef,AnyRef],
+  val transientCache: java.util.Map[AnyRef,AnyRef],
+  val cache: File,
+  val cbtHome: File,
+  val cbtRootHome: File,
+  val compatibilityTarget: File,
+  val parentBuildOrNull: BuildInterface
+) extends Context
diff --git a/stage1/MavenRepository.scala b/stage1/MavenRepository.scala
index 4184d2d..2ac7064 100644
--- a/stage1/MavenRepository.scala
+++ b/stage1/MavenRepository.scala
@@ -1,9 +1,13 @@
 package cbt
 import java.io._
 import java.net._
-case class MavenResolver( cbtHasChanged: Boolean, mavenCache: File, urls: URL* ){
-  def bind( dependencies: MavenDependency* )(implicit logger: Logger): Seq[BoundMavenDependency]
+case class MavenResolver(
+  cbtHasChanged: Boolean, mavenCache: File, urls: URL*
+)(
+  implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]
+){
+  def bind( dependencies: MavenDependency* ): Seq[BoundMavenDependency]
     = dependencies.map( BoundMavenDependency(cbtHasChanged,mavenCache,_,urls.to) ).to
-  def bindOne( dependency: MavenDependency )(implicit logger: Logger): BoundMavenDependency
+  def bindOne( dependency: MavenDependency ): BoundMavenDependency
     = BoundMavenDependency( cbtHasChanged, mavenCache, dependency, urls.to )
 }
diff --git a/stage1/Stage1.scala b/stage1/Stage1.scala
index f0540b4..27c6402 100644
--- a/stage1/Stage1.scala
+++ b/stage1/Stage1.scala
@@ -44,6 +44,8 @@ case class Stage2Args(
   cache: File,
   cbtHome: File,
   compatibilityTarget: File
+)(
+  implicit val transientCache: java.util.Map[AnyRef,AnyRef]
 ){
   val ClassLoaderCache( logger, persistentCache ) = classLoaderCache
 }
@@ -60,7 +62,7 @@ object Stage1{
       ClassLoaderCache( logger, context.persistentCache ),
       context.cbtHome,
       context.cache
-    )
+    )( context.transientCache )
 
     classLoader
       .loadClass("cbt.Stage2")
@@ -75,7 +77,7 @@ object Stage1{
 
   def buildStage2(
     buildStage1: BuildStage1Result, classLoaderCache: ClassLoaderCache, cbtHome: File, cache: File
-  ): (Boolean, ClassLoader) = {
+  )(implicit transientCache: java.util.Map[AnyRef,AnyRef]): (Boolean, ClassLoader) = {
     import classLoaderCache.logger
 
     val lib = new Stage1Lib(logger)
@@ -86,12 +88,12 @@ object Stage1{
     val stage2sourceFiles = (
       stage2.listFiles ++ (stage2 ++ "/plugins").listFiles
     ).toVector.filter(_.isFile).filter(_.toString.endsWith(".scala"))
-    
+
     val cbtHasChanged = buildStage1.changed || lib.needsUpdate(stage2sourceFiles, stage2StatusFile)
 
     val cls = this.getClass.getClassLoader.loadClass("cbt.NailgunLauncher")
-    
-    val cbtDependency = CbtDependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, stage2Target, new File(buildStage1.compatibilityClasspath))
+
+    val cbtDependency = new CbtDependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, stage2Target, new File(buildStage1.compatibilityClasspath))
 
     logger.stage1("Compiling stage2 if necessary")
     compile(
@@ -102,7 +104,7 @@ object Stage1{
       mavenCache,
       Seq("-deprecation","-feature","-unchecked"), classLoaderCache,
       zincVersion = constants.zincVersion, scalaVersion = constants.scalaVersion
-    )
+    )(transientCache)
 
     logger.stage1(s"calling CbtDependency.classLoader")
     if( cbtHasChanged && classLoaderCache.cache.containsKey( cbtDependency.classpath.string ) ) {
@@ -163,6 +165,7 @@ object Stage1{
   ): Int = {
     val args = Stage1ArgsParser(_args.toVector)
     val logger = new Logger(args.enabledLoggers, start)
+    implicit val transientCache: java.util.Map[AnyRef,AnyRef] = new java.util.HashMap
     logger.stage1(s"Stage1 start")
 
     val classLoaderCache = ClassLoaderCache( logger, persistentCache )
diff --git a/stage1/Stage1Lib.scala b/stage1/Stage1Lib.scala
index 296581c..f0bb588 100644
--- a/stage1/Stage1Lib.scala
+++ b/stage1/Stage1Lib.scala
@@ -200,8 +200,9 @@ class Stage1Lib( val logger: Logger ) extends BaseLib{
     classLoaderCache: ClassLoaderCache,
     zincVersion: String,
     scalaVersion: String
+  )(
+    implicit transientCache: java.util.Map[AnyRef, AnyRef]
   ): Option[File] = {
-
     val classpath = Dependencies(dependencies).classpath
     val cp = classpath.string
     if(classpath.files.isEmpty)
@@ -447,4 +448,26 @@ class Stage1Lib( val logger: Logger ) extends BaseLib{
     else
       cache.cache.get( a.classpath.string, cl ).asInstanceOf[ClassLoader]
   }
+
+}
+
+import scala.reflect._
+import scala.language.existentials
+case class PerClassCache(cache: java.util.Map[AnyRef,AnyRef], moduleKey: String)(implicit logger: Logger){
+  def apply[D <: Dependency: ClassTag](key: AnyRef): MethodCache[D] = new MethodCache[D](key)
+  case class MethodCache[D <: Dependency: ClassTag](key: AnyRef){
+    def memoize[T <: AnyRef](task: => T): T = {
+      val fullKey = (classTag[D].runtimeClass, moduleKey, key)
+      logger.transientCache("fetching key"+fullKey)
+      if( cache.containsKey(fullKey) ){
+        logger.transientCache("found    key"+fullKey)
+        cache.get(fullKey).asInstanceOf[T]
+      } else{
+        val value = task
+        logger.transientCache("put      key"+fullKey)
+        cache.put( fullKey, value )
+        value
+      }
+    }
+  }
 }
diff --git a/stage1/cbt.scala b/stage1/cbt.scala
index 22242d7..01c9303 100644
--- a/stage1/cbt.scala
+++ b/stage1/cbt.scala
@@ -62,7 +62,7 @@ object `package`{
     def classLoaderCache: ClassLoaderCache = new ClassLoaderCache( logger, persistentCache )
     def cbtDependency = {
       import paths._
-      CbtDependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, stage2Target, compatibilityTarget)
+      new CbtDependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, stage2Target, compatibilityTarget)(logger, transientCache)
     }
     def args: Seq[String] = argsArray.to
     def enabledLoggers: Set[String] = enabledLoggersArray.to
@@ -79,7 +79,7 @@ object `package`{
       scalaVersion: Option[String] = scalaVersion,
       cbtHome: File = cbtHome,
       parentBuild: Option[BuildInterface] = None
-    ): Context = ContextImplementation(
+    ): Context = new ContextImplementation(
       projectDirectory,
       cwd,
       args.to,
diff --git a/stage1/logger.scala b/stage1/logger.scala
index effdc35..8c8431a 100644
--- a/stage1/logger.scala
+++ b/stage1/logger.scala
@@ -41,6 +41,7 @@ case class Logger(enabledLoggers: Set[String], start: Long) {
   final def git(msg: => String) = log(names.git, msg)
   final def pom(msg: => String) = log(names.pom, msg)
   final def dynamic(msg: => String) = log(names.dynamic, msg)
+  final def transientCache(msg: => String) = log(names.transientCache, msg)
 
   private object names{
     val stage1 = "stage1"
@@ -54,6 +55,7 @@ case class Logger(enabledLoggers: Set[String], start: Long) {
     val pom = "pom"
     val git = "git"
     val dynamic = "dynamic"
+    val transientCache = "transientCache"
   }
 
   private def logUnguarded(name: String, msg: => String) = {
diff --git a/stage1/resolver.scala b/stage1/resolver.scala
index f4af73e..8e46135 100644
--- a/stage1/resolver.scala
+++ b/stage1/resolver.scala
@@ -8,6 +8,15 @@ import scala.xml._
 trait DependencyImplementation extends Dependency{
   implicit protected def logger: Logger
   protected def lib = new Stage1Lib(logger)
+  implicit protected def transientCache: java.util.Map[AnyRef,AnyRef]
+
+  /** key used by taskCache to identify different objects that represent the same logical module */
+  protected def moduleKey: String
+  /**
+   caches given value in context keyed with given key and projectDirectory
+   the context is fresh on every complete run of cbt
+   */
+  protected lazy val taskCache = new PerClassCache(transientCache, moduleKey)
 
   /**
   CAREFUL: this is never allowed to return true for the same dependency more than 
@@ -101,11 +110,11 @@ trait DependencyImplementation extends Dependency{
   )
   def dependencies: Seq[Dependency]
 
-  private object transitiveDependenciesCache extends Cache[Seq[Dependency]]
   /** return dependencies in order of linearized dependence. this is a bit tricky. */
-  def transitiveDependencies: Seq[Dependency] = transitiveDependenciesCache{
-    lib.transitiveDependencies(this)
-  }
+  def transitiveDependencies: Seq[Dependency] =
+    taskCache[DependencyImplementation]( "transitiveDependencies" ).memoize{
+      lib.transitiveDependencies(this)
+    }
 
   override def show: String = this.getClass.getSimpleName
   // ========== debug ==========
@@ -113,65 +122,63 @@ trait DependencyImplementation extends Dependency{
 }
 
 // TODO: all this hard codes the scala version, needs more flexibility
-class ScalaCompilerDependency(cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger) extends BoundMavenDependency(cbtHasChanged, mavenCache, MavenDependency("org.scala-lang","scala-compiler",version, Classifier.none), Seq(mavenCentral))
-class ScalaLibraryDependency (cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger) extends BoundMavenDependency(cbtHasChanged, mavenCache, MavenDependency("org.scala-lang","scala-library",version, Classifier.none), Seq(mavenCentral))
-class ScalaReflectDependency (cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger) extends BoundMavenDependency(cbtHasChanged, mavenCache, MavenDependency("org.scala-lang","scala-reflect",version, Classifier.none), Seq(mavenCentral))
+class ScalaCompilerDependency(cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BoundMavenDependency(cbtHasChanged, mavenCache, MavenDependency("org.scala-lang","scala-compiler",version, Classifier.none), Seq(mavenCentral))
+class ScalaLibraryDependency (cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BoundMavenDependency(cbtHasChanged, mavenCache, MavenDependency("org.scala-lang","scala-library",version, Classifier.none), Seq(mavenCentral))
+class ScalaReflectDependency (cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BoundMavenDependency(cbtHasChanged, mavenCache, MavenDependency("org.scala-lang","scala-reflect",version, Classifier.none), Seq(mavenCentral))
 
-case class ScalaDependencies(cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit val logger: Logger) extends DependencyImplementation{ sd =>
-  override final val needsUpdate = false
-  def targetClasspath = ClassPath()
-  def exportedClasspath = ClassPath()
-  def dependencies = Seq(
+class ScalaDependencies(cbtHasChanged: Boolean, mavenCache: File, version: String)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends Dependencies(
+  Seq(
     new ScalaCompilerDependency(cbtHasChanged, mavenCache, version),
     new ScalaLibraryDependency(cbtHasChanged, mavenCache, version),
     new ScalaReflectDependency(cbtHasChanged, mavenCache, version)
   )
-}
+)
 
-case class BinaryDependency( paths: Seq[File], dependencies: Seq[Dependency] )(implicit val logger: Logger) extends DependencyImplementation{
+case class BinaryDependency( paths: Seq[File], dependencies: Seq[Dependency] )(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]) extends DependencyImplementation{
+  assert(paths.nonEmpty)
   def exportedClasspath = ClassPath(paths)
   override def needsUpdate = false
   def targetClasspath = exportedClasspath
+  def moduleKey = this.getClass.getName ++ "(" ++ paths.mkString(", ") ++ ")"
 }
 
 /** Allows to easily assemble a bunch of dependencies */
-case class Dependencies( dependencies: Seq[Dependency] )(implicit val logger: Logger) extends DependencyImplementation{
+case class Dependencies( dependencies: Seq[Dependency] )(implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]) extends DependencyImplementation{
   override def needsUpdate = dependencies.exists(_.needsUpdate)
   override def exportedClasspath = ClassPath()
   override def targetClasspath = ClassPath()
+  def moduleKey = this.getClass.getName ++ "(" ++ dependencies.map(_.moduleKey).mkString(", ") ++ ")"
 }
 
-case class Stage1Dependency(cbtHasChanged: Boolean, mavenCache: File, nailgunTarget: File, stage1Target: File, compatibilityTarget: File)(implicit val logger: Logger) extends DependencyImplementation{
-  override def needsUpdate = false
-  override def targetClasspath = exportedClasspath
-  override def exportedClasspath = ClassPath( Seq(nailgunTarget, stage1Target) )
-  val compatibilityDependency = CompatibilityDependency(cbtHasChanged, compatibilityTarget)
-  override def dependencies = Seq(
-    compatibilityDependency
+class Stage1Dependency(cbtHasChanged: Boolean, mavenCache: File, nailgunTarget: File, stage1Target: File, compatibilityTarget: File)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BinaryDependency(
+  Seq(nailgunTarget, stage1Target),
+  Seq(
+    new CompatibilityDependency(cbtHasChanged, compatibilityTarget)
   ) ++
   MavenResolver(cbtHasChanged,mavenCache,mavenCentral).bind(
     MavenDependency("org.scala-lang","scala-library",constants.scalaVersion),
     MavenDependency("org.scala-lang.modules","scala-xml_"+constants.scalaMajorVersion,constants.scalaXmlVersion)
   )
+){
+  val compatibilityDependency = new CompatibilityDependency(cbtHasChanged, compatibilityTarget)
+
 }
-case class CompatibilityDependency(cbtHasChanged: Boolean, compatibilityTarget: File)(implicit val logger: Logger) extends DependencyImplementation{
-  override def needsUpdate = false
-  override def targetClasspath = exportedClasspath
-  override def exportedClasspath = ClassPath( Seq(compatibilityTarget) )
-  override def dependencies = Seq()
-}
-case class CbtDependency(cbtHasChanged: Boolean, mavenCache: File, nailgunTarget: File, stage1Target: File, stage2Target: File, compatibilityTarget: File)(implicit val logger: Logger) extends DependencyImplementation{
-  override def needsUpdate = false
-  override def targetClasspath = exportedClasspath
-  override def exportedClasspath = ClassPath( Seq( stage2Target ) )
-  val stage1Dependency = Stage1Dependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, compatibilityTarget)
-  override def dependencies = Seq(
-    stage1Dependency
+
+class CompatibilityDependency(cbtHasChanged: Boolean, compatibilityTarget: File)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BinaryDependency(
+  Seq(compatibilityTarget), Nil
+)
+
+class CbtDependency(cbtHasChanged: Boolean, mavenCache: File, nailgunTarget: File, stage1Target: File, stage2Target: File, compatibilityTarget: File)(implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]) extends BinaryDependency(
+  Seq( stage2Target ),
+  Seq(
+    new Stage1Dependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, compatibilityTarget)
   ) ++ 
   MavenResolver(cbtHasChanged, mavenCache,mavenCentral).bind(
     MavenDependency("net.incongru.watchservice","barbary-watchservice","1.0"),
     MavenDependency("org.eclipse.jgit", "org.eclipse.jgit", "4.2.0.201601211800-r")
   )
+){
+  val stage1Dependency = new Stage1Dependency(cbtHasChanged, mavenCache, nailgunTarget, stage1Target, compatibilityTarget)
 }
 
 case class Classifier(name: Option[String])
@@ -185,7 +192,9 @@ abstract class DependenciesProxy{
 }
 class BoundMavenDependencies(
   cbtHasChanged: Boolean, mavenCache: File, urls: Seq[URL], mavenDependencies: Seq[MavenDependency]
-)(implicit logger: Logger) extends Dependencies(
+)(
+  implicit logger: Logger, transientCache: java.util.Map[AnyRef,AnyRef]
+) extends Dependencies(
   mavenDependencies.map( BoundMavenDependency(cbtHasChanged,mavenCache,_,urls) )
 )
 case class MavenDependency(
@@ -201,7 +210,10 @@ object MavenDependency{
 // FIXME: take MavenResolver instead of mavenCache and repositories separately
 case class BoundMavenDependency(
   cbtHasChanged: Boolean, mavenCache: File, mavenDependency: MavenDependency, repositories: Seq[URL]
-)(implicit val logger: Logger) extends ArtifactInfo with DependencyImplementation{
+)(
+  implicit val logger: Logger, val transientCache: java.util.Map[AnyRef,AnyRef]
+) extends ArtifactInfo with DependencyImplementation{
+  def moduleKey = this.getClass.getName ++ "(" ++ mavenDependency.serialize ++ ")"
   val MavenDependency( groupId, artifactId, version, classifier ) = mavenDependency
   assert(
     Option(groupId).collect{
@@ -251,17 +263,11 @@ case class BoundMavenDependency(
       StandardCharsets.UTF_8
     ).mkString("\n").split(" ").head.trim
   }
-  
-  private object jarSha1Cache extends Cache[String]
-  def jarSha1: String = jarSha1Cache{ resolveHash("jar", true) }
-
-  private object pomSha1Cache extends Cache[String]
-  def pomSha1: String = pomSha1Cache{ resolveHash("pom", false) }
-  private object jarCache extends Cache[File]
-  def jar: File = jarCache{ resolve("jar", Some(jarSha1), true) }
 
-  private object pomCache extends Cache[File]
-  def pom: File = pomCache{ resolve("pom", Some(pomSha1), false) }
+  def jarSha1: String = taskCache[BoundMavenDependency]("jarSha1").memoize{ resolveHash("jar", true) }
+  def pomSha1: String = taskCache[BoundMavenDependency]("pomSha1").memoize{ resolveHash("pom", false) }
+  def jar: File = taskCache[BoundMavenDependency]("jar").memoize{ resolve("jar", Some(jarSha1), true) }
+  def pom: File = taskCache[BoundMavenDependency]("pom").memoize{ resolve("pom", Some(pomSha1), false) }
 
   private def pomXml = XML.loadFile(pom.string)
   // ========== pom traversal ==========
@@ -278,7 +284,7 @@ case class BoundMavenDependency(
             (parent \ "version").text
           ),
           repositories
-        )(logger)
+        )
     }.flatMap(_.transitivePom) :+ this
   }