[K/N] Use enforced property PIPELINE_TYPE in CompilerOutputTest to avoid duplicated "-language-version" setting.

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/CompilerOutputTest.kt

@@ -21,11 +21,11 @@ import java.io.File
 
 @TestDataPath("\$PROJECT_ROOT")
 @EnforcedProperty(ClassLevelProperty.COMPILER_OUTPUT_INTERCEPTOR, "NONE")
+@EnforcedProperty(ClassLevelProperty.PIPELINE_TYPE, "DEFAULT")
 class CompilerOutputTest : AbstractNativeSimpleTest() {
 
-    // TODO: unmute after fix of KT-61773
     @Test
-    fun testReleaseCompilerAgainstPreReleaseLibrary() = muteForK2(isK2 = testRunSettings.get<PipelineType>() == PipelineType.K2) {
+    fun testReleaseCompilerAgainstPreReleaseLibrary() = muteForK2(isK2 = true) { // TODO: unmute after fix of KT-61773
         // We intentionally use JS testdata, because the compilers should behave the same way in such a test.
         // To be refactored later, after CompileKotlinAgainstCustomBinariesTest.testReleaseCompilerAgainstPreReleaseLibraryJs is fixed.
         val rootDir = File("compiler/testData/compileKotlinAgainstCustomBinaries/releaseCompilerAgainstPreReleaseLibraryJs")
@@ -74,7 +74,6 @@ class CompilerOutputTest : AbstractNativeSimpleTest() {
     ): TestCompilationResult<out TestCompilationArtifact.KLIB> {
         val testCase = generateTestCaseWithSingleModule(source, TestCompilerArgs(freeCompilerArgs))
         val compilation = LibraryCompilation(
-            pipelineType = null,
             settings = testRunSettings,
             freeCompilerArgs = testCase.freeCompilerArgs,
             sourceModules = testCase.modules,

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/support/ConfigurationProperties.kt

@@ -22,6 +22,7 @@ internal enum class ProcessLevelProperty(shortName: String) {
 
 /*************** Class-level system properties ***************/
 
+@Repeatable
 @Target(AnnotationTarget.CLASS)
 internal annotation class EnforcedProperty(val property: ClassLevelProperty, val propertyValue: String)
 
@@ -33,11 +34,11 @@ internal annotation class AcceptablePropertyValues(val property: ClassLevelPrope
 
 internal class EnforcedProperties(testClass: Class<*>) {
     private val enforcedAnnotations: Map<ClassLevelProperty, String> = buildMap {
-        testClass.annotations.forEach { annotation ->
-            when (annotation) {
-                is EnforcedProperty -> this[annotation.property] = annotation.propertyValue
-                is EnforcedHostTarget -> this[ClassLevelProperty.TEST_TARGET] = HostManager.host.name
-            }
+        testClass.getAnnotationsByType(EnforcedProperty::class.java).forEach {
+            this[it.property] = it.propertyValue
+        }
+        if (testClass.isAnnotationPresent(EnforcedHostTarget::class.java)) {
+            this[ClassLevelProperty.TEST_TARGET] = HostManager.host.name
         }
     }
 
@@ -69,7 +70,7 @@ internal enum class ClassLevelProperty(shortName: String) {
     EXECUTION_TIMEOUT("executionTimeout"),
     SANITIZER("sanitizer"),
     COMPILER_OUTPUT_INTERCEPTOR("compilerOutputInterceptor"),
-
+    PIPELINE_TYPE("pipelineType"),
     ;
 
     internal val propertyName = fullPropertyName(shortName)

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/support/NativeTestSupport.kt

@@ -210,7 +210,7 @@ private object NativeTestSupport {
         output += computeForcedNoopTestRunner(enforcedProperties)
         output += computeTimeouts(enforcedProperties)
         // Parse annotations of current class, since there's no way to put annotations to upper-level enclosing class
-        output += computePipelineType(testClass.get())
+        output += computePipelineType(enforcedProperties, testClass.get())
         output += computeUsedPartialLinkageConfig(enclosingTestClass)
         output += computeCompilerOutputInterceptor(enforcedProperties)
 
@@ -468,10 +468,16 @@ private object NativeTestSupport {
         )
     }
 
-    private fun computePipelineType(testClass: Class<*>): PipelineType {
-        return if (testClass.annotations.any { it is FirPipeline })
+    private fun computePipelineType(enforcedProperties: EnforcedProperties, testClass: Class<*>): PipelineType {
+        val pipelineTypeFromFirPipelineAnnotation = if (testClass.annotations.any { it is FirPipeline })
             PipelineType.K2
         else PipelineType.K1
+
+        return ClassLevelProperty.PIPELINE_TYPE.readValue(
+            enforcedProperties,
+            PipelineType.entries.toTypedArray(),
+            default = pipelineTypeFromFirPipelineAnnotation
+        )
     }
 
     private fun computeUsedPartialLinkageConfig(enclosingTestClass: Class<*>): UsedPartialLinkageConfig {

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/support/TestDirectives.kt

@@ -160,6 +160,7 @@ internal enum class TestRunnerType {
 }
 
 internal enum class MutedOption {
+    DEFAULT,
     K1,
     K2
 }

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/support/compilation/TestCompilation.kt

@@ -139,7 +139,7 @@ internal abstract class SourceBasedCompilation<A : TestCompilationArtifact>(
     private val gcType: GCType,
     private val gcScheduler: GCScheduler,
     private val allocator: Allocator,
-    private val pipelineType: PipelineType?,
+    private val pipelineType: PipelineType,
     freeCompilerArgs: TestCompilerArgs,
     compilerPlugins: CompilerPlugins,
     override val sourceModules: Collection<TestModule>,
@@ -162,7 +162,7 @@ internal abstract class SourceBasedCompilation<A : TestCompilationArtifact>(
         sanitizer.compilerFlag?.let { compilerFlag -> add(compilerFlag) }
         gcType.compilerFlag?.let { compilerFlag -> add(compilerFlag) }
         gcScheduler.compilerFlag?.let { compilerFlag -> add(compilerFlag) }
-        pipelineType?.compilerFlags?.forEach { compilerFlag -> add(compilerFlag) }
+        pipelineType.compilerFlags.forEach { compilerFlag -> add(compilerFlag) }
         applyK2MPPArgs(this)
     }
 
@@ -191,8 +191,7 @@ internal class LibraryCompilation(
     freeCompilerArgs: TestCompilerArgs,
     sourceModules: Collection<TestModule>,
     dependencies: Iterable<TestCompilationDependency<*>>,
-    expectedArtifact: KLIB,
-    pipelineType: PipelineType? = settings.get(),
+    expectedArtifact: KLIB
 ) : SourceBasedCompilation<KLIB>(
     targets = settings.get(),
     home = settings.get(),
@@ -204,7 +203,7 @@ internal class LibraryCompilation(
     gcType = settings.get(),
     gcScheduler = settings.get(),
     allocator = settings.get(),
-    pipelineType = pipelineType,
+    pipelineType = settings.get(),
     freeCompilerArgs = freeCompilerArgs,
     compilerPlugins = settings.get(),
     sourceModules = sourceModules,

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/support/group/ExtTestCaseGroupProvider.kt

@@ -167,6 +167,13 @@ private class ExtTestDataFile(
                     IGNORE_BACKEND_DIRECTIVE_PREFIX,
                     IGNORE_BACKEND_K2_DIRECTIVE_PREFIX
                 )
+            PipelineType.DEFAULT ->
+                isIgnoredTarget(
+                    backend,
+                    testDataFile,
+                    /*includeAny = */true,
+                    IGNORE_BACKEND_DIRECTIVE_PREFIX,
+                )
         }
     }
 

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/support/settings/TestProcessSettings.kt

@@ -274,6 +274,10 @@ internal sealed class CacheMode {
 }
 
 internal enum class PipelineType(val mutedOption: MutedOption, val compilerFlags: List<String>) {
+    DEFAULT(
+        MutedOption.DEFAULT,
+        emptyList()
+    ),
     K1(
         MutedOption.K1,
         listOf("-language-version", "1.9")