Generalize AbstractForeignAnnotationsTestBase to FIR

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/FirTestDataConsistencyHandler.kt

@@ -5,16 +5,14 @@
 
 package org.jetbrains.kotlin.test.frontend.classic.handlers
 
-import org.jetbrains.kotlin.codeMetaInfo.clearTextFromDiagnosticMarkup
 import org.jetbrains.kotlin.test.WrappedException
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
+import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
 import org.jetbrains.kotlin.test.model.AfterAnalysisChecker
-import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticTest
+import org.jetbrains.kotlin.test.model.TestFile
-import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.*
-import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.test.util.convertLineSeparators
-import org.jetbrains.kotlin.test.services.moduleStructure
-import org.jetbrains.kotlin.test.services.testInfo
 import org.jetbrains.kotlin.test.utils.firTestDataFile
 import java.io.File
 
@@ -28,32 +26,17 @@ class FirTestDataConsistencyHandler(testServices: TestServices) : AfterAnalysisC
         if (testData.extension == "kts") return
         if (FirDiagnosticsDirectives.FIR_IDENTICAL in moduleStructure.allDirectives) return
         val firTestData = testData.firTestDataFile
-        if (!firTestData.exists()) {
+        testServices.assertions.assertTrue(firTestData.exists()) {
-            runFirTestAndGeneratedTestData(testData, firTestData)
+            "FIR test data does not exist; run the corresponding FIR test to generate it"
-            return
         }
-        var originalFileContent = clearTextFromDiagnosticMarkup(testData.readText()).trim()
+        testServices.assertions.assertEquals(firTestData.preprocessSource(), testData.preprocessSource()) {
-        var firFileContent = clearTextFromDiagnosticMarkup(firTestData.readText()).trim()
+            "Original and fir test data aren't identical. " +
-        if (System.lineSeparator() != "\n") {
+                    "Please, add changes from ${testData.name} to ${firTestData.name}"
-            originalFileContent = originalFileContent.replace("\r\n", "\n")
-            firFileContent = firFileContent.replace("\r\n", "\n")
-        }
-        if (originalFileContent != firFileContent) {
-            testServices.assertions.assertEqualsToFile(
-                firTestData,
-                originalFileContent,
-                message = {
-                    "Original and fir test data aren't identical. " +
-                            "Please, add changes from ${testData.name} to ${firTestData.name}"
-                }
-            )
         }
     }
 
-    private fun runFirTestAndGeneratedTestData(testData: File, firTestData: File) {
+    private fun File.preprocessSource(): String =
-        firTestData.writeText(clearTextFromDiagnosticMarkup(testData.readText()))
+        testServices.sourceFileProvider.getContentOfSourceFile(
-        val test = object : AbstractFirDiagnosticTest() {}
+            TestFile(path, readText().trim().convertLineSeparators(), this, 0, isAdditional = false, RegisteredDirectives.Empty)
-        test.initTestInfo(testServices.testInfo.copy(className = "${testServices.testInfo.className}_fir_anonymous"))
+        )
-        test.runTest(firTestData.absolutePath)
-    }
 }

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.test.runners
+
+import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+import org.jetbrains.kotlin.test.builders.firFrontendStep
+import org.jetbrains.kotlin.test.builders.firHandlersStep
+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 = {
+    globalDefaults {
+        frontend = FrontendKinds.FIR
+    }
+
+    useMetaInfoProcessors(::PsiLightTreeMetaInfoProcessor)
+    firFrontendStep()
+    firHandlersStep {
+        useHandlers(
+            ::FirDiagnosticsHandler,
+            ::FirDumpHandler,
+            ::FirCfgDumpHandler,
+            ::FirCfgConsistencyHandler,
+            ::FirNoImplicitTypesHandler,
+        )
+    }
+
+    forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
+        // TODO: port JspecifyDiagnosticComplianceHandler (it doesn't really use the frontend artifact)
+        useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
+    }
+
+    forTestsMatching("compiler/testData/diagnostics/*") {
+        useAfterAnalysisCheckers(
+            ::FirIdenticalChecker,
+            ::FirFailingTestSuppressor,
+        )
+        useMetaTestConfigurators(::FirOldFrontendMetaConfigurator)
+    }
+}
+
+abstract class AbstractFirForeignAnnotationsTestBase : AbstractForeignAnnotationsTestBase(configureFir)
+
+abstract class AbstractFirForeignAnnotationsSourceJavaTest : AbstractFirForeignAnnotationsTestBase()
+
+abstract class AbstractFirForeignAnnotationsCompiledJavaTest :
+    AbstractForeignAnnotationsCompiledJavaTest(configureFir)
+
+abstract class AbstractFirForeignAnnotationsCompiledJavaWithPsiClassReadingTest :
+    AbstractForeignAnnotationsCompiledJavaWithPsiClassReadingTest(configureFir)

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

@@ -22,10 +22,7 @@ import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirective
 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.ClassicDiagnosticsHandler
+import org.jetbrains.kotlin.test.frontend.classic.handlers.*
-import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler
-import org.jetbrains.kotlin.test.frontend.classic.handlers.JspecifyDiagnosticComplianceHandler
-import org.jetbrains.kotlin.test.frontend.classic.handlers.OldNewInferenceMetaInfoProcessor
 import org.jetbrains.kotlin.test.model.DependencyKind
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.preprocessors.JspecifyMarksCleanupPreprocessor
@@ -35,10 +32,36 @@ import org.jetbrains.kotlin.test.services.jvm.PsiClassFilesReadingForCompiledJav
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
 
-abstract class AbstractForeignAnnotationsTestBase : AbstractKotlinCompilerTest() {
+private val configureClassicFrontend: TestConfigurationBuilder.() -> Unit = {
+    globalDefaults {
+        frontend = FrontendKinds.ClassicFrontend
+    }
+
+    useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor)
+    classicFrontendStep()
+    classicFrontendHandlersStep {
+        useHandlers(
+            ::DeclarationsDumpHandler,
+            ::ClassicDiagnosticsHandler,
+        )
+    }
+
+    forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
+        configureClassicFrontendHandlersStep {
+            useHandlers(::JspecifyDiagnosticComplianceHandler)
+        }
+        useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
+    }
+
+    useAfterAnalysisCheckers(::FirTestDataConsistencyHandler)
+}
+
+abstract class AbstractForeignAnnotationsTestBase(
+    private val configureFrontend: TestConfigurationBuilder.() -> Unit = configureClassicFrontend
+) : AbstractKotlinCompilerTest() {
+
     override fun TestConfigurationBuilder.configuration() {
         globalDefaults {
-            frontend = FrontendKinds.ClassicFrontend
             targetPlatform = JvmPlatforms.defaultJvmPlatform
             dependencyKind = DependencyKind.Source
         }
@@ -56,19 +79,12 @@ abstract class AbstractForeignAnnotationsTestBase : AbstractKotlinCompilerTest()
             ::JvmEnvironmentConfigurator
         )
 
-        useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor)
         useAdditionalSourceProviders(
             ::AdditionalDiagnosticsSourceFilesProvider,
             ::CoroutineHelpersSourceFilesProvider,
         )
 
-        classicFrontendStep()
+        configureFrontend()
-        classicFrontendHandlersStep {
-            useHandlers(
-                ::DeclarationsDumpHandler,
-                ::ClassicDiagnosticsHandler,
-            )
-        }
 
         forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/tests/*") {
             defaultDirectives {
@@ -90,19 +106,15 @@ abstract class AbstractForeignAnnotationsTestBase : AbstractKotlinCompilerTest()
                 COMPILE_JAVA_USING with TestJavacVersion.JAVAC_9
             }
         }
-
-        forTestsMatching("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/*") {
-            configureClassicFrontendHandlersStep {
-                useHandlers(::JspecifyDiagnosticComplianceHandler)
-            }
-            useSourcePreprocessor(::JspecifyMarksCleanupPreprocessor)
-        }
     }
 }
 
 abstract class AbstractForeignAnnotationsSourceJavaTest : AbstractForeignAnnotationsTestBase()
 
-abstract class AbstractForeignAnnotationsCompiledJavaTest : AbstractForeignAnnotationsTestBase() {
+abstract class AbstractForeignAnnotationsCompiledJavaTest : AbstractForeignAnnotationsTestBase {
+    constructor() : super()
+    constructor(configureFrontend: TestConfigurationBuilder.() -> Unit) : super(configureFrontend)
+
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {
@@ -116,7 +128,10 @@ abstract class AbstractForeignAnnotationsCompiledJavaTest : AbstractForeignAnnot
     }
 }
 
-abstract class AbstractForeignAnnotationsCompiledJavaWithPsiClassReadingTest : AbstractForeignAnnotationsCompiledJavaTest() {
+abstract class AbstractForeignAnnotationsCompiledJavaWithPsiClassReadingTest : AbstractForeignAnnotationsCompiledJavaTest {
+    constructor() : super()
+    constructor(configureFrontend: TestConfigurationBuilder.() -> Unit) : super(configureFrontend)
+
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {