From 4ec369ac5be9dba9505948aab328431929d77e1a Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Mon, 1 Feb 2021 16:03:39 +0300 Subject: [PATCH] JVM_IR fix special bridge generation for inline classes --- .../FirBlackBoxCodegenTestGenerated.java | 28 +++++++++ .../backend/jvm/lower/BridgeLowering.kt | 18 +++--- .../inlineCollectionOfInlineClass.kt | 43 ++++++++++++++ .../inlineListOfInlineClass.kt | 56 ++++++++++++++++++ .../inlineMapOfInlineClass.kt | 57 +++++++++++++++++++ .../UIntArrayWithFullJdk_ir.txt | 2 +- .../collection_ir.txt | 2 +- .../inlineCollectionOfInlineClass/list_ir.txt | 6 +- .../inlineCollectionOfInlineClass/map_ir.txt | 5 +- .../mutableCollection_ir.txt | 2 +- .../mutableList_ir.txt | 6 +- .../mutableMap_ir.txt | 5 +- .../mutableSet2_ir.txt | 2 +- .../mutableSet_ir.txt | 2 +- .../inlineCollectionOfInlineClass/set_ir.txt | 2 +- .../specialBridges/unsignedArray_ir.txt | 2 +- .../codegen/BlackBoxCodegenTestGenerated.java | 28 +++++++++ .../IrBlackBoxCodegenTestGenerated.java | 28 +++++++++ .../LightAnalysisModeTestGenerated.java | 28 +++++++++ .../IrJsCodegenBoxES6TestGenerated.java | 28 +++++++++ .../IrJsCodegenBoxTestGenerated.java | 28 +++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 28 +++++++++ .../IrCodegenBoxWasmTestGenerated.java | 28 +++++++++ 23 files changed, 410 insertions(+), 24 deletions(-) create mode 100644 compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index 188314799ea..725024a531c 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -17356,6 +17356,34 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + public class InlineClassCollection extends AbstractFirBlackBoxCodegenTest { + @Test + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @Test + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @Test + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt index 6017d3fbd3b..78e97767e86 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt @@ -17,10 +17,8 @@ import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.codegen.isJvmInterface import org.jetbrains.kotlin.backend.jvm.ir.* import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.unboxInlineClass -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.descriptors.DescriptorVisibilities -import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.builders.* @@ -593,17 +591,23 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass fun computeJvmMethod(function: IrFunction): Method = signatureCache.getOrPut(function.symbol) { context.methodSignatureMapper.mapAsmMethod(function) } + private fun canHaveSpecialBridge(function: IrSimpleFunction): Boolean { + if (function.name in specialBridgeMethods.specialMethodNames) + return true + // Function name could be mangled by inline class rules + val functionName = function.name.asString() + if (specialBridgeMethods.specialMethodNames.any { functionName.startsWith(it.asString() + "-") }) + return true + return false + } + fun computeSpecialBridge(function: IrSimpleFunction): SpecialBridge? { // Optimization: do not try to compute special bridge for irrelevant methods. val correspondingProperty = function.correspondingPropertySymbol if (correspondingProperty != null) { if (correspondingProperty.owner.name !in specialBridgeMethods.specialPropertyNames) return null } else { - // 'remove' and 'removeAt' functions can be mangled by inline class rules - if (function.name !in specialBridgeMethods.specialMethodNames && - !function.name.asString().startsWith("removeAt-") && - !function.name.asString().startsWith("remove-") - ) { + if (!canHaveSpecialBridge(function)) { return null } } diff --git a/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt b/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt new file mode 100644 index 00000000000..284153155d9 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt @@ -0,0 +1,43 @@ +// WITH_RUNTIME + +inline class Z(val x: Int) + +inline class ZArray(val storage: IntArray) : Collection { + override val size: Int + get() = storage.size + + override fun contains(element: Z): Boolean { + return storage.contains(element.x) + } + + override fun containsAll(elements: Collection): Boolean { + return elements.all { contains(it) } + } + + override fun isEmpty(): Boolean { + return storage.isEmpty() + } + + private class ZArrayIterator(val storage: IntArray): Iterator { + var index = 0 + + override fun hasNext(): Boolean = index < storage.size + + override fun next(): Z = Z(storage[index++]) + } + + override fun iterator(): Iterator = ZArrayIterator(storage) +} + + +fun box(): String { + val zs = ZArray(IntArray(5)) + + val testSize = zs.size + if (testSize != 5) return "Failed: testSize=$testSize" + + val testContains = zs.contains(object {} as Any) + if (testContains) return "Failed: testContains=$testContains" + + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt b/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt new file mode 100644 index 00000000000..d97fafd4ea0 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt @@ -0,0 +1,56 @@ +// WITH_RUNTIME + +inline class Z(val x: Int) + +inline class ZArray(val storage: IntArray) : List { + override val size: Int + get() = storage.size + + override fun contains(element: Z): Boolean { + return storage.contains(element.x) + } + + override fun containsAll(elements: Collection): Boolean { + return elements.all { contains(it) } + } + + override fun isEmpty(): Boolean { + return storage.isEmpty() + } + + override fun get(index: Int): Z = Z(storage[index]) + + override fun indexOf(element: Z): Int = storage.indexOf(element.x) + + override fun lastIndexOf(element: Z): Int = storage.lastIndexOf(element.x) + + override fun listIterator(): ListIterator = ZArrayIterator(storage) + + override fun listIterator(index: Int): ListIterator = ZArrayIterator(storage, index) + + override fun subList(fromIndex: Int, toIndex: Int): List = TODO() + + private class ZArrayIterator(val storage: IntArray, var index: Int = 0): ListIterator { + override fun hasNext(): Boolean = index < storage.size + override fun next(): Z = Z(storage[index++]) + override fun nextIndex(): Int = index + 1 + + override fun hasPrevious(): Boolean = index > 0 + override fun previous(): Z = Z(storage[index--]) + override fun previousIndex(): Int = index - 1 + } + + override fun iterator(): Iterator = ZArrayIterator(storage) +} + + +fun box(): String { + val zs = ZArray(IntArray(5)) + + val testElement = object {} as Any + zs.contains(testElement) + zs.indexOf(testElement) + zs.lastIndexOf(testElement) + + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt b/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt new file mode 100644 index 00000000000..81fa9a51558 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt @@ -0,0 +1,57 @@ +// WITH_RUNTIME + +inline class Z(val x: Int) + +inline class ZArrayMap(val storage: IntArray) : Map { + override val size: Int + get() = storage.size + + private class MapEntry(val i: Int, val si: Int): Map.Entry { + override val key: Z get() = Z(i) + override val value: Z get() = Z(si) + } + + private class MapEntrySet(val storage: IntArray) : AbstractSet>() { + private inner class MyIterator : Iterator> { + var index = 0 + override fun hasNext(): Boolean = index < size + override fun next(): Map.Entry = MapEntry(index, storage[index++]) + } + + override val size: Int + get() = storage.size + + override fun iterator(): Iterator> = MyIterator() + } + + override val entries: Set> + get() = MapEntrySet(storage) + + override val keys: Set + get() = (0 until size).mapTo(HashSet()) { Z(it) } + + override val values: Collection + get() = storage.mapTo(ArrayList()) { Z(it) } + + override fun containsKey(key: Z): Boolean = key.x in (0 until size) + + override fun containsValue(value: Z): Boolean = storage.contains(value.x) + + override fun get(key: Z) = storage.getOrNull(key.x)?.let { Z(it) } + + override fun isEmpty(): Boolean = size > 0 +} + +fun box(): String { + val zm = ZArrayMap(IntArray(5)) + + zm.containsKey(Z(0)) + zm.containsValue(Z(0)) + zm[Z(0)] + + zm.containsKey(object {} as Any) + zm.containsValue(object {} as Any) + zm.get(object {} as Any) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt index 44b3d3082ac..0c1b909eada 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt @@ -29,7 +29,7 @@ public final class UIntArray { public synthetic final static method box-impl(p0: int[]): UIntArray public method clear(): void public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: int[]): int[] - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-fLmw4x8(p0: int): boolean public static method contains-fLmw4x8(p0: int[], p1: int): boolean public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/collection_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/collection_ir.txt index 120be8748b7..c10951b8475 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/collection_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/collection_ir.txt @@ -25,7 +25,7 @@ public final class InlineCollection { public synthetic final static method box-impl(p0: java.util.Collection): InlineCollection public method clear(): void public static method constructor-impl(p0: java.util.Collection): java.util.Collection - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-jHY5zpA(p0: int): boolean public static method contains-jHY5zpA(p0: java.util.Collection, p1: int): boolean public method containsAll(p0: java.util.Collection): boolean diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/list_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/list_ir.txt index 40a3cd61795..e8f71deff56 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/list_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/list_ir.txt @@ -28,7 +28,7 @@ public final class InlineList { public synthetic final static method box-impl(p0: java.util.List): InlineList public method clear(): void public static method constructor-impl(p0: java.util.List): java.util.List - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-jHY5zpA(p0: int): boolean public static method contains-jHY5zpA(p0: java.util.List, p1: int): boolean public method containsAll(p0: java.util.Collection): boolean @@ -43,14 +43,14 @@ public final class InlineList { public static method getSize-impl(p0: java.util.List): int public method hashCode(): int public static method hashCode-impl(p0: java.util.List): int - public synthetic bridge method indexOf(p0: java.lang.Object): int + public bridge final method indexOf(p0: java.lang.Object): int public method indexOf-jHY5zpA(p0: int): int public static method indexOf-jHY5zpA(p0: java.util.List, p1: int): int public method isEmpty(): boolean public static method isEmpty-impl(p0: java.util.List): boolean public method iterator(): java.util.Iterator public static method iterator-impl(p0: java.util.List): java.util.Iterator - public synthetic bridge method lastIndexOf(p0: java.lang.Object): int + public bridge final method lastIndexOf(p0: java.lang.Object): int public method lastIndexOf-jHY5zpA(p0: int): int public static method lastIndexOf-jHY5zpA(p0: java.util.List, p1: int): int public method listIterator(): java.util.ListIterator diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt index 8e8a274d498..da9c4407692 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt @@ -39,16 +39,17 @@ public final class InlineMap { public synthetic final static method box-impl(p0: java.util.Map): InlineMap public method clear(): void public static method constructor-impl(p0: java.util.Map): java.util.Map - public synthetic bridge method containsKey(p0: java.lang.Object): boolean + public bridge final method containsKey(p0: java.lang.Object): boolean public method containsKey-FSIWiWE(p0: int): boolean public static method containsKey-FSIWiWE(p0: java.util.Map, p1: int): boolean - public synthetic bridge method containsValue(p0: java.lang.Object): boolean + public bridge final method containsValue(p0: java.lang.Object): boolean public method containsValue-jbX5DO8(p0: double): boolean public static method containsValue-jbX5DO8(p0: java.util.Map, p1: double): boolean public synthetic bridge method entrySet(): java.util.Set public method equals(p0: java.lang.Object): boolean public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean + public bridge final method get(p0: java.lang.Object): IV public synthetic bridge method get(p0: java.lang.Object): java.lang.Object public method get-qgyy0Jc(p0: int): IV public static method get-qgyy0Jc(p0: java.util.Map, p1: int): IV diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableCollection_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableCollection_ir.txt index 73a1c6a8a28..575f2f46d03 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableCollection_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableCollection_ir.txt @@ -28,7 +28,7 @@ public final class InlineMutableCollection { public method clear(): void public static method clear-impl(p0: java.util.Collection): void public static method constructor-impl(p0: java.util.Collection): java.util.Collection - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-jHY5zpA(p0: int): boolean public static method contains-jHY5zpA(p0: java.util.Collection, p1: int): boolean public method containsAll(p0: java.util.Collection): boolean diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableList_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableList_ir.txt index e95e8ff4ae3..7af209ff5cc 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableList_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableList_ir.txt @@ -33,7 +33,7 @@ public final class InlineMutableList { public method clear(): void public static method clear-impl(p0: java.util.List): void public static method constructor-impl(p0: java.util.List): java.util.List - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public static method contains-jHY5zpA(p0: java.util.List, p1: long): boolean public method contains-jHY5zpA(p0: long): boolean public method containsAll(p0: java.util.Collection): boolean @@ -48,14 +48,14 @@ public final class InlineMutableList { public static method getSize-impl(p0: java.util.List): int public method hashCode(): int public static method hashCode-impl(p0: java.util.List): int - public synthetic bridge method indexOf(p0: java.lang.Object): int + public bridge final method indexOf(p0: java.lang.Object): int public static method indexOf-jHY5zpA(p0: java.util.List, p1: long): int public method indexOf-jHY5zpA(p0: long): int public method isEmpty(): boolean public static method isEmpty-impl(p0: java.util.List): boolean public method iterator(): java.util.Iterator public static method iterator-impl(p0: java.util.List): java.util.Iterator - public synthetic bridge method lastIndexOf(p0: java.lang.Object): int + public bridge final method lastIndexOf(p0: java.lang.Object): int public static method lastIndexOf-jHY5zpA(p0: java.util.List, p1: long): int public method lastIndexOf-jHY5zpA(p0: long): int public method listIterator(): java.util.ListIterator diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt index 3cd6ac061ca..c879e3ba8fe 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt @@ -40,16 +40,17 @@ public final class InlineMutableMap { public method clear(): void public static method clear-impl(p0: java.util.Map): void public static method constructor-impl(p0: java.util.Map): java.util.Map - public synthetic bridge method containsKey(p0: java.lang.Object): boolean + public bridge final method containsKey(p0: java.lang.Object): boolean public method containsKey-FSIWiWE(p0: int): boolean public static method containsKey-FSIWiWE(p0: java.util.Map, p1: int): boolean - public synthetic bridge method containsValue(p0: java.lang.Object): boolean + public bridge final method containsValue(p0: java.lang.Object): boolean public method containsValue-jbX5DO8(p0: double): boolean public static method containsValue-jbX5DO8(p0: java.util.Map, p1: double): boolean public synthetic bridge method entrySet(): java.util.Set public method equals(p0: java.lang.Object): boolean public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean + public bridge final method get(p0: java.lang.Object): IV public synthetic bridge method get(p0: java.lang.Object): java.lang.Object public method get-qgyy0Jc(p0: int): IV public static method get-qgyy0Jc(p0: java.util.Map, p1: int): IV diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet2_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet2_ir.txt index 2b408cd103b..c68d863467e 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet2_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet2_ir.txt @@ -45,7 +45,7 @@ public final class InlineMutableSet2 { public method clear(): void public static method clear-impl(p0: java.util.Set): void public static method constructor-impl(p0: java.util.Set): java.util.Set - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-C2ZI6mw(p0: int): boolean public static method contains-C2ZI6mw(p0: java.util.Set, p1: int): boolean public method containsAll(p0: java.util.Collection): boolean diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet_ir.txt index 0724572ec0e..4fc590cc770 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableSet_ir.txt @@ -28,7 +28,7 @@ public final class InlineMutableSet { public method clear(): void public static method clear-impl(p0: java.util.Set): void public static method constructor-impl(p0: java.util.Set): java.util.Set - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-jHY5zpA(p0: int): boolean public static method contains-jHY5zpA(p0: java.util.Set, p1: int): boolean public method containsAll(p0: java.util.Collection): boolean diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/set_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/set_ir.txt index 598f2a92f7c..377d4e338dc 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/set_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/set_ir.txt @@ -25,7 +25,7 @@ public final class InlineSet { public synthetic final static method box-impl(p0: java.util.Set): InlineSet public method clear(): void public static method constructor-impl(p0: java.util.Set): java.util.Set - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-jHY5zpA(p0: int): boolean public static method contains-jHY5zpA(p0: java.util.Set, p1: int): boolean public method containsAll(p0: java.util.Collection): boolean diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/unsignedArray_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/unsignedArray_ir.txt index a42fe476c10..e5962c29b60 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/unsignedArray_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/unsignedArray_ir.txt @@ -8,7 +8,7 @@ public final class UIntArray { public synthetic final static method box-impl(p0: int[]): UIntArray public method clear(): void public static method constructor-impl(p0: int[]): int[] - public synthetic bridge method contains(p0: java.lang.Object): boolean + public bridge final method contains(p0: java.lang.Object): boolean public method contains-WZ4Q5Ns(p0: int): boolean public static method contains-WZ4Q5Ns(p0: int[], p1: int): boolean public method containsAll(p0: java.util.Collection): boolean 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 fa8a769400f..fbd8c8d8487 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 @@ -17356,6 +17356,34 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + public class InlineClassCollection extends AbstractBlackBoxCodegenTest { + @Test + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Test + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @Test + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @Test + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") 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 baa98bc5e7a..4de1e3dfc00 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 @@ -17356,6 +17356,34 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + public class InlineClassCollection extends AbstractIrBlackBoxCodegenTest { + @Test + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @Test + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @Test + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index bd4b3d744f3..a5448fe6e4d 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -15191,6 +15191,34 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClassCollection extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) 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 21993b93b26..872d90e230b 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 @@ -13086,6 +13086,34 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClassCollection extends AbstractIrJsCodegenBoxES6Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR_ES6, testDataFilePath); + } + + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) 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 b947ffc7c3d..b85b2a4d70f 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 @@ -13086,6 +13086,34 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClassCollection extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) 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 85bb3588fd6..58a5b2bc99d 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 @@ -13151,6 +13151,34 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClassCollection extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) 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 94605af3d16..5de254d934a 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 @@ -7377,6 +7377,34 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClassCollection extends AbstractIrCodegenBoxWasmTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); + } + + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt"); + } + + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt"); + } + + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)