From 500b1cfbd3a0b453ab8f7fbab6db1e438db57167 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 4 Nov 2020 17:54:11 +0100 Subject: [PATCH] JVM IR: fix flags of $default methods in multi-file facades Do not change origin of multifile class bridges to something else because, as it turns out, there are numerous origin-specific checks in the codegen that start to behave differently for multifile bridges. Instead of the method-targeted origin MULTIFILE_BRIDGE, use new class origin JVM_MULTIFILE_CLASS to detect whether a declaration is a multifile bridge. #KT-40198 Fixed #KT-43145 Fixed --- .../kotlin/backend/jvm/DeclarationOrigins.kt | 1 - .../backend/jvm/JvmGeneratorExtensions.kt | 7 ++-- .../backend/jvm/codegen/CoroutineCodegen.kt | 5 ++- .../backend/jvm/codegen/ExpressionCodegen.kt | 36 ++++++++--------- .../jvm/lower/GenerateMultifileFacades.kt | 8 ++-- .../backend/jvm/lower/ResolveInlineCalls.kt | 9 ++--- .../ir/declarations/IrDeclarationOrigin.kt | 2 + .../org/jetbrains/kotlin/ir/util/IrUtils.kt | 5 ++- .../functionInMultifileClass.kt | 24 ++++++++++++ .../functionInMultifileClass.txt | 37 ++++++++++++++++++ ...ctionInMultifileClassWithInheritedParts.kt | 24 ++++++++++++ ...tionInMultifileClassWithInheritedParts.txt | 27 +++++++++++++ .../functionInMultifileClass_ir.txt | 39 +++++++++++++++++++ .../privateFunctionInMultifilePart.kt | 7 ---- .../privateFunctionInMultifilePart.txt | 11 ------ .../privateFunctionInMultifilePart_ir.txt | 12 ------ .../main/multifileSuspend_ir.txt | 2 +- .../codegen/BytecodeListingTestGenerated.java | 15 ++++--- .../ir/IrBytecodeListingTestGenerated.java | 15 ++++--- 19 files changed, 210 insertions(+), 76 deletions(-) create mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass.kt create mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass.txt create mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClassWithInheritedParts.kt create mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClassWithInheritedParts.txt create mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass_ir.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart_ir.txt diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/DeclarationOrigins.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/DeclarationOrigins.kt index e0fbc650e86..df9079d9a83 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/DeclarationOrigins.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/DeclarationOrigins.kt @@ -18,7 +18,6 @@ interface JvmLoweredDeclarationOrigin : IrDeclarationOrigin { object DEFAULT_IMPLS_BRIDGE_FOR_COMPATIBILITY : IrDeclarationOriginImpl("DEFAULT_IMPLS_BRIDGE_FOR_COMPATIBILITY") object DEFAULT_IMPLS_BRIDGE_TO_SYNTHETIC : IrDeclarationOriginImpl("DEFAULT_IMPLS_BRIDGE_TO_SYNTHETIC", isSynthetic = true) object DEFAULT_IMPLS_BRIDGE_FOR_COMPATIBILITY_SYNTHETIC : IrDeclarationOriginImpl("DEFAULT_IMPLS_BRIDGE_FOR_COMPATIBILITY_SYNTHETIC", isSynthetic = true) - object MULTIFILE_BRIDGE : IrDeclarationOriginImpl("MULTIFILE_BRIDGE") object FIELD_FOR_OUTER_THIS : IrDeclarationOriginImpl("FIELD_FOR_OUTER_THIS") object LAMBDA_IMPL : IrDeclarationOriginImpl("LAMBDA_IMPL") object FUNCTION_REFERENCE_IMPL : IrDeclarationOriginImpl("FUNCTION_REFERENCE_IMPL", isSynthetic = true) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensions.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensions.kt index 9402c6867ee..a2efe1faecf 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensions.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensions.kt @@ -65,11 +65,10 @@ class JvmGeneratorExtensions(private val generateFacades: Boolean = true) : Gene IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB override fun generateFacadeClass(irFactory: IrFactory, source: DeserializedContainerSource): IrClass? { - if (!generateFacades) return null - val jvmPackagePartSource = source as? JvmPackagePartSource ?: return null - val facadeName = jvmPackagePartSource.facadeClassName ?: jvmPackagePartSource.className + if (!generateFacades || source !is JvmPackagePartSource) return null + val facadeName = source.facadeClassName ?: source.className return irFactory.buildClass { - origin = IrDeclarationOrigin.FILE_CLASS + origin = if (source.facadeClassName != null) IrDeclarationOrigin.JVM_MULTIFILE_CLASS else IrDeclarationOrigin.FILE_CLASS name = facadeName.fqNameForTopLevelClassMaybeWithDollars.shortName() }.also { it.createParameterDeclarations() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt index 11052d390b0..85851b064f8 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.ir.isStaticInlineClassReplacement import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.InlineClassAbi import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.unboxInlineClass +import org.jetbrains.kotlin.backend.jvm.lower.isMultifileBridge import org.jetbrains.kotlin.backend.jvm.lower.suspendFunctionOriginal import org.jetbrains.kotlin.codegen.ClassBuilder import org.jetbrains.kotlin.codegen.coroutines.CoroutineTransformerMethodVisitor @@ -143,7 +144,6 @@ internal fun IrFunction.shouldContainSuspendMarkers(): Boolean = !isInvokeSuspen // These are tail-call bridges and do not require any bytecode modifications. origin != IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER && origin != JvmLoweredDeclarationOrigin.JVM_OVERLOADS_WRAPPER && - origin != JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE && origin != JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR && origin != JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR_FOR_HIDDEN_CONSTRUCTOR && origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE && @@ -153,6 +153,7 @@ internal fun IrFunction.shouldContainSuspendMarkers(): Boolean = !isInvokeSuspen origin != IrDeclarationOrigin.BRIDGE && origin != IrDeclarationOrigin.BRIDGE_SPECIAL && origin != IrDeclarationOrigin.DELEGATED_MEMBER && + !isMultifileBridge() && !isInvokeOfSuspendCallableReference() && !isBridgeToSuspendImplMethod() && !isStaticInlineClassReplacementDelegatingCall() @@ -199,4 +200,4 @@ internal fun IrFunction.originalReturnTypeOfSuspendFunctionReturningUnboxedInlin } != false) return null // Don't box other inline classes return returnType -} \ No newline at end of file +} 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 07a7bccc5c1..ff207eabad7 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 @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.backend.jvm.intrinsics.JavaClassProperty import org.jetbrains.kotlin.backend.jvm.lower.MultifileFacadeFileEntry import org.jetbrains.kotlin.backend.jvm.lower.constantValue import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.unboxInlineClass +import org.jetbrains.kotlin.backend.jvm.lower.isMultifileBridge import org.jetbrains.kotlin.backend.jvm.lower.suspendFunctionOriginal import org.jetbrains.kotlin.codegen.* import org.jetbrains.kotlin.codegen.AsmUtil.* @@ -213,7 +214,7 @@ class ExpressionCodegen( fun generate() { mv.visitCode() val startLabel = markNewLabel() - if (irFunction.origin == JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE) { + if (irFunction.isMultifileBridge()) { // Multifile bridges need to have line number 1 to be filtered out by the intellij debugging filters. mv.visitLineNumber(1, startLabel) } @@ -279,23 +280,22 @@ class ExpressionCodegen( if (state.isParamAssertionsDisabled) return - val notCallableFromJava = inlinedInto != null || - (DescriptorVisibilities.isPrivate(irFunction.visibility) && !(irFunction is IrSimpleFunction && irFunction.isOperator)) || - irFunction.origin.isSynthetic || - // TODO: refine this condition to not generate nullability assertions on parameters - // corresponding to captured variables and anonymous object super constructor arguments - (irFunction is IrConstructor && irFunction.parentAsClass.isAnonymousObject) || - // TODO: Implement this as a lowering, so that we can more easily exclude generated methods. - irFunction.origin == JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD || - // Although these are accessible from Java, the functions they bridge to already have the assertions. - irFunction.origin == IrDeclarationOrigin.BRIDGE_SPECIAL || - irFunction.origin == JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE || - irFunction.origin == JvmLoweredDeclarationOrigin.JVM_STATIC_WRAPPER || - irFunction.origin == JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE || - irFunction.parentAsClass.origin == JvmLoweredDeclarationOrigin.CONTINUATION_CLASS || - irFunction.parentAsClass.origin == JvmLoweredDeclarationOrigin.SUSPEND_LAMBDA - - if (notCallableFromJava) + if (inlinedInto != null || + (DescriptorVisibilities.isPrivate(irFunction.visibility) && !(irFunction is IrSimpleFunction && irFunction.isOperator)) || + irFunction.origin.isSynthetic || + // TODO: refine this condition to not generate nullability assertions on parameters + // corresponding to captured variables and anonymous object super constructor arguments + (irFunction is IrConstructor && irFunction.parentAsClass.isAnonymousObject) || + // TODO: Implement this as a lowering, so that we can more easily exclude generated methods. + irFunction.origin == JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD || + // Although these are accessible from Java, the functions they bridge to already have the assertions. + irFunction.origin == IrDeclarationOrigin.BRIDGE_SPECIAL || + irFunction.origin == JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE || + irFunction.origin == JvmLoweredDeclarationOrigin.JVM_STATIC_WRAPPER || + irFunction.parentAsClass.origin == JvmLoweredDeclarationOrigin.CONTINUATION_CLASS || + irFunction.parentAsClass.origin == JvmLoweredDeclarationOrigin.SUSPEND_LAMBDA || + irFunction.isMultifileBridge() + ) return // Do not generate non-null checks for suspend functions. When resumed the arguments diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt index cf56cd002d8..1bf292f8b90 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt @@ -116,7 +116,7 @@ private fun generateMultifileFacades( }.apply { parent = file createImplicitParameterDeclarationWithWrappedDescriptor() - origin = IrDeclarationOrigin.FILE_CLASS + origin = IrDeclarationOrigin.JVM_MULTIFILE_CLASS if (jvmClassName.packageFqName != kotlinPackageFqName) { context.classNameOverride[this] = jvmClassName } @@ -230,7 +230,6 @@ private fun IrSimpleFunction.createMultifileDelegateIfNeeded( function.body = null function.overriddenSymbols = listOf(symbol) } else { - function.origin = JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE function.overriddenSymbols = overriddenSymbols.toList() function.body = context.createIrBuilder(function.symbol).irBlockBody { +irReturn(irCall(target).also { call -> @@ -261,7 +260,7 @@ private class UpdateFunctionCallSites( super.visitFunction(declaration, declaration) override fun visitCall(expression: IrCall, data: IrFunction?): IrElement { - if (data?.origin == JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE) + if (data != null && data.isMultifileBridge()) return super.visitCall(expression, data) val newFunction = functionDelegates[expression.symbol.owner] @@ -318,3 +317,6 @@ private class UpdateConstantFacadePropertyReferences( ) facadeClass else null } } + +internal fun IrFunction.isMultifileBridge(): Boolean = + (parent as? IrClass)?.origin == IrDeclarationOrigin.JVM_MULTIFILE_CLASS diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ResolveInlineCalls.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ResolveInlineCalls.kt index a9a12d9521a..b077900832c 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ResolveInlineCalls.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ResolveInlineCalls.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.backend.jvm.lower import org.jetbrains.kotlin.backend.common.FileLoweringPass import org.jetbrains.kotlin.backend.common.phaser.makeIrModulePhase import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.codegen.isInlineFunctionCall import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.IrFunction @@ -40,7 +39,7 @@ class ResolveInlineCalls(val context: JvmBackendContext) : IrElementTransformerV val maybeFakeOverrideOfMultiFileBridge = expression.symbol.owner as? IrSimpleFunction ?: return super.visitCall(expression) val resolved = - maybeFakeOverrideOfMultiFileBridge.resolveMultiFileFacades() ?: maybeFakeOverrideOfMultiFileBridge.resolveFakeOverride() + maybeFakeOverrideOfMultiFileBridge.resolveMultiFileFacadeMember() ?: maybeFakeOverrideOfMultiFileBridge.resolveFakeOverride() ?: return super.visitCall(expression) return super.visitCall(with(expression) { IrCallImpl( @@ -69,8 +68,6 @@ class ResolveInlineCalls(val context: JvmBackendContext) : IrElementTransformerV }) } - private fun IrFunction.resolveMultiFileFacades(): IrSimpleFunction? = - if (origin == JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE) { - context.multifileFacadeMemberToPartMember[this] - } else null + private fun IrFunction.resolveMultiFileFacadeMember(): IrSimpleFunction? = + if (isMultifileBridge()) context.multifileFacadeMemberToPartMember[this] else null } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt index a4fdbd47acf..1ad9553b99c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt @@ -38,6 +38,8 @@ interface IrDeclarationOrigin { object FILE_CLASS : IrDeclarationOriginImpl("FILE_CLASS") object SYNTHETIC_FILE_CLASS : IrDeclarationOriginImpl("SYNTHETIC_FILE_CLASS", isSynthetic = true) + object JVM_MULTIFILE_CLASS : IrDeclarationOriginImpl("JVM_MULTIFILE_CLASS") + object SCRIPT_CLASS : IrDeclarationOriginImpl("SCRIPT_CLASS") object SCRIPT_STATEMENT : IrDeclarationOriginImpl("SCRIPT_STATEMENT") object SCRIPT_CALL_PARAMETER : IrDeclarationOriginImpl("SCRIPT_CALL_PARAMETER") diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt index 2a292d4b02d..ec2195bda0d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt @@ -529,7 +529,10 @@ val IrFunctionAccessExpression.typeSubstitutionMap: Map(): void +} + +@kotlin.Metadata +class A__TestKt { + // source: 'test.kt' + public method (): void + public synthetic static method internal$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static method internal(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method internalInline$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public final static method internalInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: int): void + synthetic static method private$A__TestKt$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + private final static method private$A__TestKt(p0: java.lang.String): void + synthetic static method privateInline$A__TestKt$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + private final static method privateInline$A__TestKt(p0: java.lang.String, p1: int): void + public synthetic static method public$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static method public(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method publicInline$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public final static method publicInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: int): void + public synthetic static method published$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static @kotlin.PublishedApi method published(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method publishedInline$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static @kotlin.PublishedApi method publishedInline(@org.jetbrains.annotations.NotNull p0: java.lang.String): void +} diff --git a/compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass_ir.txt b/compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass_ir.txt new file mode 100644 index 00000000000..b6a33ff0961 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass_ir.txt @@ -0,0 +1,39 @@ +@kotlin.Metadata +public final class A { + // source: 'test.kt' + public synthetic static method internal$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static method internal(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method internalInline$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public final static method internalInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: int): void + synthetic static method private$A__TestKt$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + synthetic static method privateInline$A__TestKt$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public synthetic static method public$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static method public(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method publicInline$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public final static method publicInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: int): void + public synthetic static method published$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static @kotlin.PublishedApi method published(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method publishedInline$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static @kotlin.PublishedApi method publishedInline(@org.jetbrains.annotations.NotNull p0: java.lang.String): void +} + +@kotlin.Metadata +synthetic final class A__TestKt { + // source: 'test.kt' + public synthetic static method internal$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static method internal(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method internalInline$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public final static method internalInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: int): void + synthetic static method private$A__TestKt$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + private final static method private$A__TestKt(p0: java.lang.String): void + synthetic static method privateInline$A__TestKt$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + private final static method privateInline$A__TestKt(p0: java.lang.String, p1: int): void + public synthetic static method public$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static method public(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method publicInline$default(p0: java.lang.String, p1: int, p2: int, p3: java.lang.Object): void + public final static method publicInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: int): void + public synthetic static method published$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static @kotlin.PublishedApi method published(@org.jetbrains.annotations.NotNull p0: java.lang.String): void + public synthetic static method publishedInline$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void + public final static @kotlin.PublishedApi method publishedInline(@org.jetbrains.annotations.NotNull p0: java.lang.String): void +} diff --git a/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.kt b/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.kt deleted file mode 100644 index 95174ba172d..00000000000 --- a/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.kt +++ /dev/null @@ -1,7 +0,0 @@ -// WITH_RUNTIME -// The remaining difference of JVM and JVM_IR here is reported at KT-41841. - -@file:JvmMultifileClass -@file:JvmName("A") - -private fun foo(x: String = "") {} diff --git a/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.txt b/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.txt deleted file mode 100644 index ed08c63abd7..00000000000 --- a/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.txt +++ /dev/null @@ -1,11 +0,0 @@ -@kotlin.Metadata -public final class A { - // source: 'privateFunctionInMultifilePart.kt' -} - -@kotlin.Metadata -synthetic final class A__PrivateFunctionInMultifilePartKt { - // source: 'privateFunctionInMultifilePart.kt' - synthetic static method foo$A__PrivateFunctionInMultifilePartKt$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void - private final static method foo$A__PrivateFunctionInMultifilePartKt(p0: java.lang.String): void -} diff --git a/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart_ir.txt b/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart_ir.txt deleted file mode 100644 index ad00dcdd25a..00000000000 --- a/compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart_ir.txt +++ /dev/null @@ -1,12 +0,0 @@ -@kotlin.Metadata -public final class A { - // source: 'privateFunctionInMultifilePart.kt' - final static method foo$A__PrivateFunctionInMultifilePartKt$default(@org.jetbrains.annotations.Nullable p0: java.lang.String, p1: int, p2: java.lang.Object): void -} - -@kotlin.Metadata -synthetic final class A__PrivateFunctionInMultifilePartKt { - // source: 'privateFunctionInMultifilePart.kt' - synthetic static method foo$A__PrivateFunctionInMultifilePartKt$default(p0: java.lang.String, p1: int, p2: java.lang.Object): void - private final static method foo$A__PrivateFunctionInMultifilePartKt(p0: java.lang.String): void -} diff --git a/compiler/testData/codegen/bytecodeListing/main/multifileSuspend_ir.txt b/compiler/testData/codegen/bytecodeListing/main/multifileSuspend_ir.txt index 1e0999dfe5e..05083d2acfb 100644 --- a/compiler/testData/codegen/bytecodeListing/main/multifileSuspend_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/main/multifileSuspend_ir.txt @@ -1,8 +1,8 @@ @kotlin.Metadata public final class Hello/Foo { // source: 'multifileSuspend.kt' - public final static method main(@org.jetbrains.annotations.NotNull p0: java.lang.String[]): void public final static @org.jetbrains.annotations.Nullable method main(@org.jetbrains.annotations.NotNull p0: java.lang.String[], @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object + public synthetic final static method main(p0: java.lang.String[]): void } @kotlin.Metadata diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java index b69fb42e396..c971df54263 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java @@ -700,15 +700,20 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } + @TestMetadata("functionInMultifileClass.kt") + public void testFunctionInMultifileClass() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass.kt"); + } + + @TestMetadata("functionInMultifileClassWithInheritedParts.kt") + public void testFunctionInMultifileClassWithInheritedParts() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClassWithInheritedParts.kt"); + } + @TestMetadata("internalNameMangling.kt") public void testInternalNameMangling() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/internalNameMangling.kt"); } - - @TestMetadata("privateFunctionInMultifilePart.kt") - public void testPrivateFunctionInMultifilePart() throws Exception { - runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.kt"); - } } @TestMetadata("compiler/testData/codegen/bytecodeListing/deprecated") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java index 78b2218591c..07612850dc8 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java @@ -670,15 +670,20 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @TestMetadata("functionInMultifileClass.kt") + public void testFunctionInMultifileClass() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClass.kt"); + } + + @TestMetadata("functionInMultifileClassWithInheritedParts.kt") + public void testFunctionInMultifileClassWithInheritedParts() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/functionInMultifileClassWithInheritedParts.kt"); + } + @TestMetadata("internalNameMangling.kt") public void testInternalNameMangling() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/internalNameMangling.kt"); } - - @TestMetadata("privateFunctionInMultifilePart.kt") - public void testPrivateFunctionInMultifilePart() throws Exception { - runTest("compiler/testData/codegen/bytecodeListing/defaultArguments/privateFunctionInMultifilePart.kt"); - } } @TestMetadata("compiler/testData/codegen/bytecodeListing/deprecated")