From ac7538a269f1349e4365366effb3be60e8b54946 Mon Sep 17 00:00:00 2001 From: Ilmir Usmanov Date: Thu, 8 Jul 2021 04:01:59 +0200 Subject: [PATCH] Set receivers for inline class default function stub calls Default function stubs have dispatch and receiver parameters, but inline class methods are static by design with receivers as ordinary parameters. So, take these parameters and set them as receivers during lowerings. #KT-46230: Fixed --- .../FirBlackBoxCodegenTestGenerated.java | 34 +++++++++++++++++++ .../lower/DefaultArgumentStubGenerator.kt | 34 +++++++++++++++---- .../backend/jvm/codegen/ExpressionCodegen.kt | 4 ++- .../jvm/lower/JvmDefaultParameterInjector.kt | 3 ++ .../all-compatibility.kt | 28 +++++++++++++++ .../all.kt | 28 +++++++++++++++ .../compatibility.kt | 28 +++++++++++++++ .../default.kt | 27 +++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 34 +++++++++++++++++++ .../IrBlackBoxCodegenTestGenerated.java | 34 +++++++++++++++++++ .../LightAnalysisModeTestGenerated.java | 33 ++++++++++++++++++ .../IrJsCodegenBoxES6TestGenerated.java | 13 +++++++ .../IrJsCodegenBoxTestGenerated.java | 13 +++++++ .../semantics/JsCodegenBoxTestGenerated.java | 13 +++++++ .../IrCodegenBoxWasmTestGenerated.java | 13 +++++++ 15 files changed, 332 insertions(+), 7 deletions(-) create mode 100644 compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index e009cbff9ce..e8d0328bcd9 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -19778,6 +19778,40 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + public class OverrideFunctionWithDefaultParameter { + @Test + @TestMetadata("all.kt") + public void testAll() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt"); + } + + @Test + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("all-compatibility.kt") + public void testAll_compatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt"); + } + + @Test + @TestMetadata("compatibility.kt") + public void testCompatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt"); + } + + @Test + @TestMetadata("default.kt") + public void testDefault() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt"); + } + } } @Nested diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt index 980220244b9..ffbbd6b703e 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt @@ -303,17 +303,30 @@ open class DefaultParameterInjector( } symbol.owner.typeParameters.forEach { log { "${symbol.owner}[${it.index}] : $it" } } + val isStatic = isStatic(expression.symbol.owner) + return builder(symbol).apply { copyTypeArgumentsFrom(expression) - params.forEachIndexed { i, value -> + var receivers = 0 + + if (isStatic) { + if (symbol.owner.dispatchReceiverParameter != null) { + dispatchReceiver = params[receivers++] + } + if (symbol.owner.extensionReceiverParameter != null) { + extensionReceiver = params[receivers++] + } + } else { + dispatchReceiver = expression.dispatchReceiver + extensionReceiver = expression.extensionReceiver + } + + params.drop(receivers).forEachIndexed { i, value -> log { "call::params@$i/${symbol.owner.valueParameters[i].name}: ${ir2string(value)}" } putValueArgument(i, value) } - dispatchReceiver = expression.dispatchReceiver - extensionReceiver = expression.extensionReceiver - log { "call::extension@: ${ir2string(expression.extensionReceiver)}" } log { "call::dispatch@: ${ir2string(expression.dispatchReceiver)}" } } @@ -393,12 +406,19 @@ open class DefaultParameterInjector( val realArgumentsNumber = declaration.valueParameters.size val maskValues = IntArray((declaration.valueParameters.size + 31) / 32) - assert((stubFunction.valueParameters.size - realArgumentsNumber - maskValues.size) in listOf(0, 1)) { + assert( + ((if (isStatic(expression.symbol.owner) && stubFunction.extensionReceiverParameter != null) 1 else 0) + + stubFunction.valueParameters.size - realArgumentsNumber - maskValues.size) in listOf(0, 1) + ) { "argument count mismatch: expected $realArgumentsNumber arguments + ${maskValues.size} masks + optional handler/marker, " + "got ${stubFunction.valueParameters.size} total in ${stubFunction.render()}" } var sourceParameterIndex = -1 - return stubFunction.symbol to stubFunction.valueParameters.mapIndexed { i, parameter -> + val valueParametersPrefix = + if (isStatic(expression.symbol.owner)) + listOfNotNull(stubFunction.dispatchReceiverParameter, stubFunction.extensionReceiverParameter) + else emptyList() + return stubFunction.symbol to (valueParametersPrefix + stubFunction.valueParameters).mapIndexed { i, parameter -> if (!parameter.isMovedReceiver()) { ++sourceParameterIndex } @@ -438,6 +458,8 @@ open class DefaultParameterInjector( protected open fun useConstructorMarker(function: IrFunction) = function is IrConstructor + protected open fun isStatic(function: IrFunction): Boolean = false + private fun log(msg: () -> String) = context.log { "DEFAULT-INJECTOR: ${msg()}" } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index ee3af74557d..a68cc5f09e4 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -482,7 +482,9 @@ class ExpressionCodegen( expression.symbol.owner.valueParameters.forEachIndexed { i, irParameter -> val arg = expression.getValueArgument(i) val parameterType = callable.valueParameterTypes[i] - require(arg != null) { "Null argument in ExpressionCodegen for parameter ${irParameter.render()}" } + require(arg != null) { + "Null argument in ExpressionCodegen for parameter ${irParameter.render()}" + } callGenerator.genValueAndPut(irParameter, arg, parameterType, this, data) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt index 61af4736a82..1ed09f758bd 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt @@ -32,4 +32,7 @@ class JvmDefaultParameterInjector(context: JvmBackendContext) : override fun useConstructorMarker(function: IrFunction): Boolean = function is IrConstructor || function.origin == JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_CONSTRUCTOR + + override fun isStatic(function: IrFunction): Boolean = + function.origin == JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_REPLACEMENT } diff --git a/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt new file mode 100644 index 00000000000..13015dd6abb --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt @@ -0,0 +1,28 @@ +// !LANGUAGE: +InlineClasses + +// !JVM_DEFAULT_MODE: all-compatibility +// TARGET_BACKEND: JVM +// IGNORE_BACKEND: JVM +// JVM_TARGET: 1.8 + +interface Path { + fun dispatch(maxDepth: Int = 42) + fun Int.extension(maxDepth: Int = 42) +} + +inline class RealPath(val x: Int) : Path { + override fun dispatch(maxDepth: Int) = Unit + + fun childrenDispatch(recursively: Boolean): Unit = + if (recursively) dispatch() else dispatch() + + override fun Int.extension(maxDepth: Int) = Unit + + fun Int.childrenExtension(recursively: Boolean): Unit = + if (recursively) extension() else extension() +} + +fun box(): String { + RealPath(1) + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt new file mode 100644 index 00000000000..f71fc05e9a3 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt @@ -0,0 +1,28 @@ +// !LANGUAGE: +InlineClasses + +// !JVM_DEFAULT_MODE: all +// TARGET_BACKEND: JVM +// IGNORE_BACKEND: JVM +// JVM_TARGET: 1.8 + +interface Path { + fun dispatch(maxDepth: Int = 42) + fun Int.extension(maxDepth: Int = 42) +} + +inline class RealPath(val x: Int) : Path { + override fun dispatch(maxDepth: Int) = Unit + + fun childrenDispatch(recursively: Boolean): Unit = + if (recursively) dispatch() else dispatch() + + override fun Int.extension(maxDepth: Int) = Unit + + fun Int.childrenExtension(recursively: Boolean): Unit = + if (recursively) extension() else extension() +} + +fun box(): String { + RealPath(1) + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt new file mode 100644 index 00000000000..1c82144d755 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt @@ -0,0 +1,28 @@ +// !LANGUAGE: +InlineClasses + +// !JVM_DEFAULT_MODE: compatibility +// TARGET_BACKEND: JVM +// IGNORE_BACKEND: JVM +// JVM_TARGET: 1.8 + +interface Path { + fun dispatch(maxDepth: Int = 42) + fun Int.extension(maxDepth: Int = 42) +} + +inline class RealPath(val x: Int) : Path { + override fun dispatch(maxDepth: Int) = Unit + + fun childrenDispatch(recursively: Boolean): Unit = + if (recursively) dispatch() else dispatch() + + override fun Int.extension(maxDepth: Int) = Unit + + fun Int.childrenExtension(recursively: Boolean): Unit = + if (recursively) extension() else extension() +} + +fun box(): String { + RealPath(1) + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt new file mode 100644 index 00000000000..a30f4a2de7d --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt @@ -0,0 +1,27 @@ +// !LANGUAGE: +InlineClasses + +// TARGET_BACKEND: JVM +// IGNORE_BACKEND: JVM +// JVM_TARGET: 1.8 + +interface Path { + fun dispatch(maxDepth: Int = 42) + fun Int.extension(maxDepth: Int = 42) +} + +inline class RealPath(val x: Int) : Path { + override fun dispatch(maxDepth: Int) = Unit + + fun childrenDispatch(recursively: Boolean): Unit = + if (recursively) dispatch() else dispatch() + + override fun Int.extension(maxDepth: Int) = Unit + + fun Int.childrenExtension(recursively: Boolean): Unit = + if (recursively) extension() else extension() +} + +fun box(): String { + RealPath(1) + return "OK" +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java index 83486084e63..40116653e90 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java @@ -19736,6 +19736,40 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + public class OverrideFunctionWithDefaultParameter { + @Test + @TestMetadata("all.kt") + public void testAll() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt"); + } + + @Test + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Test + @TestMetadata("all-compatibility.kt") + public void testAll_compatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt"); + } + + @Test + @TestMetadata("compatibility.kt") + public void testCompatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt"); + } + + @Test + @TestMetadata("default.kt") + public void testDefault() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt"); + } + } } @Nested diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index ebc58b4f655..2b059caac87 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java @@ -19778,6 +19778,40 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + public class OverrideFunctionWithDefaultParameter { + @Test + @TestMetadata("all.kt") + public void testAll() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt"); + } + + @Test + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("all-compatibility.kt") + public void testAll_compatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt"); + } + + @Test + @TestMetadata("compatibility.kt") + public void testCompatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt"); + } + + @Test + @TestMetadata("default.kt") + public void testDefault() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt"); + } + } } @Nested diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 2cc8d5b6bfc..b2b13479044 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -16384,6 +16384,39 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OverrideFunctionWithDefaultParameter extends AbstractLightAnalysisModeTest { + @TestMetadata("all.kt") + public void ignoreAll() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt"); + } + + @TestMetadata("all-compatibility.kt") + public void ignoreAll_compatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt"); + } + + @TestMetadata("compatibility.kt") + public void ignoreCompatibility() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt"); + } + + @TestMetadata("default.kt") + public void ignoreDefault() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt"); + } + + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + } } @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java index c9b1154d5a4..938ad8f3c9f 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java @@ -14383,6 +14383,19 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OverrideFunctionWithDefaultParameter extends AbstractIrJsCodegenBoxES6Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR_ES6, testDataFilePath); + } + + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + } } @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index 2b2b8e619a4..34a734a161f 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -13789,6 +13789,19 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OverrideFunctionWithDefaultParameter extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + } } @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index b5034b462ea..57561d42b96 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -13854,6 +13854,19 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OverrideFunctionWithDefaultParameter extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + } } @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java index 77920479aff..4b1ce864116 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java @@ -7779,6 +7779,19 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt"); } + + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OverrideFunctionWithDefaultParameter extends AbstractIrCodegenBoxWasmTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); + } + + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } } @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface")