Fix compile tests using `checkIterations`

Those tests using `checkIterations` were not working because an
invariant was working: the first iterations number is 0. As we reuse
sbt for running several tests, this is no longer true, so this commit
makes sure that they are updated with the pertinent infrastructure to
compute the performed iterations from the latest known number of
iterations.

sbt/src/sbt-test/source-dependencies/canon/build.sbt

@@ -1,10 +1,26 @@
 import sbt.internal.inc.Analysis
 import complete.DefaultParsers._
 
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis
+    if (previousAnalysis.isEmpty) {
+      streams.value.log.info("No previous analysis detected")
+      0
+    } else {
+      previousAnalysis.get match {
+        case a: Analysis => a.compilations.allCompilations.size
+      }
+    }
+  }
+}
+
 val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
   val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
   assert(expected == actual, s"Expected $expected compilations, got $actual")
 }

sbt/src/sbt-test/source-dependencies/canon/project/CompileState.scala

@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}

sbt/src/sbt-test/source-dependencies/canon/test

@@ -5,6 +5,7 @@
 # This also verifies that compilation does not get repeatedly triggered by a mismatch in
 #  paths.
 
+> recordPreviousIterations
 > compile
 > compile
-> checkIterations 1
+> checkIterations 1

sbt/src/sbt-test/source-dependencies/ext/build.sbt

@@ -1,10 +1,26 @@
 import sbt.internal.inc.Analysis
 import complete.DefaultParsers._
 
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis
+    if (previousAnalysis.isEmpty) {
+      streams.value.log.info("No previous analysis detected")
+      0
+    } else {
+      previousAnalysis.get match {
+        case a: Analysis => a.compilations.allCompilations.size
+      }
+    }
+  }
+}
+
 val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
-	val expected: Int = (Space ~> NatBasic).parsed
-	val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
-	assert(expected == actual, s"Expected $expected compilations, got $actual")
-}
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}

sbt/src/sbt-test/source-dependencies/ext/project/CompileState.scala

@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}

sbt/src/sbt-test/source-dependencies/ext/test

@@ -1,7 +1,8 @@
 # initial compilation
+> recordPreviousIterations
 > checkIterations 1
 
 # no further compilation should be necessary, since nothing changed
 # previously, a dependency on a jar in <java.home>lib/ext/ would
 # always force recompilation
-> checkIterations 1
+> checkIterations 1

sbt/src/sbt-test/source-dependencies/less-inter-inv-java/build.sbt

@@ -1,10 +1,26 @@
 import sbt.internal.inc.Analysis
 import complete.DefaultParsers._
 
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis
+    if (previousAnalysis.isEmpty) {
+      streams.value.log.info("No previous analysis detected")
+      0
+    } else {
+      previousAnalysis.get match {
+        case a: Analysis => a.compilations.allCompilations.size
+      }
+    }
+  }
+}
+
 val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
   val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
   assert(expected == actual, s"Expected $expected compilations, got $actual")
 }

sbt/src/sbt-test/source-dependencies/less-inter-inv-java/project/CompileState.scala

@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}

sbt/src/sbt-test/source-dependencies/less-inter-inv-java/test

@@ -1,4 +1,5 @@
 # 1 iteration from initial full compile
+> recordPreviousIterations
 > run
 $ copy-file changes/A2.java A.java
 

sbt/src/sbt-test/source-dependencies/less-inter-inv/build.sbt

@@ -1,10 +1,26 @@
 import sbt.internal.inc.Analysis
 import complete.DefaultParsers._
 
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis
+    if (previousAnalysis.isEmpty) {
+      streams.value.log.info("No previous analysis detected")
+      0
+    } else {
+      previousAnalysis.get match {
+        case a: Analysis => a.compilations.allCompilations.size
+      }
+    }
+  }
+}
+
 val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
   val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
   assert(expected == actual, s"Expected $expected compilations, got $actual")
 }

sbt/src/sbt-test/source-dependencies/less-inter-inv/project/CompileState.scala

@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}

sbt/src/sbt-test/source-dependencies/less-inter-inv/test

@@ -1,4 +1,5 @@
 # 1 iteration from initial full compile
+> recordPreviousIterations
 > run
 $ copy-file changes/A2.scala A.scala
 

sbt/src/sbt-test/source-dependencies/restore-classes/build.sbt

@@ -3,10 +3,26 @@ import complete.DefaultParsers._
 
 crossTarget in Compile := target.value
 
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis
+    if (previousAnalysis.isEmpty) {
+      streams.value.log.info("No previous analysis detected")
+      0
+    } else {
+      previousAnalysis.get match {
+        case a: Analysis => a.compilations.allCompilations.size
+      }
+    }
+  }
+}
+
 val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
   val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
   assert(expected == actual, s"Expected $expected compilations, got $actual")
 }

sbt/src/sbt-test/source-dependencies/restore-classes/project/CompileState.scala

@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}

sbt/src/sbt-test/source-dependencies/restore-classes/test

@@ -2,6 +2,7 @@ $ copy-file changes/A1.scala A.scala
 $ copy-file changes/B.scala B.scala
 # B depends on A
 # 1 iteration
+> recordPreviousIterations
 > compile
 
 $ copy-file changes/A2.scala A.scala