diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt index 855a928739c..8c2fb54095c 100644 --- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt +++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt @@ -294,7 +294,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager val kind = KotlinBaseTest.extractConfigurationKind(testFiles) val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles) val keyConfiguration = CompilerConfiguration() - CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration) + KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration) val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString()) val compiler = if (isJvm8Target) { @@ -303,7 +303,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager val filesHolder = holders.getOrPut(key) { FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply { println("Creating new configuration by $key") - CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, this) + KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this) }) } diff --git a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt index b7c1280e729..73298229bcd 100644 --- a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt +++ b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt @@ -24,7 +24,7 @@ abstract class AbstractCompileKotlinAgainstKlibTest : AbstractBlackBoxCodegenTes lateinit var klibName: String lateinit var outputDir: File - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR override fun doMultiFileTest(wholeFile: File, files: List) { outputDir = javaSourcesOutputDirectory @@ -56,6 +56,7 @@ abstract class AbstractCompileKotlinAgainstKlibTest : AbstractBlackBoxCodegenTes } override fun updateConfiguration(configuration: CompilerConfiguration) { + super.updateConfiguration(configuration) configuration.put(JVMConfigurationKeys.KLIB_PATHS, listOf(klibName + ".klib")) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTest.kt index 57f367d07ff..139f74af206 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTest.kt @@ -21,8 +21,8 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys abstract class AbstractForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTest : AbstractForeignAnnotationsNoAnnotationInClasspathTest() { - override fun performCustomConfiguration(configuration: CompilerConfiguration) { - super.performCustomConfiguration(configuration) + override fun updateConfiguration(configuration: CompilerConfiguration) { + super.updateConfiguration(configuration) configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true) } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt index 86dd3fe901e..e96056679ab 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt @@ -44,11 +44,12 @@ abstract class KotlinMultiFileTestWithJava ): KotlinCoreEnvironment { - val configuration = KotlinTestUtils.newConfiguration( + val configuration = createConfiguration( extractConfigurationKind(files), getTestJdkKind(files), getClasspath(file), - if (isJavaSourceRootNeeded()) listOf(javaFilesDir) else emptyList() + if (isJavaSourceRootNeeded()) listOf(javaFilesDir) else emptyList(), + files ) if (isScriptingNeeded(file)) { loadScriptingPlugin(configuration) @@ -61,16 +62,12 @@ abstract class KotlinMultiFileTestWithJava testFiles) {} - - @NotNull - protected CompilerConfiguration createConfiguration( - @NotNull ConfigurationKind kind, - @NotNull TestJdkKind jdkKind, - @NotNull List classpath, - @NotNull List javaSource, - @NotNull List testFilesWithConfigurationDirectives - ) { - CompilerConfiguration configuration = KotlinTestUtils.newConfiguration(kind, jdkKind, classpath, javaSource); - configuration.put(JVMConfigurationKeys.IR, getBackend().isIR()); - - updateConfigurationByDirectivesInTestFiles(testFilesWithConfigurationDirectives, configuration, coroutinesPackage, parseDirectivesPerFiles()); - updateConfiguration(configuration); - setCustomDefaultJvmTarget(configuration); - - configureTestSpecific(configuration, testFilesWithConfigurationDirectives); - - return configuration; - } - - public static void updateConfigurationByDirectivesInTestFiles( - @NotNull List testFilesWithConfigurationDirectives, - @NotNull CompilerConfiguration configuration - ) { - updateConfigurationByDirectivesInTestFiles(testFilesWithConfigurationDirectives, configuration, "", false); - } - - private static void updateConfigurationByDirectivesInTestFiles( - @NotNull List testFilesWithConfigurationDirectives, - @NotNull CompilerConfiguration configuration, - @NotNull String coroutinesPackage, - boolean usePreparsedDirectives - ) { - LanguageVersionSettings explicitLanguageVersionSettings = null; - boolean disableReleaseCoroutines = false; - boolean includeCompatExperimentalCoroutines = false; - - List kotlinConfigurationFlags = new ArrayList<>(0); - for (TestFile testFile : testFilesWithConfigurationDirectives) { - String content = testFile.content; - Directives directives = usePreparsedDirectives ? testFile.directives : KotlinTestUtils.parseDirectives(content); - List flags = directives.listValues("KOTLIN_CONFIGURATION_FLAGS"); - if (flags != null) { - kotlinConfigurationFlags.addAll(flags); - } - - String targetString = directives.get("JVM_TARGET"); - if (targetString != null) { - JvmTarget jvmTarget = JvmTarget.Companion.fromString(targetString); - assert jvmTarget != null : "Unknown target: " + targetString; - configuration.put(JVMConfigurationKeys.JVM_TARGET, jvmTarget); - } - - String version = directives.get("LANGUAGE_VERSION"); - if (version != null) { - throw new AssertionError( - "Do not use LANGUAGE_VERSION directive in compiler tests because it's prone to limiting the test\n" + - "to a specific language version, which will become obsolete at some point and the test won't check\n" + - "things like feature intersection with newer releases. Use `// !LANGUAGE: [+-]FeatureName` directive instead,\n" + - "where FeatureName is an entry of the enum `LanguageFeature`\n" - ); - } - - if (directives.contains("COMMON_COROUTINES_TEST")) { - assert !directives.contains("COROUTINES_PACKAGE") : "Must replace COROUTINES_PACKAGE prior to tests compilation"; - if (DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString().equals(coroutinesPackage)) { - disableReleaseCoroutines = true; - includeCompatExperimentalCoroutines = true; - } - } - - if (content.contains(DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString())) { - includeCompatExperimentalCoroutines = true; - } - - LanguageVersionSettings fileLanguageVersionSettings = parseLanguageVersionSettings(directives); - if (fileLanguageVersionSettings != null) { - assert explicitLanguageVersionSettings == null : "Should not specify !LANGUAGE directive twice"; - explicitLanguageVersionSettings = fileLanguageVersionSettings; - } - } - - if (disableReleaseCoroutines) { - explicitLanguageVersionSettings = new CompilerTestLanguageVersionSettings( - Collections.singletonMap(LanguageFeature.ReleaseCoroutines, LanguageFeature.State.DISABLED), - ApiVersion.LATEST_STABLE, - LanguageVersion.LATEST_STABLE, - Collections.emptyMap() - ); - } - if (includeCompatExperimentalCoroutines) { - JvmContentRootsKt.addJvmClasspathRoot(configuration, ForTestCompileRuntime.coroutinesCompatForTests()); - } - - if (explicitLanguageVersionSettings != null) { - CommonConfigurationKeysKt.setLanguageVersionSettings(configuration, explicitLanguageVersionSettings); - } - - updateConfigurationWithFlags(configuration, kotlinConfigurationFlags); - } - - private static final Map> FLAG_NAMESPACE_TO_CLASS = ImmutableMap.of( - "CLI", CLIConfigurationKeys.class, - "JVM", JVMConfigurationKeys.class - ); - - private static final List> FLAG_CLASSES = ImmutableList.of(CLIConfigurationKeys.class, JVMConfigurationKeys.class); - - private static final Pattern BOOLEAN_FLAG_PATTERN = Pattern.compile("([+-])(([a-zA-Z_0-9]*)\\.)?([a-zA-Z_0-9]*)"); - private static final Pattern CONSTRUCTOR_CALL_NORMALIZATION_MODE_FLAG_PATTERN = Pattern.compile( - "CONSTRUCTOR_CALL_NORMALIZATION_MODE=([a-zA-Z_\\-0-9]*)"); - private static final Pattern ASSERTIONS_MODE_FLAG_PATTERN = Pattern.compile("ASSERTIONS_MODE=([a-zA-Z_0-9-]*)"); - - private static void updateConfigurationWithFlags(@NotNull CompilerConfiguration configuration, @NotNull List flags) { - for (String flag : flags) { - Matcher m = BOOLEAN_FLAG_PATTERN.matcher(flag); - if (m.matches()) { - boolean flagEnabled = !"-".equals(m.group(1)); - String flagNamespace = m.group(3); - String flagName = m.group(4); - - tryApplyBooleanFlag(configuration, flag, flagEnabled, flagNamespace, flagName); - continue; - } - - m = CONSTRUCTOR_CALL_NORMALIZATION_MODE_FLAG_PATTERN.matcher(flag); - if (m.matches()) { - String flagValueString = m.group(1); - JVMConstructorCallNormalizationMode mode = JVMConstructorCallNormalizationMode.fromStringOrNull(flagValueString); - assert mode != null : "Wrong CONSTRUCTOR_CALL_NORMALIZATION_MODE value: " + flagValueString; - configuration.put(JVMConfigurationKeys.CONSTRUCTOR_CALL_NORMALIZATION_MODE, mode); - } - - m = ASSERTIONS_MODE_FLAG_PATTERN.matcher(flag); - if (m.matches()) { - String flagValueString = m.group(1); - JVMAssertionsMode mode = JVMAssertionsMode.fromStringOrNull(flagValueString); - assert mode != null : "Wrong ASSERTIONS_MODE value: " + flagValueString; - configuration.put(JVMConfigurationKeys.ASSERTIONS_MODE, mode); - } - } - } - - private static void tryApplyBooleanFlag( - @NotNull CompilerConfiguration configuration, - @NotNull String flag, - boolean flagEnabled, - @Nullable String flagNamespace, - @NotNull String flagName - ) { - Class configurationKeysClass; - Field configurationKeyField = null; - if (flagNamespace == null) { - for (Class flagClass : FLAG_CLASSES) { - try { - configurationKeyField = flagClass.getField(flagName); - break; - } - catch (Exception ignored) { - } - } - } - else { - configurationKeysClass = FLAG_NAMESPACE_TO_CLASS.get(flagNamespace); - assert configurationKeysClass != null : "Expected [+|-][namespace.]configurationKey, got: " + flag; - try { - configurationKeyField = configurationKeysClass.getField(flagName); - } - catch (Exception e) { - configurationKeyField = null; - } - } - assert configurationKeyField != null : "Expected [+|-][namespace.]configurationKey, got: " + flag; - - try { - @SuppressWarnings("unchecked") - CompilerConfigurationKey configurationKey = (CompilerConfigurationKey) configurationKeyField.get(null); - configuration.put(configurationKey, flagEnabled); - } - catch (Exception e) { - assert false : "Expected [+|-][namespace.]configurationKey, got: " + flag; - } - } - @Override protected void tearDown() throws Exception { myFiles = null; @@ -638,19 +445,16 @@ public abstract class CodegenTestCase extends KotlinBaseTest : KtUsefulTestCase() { @@ -58,6 +72,35 @@ abstract class KotlinBaseTest : KtUsefulTestCase() return Companion.extractConfigurationKind(files) } + protected open fun updateConfiguration(configuration: CompilerConfiguration) {} + + protected open fun setupEnvironment(environment: KotlinCoreEnvironment) {} + + protected open fun parseDirectivesPerFiles() = false + + protected open val backend = TargetBackend.ANY + + protected open fun configureTestSpecific(configuration: CompilerConfiguration, testFiles: List) {} + + protected open fun createConfiguration( + kind: ConfigurationKind, + jdkKind: TestJdkKind, + classpath: List, + javaSource: List, + testFilesWithConfigurationDirectives: List + ): CompilerConfiguration { + val configuration = KotlinTestUtils.newConfiguration(kind, jdkKind, classpath, javaSource) + configuration.put(JVMConfigurationKeys.IR, backend.isIR) + updateConfigurationByDirectivesInTestFiles( + testFilesWithConfigurationDirectives, + configuration, + coroutinesPackage, + parseDirectivesPerFiles() + ) + updateConfiguration(configuration) + configureTestSpecific(configuration, testFilesWithConfigurationDirectives) + return configuration + } open class TestFile @JvmOverloads constructor( @JvmField val name: String, @@ -97,6 +140,161 @@ abstract class KotlinBaseTest : KtUsefulTestCase() } companion object { + + private val FLAG_NAMESPACE_TO_CLASS: Map> = ImmutableMap.of( + "CLI", CLIConfigurationKeys::class.java, + "JVM", JVMConfigurationKeys::class.java + ) + + private val FLAG_CLASSES: List> = ImmutableList.of( + CLIConfigurationKeys::class.java, + JVMConfigurationKeys::class.java + ) + + private val BOOLEAN_FLAG_PATTERN = Pattern.compile("([+-])(([a-zA-Z_0-9]*)\\.)?([a-zA-Z_0-9]*)") + private val CONSTRUCTOR_CALL_NORMALIZATION_MODE_FLAG_PATTERN = Pattern.compile( + "CONSTRUCTOR_CALL_NORMALIZATION_MODE=([a-zA-Z_\\-0-9]*)" + ) + private val ASSERTIONS_MODE_FLAG_PATTERN = Pattern.compile("ASSERTIONS_MODE=([a-zA-Z_0-9-]*)") + + private fun tryApplyBooleanFlag( + configuration: CompilerConfiguration, + flag: String, + flagEnabled: Boolean, + flagNamespace: String?, + flagName: String + ) { + val configurationKeysClass: Class<*>? + var configurationKeyField: Field? = null + if (flagNamespace == null) { + for (flagClass in FLAG_CLASSES) { + try { + configurationKeyField = flagClass.getField(flagName) + break + } catch (ignored: java.lang.Exception) { + } + } + } else { + configurationKeysClass = FLAG_NAMESPACE_TO_CLASS[flagNamespace] + assert(configurationKeysClass != null) { "Expected [+|-][namespace.]configurationKey, got: $flag" } + configurationKeyField = try { + configurationKeysClass!!.getField(flagName) + } catch (e: java.lang.Exception) { + null + } + } + assert(configurationKeyField != null) { "Expected [+|-][namespace.]configurationKey, got: $flag" } + try { + val configurationKey = configurationKeyField!![null] as CompilerConfigurationKey + configuration.put(configurationKey, flagEnabled) + } catch (e: java.lang.Exception) { + assert(false) { "Expected [+|-][namespace.]configurationKey, got: $flag" } + } + } + + @JvmStatic + fun updateConfigurationByDirectivesInTestFiles1( + testFilesWithConfigurationDirectives: List, + configuration: CompilerConfiguration + ) { + updateConfigurationByDirectivesInTestFiles(testFilesWithConfigurationDirectives, configuration, "", false) + } + + + private fun updateConfigurationByDirectivesInTestFiles( + testFilesWithConfigurationDirectives: List, + configuration: CompilerConfiguration, + coroutinesPackage: String, + usePreparsedDirectives: Boolean + ) { + var explicitLanguageVersionSettings: LanguageVersionSettings? = null + var disableReleaseCoroutines = false + var includeCompatExperimentalCoroutines = false + val kotlinConfigurationFlags: MutableList = ArrayList(0) + for (testFile in testFilesWithConfigurationDirectives) { + val content = testFile.content + val directives = if (usePreparsedDirectives) testFile.directives else KotlinTestUtils.parseDirectives(content) + val flags = directives.listValues("KOTLIN_CONFIGURATION_FLAGS") + if (flags != null) { + kotlinConfigurationFlags.addAll(flags) + } + val targetString = directives["JVM_TARGET"] + if (targetString != null) { + val jvmTarget = fromString(targetString) + ?: error("Unknown target: $targetString") + configuration.put(JVMConfigurationKeys.JVM_TARGET, jvmTarget) + } + val version = directives["LANGUAGE_VERSION"] + if (version != null) { + throw AssertionError( + """ + Do not use LANGUAGE_VERSION directive in compiler tests because it's prone to limiting the test + to a specific language version, which will become obsolete at some point and the test won't check + things like feature intersection with newer releases. Use `// !LANGUAGE: [+-]FeatureName` directive instead, + where FeatureName is an entry of the enum `LanguageFeature` + + """.trimIndent() + ) + } + if (directives.contains("COMMON_COROUTINES_TEST")) { + assert(!directives.contains("COROUTINES_PACKAGE")) { "Must replace COROUTINES_PACKAGE prior to tests compilation" } + if (DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString() == coroutinesPackage) { + disableReleaseCoroutines = true + includeCompatExperimentalCoroutines = true + } + } + if (content.contains(DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.asString())) { + includeCompatExperimentalCoroutines = true + } + val fileLanguageVersionSettings: LanguageVersionSettings? = parseLanguageVersionSettings(directives) + if (fileLanguageVersionSettings != null) { + assert(explicitLanguageVersionSettings == null) { "Should not specify !LANGUAGE directive twice" } + explicitLanguageVersionSettings = fileLanguageVersionSettings + } + } + if (disableReleaseCoroutines) { + explicitLanguageVersionSettings = CompilerTestLanguageVersionSettings( + Collections.singletonMap(LanguageFeature.ReleaseCoroutines, LanguageFeature.State.DISABLED), + ApiVersion.LATEST_STABLE, + LanguageVersion.LATEST_STABLE, emptyMap() + ) + } + if (includeCompatExperimentalCoroutines) { + configuration.addJvmClasspathRoot(ForTestCompileRuntime.coroutinesCompatForTests()) + } + if (explicitLanguageVersionSettings != null) { + configuration.languageVersionSettings = explicitLanguageVersionSettings + } + updateConfigurationWithFlags(configuration, kotlinConfigurationFlags) + } + + private fun updateConfigurationWithFlags(configuration: CompilerConfiguration, flags: List) { + for (flag in flags) { + var m = BOOLEAN_FLAG_PATTERN.matcher(flag) + if (m.matches()) { + val flagEnabled = "-" != m.group(1) + val flagNamespace = m.group(3) + val flagName = m.group(4) + tryApplyBooleanFlag(configuration, flag, flagEnabled, flagNamespace, flagName) + continue + } + m = CONSTRUCTOR_CALL_NORMALIZATION_MODE_FLAG_PATTERN.matcher(flag) + if (m.matches()) { + val flagValueString = m.group(1) + val mode = JVMConstructorCallNormalizationMode.fromStringOrNull(flagValueString) + ?: error("Wrong CONSTRUCTOR_CALL_NORMALIZATION_MODE value: $flagValueString") + configuration.put(JVMConfigurationKeys.CONSTRUCTOR_CALL_NORMALIZATION_MODE, mode) + } + m = ASSERTIONS_MODE_FLAG_PATTERN.matcher(flag) + if (m.matches()) { + val flagValueString = m.group(1) + val mode = JVMAssertionsMode.fromStringOrNull(flagValueString) + ?: error("Wrong ASSERTIONS_MODE value: $flagValueString") + configuration.put(JVMConfigurationKeys.ASSERTIONS_MODE, mode) + } + } + } + fun extractConfigurationKind(files: List): ConfigurationKind { var addRuntime = false var addReflect = false diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt index 1d538318f78..165e3bea231 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCustomScriptCodegenTest.kt @@ -37,6 +37,7 @@ abstract class AbstractCustomScriptCodegenTest : CodegenTestCase() { } override fun updateConfiguration(configuration: CompilerConfiguration) { + super.updateConfiguration(configuration) if (scriptDefinitions.isNotEmpty()) { configureScriptDefinitions( scriptDefinitions, configuration, this::class.java.classLoader, MessageCollector.NONE, defaultJvmScriptingHostConfiguration diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrGenerateNotNullAssertionsTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrGenerateNotNullAssertionsTest.java index 5005f9e0ad3..6476913d41a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrGenerateNotNullAssertionsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrGenerateNotNullAssertionsTest.java @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.codegen.ir; +import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.codegen.AbstractGenerateNotNullAssertionsTest; import org.jetbrains.kotlin.test.TargetBackend; @@ -13,6 +14,7 @@ public class IrGenerateNotNullAssertionsTest extends AbstractGenerateNotNullAsse doTestNoAssertionsForKotlinFromBinary("noAssertionsForKotlin.kt", "noAssertionsForKotlinMain.kt"); } + @NotNull @Override protected TargetBackend getBackend() { return TargetBackend.JVM_IR; diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBoxTest.kt b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBoxTest.kt index 3e19858f4f1..6a6868cb4cd 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBoxTest.kt +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBoxTest.kt @@ -8,5 +8,5 @@ package org.jetbrains.kotlin.android.parcel import org.jetbrains.kotlin.test.TargetBackend abstract class AbstractParcelIrBoxTest : AbstractParcelBoxTest() { - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR } diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBytecodeListingTest.kt b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBytecodeListingTest.kt index 5c42e326da5..bf8479d2a96 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBytecodeListingTest.kt +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/AbstractParcelIrBytecodeListingTest.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.test.TargetBackend import java.io.File abstract class AbstractParcelIrBytecodeListingTest : AbstractParcelBytecodeListingTest() { - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR override fun getExpectedTextFileName(wholeFile: File): String { return wholeFile.nameWithoutExtension + ".ir.txt" diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidIrBoxTest.kt b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidIrBoxTest.kt index 69a8957c667..23024f7f458 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidIrBoxTest.kt +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidIrBoxTest.kt @@ -8,5 +8,5 @@ package org.jetbrains.kotlin.android.synthetic.test import org.jetbrains.kotlin.test.TargetBackend abstract class AbstractAndroidIrBoxTest : AbstractAndroidBoxTest() { - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR } diff --git a/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/AbstractFirAllOpenDiagnosticTest.kt b/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/AbstractFirAllOpenDiagnosticTest.kt index ff51c234d32..8db039d68bd 100644 --- a/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/AbstractFirAllOpenDiagnosticTest.kt +++ b/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/AbstractFirAllOpenDiagnosticTest.kt @@ -17,8 +17,8 @@ abstract class AbstractFirAllOpenDiagnosticTest : AbstractFirDiagnosticsTest() { service.registerExtensions(FirAllOpenComponentRegistrar().configure()) } - override fun performCustomConfiguration(configuration: CompilerConfiguration) { - super.performCustomConfiguration(configuration) + override fun updateConfiguration(configuration: CompilerConfiguration) { + super.updateConfiguration(configuration) val jar = File("plugins/fir/fir-plugin-prototype/plugin-annotations/build/libs/plugin-annotations-1.4.255-SNAPSHOT.jar") if (!jar.exists()) { throw AssertionError("Jar with annotations does not exist. Please run :plugins:fir:fir-plugin-prototype:plugin-annotations:jar") diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3IntegrationTest.kt b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3IntegrationTest.kt index 651d4360f40..1e70135cb75 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3IntegrationTest.kt +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3IntegrationTest.kt @@ -8,5 +8,5 @@ package org.jetbrains.kotlin.kapt3.test import org.jetbrains.kotlin.test.TargetBackend abstract class AbstractIrKotlinKapt3IntegrationTest : AbstractKotlinKapt3IntegrationTest() { - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR } diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3Test.kt b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3Test.kt index 5312a3cd7f3..5f14fe21e6a 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3Test.kt +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractIrKotlinKapt3Test.kt @@ -12,9 +12,9 @@ Currently Kapt3 only works with the old backend. To enable IR, modify the isIrBa */ abstract class AbstractIrClassFileToSourceStubConverterTest : AbstractClassFileToSourceStubConverterTest() { - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR } abstract class AbstractIrKotlinKaptContextTest : AbstractKotlinKaptContextTest() { - override fun getBackend() = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR } diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/AbstractSerializationIrBytecodeListingTest.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/AbstractSerializationIrBytecodeListingTest.kt index 751c33894d5..c56ba1b6cf2 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/AbstractSerializationIrBytecodeListingTest.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/AbstractSerializationIrBytecodeListingTest.kt @@ -19,7 +19,7 @@ abstract class AbstractSerializationIrBytecodeListingTest : AbstractAsmLikeInstr return wholeFile.nameWithoutExtension + ".ir.txt" } - override fun getBackend(): TargetBackend = TargetBackend.JVM_IR + override val backend = TargetBackend.JVM_IR override fun setupEnvironment(environment: KotlinCoreEnvironment) { SerializationComponentRegistrar.registerExtensions(environment.project)