Generalize AbstractForeignAnnotationsTestBase to FIR

2021-07-29 15:56:03 +02:00
parent e2e0358505
commit 5873511f64
3 changed files with 107 additions and 53 deletions
@@ -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.services.TestServices
-import org.jetbrains.kotlin.test.services.assertions
-import org.jetbrains.kotlin.test.services.moduleStructure
-import org.jetbrains.kotlin.test.services.testInfo
+import org.jetbrains.kotlin.test.model.TestFile
+import org.jetbrains.kotlin.test.services.*
+import org.jetbrains.kotlin.test.util.convertLineSeparators
 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()) {
-            runFirTestAndGeneratedTestData(testData, firTestData)
-            return
+        testServices.assertions.assertTrue(firTestData.exists()) {
+            "FIR test data does not exist; run the corresponding FIR test to generate it"
        }
-        var originalFileContent = clearTextFromDiagnosticMarkup(testData.readText()).trim()
-        var firFileContent = clearTextFromDiagnosticMarkup(firTestData.readText()).trim()
-        if (System.lineSeparator() != "\n") {
-            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}"
-                }
-            )
+        testServices.assertions.assertEquals(firTestData.preprocessSource(), testData.preprocessSource()) {
+            "Original and fir test data aren't identical. " +
+                    "Please, add changes from ${testData.name} to ${firTestData.name}"
        }
    }

-    private fun runFirTestAndGeneratedTestData(testData: File, firTestData: File) {
-        firTestData.writeText(clearTextFromDiagnosticMarkup(testData.readText()))
-        val test = object : AbstractFirDiagnosticTest() {}
-        test.initTestInfo(testServices.testInfo.copy(className = "${testServices.testInfo.className}_fir_anonymous"))
-        test.runTest(firTestData.absolutePath)
-    }
+    private fun File.preprocessSource(): String =
+        testServices.sourceFileProvider.getContentOfSourceFile(
+            TestFile(path, readText().trim().convertLineSeparators(), this, 0, isAdditional = false, RegisteredDirectives.Empty)
+        )
 }
@@ -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)
@@ -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.DeclarationsDumpHandler
-import org.jetbrains.kotlin.test.frontend.classic.handlers.JspecifyDiagnosticComplianceHandler
-import org.jetbrains.kotlin.test.frontend.classic.handlers.OldNewInferenceMetaInfoProcessor
+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
@@ -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()
-        classicFrontendHandlersStep {
-            useHandlers(
-                ::DeclarationsDumpHandler,
-                ::ClassicDiagnosticsHandler,
-            )
-        }
+        configureFrontend()

        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) {