Move foreign annotations logic into the corresponding configurator for the tests

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractForeignAnnotationsTest.kt

@@ -33,8 +33,6 @@ import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsS
 import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
 
 abstract class AbstractForeignAnnotationsTestBase : AbstractKotlinCompilerTest() {
-    protected open val foreignAnnotationsConfigurator: Constructor<JvmForeignAnnotationsConfigurator>? = null
-
     override fun TestConfigurationBuilder.configuration() {
         globalDefaults {
             frontend = FrontendKinds.ClassicFrontend
@@ -51,11 +49,10 @@ abstract class AbstractForeignAnnotationsTestBase : AbstractKotlinCompilerTest()
 
         useConfigurators(
             ::CommonEnvironmentConfigurator,
+            ::JvmForeignAnnotationsConfigurator,
             ::JvmEnvironmentConfigurator
         )
 
-        foreignAnnotationsConfigurator.takeIf { it != null }?.also { useConfigurators(it) }
-
         useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor)
         useAdditionalSourceProviders(
             ::AdditionalDiagnosticsSourceFilesProvider,
@@ -96,15 +93,9 @@ abstract class AbstractForeignAnnotationsTestBase : AbstractKotlinCompilerTest()
     }
 }
 
-abstract class AbstractForeignAnnotationsSourceJavaTest : AbstractForeignAnnotationsTestBase() {
-    override val foreignAnnotationsConfigurator: Constructor<JvmForeignAnnotationsConfigurator>
-        get() = ::JvmForeignAnnotationsConfigurator
-}
+abstract class AbstractForeignAnnotationsSourceJavaTest : AbstractForeignAnnotationsTestBase()
 
 abstract class AbstractForeignAnnotationsCompiledJavaTest : AbstractForeignAnnotationsTestBase() {
-    override val foreignAnnotationsConfigurator: Constructor<JvmForeignAnnotationsConfigurator>
-        get() = ::JvmForeignAnnotationsConfigurator
-
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt

@@ -134,13 +134,6 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
         val javaBinaryFiles = if (ALL_JAVA_AS_BINARY !in registeredDirectives) {
             module.javaFiles.filter { INCLUDE_JAVA_AS_BINARY in it.directives }
         } else module.javaFiles
-        val withForeignAnnotations = JvmEnvironmentConfigurationDirectives.WITH_FOREIGN_ANNOTATIONS in registeredDirectives
-
-        assertTrue(javaVersionToCompile == null || javaBinaryFiles.isNotEmpty() || withForeignAnnotations) {
-            "'COMPILE_JAVA_USING' can't be use if there aren't any java files to compile " +
-                    "(mark java files by 'INCLUDE_JAVA_AS_BINARY' or include foreign annotations using 'WITH_FOREIGN_ANNOTATIONS' " +
-                    "which will be compiled by specified version of javac)"
-        }
 
         val useJava9ToCompileIncludedJavaFiles = javaVersionToCompile == TestJavacVersion.JAVAC_9
 
@@ -159,40 +152,7 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
             configuration.addJvmClasspathRoot(ForTestCompileRuntime.runtimeJarForTestsWithJdk8())
         }
 
-        if (withForeignAnnotations) {
-            val annotationPath = registeredDirectives[ForeignAnnotationsDirectives.ANNOTATIONS_PATH].singleOrNull()
-                ?: JavaForeignAnnotationType.Java8Annotations
-            val javaFilesDir = createTempDirectory().toFile().also {
-                File(annotationPath.path).copyRecursively(it)
-            }
-            val foreignAnnotationsJar = compileJavaFilesLibraryToJar(
-                javaFilesDir.path,
-                "foreign-annotations",
-                assertions = JUnit5Assertions,
-                extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath },
-                useJava9 = useJava9ToCompileIncludedJavaFiles
-            )
-            configuration.addModularRootIfNotNull(useJava9ToCompileIncludedJavaFiles, "java9_annotations", foreignAnnotationsJar)
-            configuration.addJvmClasspathRoot(ForTestCompileRuntime.jvmAnnotationsForTests())
-        } else {
-            // Add jetbrains annotations of an old version, without supporting type use target
-            configuration.addJvmClasspathRoot(KtTestUtil.getAnnotationsJar())
-        }
-
-        if (JvmEnvironmentConfigurationDirectives.WITH_JSR305_TEST_ANNOTATIONS in registeredDirectives) {
-            val javaFilesDir = createTempDirectory().toFile().also {
-                File(JSR_305_TEST_ANNOTATIONS_PATH).copyRecursively(it)
-            }
-            configuration.addJvmClasspathRoot(
-                compileJavaFilesLibraryToJar(
-                    javaFilesDir.path,
-                    "jsr-305-test-annotations",
-                    assertions = JUnit5Assertions,
-                    extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath }
-                )
-            )
-            configuration.addJvmClasspathRoot(KtTestUtil.getAnnotationsJar())
-        }
+        configuration.addJvmClasspathRoot(KtTestUtil.getAnnotationsJar())
 
         val isIr = module.targetBackend?.isIR == true
         configuration.put(JVMConfigurationKeys.IR, isIr)

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmForeignAnnotationsConfigurator.kt

@@ -5,19 +5,31 @@
 
 package org.jetbrains.kotlin.test.services.configuration
 
+import org.jetbrains.kotlin.cli.jvm.addModularRootIfNotNull
+import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
+import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.config.AnalysisFlag
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JvmAnalysisFlags
+import org.jetbrains.kotlin.test.MockLibraryUtil
+import org.jetbrains.kotlin.test.TestJavacVersion
 import org.jetbrains.kotlin.test.directives.ForeignAnnotationsDirectives
 import org.jetbrains.kotlin.test.directives.ForeignAnnotationsDirectives.JSPECIFY_STATE
 import org.jetbrains.kotlin.test.directives.ForeignAnnotationsDirectives.JSR305_GLOBAL_REPORT
 import org.jetbrains.kotlin.test.directives.ForeignAnnotationsDirectives.JSR305_MIGRATION_REPORT
 import org.jetbrains.kotlin.test.directives.ForeignAnnotationsDirectives.JSR305_SPECIAL_REPORT
+import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
 import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
 import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.*
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.ReportLevel
+import java.io.File
+import kotlin.io.path.createTempDirectory
 
 enum class JavaForeignAnnotationType(val path: String) {
     Annotations("third-party/annotations"),
@@ -51,4 +63,39 @@ open class JvmForeignAnnotationsConfigurator(testServices: TestServices) : Envir
             )
         )
     }
+
+    override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) {
+        val registeredDirectives = module.directives
+        val javaVersionToCompile = registeredDirectives[JvmEnvironmentConfigurationDirectives.COMPILE_JAVA_USING].singleOrNull()
+        val useJava9ToCompileIncludedJavaFiles = javaVersionToCompile == TestJavacVersion.JAVAC_9
+        val annotationPath = registeredDirectives[ForeignAnnotationsDirectives.ANNOTATIONS_PATH].singleOrNull()
+            ?: JavaForeignAnnotationType.Java8Annotations
+        val javaFilesDir = createTempDirectory().toFile().also {
+            File(annotationPath.path).copyRecursively(it)
+        }
+        val foreignAnnotationsJar = MockLibraryUtil.compileJavaFilesLibraryToJar(
+            javaFilesDir.path,
+            "foreign-annotations",
+            assertions = JUnit5Assertions,
+            extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath },
+            useJava9 = useJava9ToCompileIncludedJavaFiles
+        )
+        configuration.addModularRootIfNotNull(useJava9ToCompileIncludedJavaFiles, "java9_annotations", foreignAnnotationsJar)
+        configuration.addJvmClasspathRoot(ForTestCompileRuntime.jvmAnnotationsForTests())
+
+        if (JvmEnvironmentConfigurationDirectives.WITH_JSR305_TEST_ANNOTATIONS in registeredDirectives) {
+            val jsr305AnnotationsDir = createTempDirectory().toFile().also {
+                File(JSR_305_TEST_ANNOTATIONS_PATH).copyRecursively(it)
+            }
+            configuration.addJvmClasspathRoot(
+                MockLibraryUtil.compileJavaFilesLibraryToJar(
+                    jsr305AnnotationsDir.path,
+                    "jsr-305-test-annotations",
+                    assertions = JUnit5Assertions,
+                    extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath }
+                )
+            )
+            configuration.addJvmClasspathRoot(KtTestUtil.getAnnotationsJar())
+        }
+    }
 }