Get rid of lambdas in AbstractForeignAnnotationsTestBase

Also enable the features from the previous two commits

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

@@ -6,51 +6,56 @@
 package org.jetbrains.kotlin.test.runners
 
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+import org.jetbrains.kotlin.test.builders.configureFirHandlersStep
 import org.jetbrains.kotlin.test.builders.firFrontendStep
 import org.jetbrains.kotlin.test.builders.firHandlersStep
+import org.jetbrains.kotlin.test.frontend.classic.handlers.FirJspecifyDiagnosticComplianceHandler
 import org.jetbrains.kotlin.test.frontend.fir.FirFailingTestSuppressor
 import org.jetbrains.kotlin.test.frontend.fir.handlers.*
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.preprocessors.JspecifyMarksCleanupPreprocessor
 import org.jetbrains.kotlin.test.services.fir.FirOldFrontendMetaConfigurator
 
-private val configureFir: TestConfigurationBuilder.() -> Unit = {
+abstract class AbstractFirForeignAnnotationsTestBase(kind: ForeignAnnotationsTestKind) : AbstractForeignAnnotationsTestBase(kind) {
-    globalDefaults {
+    override fun TestConfigurationBuilder.configureFrontend() {
-        frontend = FrontendKinds.FIR
+        globalDefaults {
-    }
+            frontend = FrontendKinds.FIR
+        }
 
-    useMetaInfoProcessors(::PsiLightTreeMetaInfoProcessor)
+        useMetaInfoProcessors(::PsiLightTreeMetaInfoProcessor)
-    firFrontendStep()
+        firFrontendStep()
-    firHandlersStep {
+        firHandlersStep {
-        useHandlers(
+            useHandlers(
-            ::FirDiagnosticsHandler,
+                ::FirDiagnosticsHandler,
-            ::FirDumpHandler,
+                ::FirDumpHandler,
-            ::FirCfgDumpHandler,
+                ::FirCfgDumpHandler,
-            ::FirCfgConsistencyHandler,
+                ::FirCfgConsistencyHandler,
-            ::FirNoImplicitTypesHandler,
+                ::FirNoImplicitTypesHandler,
-        )
+            )
-    }
+        }
 
-    forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
+        forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
-        // TODO: port JspecifyDiagnosticComplianceHandler (it doesn't really use the frontend artifact)
+            configureFirHandlersStep {
-        useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
+                useHandlers(::FirJspecifyDiagnosticComplianceHandler)
-    }
+            }
+            useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
+        }
 
-    forTestsMatching("compiler/testData/diagnostics/*") {
+        forTestsMatching("compiler/testData/diagnostics/*") {
-        useAfterAnalysisCheckers(
+            useAfterAnalysisCheckers(
-            ::FirIdenticalChecker,
+                ::FirIdenticalChecker,
-            ::FirFailingTestSuppressor,
+                ::FirFailingTestSuppressor,
-        )
+            )
-        useMetaTestConfigurators(::FirOldFrontendMetaConfigurator)
+            useMetaTestConfigurators(::FirOldFrontendMetaConfigurator)
+        }
     }
 }
 
-abstract class AbstractFirForeignAnnotationsTestBase : AbstractForeignAnnotationsTestBase(configureFir)
+abstract class AbstractFirForeignAnnotationsSourceJavaTest :
-
+    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.SOURCE)
-abstract class AbstractFirForeignAnnotationsSourceJavaTest : AbstractFirForeignAnnotationsTestBase()
 
 abstract class AbstractFirForeignAnnotationsCompiledJavaTest :
-    AbstractForeignAnnotationsCompiledJavaTest(configureFir)
+    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA)
 
 abstract class AbstractFirForeignAnnotationsCompiledJavaWithPsiClassReadingTest :
-    AbstractForeignAnnotationsCompiledJavaWithPsiClassReadingTest(configureFir)
+    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA_WITH_PSI_CLASS_LOADING)

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

@@ -21,45 +21,24 @@ import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirective
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_FOREIGN_ANNOTATIONS
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_JSR305_TEST_ANNOTATIONS
-import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
 import org.jetbrains.kotlin.test.frontend.classic.handlers.*
 import org.jetbrains.kotlin.test.model.DependencyKind
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.preprocessors.JspecifyMarksCleanupPreprocessor
+import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.configuration.*
 import org.jetbrains.kotlin.test.services.jvm.ForeignAnnotationAgainstCompiledJavaTestSuppressor
 import org.jetbrains.kotlin.test.services.jvm.PsiClassFilesReadingForCompiledJavaTestSuppressor
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
 
-private val configureClassicFrontend: TestConfigurationBuilder.() -> Unit = {
+enum class ForeignAnnotationsTestKind(val compiledJava: Boolean, val psiClassLoading: Boolean) {
-    globalDefaults {
+    SOURCE(false, false),
-        frontend = FrontendKinds.ClassicFrontend
+    COMPILED_JAVA(true, false),
-    }
+    COMPILED_JAVA_WITH_PSI_CLASS_LOADING(true, true)
-
-    useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor)
-    classicFrontendStep()
-    classicFrontendHandlersStep {
-        useHandlers(
-            ::DeclarationsDumpHandler,
-            ::ClassicDiagnosticsHandler,
-        )
-    }
-
-    forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
-        configureClassicFrontendHandlersStep {
-            useHandlers(::JspecifyDiagnosticComplianceHandler)
-        }
-        useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
-    }
-
-    useAfterAnalysisCheckers(::FirTestDataConsistencyHandler)
 }
 
-abstract class AbstractForeignAnnotationsTestBase(
+abstract class AbstractForeignAnnotationsTestBase(private val kind: ForeignAnnotationsTestKind) : AbstractKotlinCompilerTest() {
-    private val configureFrontend: TestConfigurationBuilder.() -> Unit = configureClassicFrontend
-) : AbstractKotlinCompilerTest() {
-
     override fun TestConfigurationBuilder.configuration() {
         globalDefaults {
             targetPlatform = JvmPlatforms.defaultJvmPlatform
@@ -69,10 +48,24 @@ abstract class AbstractForeignAnnotationsTestBase(
         defaultDirectives {
             +REPORT_JVM_DIAGNOSTICS_ON_FRONTEND
             +WITH_FOREIGN_ANNOTATIONS
+            if (kind.compiledJava) {
+                +ALL_JAVA_AS_BINARY
+                +SKIP_TXT
+            }
+            if (kind.psiClassLoading) {
+                +USE_PSI_CLASS_FILES_READING
+            }
         }
 
         enableMetaInfoHandler()
 
+        if (kind.compiledJava) {
+            useMetaTestConfigurators(::ForeignAnnotationAgainstCompiledJavaTestSuppressor)
+        }
+        if (kind.psiClassLoading) {
+            useMetaTestConfigurators(::PsiClassFilesReadingForCompiledJavaTestSuppressor)
+        }
+
         useConfigurators(
             ::CommonEnvironmentConfigurator,
             ::JvmForeignAnnotationsConfigurator,
@@ -107,39 +100,50 @@ abstract class AbstractForeignAnnotationsTestBase(
             }
         }
     }
+
+    abstract fun TestConfigurationBuilder.configureFrontend()
 }
 
-abstract class AbstractForeignAnnotationsSourceJavaTest : AbstractForeignAnnotationsTestBase()
+private class FirForeignDiagnosticsTestDataConsistencyHandler(testServices: TestServices) :
+    FirTestDataConsistencyHandler(testServices) {
 
-abstract class AbstractForeignAnnotationsCompiledJavaTest : AbstractForeignAnnotationsTestBase {
+    override fun correspondingFirTest(): AbstractKotlinCompilerTest =
-    constructor() : super()
+        object : AbstractFirForeignAnnotationsSourceJavaTest() {}
-    constructor(configureFrontend: TestConfigurationBuilder.() -> Unit) : super(configureFrontend)
+}
 
-    override fun configure(builder: TestConfigurationBuilder) {
+abstract class AbstractOldFrontendForeignAnnotationsTestBase(kind: ForeignAnnotationsTestKind) :
-        super.configure(builder)
+    AbstractForeignAnnotationsTestBase(kind) {
-        with(builder) {
-            defaultDirectives {
-                +ALL_JAVA_AS_BINARY
-                +SKIP_TXT
-            }
 
-            useMetaTestConfigurators(::ForeignAnnotationAgainstCompiledJavaTestSuppressor)
+    override fun TestConfigurationBuilder.configureFrontend() {
+        globalDefaults {
+            frontend = FrontendKinds.ClassicFrontend
         }
+
+        useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor)
+        classicFrontendStep()
+        classicFrontendHandlersStep {
+            useHandlers(
+                ::DeclarationsDumpHandler,
+                ::ClassicDiagnosticsHandler,
+            )
+        }
+
+        forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
+            configureClassicFrontendHandlersStep {
+                useHandlers(::JspecifyDiagnosticComplianceHandler)
+            }
+            useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
+        }
+
+        useAfterAnalysisCheckers(::FirForeignDiagnosticsTestDataConsistencyHandler)
     }
 }
 
-abstract class AbstractForeignAnnotationsCompiledJavaWithPsiClassReadingTest : AbstractForeignAnnotationsCompiledJavaTest {
+abstract class AbstractForeignAnnotationsSourceJavaTest :
-    constructor() : super()
+    AbstractOldFrontendForeignAnnotationsTestBase(ForeignAnnotationsTestKind.SOURCE)
-    constructor(configureFrontend: TestConfigurationBuilder.() -> Unit) : super(configureFrontend)
 
-    override fun configure(builder: TestConfigurationBuilder) {
+abstract class AbstractForeignAnnotationsCompiledJavaTest :
-        super.configure(builder)
+    AbstractOldFrontendForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA)
-        with(builder) {
-            defaultDirectives {
-                +USE_PSI_CLASS_FILES_READING
-            }
 
-            useMetaTestConfigurators(::PsiClassFilesReadingForCompiledJavaTestSuppressor)
+abstract class AbstractForeignAnnotationsCompiledJavaWithPsiClassReadingTest :
-        }
+    AbstractOldFrontendForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA_WITH_PSI_CLASS_LOADING)
-    }
-}