Class dependencies

build.sbt

@@ -158,7 +158,7 @@ lazy val compilerInterface = (project in internalPath / "compiler-interface").
     // javaOnlySettings,
     name := "Compiler Interface",
     crossScalaVersions := Seq(scala211),
-    libraryDependencies ++= Seq(utilInterface),
+    libraryDependencies ++= Seq(utilInterface, scalaLibrary.value % Test),
     exportJars := true,
     watchSources <++= apiDefinitions,
     resourceGenerators in Compile <+= (version, resourceManaged, streams, compile in Compile) map generateVersionFile,
@@ -203,7 +203,7 @@ lazy val compilerBridge: Project = (project in internalPath / "compiler-bridge")
 // defines operations on the API of a source, including determining whether it has changed and converting it to a string
 //   and discovery of Projclasses and annotations
 lazy val incrementalcompilerApiInfo = (project in internalPath / "incrementalcompiler-apiinfo").
-  dependsOn(compilerInterface, incrementalcompilerClassfile).
+  dependsOn(compilerInterface, incrementalcompilerClassfile % "compile;test->test").
   settings(
     testedBaseSettings,
     name := "Incrementalcompiler ApiInfo"
@@ -222,7 +222,7 @@ lazy val incrementalcompilerClasspath = (project in internalPath / "incrementalc
 
 // class file reader and analyzer
 lazy val incrementalcompilerClassfile = (project in internalPath / "incrementalcompiler-classfile").
-  dependsOn(compilerInterface).
+  dependsOn(compilerInterface % "compile;test->test").
   settings(
     testedBaseSettings,
     libraryDependencies ++= Seq(sbtIO, utilLogging),

incrementalcompiler/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala

@@ -110,14 +110,35 @@ class IncrementalCompilerImpl extends IncrementalCompiler {
     }
   }
 
+  private class LookupImpl(compileConfiguration: CompileConfiguration) extends Lookup {
+    private val entry = MixedAnalyzingCompiler.classPathLookup(compileConfiguration)
+
+    override def lookupOnClasspath(binaryClassName: String): Option[File] =
+      entry(binaryClassName)
+    override def lookupAnalysis(classFile: File): Option[CompileAnalysis] =
+      compileConfiguration.getAnalysis(classFile)
+
+    override def lookupAnalysis(binaryDependency: File, binaryClassName: String): Option[CompileAnalysis] = {
+      lookupOnClasspath(binaryClassName) flatMap { defines =>
+        if (binaryDependency != Locate.resolve(defines, binaryClassName))
+          None
+        else
+          lookupAnalysis(defines)
+      }
+    }
+
+    override def lookupAnalysis(binaryClassName: String): Option[CompileAnalysis] =
+      lookupOnClasspath(binaryClassName).flatMap(lookupAnalysis)
+  }
+
   /** Actually runs the incremental compiler using the given mixed compiler.  This will prune the inputs based on the MiniSetup. */
   private def compileInternal(
     mixedCompiler: MixedAnalyzingCompiler,
     equiv: Equiv[MiniSetup],
     equivPairs: Equiv[Array[T2[String, String]]],
     log: Logger
   ): (Analysis, Boolean) = {
-    val entry = MixedAnalyzingCompiler.classPathLookup(mixedCompiler.config)
+    val lookup = new LookupImpl(mixedCompiler.config)
     import mixedCompiler.config._
     import mixedCompiler.config.currentSetup.output
     val sourcesSet = sources.toSet
@@ -136,7 +157,7 @@ class IncrementalCompilerImpl extends IncrementalCompiler {
       case _ => Incremental.prune(sourcesSet, previousAnalysis)
     }
     // Run the incremental compiler using the mixed compiler we've defined.
-    IncrementalCompile(sourcesSet, entry, mixedCompiler.compile, analysis, getAnalysis, output, log, incOptions).swap
+    IncrementalCompile(sourcesSet, lookup, mixedCompiler.compile, analysis, output, log, incOptions).swap
   }
 
   def setup(analysisMap: F1[File, Maybe[CompileAnalysis]], definesClass: F1[File, DefinesClass], skip: Boolean, cacheFile: File, cache: GlobalsCache,

incrementalcompiler/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala

@@ -5,12 +5,9 @@ package inc
 import java.io.File
 import java.lang.ref.{ SoftReference, Reference }
 
-import sbt.internal.inc.classfile.Analyze
-import sbt.internal.inc.classpath.ClasspathUtilities
 import inc.javac.AnalyzingJavaCompiler
 import Locate.DefinesClass
 import xsbti.{ AnalysisCallback => XAnalysisCallback, Reporter }
-import xsbti.api.Source
 import xsbti.compile.CompileOrder._
 import xsbti.compile._
 import sbt.io.IO
@@ -167,7 +164,6 @@ object MixedAnalyzingCompiler {
     import config._
     import currentSetup._
     val absClasspath = classpath.map(_.getAbsoluteFile)
-    val apiOption = (api: Either[Boolean, Source]) => api.right.toOption
     val cArgs = new CompilerArguments(compiler.scalaInstance, compiler.cp)
     val searchClasspath = explicitBootClasspath(options.scalacOptions) ++ withBootclasspath(cArgs, absClasspath)
     (searchClasspath, Locate.entry(searchClasspath, definesClass))

incrementalcompiler/src/main/scala/sbt/internal/inc/javac/AnalyzingJavaCompiler.scala

@@ -8,7 +8,6 @@ import java.io.File
 import sbt._
 import sbt.internal.inc.classfile.Analyze
 import sbt.internal.inc.classpath.ClasspathUtilities
-import xsbti.api.Source
 import xsbti.compile._
 import xsbti.{ AnalysisCallback, Reporter }
 import sbt.io.PathFinder
@@ -71,10 +70,12 @@ final class AnalyzingJavaCompiler private[sbt] (
       // TODO - Perhaps we just record task 1/2 here
 
       // Reads the API information directly from the Class[_] object. Used when Analyzing dependencies.
-      def readAPI(source: File, classes: Seq[Class[_]]): Set[String] = {
-        val (api, inherits) = ClassToAPI.process(classes)
-        callback.api(source, api)
-        inherits.map(_.getName)
+      def readAPI(source: File, classes: Seq[Class[_]]): Set[(String, String)] = {
+        val (apis, inherits) = ClassToAPI.process(classes)
+        apis.foreach(callback.api(source, _))
+        inherits.map {
+          case (from: Class[_], to: Class[_]) => (from.getName, to.getName)
+        }
       }
       // Runs the analysis portion of Javac.
       timed("Java analysis", log) {

incrementalcompiler/src/sbt-test/source-dependencies/check-classes/A.scala

@@ -0,0 +1 @@
+object A

incrementalcompiler/src/sbt-test/source-dependencies/check-classes/test

@@ -0,0 +1,2 @@
+> compile
+> checkClasses A.scala: A

incrementalcompiler/src/sbt-test/source-dependencies/check-dependencies/test

@@ -1,3 +1,3 @@
 > compile
 
-> checkDependencies A.scala: B.scala C.scala
+> checkDependencies A: B C

incrementalcompiler/src/sbt-test/source-dependencies/check-products/test

@@ -1,2 +1,2 @@
 > compile
-> checkProducts A.scala: A A$
+> checkProducts A.scala: A.class A$.class

incrementalcompiler/src/sbt-test/source-dependencies/check-recompilations/test

@@ -5,6 +5,6 @@ $ copy-file changes/A.scala A.scala
 > compile
 
 > checkRecompilations 0
-> checkRecompilations 1 A.scala
-> checkRecompilations 2 B.scala C.scala
-> checkRecompilations 3 D.scala
+> checkRecompilations 1 A
+> checkRecompilations 2 B C
+> checkRecompilations 3 D

incrementalcompiler/src/sbt-test/source-dependencies/class-based-inheritance/changes/A1.scala

@@ -0,0 +1,5 @@
+class A {
+  class AA
+}
+
+class A2

incrementalcompiler/src/sbt-test/source-dependencies/class-based-inheritance/changes/A2.scala

@@ -0,0 +1,8 @@
+class A {
+  class AA {
+    // add a member to an inner class, dependencies on A shouldn't be recompiled
+    def foo: Int = 123
+  }
+}
+
+class A2

incrementalcompiler/src/sbt-test/source-dependencies/class-based-inheritance/src/main/scala/A.scala

@@ -0,0 +1,5 @@
+class A {
+  // class AA
+}
+
+class A2

incrementalcompiler/src/sbt-test/source-dependencies/class-based-inheritance/src/main/scala/B.scala

@@ -0,0 +1 @@
+class B extends A2

incrementalcompiler/src/sbt-test/source-dependencies/class-based-inheritance/src/main/scala/C.scala

@@ -0,0 +1 @@
+class C extends A

incrementalcompiler/src/sbt-test/source-dependencies/class-based-inheritance/test

@@ -0,0 +1,21 @@
+# Test for class-based invalidation of dependencies
+# by inheritance. The source file A.scala defines
+# A and A2 classes. The B.scala inherits from A2 but
+# in the test api of A is modified. B.scala shouldn't
+# get invalidated if invalidation happens at
+# class level
+# this test case covers https://github.com/sbt/sbt/issues/2320
+
+# introduces first compile iteration
+> compile
+$ copy-file changes/A1.scala src/main/scala/A.scala
+# second iteration and third iteration (due to invalidation of C)
+> compile
+$ copy-file changes/A2.scala src/main/scala/A.scala
+# fourth iteration
+> compile
+# check if there were exactly four compile iterations performed
+> checkRecompilations 0 B
+> checkRecompilations 1
+> checkRecompilations 2 C
+> checkRecompilations 3 A A2 A.AA

incrementalcompiler/src/sbt-test/source-dependencies/class-based-memberRef/changes/A1.scala

@@ -0,0 +1,7 @@
+class A1 {
+  //def foo: Int = 123
+}
+
+class A2 {
+  def bar: Int = 42
+}

incrementalcompiler/src/sbt-test/source-dependencies/class-based-memberRef/incOptions.properties

@@ -0,0 +1 @@
+recompileAllFraction = 1.0

incrementalcompiler/src/sbt-test/source-dependencies/class-based-memberRef/src/main/scala/A.scala

@@ -0,0 +1,7 @@
+class A1 {
+  def foo: Int = 123
+}
+
+class A2 {
+  def bar: Int = 42
+}

incrementalcompiler/src/sbt-test/source-dependencies/class-based-memberRef/src/main/scala/B.scala

@@ -0,0 +1,6 @@
+class B1(a1: A1)
+
+class B2(a2: A2) {
+  def foo: Int = 53
+  def abc: Int = foo + a2.bar
+}

incrementalcompiler/src/sbt-test/source-dependencies/class-based-memberRef/test

@@ -0,0 +1,11 @@
+# Test for class-based invalidation of dependencies by member reference
+# This test checks if name hashes are tracked at the class level so
+# only classes that depend on an API of a modified class are invalidated
+
+# introduces first compile iteration
+> compile
+$ copy-file changes/A1.scala src/main/scala/A.scala
+# second iteration
+> compile
+> checkRecompilations 0 B1 B2
+> checkRecompilations 1 A1 A2

incrementalcompiler/src/sbt-test/source-dependencies/external-src-dependency/build.sbt

@@ -0,0 +1,14 @@
+lazy val commonSettings = Seq(
+  logLevel := Level.Debug
+)
+lazy val provider = project.settings(commonSettings)
+lazy val use = project.settings(commonSettings).dependsOn(provider)
+
+InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) =>
+  (argTask, compile in Compile in use) map { (args: Seq[String], a: sbt.inc.Analysis) =>
+    assert(args.size == 1)
+    val expectedIterationsNumber = args(0).toInt
+    assert(a.compilations.allCompilations.size == expectedIterationsNumber, 
+      "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))
+  }
+}

incrementalcompiler/src/sbt-test/source-dependencies/external-src-dependency/changes/A1.scala

@@ -0,0 +1,4 @@
+// add a comment to trigger a recompilation of A.scala, this should not trigger a recompilation of B.scala
+class A {
+  class Inner
+}

incrementalcompiler/src/sbt-test/source-dependencies/external-src-dependency/changes/A2.scala

@@ -0,0 +1,5 @@
+class A {
+  class Inner {
+    def foo: Int = 187
+  }
+}

incrementalcompiler/src/sbt-test/source-dependencies/external-src-dependency/pending

@@ -0,0 +1,9 @@
+> compile
+
+$ copy-file changes/A1.scala provider/A.scala
+> compile
+> check-number-of-compiler-iterations 1
+
+$ copy-file changes/A2.scala provider/A.scala
+> compile
+> check-number-of-compiler-iterations 1

incrementalcompiler/src/sbt-test/source-dependencies/external-src-dependency/provider/A.scala

@@ -0,0 +1,3 @@
+class A {
+  class Inner
+}

incrementalcompiler/src/sbt-test/source-dependencies/external-src-dependency/use/B.scala

@@ -0,0 +1,4 @@
+class B extends A {
+  // introduce dependency on Inner
+  def inner: Inner = null
+}

incrementalcompiler/src/sbt-test/source-dependencies/import-class/B.scala

@@ -1 +1,3 @@
 import a.A
+
+class B