From 2727163a63c9fcdfdd94a9bfb5912f8d9ad66e12 Mon Sep 17 00:00:00 2001 From: Sergej Jaskiewicz Date: Tue, 25 Jul 2023 12:45:37 +0200 Subject: [PATCH] [test] Introduce `DeserializedIrBackend` backend kind We have `BackendKinds.IrBackend` for IR emitted by the frontend. We need a different backend kind for IR deserialized from klibs. We cannot use `BackendKinds.IrBackend` for that purpose, because we cannot have two different `IrBackendInput` subclasses with the same kind. We need a different `IrBackendInput` subclass for deserialized IR because the `IrBackendInput` for frontend-emitted IR contains some properties like `sourceFiles` which don't make sense for deserialized IR. Since we now have two backend kinds for IR artifacts, we need to make certain functions and classes in the test infrastructure generic over backend kinds. Note: the JsIrDeserializedFromKlibBackendInput class is not used anywhere yet. We will use it in the coming commits. --- .../kotlin/test/TestConfiguration.kt | 10 +++- .../org/jetbrains/kotlin/test/TestStep.kt | 58 +++++++++++++------ .../jetbrains/kotlin/test/TestStepBuilder.kt | 35 +++++++---- .../test/services/DependencyProvider.kt | 12 +++- .../backend/handlers/AbstractIrHandler.kt | 4 +- .../IrMangledNameAndSignatureDumpHandler.kt | 6 +- .../handlers/IrPrettyKotlinDumpHandler.kt | 6 +- .../backend/handlers/IrTextDumpHandler.kt | 6 +- .../backend/handlers/IrTreeVerifierHandler.kt | 6 +- .../kotlin/test/backend/ir/IrBackendInput.kt | 19 +++++- .../test/builders/CompilerTestDslHelpers.kt | 42 +++++++++----- .../test/builders/TestConfigurationBuilder.kt | 45 ++++++++------ .../kotlin/test/model/TestArtifactKinds.kt | 10 ++++ .../codegen/BaseCodegenConfiguration.kt | 27 +++++---- .../kotlin/js/test/ir/AbstractJsIrTest.kt | 9 ++- 15 files changed, 208 insertions(+), 87 deletions(-) diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt index b21012685cb..d1625e14d04 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt @@ -16,7 +16,11 @@ import org.jetbrains.kotlin.test.services.ModuleStructureExtractor import org.jetbrains.kotlin.test.services.PreAnalysisHandler import org.jetbrains.kotlin.test.services.TestServices -typealias Constructor = (TestServices) -> T +typealias Constructor = (TestServices) -> R + +typealias Constructor2 = (TestServices, T) -> R + +typealias Constructor3 = (TestServices, T1, T2) -> R abstract class TestConfiguration { abstract val rootDisposable: Disposable @@ -44,11 +48,11 @@ abstract class TestConfiguration { // ---------------------------- Utils ---------------------------- -fun ((TestServices, T) -> R).bind(value: T): Constructor { +fun Constructor2.bind(value: T): Constructor { return { this.invoke(it, value) } } -fun ((TestServices, T1, T2) -> R).bind(value1: T1, value2: T2): Constructor { +fun Constructor3.bind(value1: T1, value2: T2): Constructor { return { this.invoke(it, value1, value2) } } diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStep.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStep.kt index 53aae2bebbb..7e491501080 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStep.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStep.kt @@ -8,27 +8,41 @@ package org.jetbrains.kotlin.test import org.jetbrains.kotlin.test.TestRunner.Companion.shouldRun import org.jetbrains.kotlin.test.model.* -sealed class TestStep, O : ResultingArtifact> { - abstract val inputArtifactKind: TestArtifactKind +sealed class TestStep + where InputArtifact : ResultingArtifact, + OutputArtifact : ResultingArtifact { + abstract val inputArtifactKind: TestArtifactKind open fun shouldProcessModule(module: TestModule, inputArtifact: ResultingArtifact<*>): Boolean { return inputArtifact.kind == inputArtifactKind } - abstract fun processModule(module: TestModule, inputArtifact: I, thereWereExceptionsOnPreviousSteps: Boolean): StepResult + abstract fun processModule( + module: TestModule, + inputArtifact: InputArtifact, + thereWereExceptionsOnPreviousSteps: Boolean, + ): StepResult - class FacadeStep, O : ResultingArtifact>(val facade: AbstractTestFacade) : TestStep() { - override val inputArtifactKind: TestArtifactKind + class FacadeStep( + val facade: AbstractTestFacade, + ) : TestStep() + where InputArtifact : ResultingArtifact, + OutputArtifact : ResultingArtifact { + override val inputArtifactKind: TestArtifactKind get() = facade.inputKind - val outputArtifactKind: TestArtifactKind + val outputArtifactKind: TestArtifactKind get() = facade.outputKind override fun shouldProcessModule(module: TestModule, inputArtifact: ResultingArtifact<*>): Boolean { return super.shouldProcessModule(module, inputArtifact) && facade.shouldRunAnalysis(module) } - override fun processModule(module: TestModule, inputArtifact: I, thereWereExceptionsOnPreviousSteps: Boolean): StepResult { + override fun processModule( + module: TestModule, + inputArtifact: InputArtifact, + thereWereExceptionsOnPreviousSteps: Boolean, + ): StepResult { val outputArtifact = try { facade.transform(module, inputArtifact) ?: return StepResult.NoArtifactFromFacade } catch (e: Throwable) { @@ -39,17 +53,22 @@ sealed class TestStep, O : ResultingArtifact> { } } - class HandlersStep>( - override val inputArtifactKind: TestArtifactKind, - val handlers: List> - ) : TestStep() { + class HandlersStep>( + override val inputArtifactKind: TestArtifactKind, + val handlers: List> + ) : TestStep() { init { - require(handlers.all { it.artifactKind == inputArtifactKind }) + for (handler in handlers) { + require(handler.artifactKind == inputArtifactKind) { + "Artifact kind mismatch. Artifact kind of each handler must match input artifact kind ($inputArtifactKind). " + + "In handler $handler artifact kind is ${handler.artifactKind}" + } + } } override fun processModule( module: TestModule, - inputArtifact: I, + inputArtifact: InputArtifact, thereWereExceptionsOnPreviousSteps: Boolean ): StepResult.HandlersResult { val exceptions = mutableListOf() @@ -69,15 +88,20 @@ sealed class TestStep, O : ResultingArtifact> { } } - sealed class StepResult> { - class Artifact>(val outputArtifact: O) : StepResult() - class ErrorFromFacade>(val exception: WrappedException) : StepResult() + sealed class StepResult> { + + class Artifact>(val outputArtifact: OutputArtifact) : + StepResult() + + class ErrorFromFacade>(val exception: WrappedException) : + StepResult() + data class HandlersResult( val exceptionsFromHandlers: Collection, val shouldRunNextSteps: Boolean ) : StepResult() - object NoArtifactFromFacade : StepResult() + data object NoArtifactFromFacade : StepResult() } } diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStepBuilder.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStepBuilder.kt index 05b847dc5c5..3f60f0068dd 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStepBuilder.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestStepBuilder.kt @@ -8,38 +8,49 @@ package org.jetbrains.kotlin.test import org.jetbrains.kotlin.test.model.* import org.jetbrains.kotlin.test.services.TestServices -sealed class TestStepBuilder, O : ResultingArtifact> { +sealed class TestStepBuilder + where InputArtifact : ResultingArtifact, + OutputArtifact : ResultingArtifact { @TestInfrastructureInternals - abstract fun createTestStep(testServices: TestServices): TestStep + abstract fun createTestStep(testServices: TestServices): TestStep } -class FacadeStepBuilder, O : ResultingArtifact>( - val facade: Constructor> -) : TestStepBuilder() { +class FacadeStepBuilder( + val facade: Constructor>, +) : TestStepBuilder() + where InputArtifact : ResultingArtifact, + OutputArtifact : ResultingArtifact { @TestInfrastructureInternals - override fun createTestStep(testServices: TestServices): TestStep.FacadeStep { + override fun createTestStep(testServices: TestServices): TestStep.FacadeStep { return TestStep.FacadeStep(facade.invoke(testServices)) } } -class HandlersStepBuilder>(val artifactKind: TestArtifactKind) : TestStepBuilder() { - private val handlers: MutableList>> = mutableListOf() +class HandlersStepBuilder(val artifactKind: InputArtifactKind) : + TestStepBuilder() + where InputArtifact : ResultingArtifact, + InputArtifactKind : TestArtifactKind { + private val handlers: MutableList>> = mutableListOf() - fun useHandlers(vararg constructor: Constructor>) { + fun useHandlers(vararg constructor: Constructor>) { handlers += constructor } - fun useHandlersAtFirst(vararg constructor: Constructor>) { + fun useHandlers(vararg constructor: Constructor2>) { + constructor.mapTo(handlers) { it.bind(artifactKind) } + } + + fun useHandlersAtFirst(vararg constructor: Constructor>) { handlers.addAll(0, constructor.toList()) } - fun useHandlers(constructors: List>>) { + fun useHandlers(constructors: List>>) { handlers += constructors } @TestInfrastructureInternals - override fun createTestStep(testServices: TestServices): TestStep.HandlersStep { + override fun createTestStep(testServices: TestServices): TestStep.HandlersStep { return TestStep.HandlersStep(artifactKind, handlers.map { it.invoke(testServices) }) } } diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt index 3ee7693e606..7fac29be9f3 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt @@ -35,16 +35,22 @@ class DependencyProviderImpl( return testModulesByName[name] ?: assertions.fail { "Module $name is not defined" } } - override fun > getArtifactSafe(module: TestModule, kind: TestArtifactKind): A? { + override fun > getArtifactSafe( + module: TestModule, + kind: TestArtifactKind, + ): OutputArtifact? { @Suppress("UNCHECKED_CAST") - return artifactsByModule.getMap(module)[kind] as A? + return artifactsByModule.getMap(module)[kind] as OutputArtifact? } override fun > getArtifact(module: TestModule, kind: TestArtifactKind): A { return getArtifactSafe(module, kind) ?: error("Artifact with kind $kind is not registered for module ${module.name}") } - fun > registerArtifact(module: TestModule, artifact: ResultingArtifact) { + fun > registerArtifact( + module: TestModule, + artifact: ResultingArtifact, + ) { val kind = artifact.kind val previousValue = artifactsByModule.getMap(module).put(kind, artifact) if (previousValue != null) error("Artifact with kind $kind already registered for module ${module.name}") diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/AbstractIrHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/AbstractIrHandler.kt index 4526ed0d70f..dcfa49c6f99 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/AbstractIrHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/AbstractIrHandler.kt @@ -7,11 +7,13 @@ package org.jetbrains.kotlin.test.backend.handlers import org.jetbrains.kotlin.test.backend.ir.IrBackendInput import org.jetbrains.kotlin.test.model.BackendInputHandler +import org.jetbrains.kotlin.test.model.BackendKind import org.jetbrains.kotlin.test.model.BackendKinds import org.jetbrains.kotlin.test.services.TestServices abstract class AbstractIrHandler( testServices: TestServices, + artifactKind: BackendKind = BackendKinds.IrBackend, failureDisablesNextSteps: Boolean = false, doNotRunIfThereWerePreviousFailures: Boolean = false -) : BackendInputHandler(testServices, BackendKinds.IrBackend, failureDisablesNextSteps, doNotRunIfThereWerePreviousFailures) +) : BackendInputHandler(testServices, artifactKind, failureDisablesNextSteps, doNotRunIfThereWerePreviousFailures) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrMangledNameAndSignatureDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrMangledNameAndSignatureDumpHandler.kt index db2b4dc04b7..60e7190629e 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrMangledNameAndSignatureDumpHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrMangledNameAndSignatureDumpHandler.kt @@ -35,6 +35,7 @@ import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_LOCAL_DEC import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_SIGNATURES import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.MUTE_SIGNATURE_COMPARISON_K2 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.SKIP_SIGNATURE_DUMP +import org.jetbrains.kotlin.test.model.BackendKind import org.jetbrains.kotlin.test.model.FrontendKinds import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices @@ -92,7 +93,10 @@ private const val CHECK_MARKER = "// CHECK" * any backends, we print the actual mangled name and signature for this declaration. * - Otherwise, we print the parsed `// CHECK` block as is. */ -class IrMangledNameAndSignatureDumpHandler(testServices: TestServices) : AbstractIrHandler(testServices) { +class IrMangledNameAndSignatureDumpHandler( + testServices: TestServices, + artifactKind: BackendKind, +) : AbstractIrHandler(testServices, artifactKind) { companion object { const val DUMP_EXTENSION = "sig.kt.txt" diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrPrettyKotlinDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrPrettyKotlinDumpHandler.kt index d709fae772b..b63a1ccf238 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrPrettyKotlinDumpHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrPrettyKotlinDumpHandler.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.EXTERNAL_FILE import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.SKIP_KT_DUMP import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.model.BackendKind import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices import org.jetbrains.kotlin.test.services.moduleStructure @@ -30,7 +31,10 @@ import org.jetbrains.kotlin.test.utils.withExtension * This handler can be enabled by specifying the [DUMP_KT_IR] test directive, * or disabled with the [SKIP_KT_DUMP] directive. */ -class IrPrettyKotlinDumpHandler(testServices: TestServices) : AbstractIrHandler(testServices) { +class IrPrettyKotlinDumpHandler( + testServices: TestServices, + artifactKind: BackendKind, +) : AbstractIrHandler(testServices, artifactKind) { companion object { const val DUMP_EXTENSION = "kt.txt" } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt index d0e5be56ef6..3abceedbdba 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.EXTERNAL_FILE import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.FIR_IDENTICAL import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.model.BackendKind import org.jetbrains.kotlin.test.model.FrontendKinds import org.jetbrains.kotlin.test.model.TestFile import org.jetbrains.kotlin.test.model.TestModule @@ -31,7 +32,10 @@ import org.jetbrains.kotlin.test.utils.withExtension import org.jetbrains.kotlin.test.utils.withSuffixAndExtension import java.io.File -class IrTextDumpHandler(testServices: TestServices) : AbstractIrHandler(testServices) { +class IrTextDumpHandler( + testServices: TestServices, + artifactKind: BackendKind, +) : AbstractIrHandler(testServices, artifactKind) { companion object { const val DUMP_EXTENSION = "ir.txt" diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt index 5e558c2ba50..4dabbcf4d46 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt @@ -14,11 +14,15 @@ import org.jetbrains.kotlin.test.backend.ir.IrBackendInput import org.jetbrains.kotlin.test.directives.CodegenTestDirectives import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.EXTERNAL_FILE import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.model.BackendKind import org.jetbrains.kotlin.test.model.FrontendKinds import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices -class IrTreeVerifierHandler(testServices: TestServices) : AbstractIrHandler(testServices) { +class IrTreeVerifierHandler( + testServices: TestServices, + artifactKind: BackendKind, +) : AbstractIrHandler(testServices, artifactKind) { override val directiveContainers: List get() = listOf(CodegenTestDirectives) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt index 3f771ad209f..3f48a698c5e 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt @@ -18,12 +18,13 @@ import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.util.KotlinMangler import org.jetbrains.kotlin.metadata.ProtoBuf +import org.jetbrains.kotlin.test.model.BackendKind import org.jetbrains.kotlin.test.model.BackendKinds import org.jetbrains.kotlin.test.model.ResultingArtifact // IR backend (JVM, JS, Native, Wasm) sealed class IrBackendInput : ResultingArtifact.BackendInput() { - override val kind: BackendKinds.IrBackend + override val kind: BackendKind get() = BackendKinds.IrBackend abstract val irModuleFragment: IrModuleFragment @@ -93,6 +94,22 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput() { val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment, ) : IrBackendInput() + data class JsIrDeserializedFromKlibBackendInput( + override val irModuleFragment: IrModuleFragment, + override val dependentIrModuleFragments: List, + override val irPluginContext: IrPluginContext, + override val diagnosticReporter: BaseDiagnosticsCollector, + override val descriptorMangler: KotlinMangler.DescriptorMangler, + override val irMangler: KotlinMangler.IrMangler, + override val firMangler: FirMangler?, + ) : IrBackendInput() { + + override val kind: BackendKind + get() = BackendKinds.DeserializedIrBackend + + override var irActualizerResult: IrActualizedResult? = null + } + class WasmBackendInput( override val irModuleFragment: IrModuleFragment, override val dependentIrModuleFragments: List, diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt index e127b2f6674..90bb948755b 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt @@ -10,6 +10,7 @@ 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.CompilerStepsNames.CLASSIC_FRONTEND_HANDLERS_STEP_NAME +import org.jetbrains.kotlin.test.builders.CompilerStepsNames.DESERIALIZED_IR_HANDLERS_STEP_NAME import org.jetbrains.kotlin.test.builders.CompilerStepsNames.FIR_HANDLERS_STEP_NAME import org.jetbrains.kotlin.test.builders.CompilerStepsNames.JS_ARTIFACTS_HANDLERS_STEP_NAME import org.jetbrains.kotlin.test.builders.CompilerStepsNames.JVM_ARTIFACTS_HANDLERS_STEP_NAME @@ -35,6 +36,7 @@ object CompilerStepsNames { const val CONVERTER_STEP_NAME = "converter" const val RAW_IR_HANDLERS_STEP_NAME = "raw IR handlers" + const val DESERIALIZED_IR_HANDLERS_STEP_NAME = "deserialized IR handlers" const val JVM_BACKEND_STEP_NAME = "jvm backend" const val JVM_ARTIFACTS_HANDLERS_STEP_NAME = "jvm artifacts handlers" @@ -78,86 +80,98 @@ fun TestConfigurationBuilder.jvmIrBackendStep() { // use those ones to define new step inline fun TestConfigurationBuilder.classicFrontendHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(CLASSIC_FRONTEND_HANDLERS_STEP_NAME, FrontendKinds.ClassicFrontend, init) } inline fun TestConfigurationBuilder.firHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(FIR_HANDLERS_STEP_NAME, FrontendKinds.FIR, init) } inline fun TestConfigurationBuilder.irHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(RAW_IR_HANDLERS_STEP_NAME, BackendKinds.IrBackend, init) } +inline fun TestConfigurationBuilder.deserializedIrHandlersStep( + init: HandlersStepBuilder.() -> Unit = {} +) { + namedHandlersStep(DESERIALIZED_IR_HANDLERS_STEP_NAME, BackendKinds.DeserializedIrBackend, init) +} + inline fun TestConfigurationBuilder.jvmArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(JVM_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Jvm, init) } inline fun TestConfigurationBuilder.jsArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(JS_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Js, init) } inline fun TestConfigurationBuilder.wasmArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(WASM_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Wasm, init) } inline fun TestConfigurationBuilder.klibArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { namedHandlersStep(KLIB_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.KLib, init) } // and those ones to configure already defined step inline fun TestConfigurationBuilder.configureClassicFrontendHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(CLASSIC_FRONTEND_HANDLERS_STEP_NAME, FrontendKinds.ClassicFrontend, init) } inline fun TestConfigurationBuilder.configureFirHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(FIR_HANDLERS_STEP_NAME, FrontendKinds.FIR, init) } inline fun TestConfigurationBuilder.configureIrHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(RAW_IR_HANDLERS_STEP_NAME, BackendKinds.IrBackend, init) } +inline fun TestConfigurationBuilder.configureDeserializedIrHandlersStep( + init: HandlersStepBuilder.() -> Unit = {} +) { + configureNamedHandlersStep(DESERIALIZED_IR_HANDLERS_STEP_NAME, BackendKinds.DeserializedIrBackend, init) +} + inline fun TestConfigurationBuilder.configureJvmArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(JVM_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Jvm, init) } inline fun TestConfigurationBuilder.configureJsArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(JS_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Js, init) } inline fun TestConfigurationBuilder.configureWasmArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(WASM_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Wasm, init) } inline fun TestConfigurationBuilder.configureKlibArtifactsHandlersStep( - init: HandlersStepBuilder.() -> Unit = {} + init: HandlersStepBuilder.() -> Unit = {} ) { configureNamedHandlersStep(KLIB_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.KLib, init) } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt index 9e37bd55435..1006111b332 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt @@ -104,45 +104,52 @@ class TestConfigurationBuilder { } } - inline fun > handlersStep( - artifactKind: TestArtifactKind, - init: HandlersStepBuilder.() -> Unit - ): HandlersStepBuilder { + inline fun handlersStep( + artifactKind: InputArtifactKind, + init: HandlersStepBuilder.() -> Unit, + ): HandlersStepBuilder + where InputArtifact : ResultingArtifact, + InputArtifactKind : TestArtifactKind { return HandlersStepBuilder(artifactKind).also { it.init() steps += it } } - inline fun > namedHandlersStep( + inline fun namedHandlersStep( name: String, - artifactKind: TestArtifactKind, - init: HandlersStepBuilder.() -> Unit - ): HandlersStepBuilder { - val previouslyContainedStep = namedStepOfType(name) - if (previouslyContainedStep == null) { + artifactKind: InputArtifactKind, + init: HandlersStepBuilder.() -> Unit, + ): HandlersStepBuilder + where InputArtifact : ResultingArtifact, + InputArtifactKind : TestArtifactKind { + val previouslyContainedStep = namedStepOfType(name) + return if (previouslyContainedStep == null) { val step = handlersStep(artifactKind, init) namedSteps[name] = step - return step + step } else { configureNamedHandlersStep(name, artifactKind, init) - return previouslyContainedStep + previouslyContainedStep } } - inline fun > configureNamedHandlersStep( + inline fun configureNamedHandlersStep( name: String, - artifactKind: TestArtifactKind, - init: HandlersStepBuilder.() -> Unit - ) { - val step = namedStepOfType(name) ?: error { "Step \"$name\" not found" } + artifactKind: InputArtifactKind, + init: HandlersStepBuilder.() -> Unit + ) where InputArtifact : ResultingArtifact, + InputArtifactKind : TestArtifactKind { + val step = namedStepOfType(name) ?: error { "Step \"$name\" not found" } require(step.artifactKind == artifactKind) { "Step kind: ${step.artifactKind}, passed kind is $artifactKind" } step.apply(init) } - fun > namedStepOfType(name: String): HandlersStepBuilder? { + fun namedStepOfType(name: String): HandlersStepBuilder? + where InputArtifact : ResultingArtifact, + InputArtifactKind : TestArtifactKind { @Suppress("UNCHECKED_CAST") - return namedSteps[name] as HandlersStepBuilder? + return namedSteps[name] as HandlersStepBuilder? } fun useSourcePreprocessor(vararg preprocessors: Constructor, needToPrepend: Boolean = false) { diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt index 288e8b156e9..e123201a61b 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt @@ -29,12 +29,22 @@ val FrontendKind<*>.isFir: Boolean object BackendKinds { object ClassicBackend : BackendKind("ClassicBackend") + + /** + * The artifact kind representing IR generated by the frontend. + */ object IrBackend : BackendKind("IrBackend") + /** + * The artifact kind representing IR deserialized from a klib. + */ + object DeserializedIrBackend : BackendKind("DeserializedIrBackend") + fun fromString(string: String): BackendKind<*>? { return when (string) { "ClassicBackend" -> ClassicBackend "IrBackend" -> IrBackend + "DeserializedIrBackend" -> DeserializedIrBackend else -> null } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/codegen/BaseCodegenConfiguration.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/codegen/BaseCodegenConfiguration.kt index 143aa01db1b..551d49dd872 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/codegen/BaseCodegenConfiguration.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/codegen/BaseCodegenConfiguration.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.backend.handlers.* import org.jetbrains.kotlin.test.backend.ir.IrActualizerAndPluginsFacade import org.jetbrains.kotlin.test.backend.ir.IrBackendInput -import org.jetbrains.kotlin.test.backend.ir.IrDiagnosticsHandler +import org.jetbrains.kotlin.test.bind import org.jetbrains.kotlin.test.builders.* import org.jetbrains.kotlin.test.directives.CodegenTestDirectives import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.DUMP_SMAP @@ -151,46 +151,51 @@ fun TestConfigurationBuilder.commonHandlersForCodegenTest() { } } -fun HandlersStepBuilder.dumpHandlersForConverterStep() { - useHandlers(::IrTreeVerifierHandler, ::IrTextDumpHandler, ::IrMangledNameAndSignatureDumpHandler) +fun HandlersStepBuilder.dumpHandlersForConverterStep() + where InputArtifactKind : BackendKind { + useHandlers( + ::IrTreeVerifierHandler, + ::IrTextDumpHandler, + ::IrMangledNameAndSignatureDumpHandler, + ) } -fun HandlersStepBuilder.dumpHandlersForBackendStep() { +fun HandlersStepBuilder.dumpHandlersForBackendStep() { useHandlers(::BytecodeListingHandler) } -fun HandlersStepBuilder.boxHandlersForBackendStep() { +fun HandlersStepBuilder.boxHandlersForBackendStep() { useHandlers(::JvmBoxRunner) } -fun HandlersStepBuilder.steppingHandlersForBackendStep() { +fun HandlersStepBuilder.steppingHandlersForBackendStep() { useHandlers(::SteppingDebugRunner) } -fun HandlersStepBuilder.localVariableHandlersForBackendStep() { +fun HandlersStepBuilder.localVariableHandlersForBackendStep() { useHandlers(::LocalVariableDebugRunner) } -fun HandlersStepBuilder.commonClassicFrontendHandlersForCodegenTest() { +fun HandlersStepBuilder.commonClassicFrontendHandlersForCodegenTest() { useHandlers( ::NoCompilationErrorsHandler, ) } -fun HandlersStepBuilder.commonFirHandlersForCodegenTest() { +fun HandlersStepBuilder.commonFirHandlersForCodegenTest() { useHandlers( ::NoFirCompilationErrorsHandler, ) } -fun HandlersStepBuilder.commonBackendHandlersForCodegenTest() { +fun HandlersStepBuilder.commonBackendHandlersForCodegenTest() { useHandlers( ::NoJvmSpecificCompilationErrorsHandler, ::DxCheckerHandler, ) } -fun HandlersStepBuilder.inlineHandlers() { +fun HandlersStepBuilder.inlineHandlers() { useHandlers( ::BytecodeInliningHandler, ::SMAPDumpHandler diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsIrTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsIrTest.kt index b87b6cffba5..fba4d1d3cc3 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsIrTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsIrTest.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.parsing.parseBoolean import org.jetbrains.kotlin.test.Constructor import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.bind import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.builders.configureJsArtifactsHandlersStep import org.jetbrains.kotlin.test.builders.jsArtifactsHandlersStep @@ -207,7 +208,9 @@ open class AbstractIrJsSteppingTest : AbstractJsIrTest( } useAdditionalSourceProviders(::JsSteppingTestAdditionalSourceProvider) jsArtifactsHandlersStep { - useHandlers({ JsDebugRunner(it, localVariables = false) }) + useHandlers( + ::JsDebugRunner.bind(false) + ) } } } @@ -223,7 +226,9 @@ open class AbstractIrJsLocalVariableTest : AbstractJsIrTest( } useAdditionalSourceProviders(::JsSteppingTestAdditionalSourceProvider) jsArtifactsHandlersStep { - useHandlers({ JsDebugRunner(it, localVariables = true) }) + useHandlers( + ::JsDebugRunner.bind(true) + ) } } }