From b5ba9ee6719e779631f7361c6bd50e4003645dd9 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 23 Aug 2023 15:37:01 +0200 Subject: [PATCH] IR: refactor resolveFakeOverride call sites Split it to 4 functions for clarity: resolveFakeOverride, resolveFakeOverrideOrFail, resolveFakeOverrideMaybeAbstract, resolveFakeOverrideMaybeAbstractOrFail. Remove/inline duplicated utilities and remove unused parameters. --- .../IrExpectActualMatchingContext.kt | 2 +- .../backend/js/export/ExportModelGenerator.kt | 2 +- .../js/ic/IdSignatureHashCalculator.kt | 16 ++--- .../backend/js/lower/BridgesConstruction.kt | 6 ++ .../js/transformers/irToJs/jsAstUtils.kt | 2 +- ...nheritedDefaultMethodsOnClassesLowering.kt | 5 +- .../backend/jvm/lower/InterfaceLowering.kt | 7 +- .../jvm/lower/JvmPropertiesLowering.kt | 6 +- .../jvm/lower/SyntheticAccessorLowering.kt | 12 ++-- .../backend/jvm/JvmCachedDeclarations.kt | 4 +- .../jvm/MemoizedInlineClassReplacements.kt | 2 +- .../kotlin/ir/interpreter/state/Complex.kt | 4 -- .../kotlin/ir/util/IrFakeOverrideUtils.kt | 64 +++++++++---------- .../org/jetbrains/kotlin/ir/util/IrUtils.kt | 6 -- .../backend/handlers/IrInlineBodiesHandler.kt | 6 +- .../kotlin/backend/konan/cgen/CBridgeGen.kt | 2 +- .../backend/konan/llvm/CodeGenerator.kt | 2 +- .../objcexport/ObjCExportCodeGenerator.kt | 2 +- .../backend/konan/lower/InteropLowering.kt | 2 +- 19 files changed, 72 insertions(+), 80 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt index 0c5e4da9efc..1e1eb8f0023 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt @@ -469,7 +469,7 @@ internal abstract class IrExpectActualMatchingContext( var ir = asIr() if (ir.isFakeOverride && ir is IrOverridableDeclaration<*>) { - ir.resolveFakeOverrideOrNull()?.let { ir = it } + ir.resolveFakeOverride()?.let { ir = it } } return when (ir.origin) { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt index e39107997b0..b355eea783b 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt @@ -778,7 +778,7 @@ private fun shouldDeclarationBeExported(declaration: IrDeclarationWithName, cont fun IrOverridableDeclaration<*>.isAllowedFakeOverriddenDeclaration(context: JsIrBackendContext): Boolean { val firstExportedRealOverride = runIf(isFakeOverride) { - resolveFakeOverrideOrNull(allowAbstract = true) { it === this || it.parentClassOrNull?.isExported(context) != true } + resolveFakeOverrideMaybeAbstract { it === this || it.parentClassOrNull?.isExported(context) != true } } if (firstExportedRealOverride?.parentClassOrNull.isExportedInterface(context)) { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt index 6945713ab5d..3d5ac963065 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt @@ -6,14 +6,16 @@ package org.jetbrains.kotlin.ir.backend.js.ic import org.jetbrains.kotlin.ir.IrElement -import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrDeclaration +import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrFunctionReference import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.util.IdSignature import org.jetbrains.kotlin.ir.util.isFakeOverride -import org.jetbrains.kotlin.ir.util.render -import org.jetbrains.kotlin.ir.util.resolveFakeOverride +import org.jetbrains.kotlin.ir.util.resolveFakeOverrideOrFail import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.ir.visitors.acceptVoid @@ -35,12 +37,8 @@ internal class IdSignatureHashCalculator(private val icHasher: ICHasher) { private val IrFunction.inlineFunctionFlatHash: ICHash get() = inlineFunctionFlatHashes.getOrPut(this) { - val flatHash = if (isFakeOverride && this is IrSimpleFunction) { - resolveFakeOverride()?.let { icHasher.calculateIrFunctionHash(it) } - ?: icError("can not resolve fake override for ${render()}") - } else { - icHasher.calculateIrFunctionHash(this) - } + val function = if (isFakeOverride && this is IrSimpleFunction) resolveFakeOverrideOrFail() else this + val flatHash = icHasher.calculateIrFunctionHash(function) ICHash(symbol.calculateSymbolHash().hash.combineWith(flatHash.hash)) } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt index e4535ccfce7..bf4d5d60fd6 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt @@ -248,3 +248,9 @@ data class IrBasedFunctionHandle(val function: IrSimpleFunction) : FunctionHandl override fun getOverridden() = function.overriddenSymbols.map { IrBasedFunctionHandle(it.owner) } } + +private fun IrSimpleFunction.findInterfaceImplementation(): IrSimpleFunction? { + if (isReal) return null + + return resolveFakeOverride()?.run { if (parentAsClass.isInterface) this else null } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt index cc4bb769aef..ba840ed711c 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt @@ -195,7 +195,7 @@ fun translateCall( expression.superQualifierSymbol?.let { superQualifier -> val (target: IrSimpleFunction, klass: IrClass) = if (superQualifier.owner.isInterface) { - val impl = function.resolveFakeOverride()!! + val impl = function.resolveFakeOverrideOrFail() Pair(impl, impl.parentAsClass) } else { Pair(function, superQualifier.owner) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt index f482eb18df1..5116f116dd1 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt @@ -165,7 +165,8 @@ private class InterfaceSuperCallsLowering(val context: JvmBackendContext) : IrEl } val superCallee = expression.symbol.owner - if (superCallee.isDefinitelyNotDefaultImplsMethod(context.config.jvmDefaultMode)) return super.visitCall(expression) + if (superCallee.isDefinitelyNotDefaultImplsMethod(context.config.jvmDefaultMode, superCallee.resolveFakeOverride())) + return super.visitCall(expression) val redirectTarget = context.cachedDeclarations.getDefaultImplsFunction(superCallee) val newCall = createDelegatingCallWithPlaceholderTypeArguments(expression, redirectTarget, context.irBuiltIns) @@ -235,7 +236,7 @@ private class InterfaceDefaultCallsLowering(val context: JvmBackendContext) : Ir internal fun IrSimpleFunction.isDefinitelyNotDefaultImplsMethod( jvmDefaultMode: JvmDefaultMode, - implementation: IrSimpleFunction? = resolveFakeOverride() + implementation: IrSimpleFunction?, ): Boolean = implementation == null || implementation.origin == IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB || diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt index 76c7ec36e6f..c5c2592e4a7 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt @@ -22,7 +22,10 @@ import org.jetbrains.kotlin.ir.expressions.IrReturn import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.types.defaultType -import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.ir.util.functions +import org.jetbrains.kotlin.ir.util.isMethodOfAny +import org.jetbrains.kotlin.ir.util.parentAsClass +import org.jetbrains.kotlin.ir.util.resolveFakeOverrideOrFail import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid @@ -101,7 +104,7 @@ internal class InterfaceLowering(val context: JvmBackendContext) : IrElementTran if (function.name.asString().endsWith("\$default")) { continue } - val implementation = function.resolveFakeOverride() ?: error("No single implementation found for: ${function.render()}") + val implementation = function.resolveFakeOverrideOrFail() when { DescriptorVisibilities.isPrivate(implementation.visibility) || implementation.isMethodOfAny() -> diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt index e47eb072f1d..1a82aa68b92 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt @@ -83,13 +83,13 @@ class JvmPropertiesLowering(private val backendContext: JvmBackendContext) : IrE // to get the backing field which would no longer exist. val inInlineFunctionScope = allScopes.any { scope -> (scope.irElement as? IrFunction)?.isInline ?: false } if (inInlineFunctionScope) return false - val backingField = property.resolveFakeOverride()!!.backingField + val backingField = property.resolveFakeOverrideOrFail().backingField return backingField?.parent == currentClass?.irElement && backingField?.origin == JvmLoweredDeclarationOrigin.COMPANION_PROPERTY_BACKING_FIELD } private fun IrBuilderWithScope.substituteSetter(irProperty: IrProperty, expression: IrCall): IrExpression { - val backingField = irProperty.resolveFakeOverride()!!.backingField!! + val backingField = irProperty.resolveFakeOverrideOrFail().backingField!! return patchReceiver( irSetField( patchFieldAccessReceiver(expression, irProperty), @@ -100,7 +100,7 @@ class JvmPropertiesLowering(private val backendContext: JvmBackendContext) : IrE } private fun IrBuilderWithScope.substituteGetter(irProperty: IrProperty, expression: IrCall): IrExpression { - val backingField = irProperty.resolveFakeOverride()!!.backingField!! + val backingField = irProperty.resolveFakeOverrideOrFail().backingField!! val patchedReceiver = patchFieldAccessReceiver(expression, irProperty) return if (irProperty.isLateinit) { irBlock { diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt index cff737e2e1f..0f42b2c2952 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt @@ -73,8 +73,8 @@ internal class SyntheticAccessorLowering(val context: JvmBackendContext) : FileL return true val declaration = when (declarationRaw) { - is IrSimpleFunction -> declarationRaw.resolveFakeOverride(allowAbstract = true)!! - is IrField -> declarationRaw.resolveFakeOverride() + is IrSimpleFunction -> declarationRaw.resolveFakeOverrideMaybeAbstractOrFail() + is IrField -> declarationRaw.resolveFieldFakeOverride() else -> declarationRaw } @@ -376,15 +376,13 @@ private class SyntheticAccessorTransformer( } } -private fun IrField.resolveFakeOverride(): IrField { +private fun IrField.resolveFieldFakeOverride(): IrField { val correspondingProperty = correspondingPropertySymbol?.owner if (correspondingProperty == null || !correspondingProperty.isFakeOverride) return this - val realProperty = correspondingProperty.resolveFakeOverride() - ?: throw AssertionError("No real override for ${correspondingProperty.render()}") - return realProperty.backingField + return correspondingProperty.resolveFakeOverrideOrFail().backingField ?: throw AssertionError( "Fake override property ${correspondingProperty.render()} with backing field " + - "overrides a real property with no backing field: ${realProperty.render()}" + "overrides a real property with no backing field: ${correspondingProperty.resolveFakeOverrideOrFail().render()}" ) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt index f1d2033a79d..c3c37019622 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt @@ -201,7 +201,7 @@ class JvmCachedDeclarations( // The classes are not actually related and `I2.DefaultImpls.f` is not a fake override but a bridge. val defaultImplsOrigin = if (!forCompatibilityMode && !interfaceFun.isFakeOverride) interfaceFun.origin - else interfaceFun.resolveFakeOverride()!!.origin + else interfaceFun.resolveFakeOverrideOrFail().origin // Interface functions are public or private, with one exception: clone in Cloneable, which is protected. // However, Cloneable has no DefaultImpls, so this merely replicates the incorrect behavior of the old backend. @@ -225,7 +225,7 @@ class JvmCachedDeclarations( ).also { it.copyCorrespondingPropertyFrom(interfaceFun) - if (forCompatibilityMode && !interfaceFun.resolveFakeOverride()!!.origin.isSynthetic) { + if (forCompatibilityMode && !interfaceFun.resolveFakeOverrideOrFail().origin.isSynthetic) { context.createJvmIrBuilder(it.symbol).run { it.annotations = it.annotations .filterNot { it.symbol.owner.constructedClass.hasEqualFqName(DeprecationResolver.JAVA_DEPRECATED) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt index 6111d306b06..e8558118577 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt @@ -225,7 +225,7 @@ class MemoizedInlineClassReplacements( // When using the new mangling scheme we might run into dependencies using the old scheme // for which we will fall back to the old mangling scheme as well. if (!useOldManglingScheme && replacement.name.asString().contains('-') && function.parentClassId != null) { - val resolved = (function as? IrSimpleFunction)?.resolveFakeOverride(true) + val resolved = (function as? IrSimpleFunction)?.resolveFakeOverrideMaybeAbstractOrFail() if (resolved?.parentClassId?.let { classFileContainsMethod(it, replacement, context) } == false) { return buildReplacementInner(function, replacementOrigin, noFakeOverride, true, body) } diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/state/Complex.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/state/Complex.kt index c06daf4c2e9..8e46feaae06 100644 --- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/state/Complex.kt +++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/state/Complex.kt @@ -35,10 +35,6 @@ internal interface Complex : State { } } - fun getRealFunction(owner: IrSimpleFunction): IrSimpleFunction { - return owner.resolveFakeOverride() as IrSimpleFunction - } - override fun getIrFunctionByIrCall(expression: IrCall): IrFunction? { val receiver = expression.superQualifierSymbol?.owner ?: irClass val irFunction = getIrFunctionFromGivenClass(receiver, expression.symbol.owner) ?: return null diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrFakeOverrideUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrFakeOverrideUtils.kt index 44cee4da94c..082fbf8adf8 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrFakeOverrideUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrFakeOverrideUtils.kt @@ -19,20 +19,18 @@ val IrDeclaration.isFakeOverride: Boolean } val IrSimpleFunction.target: IrSimpleFunction - get() = if (modality == Modality.ABSTRACT) - this - else - resolveFakeOverride() ?: error("Could not resolveFakeOverride() for ${this.render()}") + get() = if (modality == Modality.ABSTRACT) this else resolveFakeOverrideOrFail() -val IrFunction.target: IrFunction get() = when (this) { - is IrSimpleFunction -> this.target - is IrConstructor -> this - else -> error(this) -} +val IrFunction.target: IrFunction + get() = when (this) { + is IrSimpleFunction -> this.target + is IrConstructor -> this + else -> error(this) + } fun > T.collectRealOverrides( toSkip: (T) -> Boolean = { false }, - filter: (T) -> Boolean = { false } + filter: (T) -> Boolean = { false }, ): Set { if (isReal && !toSkip(this)) return setOf(this) @@ -92,31 +90,29 @@ fun Collection.collectAndFilterRealOverrides(): Set error("all members should be of the same kind, got ${map { it.render() }}") } -fun > T.resolveFakeOverride( - allowAbstract: Boolean = false, - toSkip: (T) -> Boolean = { false } -): T? = - resolveFakeOverrideOrNull(allowAbstract, toSkip).also { - if (allowAbstract && it == null) { - error("No real overrides for ${this.render()}") - } - } +fun > T.resolveFakeOverrideMaybeAbstractOrFail(): T = + resolveFakeOverrideMaybeAbstract() ?: error("No real overrides for ${this.render()}") -// TODO: use this implementation instead of any other -fun > T.resolveFakeOverrideOrNull( - allowAbstract: Boolean = false, - toSkip: (T) -> Boolean = { false } +fun > T.resolveFakeOverrideMaybeAbstract( + toSkip: (T) -> Boolean = { false }, ): T? { if (!isFakeOverride && !toSkip(this)) return this - return if (allowAbstract) { - collectRealOverrides(toSkip).firstOrNull() - } else { - collectRealOverrides(toSkip, { it.modality == Modality.ABSTRACT }) - .let { realOverrides -> - // Kotlin forbids conflicts between overrides, but they may trickle down from Java. - realOverrides.singleOrNull { (it.parent as? IrClass)?.isInterface != true } - // TODO: We take firstOrNull instead of singleOrNull here because of KT-36188. - ?: realOverrides.firstOrNull() - } - } + return collectRealOverrides(toSkip).firstOrNull() +} + +fun > T.resolveFakeOverrideOrFail(): T = + resolveFakeOverride() ?: error("No real overrides for ${this.render()}") + +// TODO: use this implementation instead of any other +fun > T.resolveFakeOverride( + toSkip: (T) -> Boolean = { false }, +): T? { + if (!isFakeOverride && !toSkip(this)) return this + return collectRealOverrides(toSkip) { it.modality == Modality.ABSTRACT } + .let { realOverrides -> + // Kotlin forbids conflicts between overrides, but they may trickle down from Java. + realOverrides.singleOrNull { (it.parent as? IrClass)?.isInterface != true } + // TODO: We take firstOrNull instead of singleOrNull here because of KT-36188. + ?: realOverrides.firstOrNull() + } } 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 f12102ebcce..84df38bb10e 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 @@ -306,12 +306,6 @@ fun IrClass.isSubclassOf(ancestor: IrClass): Boolean { return this.hasAncestorInSuperTypes() } -fun IrSimpleFunction.findInterfaceImplementation(): IrSimpleFunction? { - if (isReal) return null - - return resolveFakeOverride()?.run { if (parentAsClass.isInterface) this else null } -} - val IrClass.isAnnotationClass get() = kind == ClassKind.ANNOTATION_CLASS val IrClass.isEnumClass get() = kind == ClassKind.ENUM_CLASS val IrClass.isEnumEntry get() = kind == ClassKind.ENUM_ENTRY diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInlineBodiesHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInlineBodiesHandler.kt index 1e4ecb41bdb..eb9bf74db4d 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInlineBodiesHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInlineBodiesHandler.kt @@ -6,14 +6,14 @@ package org.jetbrains.kotlin.test.backend.handlers import org.jetbrains.kotlin.ir.IrElement -import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI +import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.declarations.lazy.AbstractIrLazyFunction import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.ir.util.DeserializableClass import org.jetbrains.kotlin.ir.util.IdSignature -import org.jetbrains.kotlin.ir.util.resolveFakeOverride +import org.jetbrains.kotlin.ir.util.resolveFakeOverrideOrFail import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.test.backend.ir.IrBackendInput @@ -59,7 +59,7 @@ class IrInlineBodiesHandler(testServices: TestServices) : AbstractIrHandler(test assertions.assertTrue(symbol.isBound) val callee = symbol.owner if (callee.symbol.signature in declaredInlineFunctionSignatures) { - val trueCallee = (callee as IrSimpleFunction).resolveFakeOverride()!! + val trueCallee = (callee as IrSimpleFunction).resolveFakeOverrideOrFail() assertions.assertTrue(trueCallee.hasBody()) { "IrInlineBodiesHandler: function with body expected" } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt index ccea5930ec6..2d73a42ebae 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt @@ -307,7 +307,7 @@ internal fun KotlinStubs.generateObjCCall( receiver: ObjCCallReceiver, arguments: List ) = builder.irBlock { - val resolved = method.resolveFakeOverride(allowAbstract = true)?: method + val resolved = method.resolveFakeOverrideMaybeAbstract() ?: method val isDirect = directSymbolName != null val exceptionMode = ForeignExceptionMode.byValue( diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt index b9b5e4605cc..983dac30155 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt @@ -306,7 +306,7 @@ internal object VirtualTablesLookup { } internal fun IrSimpleFunction.findOverriddenMethodOfAny() = - resolveFakeOverride(allowAbstract = false).takeIf { it?.parentClassOrNull?.isAny() == true } + resolveFakeOverride().takeIf { it?.parentClassOrNull?.isAny() == true } /* * Special trampoline function to call actual virtual implementation. This helps with reducing diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt index 76c83804cd2..471f314b99e 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt @@ -1533,7 +1533,7 @@ private fun ObjCExportCodeGenerator.itablePlace(irFunction: IrSimpleFunction): C assert(irFunction.isOverridable) val irClass = irFunction.parentAsClass return if (irClass.isInterface - && (irFunction.isReal || irFunction.resolveFakeOverride(allowAbstract = true)?.parent != context.irBuiltIns.anyClass.owner) + && (irFunction.isReal || irFunction.resolveFakeOverrideMaybeAbstract()?.parent != context.irBuiltIns.anyClass.owner) ) { context.getLayoutBuilder(irClass).itablePlace(irFunction) } else { diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt index 637d47f1b49..c7c7c28dfec 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt @@ -1088,7 +1088,7 @@ private class InteropTransformer( builder.at(expression) val function = expression.symbol.owner - if ((function as? IrSimpleFunction)?.resolveFakeOverride(allowAbstract = true)?.symbol + if ((function as? IrSimpleFunction)?.resolveFakeOverrideMaybeAbstract()?.symbol == symbols.interopNativePointedRawPtrGetter) { // Replace by the intrinsic call to be handled by code generator: