[Test] Require specifying parser for FIR test. Unify names for FIR tests

Now all tests with `Fir` in name are named accordingly to parser which
  is used in them -- `FirPsi` or `FirLightTree`. This is needed to keep
  consistency between different types of tests, because there is no
  single default in parser mode between different scenarios of using FIR

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/ir/interpreter/JvmIrInterpreterAfterFirPsi2IrTestGenerated.java

@@ -19,7 +19,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/ir/interpreter")
 @TestDataPath("$PROJECT_ROOT")
-public class JvmIrInterpreterAfterFir2IrTestGenerated extends AbstractJvmIrInterpreterAfterFir2IrTest {
+public class JvmIrInterpreterAfterFirPsi2IrTestGenerated extends AbstractJvmIrInterpreterAfterFirPsi2IrTest {
     @Test
     @TestMetadata("abstract1.kt")
     public void testAbstract1() throws Exception {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/CodegenTestDirectives.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.test.directives
 
 import org.jetbrains.kotlin.backend.common.phaser.AnyNamedPhase
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.backend.handlers.*
 import org.jetbrains.kotlin.test.backend.ir.JvmIrBackendFacade
@@ -13,6 +14,7 @@ import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability.File
 import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability.Global
 import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
 import org.jetbrains.kotlin.test.directives.model.ValueDirective
+import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.TestModule
 
@@ -205,7 +207,9 @@ fun extractIgnoredDirectivesForTargetBackend(
         FrontendKinds.ClassicFrontend -> listOf(CodegenTestDirectives.IGNORE_BACKEND_K1)
         FrontendKinds.FIR -> listOfNotNull(
             CodegenTestDirectives.IGNORE_BACKEND_K2,
-            CodegenTestDirectives.IGNORE_BACKEND_K2_LIGHT_TREE.takeIf { module.directives.contains(FirDiagnosticsDirectives.USE_LIGHT_TREE) }
+            CodegenTestDirectives.IGNORE_BACKEND_K2_LIGHT_TREE.takeIf {
+                module.directives.singleOrZeroValue(FirDiagnosticsDirectives.FIR_PARSER) == FirParser.LightTree
+            }
         )
         else -> return emptyList()
     }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt

@@ -5,6 +5,9 @@
 
 package org.jetbrains.kotlin.test.directives
 
+import org.jetbrains.kotlin.test.FirParser
+import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.FIR_PARSER
 import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability.Global
 import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
 import org.jetbrains.kotlin.test.frontend.fir.handlers.FirResolvedTypesVerifier
@@ -36,8 +39,8 @@ object FirDiagnosticsDirectives : SimpleDirectivesContainer() {
         applicability = Global
     )
 
-    val USE_LIGHT_TREE by directive(
-        description = "Enables light tree parser instead of PSI"
+    val FIR_PARSER by enumDirective<FirParser>(
+        description = "Defines which parser should be used for FIR compiler"
     )
 
     val FIR_DISABLE_LAZY_RESOLVE_CHECKS by directive(
@@ -45,10 +48,7 @@ object FirDiagnosticsDirectives : SimpleDirectivesContainer() {
     )
 
     val COMPARE_WITH_LIGHT_TREE by directive(
-        description = """
-            Enable comparing diagnostics between PSI and light tree modes
-            For enabling light tree mode use $USE_LIGHT_TREE directive
-        """.trimIndent(),
+        description = "Enable comparing diagnostics between PSI and light tree modes",
         applicability = Global
     )
 
@@ -78,3 +78,9 @@ object FirDiagnosticsDirectives : SimpleDirectivesContainer() {
         """.trimIndent()
     )
 }
+
+fun TestConfigurationBuilder.configureFirParser(parser: FirParser) {
+    defaultDirectives {
+        FIR_PARSER with parser
+    }
+}

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

@@ -11,8 +11,8 @@ 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.model.TestFile
-import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticTest
-import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticsTestWithJvmIrBackend
+import org.jetbrains.kotlin.test.runners.AbstractFirPsiDiagnosticsTestWithJvmIrBackend
+import org.jetbrains.kotlin.test.runners.AbstractFirPsiDiagnosticTest
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
 import org.jetbrains.kotlin.test.services.*
 import org.jetbrains.kotlin.test.utils.firTestDataFile
@@ -59,7 +59,7 @@ open class FirTestDataConsistencyHandler(testServices: TestServices) : AfterAnal
     }
 
     protected open fun correspondingFirTest(): AbstractKotlinCompilerTest {
-        return if ("Backend" in testServices.testInfo.className) object : AbstractFirDiagnosticsTestWithJvmIrBackend() {}
-        else object : AbstractFirDiagnosticTest() {}
+        return if ("Backend" in testServices.testInfo.className) object : AbstractFirPsiDiagnosticsTestWithJvmIrBackend() {}
+        else object : AbstractFirPsiDiagnosticTest() {}
     }
 }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt

@@ -38,7 +38,9 @@ import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
+import org.jetbrains.kotlin.test.directives.model.singleValue
 import org.jetbrains.kotlin.test.getAnalyzerServices
 import org.jetbrains.kotlin.test.model.FrontendFacade
 import org.jetbrains.kotlin.test.model.FrontendKinds
@@ -261,11 +263,11 @@ open class FirFrontendFacade(
 
         PsiElementFinder.EP.getPoint(project).unregisterExtension(JavaElementFinder::class.java)
 
-        val lightTreeEnabled = FirDiagnosticsDirectives.USE_LIGHT_TREE in module.directives
-        val (ktFiles, lightTreeFiles) = if (lightTreeEnabled) {
-            emptyList<KtFile>() to testServices.sourceFileProvider.getLightTreeFilesForSourceFiles(module.files).values
-        } else {
-            testServices.sourceFileProvider.getKtFilesForSourceFiles(module.files, project).values to emptyList()
+        val parser = module.directives.singleValue(FirDiagnosticsDirectives.FIR_PARSER)
+
+        val (ktFiles, lightTreeFiles) = when (parser) {
+            FirParser.LightTree -> emptyList<KtFile>() to testServices.sourceFileProvider.getLightTreeFilesForSourceFiles(module.files).values
+            FirParser.Psi -> testServices.sourceFileProvider.getKtFilesForSourceFiles(module.files, project).values to emptyList()
         }
 
         val extensionRegistrars = FirExtensionRegistrar.getInstances(project)
@@ -295,7 +297,7 @@ open class FirFrontendFacade(
             ktFiles,
             lightTreeFiles,
             IrGenerationExtension.getInstances(project),
-            lightTreeEnabled,
+            parser,
             enablePluginPhases,
             generateSignatures = module.targetBackend == TargetBackend.JVM_IR_SERIALIZE
         )

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt

@@ -34,11 +34,13 @@ import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.psi.KtQualifiedExpression
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives
 import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
+import org.jetbrains.kotlin.test.directives.model.singleValue
 import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact
 import org.jetbrains.kotlin.test.model.TestFile
 import org.jetbrains.kotlin.test.model.TestModule
@@ -66,7 +68,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
             val currentModule = part.module
 
             val lightTreeComparingModeEnabled = FirDiagnosticsDirectives.COMPARE_WITH_LIGHT_TREE in currentModule.directives
-            val lightTreeEnabled = FirDiagnosticsDirectives.USE_LIGHT_TREE in currentModule.directives
+            val lightTreeEnabled = currentModule.directives.singleValue(FirDiagnosticsDirectives.FIR_PARSER) == FirParser.LightTree
 
             for (file in currentModule.files) {
                 val firFile = info.mainFirFiles[file] ?: continue
@@ -491,7 +493,7 @@ class PsiLightTreeMetaInfoProcessor(testServices: TestServices) : AbstractTwoAtt
     }
 
     override fun firstAttributeEnabled(module: TestModule): Boolean {
-        return FirDiagnosticsDirectives.USE_LIGHT_TREE !in module.directives
+        return module.directives.singleValue(FirDiagnosticsDirectives.FIR_PARSER) == FirParser.Psi
     }
 }
 

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

@@ -7,13 +7,11 @@ package org.jetbrains.kotlin.test.runners
 
 import org.jetbrains.kotlin.platform.konan.NativePlatforms
 import org.jetbrains.kotlin.test.Constructor
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.classicFrontendHandlersStep
 import org.jetbrains.kotlin.test.builders.firHandlersStep
-import org.jetbrains.kotlin.test.directives.ConfigurationDirectives
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
-import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
-import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
+import org.jetbrains.kotlin.test.directives.*
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact
 import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler
@@ -88,7 +86,7 @@ abstract class AbstractDiagnosticsNativeTest : AbstractDiagnosticsNativeTestBase
     }
 }
 
-abstract class AbstractFirNativeDiagnosticsTest : AbstractDiagnosticsNativeTestBase<FirOutputArtifact>() {
+abstract class AbstractFirNativeDiagnosticsTestBase(val parser: FirParser) : AbstractDiagnosticsNativeTestBase<FirOutputArtifact>() {
     override val targetFrontend: FrontendKind<FirOutputArtifact>
         get() = FrontendKinds.FIR
 
@@ -108,24 +106,20 @@ abstract class AbstractFirNativeDiagnosticsTest : AbstractDiagnosticsNativeTestB
         }
     }
 
-    override fun configure(builder: TestConfigurationBuilder) {
-        super.configure(builder)
-        builder.enableLazyResolvePhaseChecking()
-
-        builder.forTestsMatching("compiler/testData/diagnostics/*") {
-            configurationForClassicAndFirTestsAlongside()
-        }
-    }
-}
-
-abstract class AbstractFirNativeDiagnosticsWithLightTreeTest : AbstractFirNativeDiagnosticsTest() {
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {
-            defaultDirectives {
-                +FirDiagnosticsDirectives.USE_LIGHT_TREE
+            configureFirParser(parser)
+            enableLazyResolvePhaseChecking()
+
+            forTestsMatching("compiler/testData/diagnostics/*") {
+                configurationForClassicAndFirTestsAlongside()
             }
         }
     }
 }
 
+abstract class AbstractFirPsiNativeDiagnosticsTest : AbstractFirNativeDiagnosticsTestBase(FirParser.Psi)
+abstract class AbstractFirLightTreeNativeDiagnosticsTest : AbstractFirNativeDiagnosticsTestBase(FirParser.LightTree)
+
+

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.test.runners
 
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.test.Constructor
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.backend.classic.ClassicBackendInput
@@ -19,6 +20,7 @@ import org.jetbrains.kotlin.test.builders.classicFrontendHandlersStep
 import org.jetbrains.kotlin.test.builders.firHandlersStep
 import org.jetbrains.kotlin.test.builders.jvmArtifactsHandlersStep
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
@@ -146,7 +148,9 @@ abstract class AbstractDiagnosticsTestWithJvmIrBackend :
         get() = ::JvmIrBackendFacade
 }
 
-abstract class AbstractFirDiagnosticsTestWithJvmIrBackend : AbstractDiagnosticsTestWithJvmBackend<FirOutputArtifact, IrBackendInput>() {
+abstract class AbstractFirDiagnosticsTestWithJvmIrBackendBase(
+    val parser: FirParser
+) : AbstractDiagnosticsTestWithJvmBackend<FirOutputArtifact, IrBackendInput>() {
     override val targetFrontend: FrontendKind<FirOutputArtifact>
         get() = FrontendKinds.FIR
 
@@ -169,4 +173,11 @@ abstract class AbstractFirDiagnosticsTestWithJvmIrBackend : AbstractDiagnosticsT
         if (InTextDirectivesUtils.isDirectiveDefined(wholeText, "// TARGET_BACKEND: JVM_OLD")) return
         super.runTest(filePath)
     }
+
+    override fun configure(builder: TestConfigurationBuilder) {
+        super.configure(builder)
+        builder.configureFirParser(parser)
+    }
 }
+
+abstract class AbstractFirPsiDiagnosticsTestWithJvmIrBackend : AbstractFirDiagnosticsTestWithJvmIrBackendBase(FirParser.Psi)

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

@@ -18,13 +18,14 @@ import org.jetbrains.kotlin.test.builders.firHandlersStep
 import org.jetbrains.kotlin.test.coerce
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives.WITH_STDLIB
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.FIR_DUMP
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.USE_LIGHT_TREE
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.WITH_EXTENDED_CHECKERS
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.JDK_KIND
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_REFLECT
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives.ALLOW_KOTLIN_PACKAGE
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives.LANGUAGE
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.fir.*
 import org.jetbrains.kotlin.test.frontend.fir.handlers.*
 import org.jetbrains.kotlin.test.model.DependencyKind
@@ -37,23 +38,16 @@ import org.jetbrains.kotlin.test.services.service
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
 
-abstract class AbstractFirDiagnosticTest : AbstractKotlinCompilerTest() {
+abstract class AbstractFirDiagnosticTestBase(val parser: FirParser) : AbstractKotlinCompilerTest() {
     override fun TestConfigurationBuilder.configuration() {
         baseFirDiagnosticTestConfiguration()
         enableLazyResolvePhaseChecking()
+        configureFirParser(parser)
     }
 }
 
-abstract class AbstractFirDiagnosticsWithLightTreeTest : AbstractFirDiagnosticTest() {
-    override fun configure(builder: TestConfigurationBuilder) {
-        super.configure(builder)
-        with(builder) {
-            defaultDirectives {
-                +USE_LIGHT_TREE
-            }
-        }
-    }
-}
+abstract class AbstractFirPsiDiagnosticTest : AbstractFirDiagnosticTestBase(FirParser.Psi)
+abstract class AbstractFirLightTreeDiagnosticsTest : AbstractFirDiagnosticTestBase(FirParser.LightTree)
 
 fun TestConfigurationBuilder.configurationForClassicAndFirTestsAlongside() {
     useAfterAnalysisCheckers(

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.test.runners
 
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives.SPEC_HELPERS
@@ -14,7 +15,7 @@ import org.jetbrains.kotlin.test.frontend.fir.handlers.FirIdenticalChecker
 import org.jetbrains.kotlin.test.services.fir.FirOldFrontendMetaConfigurator
 import org.jetbrains.kotlin.test.services.sourceProviders.SpecHelpersSourceFilesProvider
 
-abstract class AbstractFirDiagnosticTestSpec : AbstractFirDiagnosticTest() {
+abstract class AbstractFirDiagnosticTestSpecBase(parser: FirParser) : AbstractFirDiagnosticTestBase(parser) {
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {
@@ -23,6 +24,8 @@ abstract class AbstractFirDiagnosticTestSpec : AbstractFirDiagnosticTest() {
     }
 }
 
+abstract class AbstractFirPsiDiagnosticTestSpec : AbstractFirDiagnosticTestSpecBase(FirParser.Psi)
+
 fun TestConfigurationBuilder.baseFirSpecDiagnosticTestConfiguration(baseDir: String = ".") {
     defaultDirectives {
         +SPEC_HELPERS

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

@@ -5,11 +5,13 @@
 
 package org.jetbrains.kotlin.test.runners
 
+import org.jetbrains.kotlin.test.FirParser
 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.directives.LanguageSettingsDirectives
+import org.jetbrains.kotlin.test.directives.configureFirParser
 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.*
@@ -17,7 +19,10 @@ import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.preprocessors.JspecifyMarksCleanupPreprocessor
 import org.jetbrains.kotlin.test.services.fir.FirOldFrontendMetaConfigurator
 
-abstract class AbstractFirForeignAnnotationsTestBase(kind: ForeignAnnotationsTestKind) : AbstractForeignAnnotationsTestBase(kind) {
+abstract class AbstractFirForeignAnnotationsTestBase(
+    kind: ForeignAnnotationsTestKind,
+    val parser: FirParser
+) : AbstractForeignAnnotationsTestBase(kind) {
     override fun TestConfigurationBuilder.configureFrontend() {
         globalDefaults {
             frontend = FrontendKinds.FIR
@@ -27,6 +32,8 @@ abstract class AbstractFirForeignAnnotationsTestBase(kind: ForeignAnnotationsTes
             LanguageSettingsDirectives.LANGUAGE with "+EnableDfaWarningsInK2"
         }
 
+        configureFirParser(parser)
+
         useMetaInfoProcessors(::PsiLightTreeMetaInfoProcessor)
         firFrontendStep()
         firHandlersStep {
@@ -56,11 +63,11 @@ abstract class AbstractFirForeignAnnotationsTestBase(kind: ForeignAnnotationsTes
     }
 }
 
-abstract class AbstractFirForeignAnnotationsSourceJavaTest :
-    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.SOURCE)
+abstract class AbstractFirPsiForeignAnnotationsSourceJavaTest :
+    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.SOURCE, FirParser.Psi)
 
-abstract class AbstractFirForeignAnnotationsCompiledJavaTest :
-    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA)
+abstract class AbstractFirPsiForeignAnnotationsCompiledJavaTest :
+    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA, FirParser.Psi)
 
-abstract class AbstractFirForeignAnnotationsCompiledJavaWithPsiClassReadingTest :
-    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA_WITH_PSI_CLASS_LOADING)
+abstract class AbstractFirPsiForeignAnnotationsCompiledJavaWithPsiClassReadingTest :
+    AbstractFirForeignAnnotationsTestBase(ForeignAnnotationsTestKind.COMPILED_JAVA_WITH_PSI_CLASS_LOADING, FirParser.Psi)

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

@@ -108,7 +108,7 @@ private class FirForeignDiagnosticsTestDataConsistencyHandler(testServices: Test
     FirTestDataConsistencyHandler(testServices) {
 
     override fun correspondingFirTest(): AbstractKotlinCompilerTest =
-        object : AbstractFirForeignAnnotationsSourceJavaTest() {}
+        object : AbstractFirPsiForeignAnnotationsSourceJavaTest() {}
 }
 
 abstract class AbstractOldFrontendForeignAnnotationsTestBase(kind: ForeignAnnotationsTestKind) :

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

@@ -18,7 +18,8 @@ import org.jetbrains.kotlin.test.builders.configureClassicFrontendHandlersStep
 import org.jetbrains.kotlin.test.builders.configureFirHandlersStep
 import org.jetbrains.kotlin.test.builders.configureJvmArtifactsHandlersStep
 import org.jetbrains.kotlin.test.directives.AsmLikeInstructionListingDirectives.CHECK_ASM_LIKE_INSTRUCTIONS
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.USE_LIGHT_TREE
+import org.jetbrains.kotlin.test.FirParser
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
@@ -100,7 +101,7 @@ open class AbstractIrAsmLikeInstructionListingTest :
         get() = ::JvmIrBackendFacade
 }
 
-abstract class AbstractFirAsmLikeInstructionListingTestBase(val useLightTree: Boolean) :
+abstract class AbstractFirAsmLikeInstructionListingTestBase(val parser: FirParser) :
     AbstractAsmLikeInstructionListingTestBase<FirOutputArtifact, IrBackendInput>(
         FrontendKinds.FIR,
         TargetBackend.JVM_IR
@@ -117,12 +118,13 @@ abstract class AbstractFirAsmLikeInstructionListingTestBase(val useLightTree: Bo
 
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
-        if (useLightTree) {
-            builder.defaultDirectives { +USE_LIGHT_TREE }
-        }
+        builder.configureFirParser(parser)
     }
 }
 
-open class AbstractFirAsmLikeInstructionListingTest : AbstractFirAsmLikeInstructionListingTestBase(useLightTree = true)
+open class AbstractFirLightTreeAsmLikeInstructionListingTest : AbstractFirAsmLikeInstructionListingTestBase(FirParser.LightTree)
+
+@FirPsiCodegenTest
+open class AbstractFirPsiAsmLikeInstructionListingTest : AbstractFirAsmLikeInstructionListingTestBase(FirParser.Psi)
 
 

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

@@ -21,7 +21,7 @@ open class AbstractIrBlackBoxInlineCodegenTest : AbstractIrBlackBoxCodegenTest()
     }
 }
 
-open class AbstractFirBlackBoxInlineCodegenTest : AbstractFirBlackBoxCodegenTest() {
+open class AbstractFirLightTreeBlackBoxInlineCodegenTest : AbstractFirLightTreeBlackBoxCodegenTest() {
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         builder.useInlineHandlers()
@@ -32,8 +32,6 @@ open class AbstractFirBlackBoxInlineCodegenTest : AbstractFirBlackBoxCodegenTest
 open class AbstractFirPsiBlackBoxInlineCodegenTest : AbstractFirPsiBlackBoxCodegenTest() {
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
-        with(builder) {
-            useInlineHandlers()
-        }
+        builder.useInlineHandlers()
     }
 }

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.test.runners.codegen
 
 import org.jetbrains.kotlin.test.Constructor
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.backend.BlackBoxCodegenSuppressor
 import org.jetbrains.kotlin.test.backend.classic.ClassicBackendInput
@@ -15,9 +16,7 @@ import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.backend.ir.JvmIrBackendFacade
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.configureJvmArtifactsHandlersStep
-import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
-import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
+import org.jetbrains.kotlin.test.directives.*
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerWithTargetBackendTest
 import org.jetbrains.kotlin.test.frontend.classic.*
 import org.jetbrains.kotlin.test.frontend.fir.Fir2IrResultsConverter
@@ -81,7 +80,7 @@ open class AbstractIrBytecodeListingTest : AbstractBytecodeListingTestBase<Class
         get() = ::JvmIrBackendFacade
 }
 
-abstract class AbstractFirBytecodeListingTestBase(val useLightTree: Boolean) :
+abstract class AbstractFirBytecodeListingTestBase(val parser: FirParser) :
     AbstractBytecodeListingTestBase<FirOutputArtifact, IrBackendInput>(
         TargetBackend.JVM_IR,
         FrontendKinds.FIR
@@ -97,13 +96,11 @@ abstract class AbstractFirBytecodeListingTestBase(val useLightTree: Boolean) :
 
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
-        if (useLightTree) {
-            builder.defaultDirectives { +FirDiagnosticsDirectives.USE_LIGHT_TREE }
-        }
+        builder.configureFirParser(parser)
     }
 }
 
-open class AbstractFirBytecodeListingTest : AbstractFirBytecodeListingTestBase(useLightTree = true)
+open class AbstractFirLightTreeBytecodeListingTest : AbstractFirBytecodeListingTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
-open class AbstractFirPsiBytecodeListingTest : AbstractFirBytecodeListingTestBase(useLightTree = false)
+open class AbstractFirPsiBytecodeListingTest : AbstractFirBytecodeListingTestBase(FirParser.Psi)

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

@@ -18,7 +18,8 @@ import org.jetbrains.kotlin.test.builders.configureJvmArtifactsHandlersStep
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_REFLECT
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives.WITH_STDLIB
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
+import org.jetbrains.kotlin.test.FirParser
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
@@ -83,7 +84,7 @@ open class AbstractIrBytecodeTextTest : AbstractBytecodeTextTestBase<ClassicFron
         get() = ::JvmIrBackendFacade
 }
 
-open class AbstractFirBytecodeTextTestBase(val useLightTree: Boolean) : AbstractBytecodeTextTestBase<FirOutputArtifact, IrBackendInput>(
+open class AbstractFirBytecodeTextTestBase(val parser: FirParser) : AbstractBytecodeTextTestBase<FirOutputArtifact, IrBackendInput>(
     targetBackend = TargetBackend.JVM_IR,
     targetFrontend = FrontendKinds.FIR
 ) {
@@ -102,15 +103,13 @@ open class AbstractFirBytecodeTextTestBase(val useLightTree: Boolean) : Abstract
             defaultDirectives {
                 // See KT-44152
                 -USE_PSI_CLASS_FILES_READING
-                if (useLightTree) {
-                    +FirDiagnosticsDirectives.USE_LIGHT_TREE
-                }
+                builder.configureFirParser(parser)
             }
         }
     }
 }
 
-open class AbstractFirBytecodeTextTest : AbstractFirBytecodeTextTestBase(useLightTree = true)
+open class AbstractFirLightTreeBytecodeTextTest : AbstractFirBytecodeTextTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
-open class AbstractFirPsiBytecodeTextTest : AbstractFirBytecodeTextTestBase(useLightTree = false)
+open class AbstractFirPsiBytecodeTextTest : AbstractFirBytecodeTextTestBase(FirParser.Psi)

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

@@ -20,8 +20,9 @@ import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.configureIrHandlersStep
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.IGNORE_BACKEND_K2_MULTI_MODULE
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.IGNORE_BACKEND_MULTI_MODULE
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.SERIALIZE_IR
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.directives.model.ValueDirective
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
@@ -103,7 +104,7 @@ open class AbstractIrSerializeCompileKotlinAgainstInlineKotlinTest : AbstractIrC
     }
 }
 
-open class AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(val useLightTree: Boolean) :
+open class AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(val parser: FirParser) :
     AbstractCompileKotlinAgainstInlineKotlinTestBase<FirOutputArtifact, IrBackendInput>(FrontendKinds.FIR, TargetBackend.JVM_IR_SERIALIZE) {
 
     override val frontendFacade: Constructor<FrontendFacade<FirOutputArtifact>>
@@ -120,15 +121,13 @@ open class AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(val useL
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         builder.configureForSerialization()
-        if (useLightTree) {
-            builder.defaultDirectives { +FirDiagnosticsDirectives.USE_LIGHT_TREE }
-        }
+        builder.configureFirParser(parser)
     }
 }
 
-open class AbstractFirSerializeCompileKotlinAgainstInlineKotlinTest :
-    AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(useLightTree = true)
+open class AbstractFirLightTreeSerializeCompileKotlinAgainstInlineKotlinTest :
+    AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
 open class AbstractFirPsiSerializeCompileKotlinAgainstInlineKotlinTest :
-    AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(useLightTree = false)
+    AbstractFirSerializeCompileKotlinAgainstInlineKotlinTestBase(FirParser.Psi)

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

@@ -13,8 +13,9 @@ import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.configureFirHandlersStep
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives.WITH_STDLIB
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.USE_LIGHT_TREE
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.fir.Fir2IrResultsConverter
 import org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade
 import org.jetbrains.kotlin.test.frontend.fir.FirMetaInfoDiffSuppressor
@@ -26,7 +27,7 @@ import org.jetbrains.kotlin.test.frontend.fir.handlers.FirScopeDumpHandler
 import org.jetbrains.kotlin.test.model.*
 
 abstract class AbstractFirBlackBoxCodegenTestBase(
-    val useLightTree: Boolean
+    val parser: FirParser
 ) : AbstractJvmBlackBoxCodegenTestBase<FirOutputArtifact, IrBackendInput>(
     FrontendKinds.FIR,
     TargetBackend.JVM_IR
@@ -43,12 +44,10 @@ abstract class AbstractFirBlackBoxCodegenTestBase(
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {
+            configureFirParser(parser)
             defaultDirectives {
                 // See KT-44152
                 -USE_PSI_CLASS_FILES_READING
-                if (useLightTree) {
-                    +USE_LIGHT_TREE
-                }
             }
 
             forTestsMatching("*WithStdLib/*") {
@@ -84,7 +83,7 @@ abstract class AbstractFirBlackBoxCodegenTestBase(
     }
 }
 
-open class AbstractFirBlackBoxCodegenTest : AbstractFirBlackBoxCodegenTestBase(useLightTree = true)
+open class AbstractFirLightTreeBlackBoxCodegenTest : AbstractFirBlackBoxCodegenTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
-open class AbstractFirPsiBlackBoxCodegenTest : AbstractFirBlackBoxCodegenTestBase(useLightTree = false)
+open class AbstractFirPsiBlackBoxCodegenTest : AbstractFirBlackBoxCodegenTestBase(FirParser.Psi)

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

@@ -12,7 +12,8 @@ import org.jetbrains.kotlin.test.backend.classic.ClassicJvmBackendFacade
 import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.backend.ir.JvmIrBackendFacade
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
+import org.jetbrains.kotlin.test.FirParser
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
@@ -61,7 +62,7 @@ open class AbstractLocalVariableTest : AbstractLocalVariableTestBase<ClassicFron
     }
 }
 
-open class AbstractFirLocalVariableTestBase(val useLightTree: Boolean) : AbstractLocalVariableTestBase<FirOutputArtifact, IrBackendInput>(
+open class AbstractFirLocalVariableTestBase(val parser: FirParser) : AbstractLocalVariableTestBase<FirOutputArtifact, IrBackendInput>(
     FrontendKinds.FIR,
     TargetBackend.JVM_IR
 ) {
@@ -77,13 +78,11 @@ open class AbstractFirLocalVariableTestBase(val useLightTree: Boolean) : Abstrac
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         builder.configureDumpHandlersForCodegenTest()
-        if (useLightTree) {
-            builder.defaultDirectives { +FirDiagnosticsDirectives.USE_LIGHT_TREE }
-        }
+        builder.configureFirParser(parser)
     }
 }
 
-open class AbstractFirLocalVariableTest : AbstractFirLocalVariableTestBase(useLightTree = true)
+open class AbstractFirLightTreeLocalVariableTest : AbstractFirLocalVariableTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
-open class AbstractFirPsiLocalVariableTest : AbstractFirLocalVariableTestBase(useLightTree = false)
+open class AbstractFirPsiLocalVariableTest : AbstractFirLocalVariableTestBase(FirParser.Psi)

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

@@ -12,7 +12,8 @@ import org.jetbrains.kotlin.test.backend.classic.ClassicJvmBackendFacade
 import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.backend.ir.JvmIrBackendFacade
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
+import org.jetbrains.kotlin.test.FirParser
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
@@ -61,7 +62,7 @@ open class AbstractSteppingTest : AbstractSteppingTestBase<ClassicFrontendOutput
     }
 }
 
-open class AbstractFirSteppingTestBase(val useLightTree: Boolean) : AbstractSteppingTestBase<FirOutputArtifact, IrBackendInput>(
+open class AbstractFirSteppingTestBase(val parser: FirParser) : AbstractSteppingTestBase<FirOutputArtifact, IrBackendInput>(
     FrontendKinds.FIR,
     TargetBackend.JVM_IR
 ) {
@@ -77,13 +78,11 @@ open class AbstractFirSteppingTestBase(val useLightTree: Boolean) : AbstractStep
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         builder.configureDumpHandlersForCodegenTest()
-        if (useLightTree) {
-            builder.defaultDirectives { +FirDiagnosticsDirectives.USE_LIGHT_TREE }
-        }
+        builder.configureFirParser(parser)
     }
 }
 
-open class AbstractFirSteppingTest : AbstractFirSteppingTestBase(useLightTree = true)
+open class AbstractFirLightTreeSteppingTest : AbstractFirSteppingTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
-open class AbstractFirPsiSteppingTest : AbstractFirSteppingTestBase(useLightTree = false)
+open class AbstractFirPsiSteppingTest : AbstractFirSteppingTestBase(FirParser.Psi)

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

@@ -18,8 +18,9 @@ import org.jetbrains.kotlin.test.builders.firHandlersStep
 import org.jetbrains.kotlin.test.builders.irHandlersStep
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_IR
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_KT_IR
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact
@@ -116,7 +117,7 @@ open class AbstractIrTextTest : AbstractIrTextTestBase<ClassicFrontendOutputArti
     }
 }
 
-open class AbstractFir2IrTextTestBase(val useLightTree: Boolean) : AbstractIrTextTestBase<FirOutputArtifact>() {
+open class AbstractFirIrTextTestBase(val parser: FirParser) : AbstractIrTextTestBase<FirOutputArtifact>() {
     override val frontend: FrontendKind<*>
         get() = FrontendKinds.FIR
     override val frontendFacade: Constructor<FrontendFacade<FirOutputArtifact>>
@@ -127,12 +128,7 @@ open class AbstractFir2IrTextTestBase(val useLightTree: Boolean) : AbstractIrTex
     override fun configure(builder: TestConfigurationBuilder) {
         super.configure(builder)
         with(builder) {
-            if (useLightTree) {
-                defaultDirectives {
-                    +FirDiagnosticsDirectives.USE_LIGHT_TREE
-                }
-            }
-
+            configureFirParser(parser)
             useAfterAnalysisCheckers(
                 ::FirIrDumpIdenticalChecker,
                 ::BlackBoxCodegenSuppressor
@@ -147,12 +143,12 @@ open class AbstractFir2IrTextTestBase(val useLightTree: Boolean) : AbstractIrTex
     }
 }
 
-open class AbstractFir2IrTextTest : AbstractFir2IrTextTestBase(useLightTree = true)
+open class AbstractFirLightTreeIrTextTest : AbstractFirIrTextTestBase(FirParser.LightTree)
 
 @FirPsiCodegenTest
-open class AbstractFirPsi2IrTextTest : AbstractFir2IrTextTestBase(useLightTree = false)
+open class AbstractFirPsiIrTextTest : AbstractFirIrTextTestBase(FirParser.Psi)
 
-open class AbstractFir2IrJsTextTestBase(useLightTree: Boolean) : AbstractFir2IrTextTestBase(useLightTree) {
+open class AbstractFirIrJsTextTestBase(parser: FirParser) : AbstractFirIrTextTestBase(parser) {
     override fun TestConfigurationBuilder.applyConfigurators() {
         useConfigurators(
             ::CommonEnvironmentConfigurator,
@@ -175,4 +171,4 @@ open class AbstractFir2IrJsTextTestBase(useLightTree: Boolean) : AbstractFir2IrT
     }
 }
 
-open class AbstractFir2IrJsTextTest : AbstractFir2IrJsTextTestBase(useLightTree = true)
+open class AbstractFirLightTreeIrJsTextTest : AbstractFirIrJsTextTestBase(FirParser.LightTree)

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/ir/interpreter/AbstractIrInterpreterTest.kt

@@ -9,12 +9,14 @@ import org.jetbrains.kotlin.config.AnalysisFlag
 import org.jetbrains.kotlin.config.AnalysisFlags
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.test.FirParser
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.backend.BlackBoxCodegenSuppressor
 import org.jetbrains.kotlin.test.backend.handlers.IrInterpreterBackendHandler
 import org.jetbrains.kotlin.test.builders.*
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
+import org.jetbrains.kotlin.test.directives.configureFirParser
 import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
 import org.jetbrains.kotlin.test.model.BinaryKind
 import org.jetbrains.kotlin.test.model.DependencyKind
@@ -22,6 +24,7 @@ import org.jetbrains.kotlin.test.model.FrontendKind
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.preprocessors.IrInterpreterImplicitKotlinImports
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerWithTargetBackendTest
+import org.jetbrains.kotlin.test.runners.codegen.FirPsiCodegenTest
 import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator
@@ -81,7 +84,15 @@ open class AbstractJvmIrInterpreterTest(frontendKind: FrontendKind<*>) : Abstrac
     }
 }
 
-open class AbstractJvmIrInterpreterAfterFir2IrTest : AbstractJvmIrInterpreterTest(FrontendKinds.FIR)
+abstract class AbstractJvmIrInterpreterAfterFir2IrTestBase(val parser: FirParser) : AbstractJvmIrInterpreterTest(FrontendKinds.FIR) {
+    override fun configure(builder: TestConfigurationBuilder) {
+        super.configure(builder)
+        builder.configureFirParser(parser)
+    }
+}
+
+open class AbstractJvmIrInterpreterAfterFirPsi2IrTest : AbstractJvmIrInterpreterAfterFir2IrTestBase(FirParser.Psi)
+
 open class AbstractJvmIrInterpreterAfterPsi2IrTest : AbstractJvmIrInterpreterTest(FrontendKinds.ClassicFrontend)
 
 class IrInterpreterEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {