From 2a524920a5a503e0f36fb6359786bcc4603f2c00 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Thu, 23 Aug 2018 18:09:14 +0300 Subject: [PATCH] Don't remap inline function args requiring inline class boxing/unboxing Same as for primitives: inline lambda expects to see a boxed value, so, even if an argument is a local variable, it can't be remapped, because it contains unboxed representation. --- .../jetbrains/kotlin/codegen/StackValue.java | 29 +++++++++++++++++ .../kotlin/codegen/inline/InlineCodegen.kt | 19 +++++++---- ...efaultValueOfInlineClassTypeInInlineFun.kt | 32 +++++++++++++++++++ .../inlineClassesAsInlineFunParameters.kt | 26 +++++++++++++++ ...ClassesRefTypesInInlineLambdaParameters.kt | 25 +++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 15 +++++++++ .../LightAnalysisModeTestGenerated.java | 15 +++++++++ .../ir/IrBlackBoxCodegenTestGenerated.java | 15 +++++++++ .../IrJsCodegenBoxTestGenerated.java | 15 +++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 15 +++++++++ 10 files changed, 200 insertions(+), 6 deletions(-) create mode 100644 compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java index c977c62ba27..8ec6394a0c2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java @@ -487,6 +487,33 @@ public abstract class StackValue { coerce(fromType, toType, v); } + public static boolean requiresInlineClassBoxingOrUnboxing( + @NotNull Type fromType, + @Nullable KotlinType fromKotlinType, + @NotNull Type toType, + @Nullable KotlinType toKotlinType + ) { + // NB see also coerceInlineClasses below + + if (fromKotlinType == null || toKotlinType == null) return false; + + boolean isFromTypeInlineClass = InlineClassesUtilsKt.isInlineClassType(fromKotlinType); + boolean isToTypeInlineClass = InlineClassesUtilsKt.isInlineClassType(toKotlinType); + + if (!isFromTypeInlineClass && !isToTypeInlineClass) return false; + + boolean isFromTypeUnboxed = isFromTypeInlineClass && isUnboxedInlineClass(fromKotlinType, fromType); + boolean isToTypeUnboxed = isToTypeInlineClass && isUnboxedInlineClass(toKotlinType, toType); + + if (isFromTypeInlineClass && isToTypeInlineClass) { + return isFromTypeUnboxed != isToTypeUnboxed; + } + else { + return isFromTypeInlineClass /* && !isToTypeInlineClass */ && isFromTypeUnboxed || + isToTypeInlineClass /* && !isFromTypeInlineClass */ && isToTypeUnboxed; + } + } + private static boolean coerceInlineClasses( @NotNull Type fromType, @Nullable KotlinType fromKotlinType, @@ -494,6 +521,8 @@ public abstract class StackValue { @Nullable KotlinType toKotlinType, @NotNull InstructionAdapter v ) { + // NB see also requiresInlineClassBoxingOrUnboxing above + if (fromKotlinType == null || toKotlinType == null) return false; boolean isFromTypeInlineClass = InlineClassesUtilsKt.isInlineClassType(fromKotlinType); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt index 7f3b53d5cb4..8db7a815b18 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt @@ -326,13 +326,14 @@ abstract class InlineCodegen( ) { val isDefaultParameter = kind === ValueKind.DEFAULT_PARAMETER val jvmType = jvmKotlinType.type - if (!isDefaultParameter && shouldPutGeneralValue(jvmType, stackValue)) { - stackValue.put(jvmType, jvmKotlinType.kotlinType, codegen.v) + val kotlinType = jvmKotlinType.kotlinType + if (!isDefaultParameter && shouldPutGeneralValue(jvmType, kotlinType, stackValue)) { + stackValue.put(jvmType, kotlinType, codegen.v) } if (!asFunctionInline && Type.VOID_TYPE !== jvmType) { //TODO remap only inlinable closure => otherwise we could get a lot of problem - val couldBeRemapped = !shouldPutGeneralValue(jvmType, stackValue) && kind !== ValueKind.DEFAULT_PARAMETER + val couldBeRemapped = !shouldPutGeneralValue(jvmType, kotlinType, stackValue) && kind !== ValueKind.DEFAULT_PARAMETER val remappedValue = if (couldBeRemapped) stackValue else null val info: ParameterInfo @@ -603,11 +604,17 @@ abstract class InlineCodegen( /*descriptor is null for captured vars*/ - private fun shouldPutGeneralValue(type: Type, stackValue: StackValue): Boolean { + private fun shouldPutGeneralValue(type: Type, kotlinType: KotlinType?, stackValue: StackValue): Boolean { //remap only inline functions (and maybe non primitives) - //TODO - clean asserion and remapping logic + //TODO - clean assertion and remapping logic + + // don't remap boxing/unboxing primitives if (isPrimitive(type) != isPrimitive(stackValue.type)) { - //don't remap boxing/unboxing primitives - lost identity and perfomance + return true + } + + // don't remap boxing/unboxing inline classes + if (StackValue.requiresInlineClassBoxingOrUnboxing(stackValue.type, stackValue.kotlinType, type, kotlinType)) { return true } diff --git a/compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt b/compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt new file mode 100644 index 00000000000..cefca461fda --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt @@ -0,0 +1,32 @@ +// !LANGUAGE: +InlineClasses +// IGNORE_BACKEND: JVM_IR + +inline class Z(val int: Int) +inline class L(val long: Long) +inline class Str(val string: String) +inline class Obj(val obj: Any) + +inline fun withDefaultZ(fn: (Z) -> R, x: Z = Z(42)) = fn(x) +inline fun withDefaultL(fn: (L) -> R, x: L = L(42L)) = fn(x) +inline fun withDefaultL2(x: L = L(42L), fn: (L) -> R) = fn(x) +inline fun withDefaultStr(fn: (Str) -> R, x: Str = Str("abc")) = fn(x) +inline fun withDefaultObj(fn: (Obj) -> R, x: Obj = Obj("abc")) = fn(x) +inline fun withDefaultObj2(x: Obj = Obj("abc"), fn: (Obj) -> R) = fn(x) + +fun testWithDefaultZ() = withDefaultZ({ Z(it.int + 1) }) +fun testWithDefaultL() = withDefaultL({ L(it.long + 1L) }) +fun testWithDefaultL2() = withDefaultL2(fn = { L(it.long + 1L) }) +fun testWithDefaultStr() = withDefaultStr({ Str(it.string + "1") }) +fun testWithDefaultObj() = withDefaultObj({ Obj(it.obj.toString() + "1") }) +fun testWithDefaultObj2() = withDefaultObj2(fn = { Obj(it.obj.toString() + "1") }) + +fun box(): String { + if (testWithDefaultZ().int != 43) throw AssertionError() + if (testWithDefaultL().long != 43L) throw AssertionError() + if (testWithDefaultL2().long != 43L) throw AssertionError() + if (testWithDefaultStr().string != "abc1") throw AssertionError() + if (testWithDefaultObj().obj != "abc1") throw AssertionError() + if (testWithDefaultObj2().obj != "abc1") throw AssertionError() + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt b/compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt new file mode 100644 index 00000000000..22843d64361 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt @@ -0,0 +1,26 @@ +// !LANGUAGE: +InlineClasses +// IGNORE_BACKEND: JVM_IR + +inline class Z(val int: Int) +inline class L(val long: Long) +inline class Str(val string: String) +inline class Obj(val obj: Any) + +inline fun s1Z(x: Z, fn: (Int, Z) -> R) = fn(1, x) +inline fun s1L(x: L, fn: (Int, L) -> R) = fn(1, x) +inline fun s1Str(x: Str, fn: (Int, Str) -> R) = fn(1, x) +inline fun s1Obj(x: Obj, fn: (Int, Obj) -> R) = fn(1, x) + +fun testS1Z(a: Z) = s1Z(a) { i, xx -> Z(xx.int + i) } +fun testS1L(a: L) = s1L(a) { i, xx -> L(xx.long + i.toLong()) } +fun testS1Str(a: Str) = s1Str(a) { i, xx -> Str(xx.string + i.toString()) } +fun testS1Obj(a: Obj) = s1Obj(a) { i, xx -> Obj(xx.obj.toString() + i.toString()) } + +fun box(): String { + if (testS1Z(Z(42)).int != 43) throw AssertionError() + if (testS1L(L(42L)).long != 43L) throw AssertionError() + if (testS1Str(Str("abc")).string != "abc1") throw AssertionError() + if (testS1Obj(Obj("abc")).obj != "abc1") throw AssertionError() + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt b/compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt new file mode 100644 index 00000000000..98112d69018 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt @@ -0,0 +1,25 @@ +// !LANGUAGE: +InlineClasses +// IGNORE_BACKEND: JVM_IR + +inline class Str(val string: String) +inline class Obj(val obj: Any) + +inline fun s0(x: T, fn: (Int, T) -> R) = fn(0, x) + +inline fun weirdMix(x: T, fn: (Int, T, Long, T) -> R) = fn(0, x, 0L, x) + +fun testS0Str(x: Str) = s0(x) { _, xx -> Str(xx.string + "123") } +fun testS0Any(x: Obj) = s0(x) { _, xx -> Obj(xx.obj.toString() + "123") } + +fun testWeirdMixStr(x: Str) = weirdMix(x) { _, xx, _, _ -> Str(xx.string + "123") } +fun testWeirdMixAny(x: Obj) = weirdMix(x) { _, xx, _, _ -> Obj(xx.obj.toString() + "123") } + +fun box(): String { + if (testS0Str(Str("abc")).string != "abc123") throw AssertionError() + if (testS0Any(Obj("abc")).obj != "abc123") throw AssertionError() + + if (testWeirdMixStr(Str("abc")).string != "abc123") throw AssertionError() + if (testWeirdMixAny(Obj("abc")).obj != "abc123") throw AssertionError() + + return "OK" +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 73883d6c5e2..e7048075903 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -11515,6 +11515,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt"); } + @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") + public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt"); + } + @TestMetadata("elvisWithInlineClassAndNullConstant.kt") public void testElvisWithInlineClassAndNullConstant() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt"); @@ -11565,6 +11570,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt"); } + @TestMetadata("inlineClassesAsInlineFunParameters.kt") + public void testInlineClassesAsInlineFunParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt"); + } + @TestMetadata("inlineClassesCheckCast.kt") public void testInlineClassesCheckCast() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt"); @@ -11575,6 +11585,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt"); } + @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") + public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt"); + } + @TestMetadata("inlineFunctionInsideInlineClass.kt") public void testInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 6bff014f99e..d71930cb909 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -11515,6 +11515,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt"); } + @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") + public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt"); + } + @TestMetadata("elvisWithInlineClassAndNullConstant.kt") public void testElvisWithInlineClassAndNullConstant() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt"); @@ -11565,6 +11570,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt"); } + @TestMetadata("inlineClassesAsInlineFunParameters.kt") + public void testInlineClassesAsInlineFunParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt"); + } + @TestMetadata("inlineClassesCheckCast.kt") public void testInlineClassesCheckCast() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt"); @@ -11575,6 +11585,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt"); } + @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") + public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt"); + } + @TestMetadata("inlineFunctionInsideInlineClass.kt") public void testInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index a7853e3be0c..4eaa9439136 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -11515,6 +11515,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt"); } + @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") + public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt"); + } + @TestMetadata("elvisWithInlineClassAndNullConstant.kt") public void testElvisWithInlineClassAndNullConstant() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt"); @@ -11565,6 +11570,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt"); } + @TestMetadata("inlineClassesAsInlineFunParameters.kt") + public void testInlineClassesAsInlineFunParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt"); + } + @TestMetadata("inlineClassesCheckCast.kt") public void testInlineClassesCheckCast() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt"); @@ -11575,6 +11585,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt"); } + @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") + public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt"); + } + @TestMetadata("inlineFunctionInsideInlineClass.kt") public void testInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java index 023cedae434..fd875bf6cdc 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java @@ -10080,6 +10080,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt"); } + @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") + public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt"); + } + @TestMetadata("elvisWithInlineClassAndNullConstant.kt") public void testElvisWithInlineClassAndNullConstant() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt"); @@ -10125,6 +10130,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt"); } + @TestMetadata("inlineClassesAsInlineFunParameters.kt") + public void testInlineClassesAsInlineFunParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt"); + } + @TestMetadata("inlineClassesCheckCast.kt") public void testInlineClassesCheckCast() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt"); @@ -10135,6 +10145,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt"); } + @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") + public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt"); + } + @TestMetadata("inlineFunctionInsideInlineClass.kt") public void testInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index def02109e7f..c2d94186a3c 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -11140,6 +11140,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt"); } + @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") + public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultValueOfInlineClassTypeInInlineFun.kt"); + } + @TestMetadata("elvisWithInlineClassAndNullConstant.kt") public void testElvisWithInlineClassAndNullConstant() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt"); @@ -11185,6 +11190,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt"); } + @TestMetadata("inlineClassesAsInlineFunParameters.kt") + public void testInlineClassesAsInlineFunParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt"); + } + @TestMetadata("inlineClassesCheckCast.kt") public void testInlineClassesCheckCast() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt"); @@ -11195,6 +11205,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt"); } + @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") + public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt"); + } + @TestMetadata("inlineFunctionInsideInlineClass.kt") public void testInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt");