[BTA tests] Allow passing strategy config once to Project instance

^KT-61860 In Progress

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/model/AbstractModule.kt

@@ -43,6 +43,7 @@ abstract class AbstractModule(
     final override val moduleName: String,
     val moduleDirectory: Path,
     val dependencies: List<Dependency>,
+    override val defaultStrategyConfig: CompilerExecutionStrategyConfiguration,
     final override val additionalCompilationArguments: List<String> = emptyList(),
 ) : Module {
     override val sourcesDirectory: Path

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/model/JvmModule.kt

@@ -23,12 +23,14 @@ class JvmModule(
     moduleName: String,
     moduleDirectory: Path,
     dependencies: List<Dependency>,
+    defaultStrategyConfig: CompilerExecutionStrategyConfiguration,
     additionalCompilationArguments: List<String> = emptyList(),
 ) : AbstractModule(
     project,
     moduleName,
     moduleDirectory,
     dependencies,
+    defaultStrategyConfig,
     additionalCompilationArguments,
 ) {
     override fun compileImpl(
@@ -75,8 +77,8 @@ class JvmModule(
     }
 
     override fun compileIncrementally(
-        strategyConfig: CompilerExecutionStrategyConfiguration,
         sourcesChanges: SourcesChanges,
+        strategyConfig: CompilerExecutionStrategyConfiguration,
         forceOutput: LogLevel?,
         forceNonIncrementalCompilation: Boolean,
         compilationConfigAction: (JvmCompilationConfiguration) -> Unit,

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/model/Module.kt

@@ -46,16 +46,18 @@ interface Module : Dependency {
      */
     val icCachesDir: Path
 
+    val defaultStrategyConfig: CompilerExecutionStrategyConfiguration
+
     fun compile(
-        strategyConfig: CompilerExecutionStrategyConfiguration,
+        strategyConfig: CompilerExecutionStrategyConfiguration = defaultStrategyConfig,
         forceOutput: LogLevel? = null,
         compilationConfigAction: (JvmCompilationConfiguration) -> Unit = {},
         assertions: context(Module) CompilationOutcome.() -> Unit = {},
     ): CompilationResult
 
     fun compileIncrementally(
-        strategyConfig: CompilerExecutionStrategyConfiguration,
         sourcesChanges: SourcesChanges,
+        strategyConfig: CompilerExecutionStrategyConfiguration = defaultStrategyConfig,
         forceOutput: LogLevel? = null,
         forceNonIncrementalCompilation: Boolean = false,
         compilationConfigAction: (JvmCompilationConfiguration) -> Unit = {},

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/model/Project.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.buildtools.api.tests.compilation.model
 
+import org.jetbrains.kotlin.buildtools.api.CompilerExecutionStrategyConfiguration
 import org.jetbrains.kotlin.buildtools.api.ProjectId
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -14,6 +15,7 @@ import kotlin.io.path.createDirectories
 import kotlin.io.path.isDirectory
 
 class Project(
+    val defaultStrategyConfig: CompilerExecutionStrategyConfiguration,
     val projectDirectory: Path,
 ) {
     val projectId = ProjectId.ProjectUUID(UUID.randomUUID())
@@ -24,7 +26,7 @@ class Project(
         additionalCompilationArguments: List<String> = emptyList(),
     ): Module {
         val moduleDirectory = projectDirectory.resolve(moduleName)
-        val module = JvmModule(this, moduleName, moduleDirectory, dependencies, additionalCompilationArguments)
+        val module = JvmModule(this, moduleName, moduleDirectory, dependencies, defaultStrategyConfig, additionalCompilationArguments)
         module.sourcesDirectory.createDirectories()
         val templatePath = Paths.get("src/main/resources/modules/$moduleName")
         assert(templatePath.isDirectory()) {
@@ -39,8 +41,8 @@ class Project(
     }
 }
 
-fun BaseCompilationTest.project(action: Project.() -> Unit) {
-    Project(workingDirectory).apply {
+fun BaseCompilationTest.project(strategyConfig: CompilerExecutionStrategyConfiguration, action: Project.() -> Unit) {
+    Project(strategyConfig, workingDirectory).apply {
         action()
         endCompilationRound()
     }

compiler/build-tools/kotlin-build-tools-api-tests/src/main/kotlin/compilation/scenario/scenarioDsl.kt

@@ -66,8 +66,8 @@ private class ScenarioModuleImpl(
         assertions: context(Module) CompilationOutcome.() -> Unit,
     ) {
         module.compileIncrementally(
-            strategyConfig,
             sourcesChanges,
+            strategyConfig,
             forceOutput,
             compilationConfigAction = { compilationOptionsModifier?.invoke(it) },
             incrementalCompilationConfigAction = { incrementalCompilationOptionsModifier?.invoke(it) },
@@ -91,14 +91,15 @@ private class ScenarioDsl(
         incrementalCompilationOptionsModifier: ((IncrementalJvmCompilationConfiguration<*>) -> Unit)?,
     ): ScenarioModule {
         val transformedDependencies = dependencies.map { (it as ScenarioModuleImpl).module }
-        val module = project.module(moduleName, transformedDependencies, additionalCompilationArguments)
+        val module =
+            project.module(moduleName, transformedDependencies, additionalCompilationArguments)
         return GlobalCompiledProjectsCache.getProjectFromCache(module, strategyConfig, compilationOptionsModifier, incrementalCompilationOptionsModifier)
             ?: GlobalCompiledProjectsCache.putProjectIntoCache(module, strategyConfig, compilationOptionsModifier, incrementalCompilationOptionsModifier)
     }
 }
 
 fun BaseCompilationTest.scenario(strategyConfig: CompilerExecutionStrategyConfiguration, action: Scenario.() -> Unit) {
-    action(ScenarioDsl(Project(workingDirectory), strategyConfig))
+    action(ScenarioDsl(Project(strategyConfig, workingDirectory), strategyConfig))
 }
 
 private data class GlobalCompiledProjectsCacheKey(
@@ -135,8 +136,8 @@ private object GlobalCompiledProjectsCache {
         incrementalCompilationOptionsModifier: ((IncrementalJvmCompilationConfiguration<*>) -> Unit)?,
     ): ScenarioModuleImpl {
         module.compileIncrementally(
-            strategyConfig,
             SourcesChanges.Unknown,
+            strategyConfig,
             compilationConfigAction = { compilationOptionsModifier?.invoke(it) },
             incrementalCompilationConfigAction = { incrementalCompilationOptionsModifier?.invoke(it) }
         )

compiler/build-tools/kotlin-build-tools-api-tests/src/testCompatibility/kotlin/ExampleCompatibilityCompilationTest.kt

@@ -20,14 +20,14 @@ class ExampleCompatibilityCompilationTest : BaseCompilationTest() {
     @DisplayName("Sample compatibility compilation test that is run as part of each test suit")
     @TestMetadata("jvm-module-1")
     fun testCompatibilityCompilation(strategyConfig: CompilerExecutionStrategyConfiguration) {
-        project {
+        project(strategyConfig) {
             val module1 = module("jvm-module-1")
             val module2 = module("jvm-module-2", listOf(module1))
 
-            module1.compile(strategyConfig) {
+            module1.compile {
                 assertOutputs("FooKt.class", "Bar.class", "BazKt.class")
             }
-            module2.compile(strategyConfig) {
+            module2.compile {
                 assertOutputs("AKt.class", "BKt.class")
             }
         }

compiler/build-tools/kotlin-build-tools-api-tests/src/testExample/kotlin/ExampleIncrementalCompilationTest.kt

@@ -23,16 +23,15 @@ class ExampleIncrementalCompilationTest : BaseCompilationTest() {
     @DefaultStrategyAgnosticCompilationTest
     @TestMetadata("jvm-module-1")
     fun testSingleModule(strategyConfig: CompilerExecutionStrategyConfiguration) {
-        project {
+        project(strategyConfig) {
             val module1 = module("jvm-module-1")
 
-            module1.compileIncrementally(strategyConfig, SourcesChanges.Unknown)
+            module1.compileIncrementally(SourcesChanges.Unknown)
 
             val fooKt = module1.sourcesDirectory.resolve("foo.kt")
             fooKt.writeText(fooKt.readText().replace("foo()", "foo(i: Int = 1)"))
 
             module1.compileIncrementally(
-                strategyConfig,
                 SourcesChanges.Known(modifiedFiles = listOf(fooKt.toFile()), removedFiles = emptyList()),
             ) {
                 assertCompiledSources("foo.kt", "bar.kt")
@@ -45,18 +44,17 @@ class ExampleIncrementalCompilationTest : BaseCompilationTest() {
     @DefaultStrategyAgnosticCompilationTest
     @TestMetadata("jvm-module-1")
     fun testTwoModules(strategyConfig: CompilerExecutionStrategyConfiguration) {
-        project {
+        project(strategyConfig) {
             val module1 = module("jvm-module-1")
             val module2 = module("jvm-module-2", listOf(module1))
 
-            module1.compileIncrementally(strategyConfig, SourcesChanges.Unknown)
-            module2.compileIncrementally(strategyConfig, SourcesChanges.Unknown)
+            module1.compileIncrementally(SourcesChanges.Unknown)
+            module2.compileIncrementally(SourcesChanges.Unknown)
 
             val barKt = module1.sourcesDirectory.resolve("bar.kt")
             barKt.writeText(barKt.readText().replace("bar()", "bar(i: Int = 1)"))
 
             module1.compileIncrementally(
-                strategyConfig,
                 SourcesChanges.Known(modifiedFiles = listOf(barKt.toFile()), removedFiles = emptyList()),
                 incrementalCompilationConfigAction = {
                     it.keepIncrementalCompilationCachesInMemory(false)
@@ -64,7 +62,6 @@ class ExampleIncrementalCompilationTest : BaseCompilationTest() {
             )
 
             module2.compileIncrementally(
-                strategyConfig,
                 SourcesChanges.Known(modifiedFiles = emptyList(), removedFiles = emptyList())
             ) {
                 assertCompiledSources("b.kt")

compiler/build-tools/kotlin-build-tools-api-tests/src/testExample/kotlin/ExampleNonIncrementalCompilationTest.kt

@@ -19,14 +19,14 @@ class ExampleNonIncrementalCompilationTest : BaseCompilationTest() {
     @DisplayName("Sample non-incremental compilation test with two modules")
     @DefaultStrategyAgnosticCompilationTest
     fun myTest(strategyConfig: CompilerExecutionStrategyConfiguration) {
-        project {
+        project(strategyConfig) {
             val module1 = module("jvm-module-1")
             val module2 = module("jvm-module-2", listOf(module1))
 
-            module1.compile(strategyConfig) {
+            module1.compile {
                 assertOutputs("FooKt.class", "Bar.class", "BazKt.class")
             }
-            module2.compile(strategyConfig) {
+            module2.compile {
                 assertOutputs("AKt.class", "BKt.class")
             }
         }
@@ -35,12 +35,12 @@ class ExampleNonIncrementalCompilationTest : BaseCompilationTest() {
     @DisplayName("Sample non-incremental compilation test with a single module and a compilation error")
     @DefaultStrategyAgnosticCompilationTest
     fun failedCompilationTest(strategyConfig: CompilerExecutionStrategyConfiguration) {
-        project {
+        project(strategyConfig) {
             val module1 = module("jvm-module-1")
 
             module1.sourcesDirectory.resolve("bar.kt").writeText("aaaa")
 
-            module1.compile(strategyConfig) {
+            module1.compile {
                 expectFail()
                 assertLogContainsPatterns(LogLevel.ERROR, ".*bar\\.kt:1:1 Syntax error: Expecting a top level declaration.*".toRegex())
             }