From 51f726be9bd6830110163b791043d7345638e7f3 Mon Sep 17 00:00:00 2001 From: Mads Ager Date: Thu, 19 Dec 2019 15:38:21 +0100 Subject: [PATCH] JVM_IR: Fix check for whether classes are from Java. This allows us to not generate redundant immutable collection stubs. The code to generate the immutable collection stubs does not deal well with thinking that all external declarations come from Java. --- .../kotlin/backend/jvm/JvmGeneratorExtensions.kt | 2 +- .../kotlin/backend/jvm/lower/BridgeLowering.kt | 9 +++++---- .../backend/jvm/lower/CollectionStubMethodLowering.kt | 2 +- .../box/toArray/toArrayShouldBePublicWithJava.kt | 1 - .../testData/compileKotlinAgainstKotlin/jvmNames.kt | 10 +++++++++- 5 files changed, 16 insertions(+), 8 deletions(-) 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 d0720f4d2be..2421df9b928 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 @@ -72,7 +72,7 @@ class JvmGeneratorExtensions(private val generateFacades: Boolean = true) : Gene null override fun computeExternalDeclarationOrigin(descriptor: DeclarationDescriptor): IrDeclarationOrigin? = - if (descriptor is JavaCallableMemberDescriptor) + if (descriptor is JavaCallableMemberDescriptor || descriptor is JavaClassDescriptor) IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB else IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB 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 d4441cb7398..83a7161230f 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 @@ -108,7 +108,7 @@ private class BridgeLowering(val context: JvmBackendContext) : ClassLoweringPass irFunction.modality !== Modality.ABSTRACT && irFunction.visibility !== Visibilities.INVISIBLE_FAKE && irFunction.overriddenInClasses().firstOrNull { it.getJvmSignature() != ourSignature || it.origin != IrDeclarationOrigin.FAKE_OVERRIDE } - ?.let { (it.getJvmName() != ourMethodName || it.getJvmSignature() == specialOverrideSignature) && it.comesFromJava() } == true + ?.let { (it.getJvmName() != ourMethodName || it.getJvmSignature() == specialOverrideSignature) && it.isExternalDeclaration() } == true ) { val resolved = irFunction.findConcreteSuperDeclaration()!! val resolvedSignature = resolved.getJvmSignature() @@ -492,10 +492,11 @@ fun IrSimpleFunction.overriddenInClasses(): Sequence = fun IrSimpleFunction.isCollectionStub(): Boolean = origin == IrDeclarationOrigin.IR_BUILTINS_STUB -// TODO: At present, there is no reliable way to distinguish Java imports from Kotlin cross-module imports. -val ORIGINS_FROM_JAVA = setOf(IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB) +val EXTERNAL_ORIGIN = setOf(IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB) -fun IrDeclaration.comesFromJava() = parentAsClass.origin in ORIGINS_FROM_JAVA +fun IrDeclaration.comesFromJava() = parentAsClass.origin == IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB + +fun IrDeclaration.isExternalDeclaration() = parentAsClass.origin in EXTERNAL_ORIGIN // Method has the same name, same arguments as `other`. Return types may differ. fun Method.sameCallAs(other: Method) = diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt index b70c5ce396d..4a02d665186 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt @@ -204,7 +204,7 @@ private class CollectionStubMethodLowering(val context: JvmBackendContext) : Cla }.toHashSet() } - fun IrClass.comesFromJava() = origin in ORIGINS_FROM_JAVA + fun IrClass.comesFromJava() = origin == IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB private fun Collection.findMostSpecificTypeForClass(classifier: IrClassSymbol): IrType { val types = this.filter { it.classifierOrNull == classifier } diff --git a/compiler/testData/codegen/box/toArray/toArrayShouldBePublicWithJava.kt b/compiler/testData/codegen/box/toArray/toArrayShouldBePublicWithJava.kt index caafe5531b7..10ab19f3238 100644 --- a/compiler/testData/codegen/box/toArray/toArrayShouldBePublicWithJava.kt +++ b/compiler/testData/codegen/box/toArray/toArrayShouldBePublicWithJava.kt @@ -1,5 +1,4 @@ // IGNORE_BACKEND_FIR: JVM_IR -// IGNORE_BACKEND: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME // IGNORE_LIGHT_ANALYSIS diff --git a/compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt b/compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt index a0f955970d4..88011ca28c9 100644 --- a/compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt +++ b/compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt @@ -14,9 +14,12 @@ var v: Int = 1 fun consumeInt(x: Int) {} -class A { +open class A { val OK: String = "OK" @JvmName("OK") get + + @JvmName("g") + fun f(x: T, y: Int = 1) = x } annotation class Anno(@get:JvmName("uglyJvmName") val value: String) @@ -25,6 +28,8 @@ annotation class Anno(@get:JvmName("uglyJvmName") val value: String) import lib.* +class B : A() + @Anno("OK") fun annotated() {} @@ -36,5 +41,8 @@ fun box(): String { val annoValue = (::annotated.annotations.single() as Anno).value if (annoValue != "OK") return "Fail annotation value: $annoValue" + val b = B() + if (b.f("OK") != "OK") return "Fail call of annotated method" + return A().OK }