From 9b6fef005fd42049858b0b48ab9d7f5c7e4551c9 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Wed, 26 Jun 2019 07:25:21 +0200 Subject: [PATCH] Simplify LocalDeclarationsLowering, support declaration pop up via separate lower 1. Scheme of capturing local variables not touched 2. Lowered local functions are transposed to the nearest class (including local) or file 3. Local classes are also transpose to the nearest class (including local) or file --- .../backend/common/lower/ClosureAnnotator.kt | 5 +- .../common/lower/InitializersLowering.kt | 5 +- .../common/lower/LocalClassPopupLowering.kt | 41 +++++ .../common/lower/LocalDeclarationsLowering.kt | 168 ++++++++---------- .../kotlin/ir/backend/js/JsLoweringPhases.kt | 8 + .../jvm/descriptors/JvmDeclarationFactory.kt | 2 +- .../lower/JvmOverloadsAnnotationLowering.kt | 3 +- .../property/privateSetOuterClass.kt | 1 - ...nForLocalClassInFunctionWithMangledName.kt | 1 - .../box/reflection/classes/qualifiedName.kt | 1 - .../anonymousObjectInInlinedLambda.kt | 1 - .../lambdaInLocalClassConstructor.kt | 2 +- .../enclosing/lambdaInObjectExpression.kt | 2 +- .../enclosing/localClassInTopLevelFunction.kt | 1 - 14 files changed, 130 insertions(+), 111 deletions(-) create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalClassPopupLowering.kt diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt index edda65e2e5a..5a8d54c5bd6 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt @@ -27,7 +27,6 @@ import org.jetbrains.kotlin.ir.expressions.IrFunctionReference import org.jetbrains.kotlin.ir.expressions.IrPropertyReference import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression import org.jetbrains.kotlin.ir.symbols.IrValueSymbol -import org.jetbrains.kotlin.ir.util.dump import org.jetbrains.kotlin.ir.util.isLocal import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid @@ -45,12 +44,12 @@ import kotlin.collections.toList class Closure(val capturedValues: List = emptyList()) -class ClosureAnnotator(declaration: IrDeclaration) { +class ClosureAnnotator(irFile: IrFile) { private val closureBuilders = mutableMapOf() init { // Collect all closures for classes and functions. Collect call graph - declaration.acceptChildrenVoid(ClosureCollectorVisitor()) + irFile.acceptChildrenVoid(ClosureCollectorVisitor()) } fun getFunctionClosure(declaration: IrFunction) = getClosure(declaration) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt index f925b2fe376..87f3d600629 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.ir.util.patchDeclarationParents import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl +import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols import org.jetbrains.kotlin.ir.visitors.* import org.jetbrains.kotlin.name.Name @@ -161,7 +162,7 @@ class InitializersLowering( companion object { val clinitName = Name.special("") - fun IrStatement.copy(containingDeclaration: IrDeclarationParent) = deepCopyWithWrappedDescriptors(containingDeclaration) - fun IrExpression.copy(containingDeclaration: IrDeclarationParent) = deepCopyWithWrappedDescriptors(containingDeclaration) + fun IrStatement.copy(containingDeclaration: IrDeclarationParent) = deepCopyWithSymbols(containingDeclaration) + fun IrExpression.copy(containingDeclaration: IrDeclarationParent) = deepCopyWithSymbols(containingDeclaration) } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalClassPopupLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalClassPopupLowering.kt new file mode 100644 index 00000000000..5f34692f490 --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalClassPopupLowering.kt @@ -0,0 +1,41 @@ +package org.jetbrains.kotlin.backend.common.lower + +import org.jetbrains.kotlin.backend.common.BackendContext +import org.jetbrains.kotlin.backend.common.FileLoweringPass +import org.jetbrains.kotlin.backend.common.IrElementTransformerVoidWithContext +import org.jetbrains.kotlin.backend.common.ir.addChild +import org.jetbrains.kotlin.ir.IrStatement +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclarationContainer +import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl + +//This lower takes part of old LocalDeclarationLowering job to pop up local classes from functions +class LocalClassPopupLowering(val context: BackendContext) : FileLoweringPass { + + override fun lower(irFile: IrFile) { + val extractedLocalClasses = arrayListOf>() + + irFile.transform(object : IrElementTransformerVoidWithContext() { + + override fun visitClassNew(declaration: IrClass): IrStatement { + val newDeclaration = super.visitClassNew(declaration) + if (newDeclaration !is IrClass || !newDeclaration.isLocalNotInner()) { + return newDeclaration + } + + val newContainer = allScopes.asReversed().drop(1/*skip self*/).firstOrNull { + //find first class local or not; + // to reproduce original LocalDeclarationLowering behaviour add: '&& !it.irElement.isLocal' condition + it.irElement is IrClass + }?.irElement as? IrClass ?: currentFile + extractedLocalClasses.add(newDeclaration to newContainer) + return IrCompositeImpl(declaration.startOffset, declaration.endOffset, context.irBuiltIns.unitType) + } + }, null) + + for ((local, newContainer) in extractedLocalClasses) { + newContainer.addChild(local) + } + } +} \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt index c84ce28a443..3cc92ff96a2 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt @@ -6,15 +6,20 @@ package org.jetbrains.kotlin.backend.common.lower import org.jetbrains.kotlin.backend.common.BackendContext -import org.jetbrains.kotlin.backend.common.DeclarationContainerLoweringPass +import org.jetbrains.kotlin.backend.common.FileLoweringPass +import org.jetbrains.kotlin.backend.common.IrElementVisitorVoidWithContext +import org.jetbrains.kotlin.backend.common.ScopeWithIr import org.jetbrains.kotlin.backend.common.descriptors.* +import org.jetbrains.kotlin.backend.common.ir.addChild import org.jetbrains.kotlin.backend.common.ir.copyTo import org.jetbrains.kotlin.backend.common.ir.copyTypeParametersFrom +import org.jetbrains.kotlin.backend.common.ir.ir2string import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement +import org.jetbrains.kotlin.ir.builders.Scope import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl @@ -28,11 +33,10 @@ import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl import org.jetbrains.kotlin.ir.types.IrType -import org.jetbrains.kotlin.ir.util.patchDeclarationParents -import org.jetbrains.kotlin.ir.util.transformDeclarationsFlat +import org.jetbrains.kotlin.ir.util.dump import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid -import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid +import org.jetbrains.kotlin.ir.visitors.acceptVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.name.Name import java.util.* @@ -59,52 +63,18 @@ class LocalDeclarationsLowering( val localNameProvider: LocalNameProvider = LocalNameProvider.DEFAULT, val loweredConstructorVisibility: Visibility = Visibilities.PRIVATE ) : - DeclarationContainerLoweringPass { + FileLoweringPass { - private object DECLARATION_ORIGIN_FIELD_FOR_CAPTURED_VALUE : + object DECLARATION_ORIGIN_FIELD_FOR_CAPTURED_VALUE : IrDeclarationOriginImpl("FIELD_FOR_CAPTURED_VALUE", isSynthetic = true) private object STATEMENT_ORIGIN_INITIALIZER_OF_FIELD_FOR_CAPTURED_VALUE : IrStatementOriginImpl("INITIALIZER_OF_FIELD_FOR_CAPTURED_VALUE") - override fun lower(irDeclarationContainer: IrDeclarationContainer) { - if (irDeclarationContainer is IrDeclaration) { - val parents = irDeclarationContainer.parents - - if (parents.any { it is IrFunction || it is IrField }) { - // Lowering of non-local declarations handles all local declarations inside. - // This declaration is local and shouldn't be considered. - return - } - } - - // Continuous numbering across all declarations in the container. - lambdasCount = 0 - - irDeclarationContainer.transformDeclarationsFlat { memberDeclaration -> - // TODO: may be do the opposite - specify the list of IR elements which need not to be transformed - when (memberDeclaration) { - is IrFunction -> LocalDeclarationsTransformer(memberDeclaration).lowerLocalDeclarations() - is IrProperty -> LocalDeclarationsTransformer(memberDeclaration).lowerLocalDeclarations() - is IrField -> LocalDeclarationsTransformer(memberDeclaration).lowerLocalDeclarations() - is IrAnonymousInitializer -> LocalDeclarationsTransformer(memberDeclaration).lowerLocalDeclarations() - is IrEnumEntry -> { - // The responsibility of pulling up classes for enum entries is on EnumClassLowering. - // Moreover, EnumClassLowering needs information whether a enum entry has its own class or not. - val correspondingClass = memberDeclaration.correspondingClass - memberDeclaration.correspondingClass = null - LocalDeclarationsTransformer(memberDeclaration).lowerLocalDeclarations().also { - memberDeclaration.correspondingClass = correspondingClass - } - } - // TODO: visit children as well - else -> null - } - } + override fun lower(irFile: IrFile) { + LocalDeclarationsTransformer(irFile).lowerLocalDeclarations() } - private var lambdasCount = 0 - private abstract class LocalContext { /** * @return the expression to get the value for given declaration, or `null` if [IrGetValue] should be used. @@ -126,12 +96,15 @@ class LocalDeclarationsLowering( } } - private class LocalFunctionContext(override val declaration: IrSimpleFunction) : LocalContextWithClosureAsParameters() { + private class LocalFunctionContext( + override val declaration: IrSimpleFunction, + val index: Int, + val ownerForLoweredDeclaration: IrDeclarationContainer + ) : + LocalContextWithClosureAsParameters() { lateinit var closure: Closure override lateinit var transformedDeclaration: IrSimpleFunction - - var index: Int = -1 } private class LocalClassConstructorContext(override val declaration: IrConstructor) : LocalContextWithClosureAsParameters() { @@ -167,7 +140,7 @@ class LocalDeclarationsLowering( } - private inner class LocalDeclarationsTransformer(val memberDeclaration: IrDeclaration) { + private inner class LocalDeclarationsTransformer(val irFile: IrFile) { val localFunctions: MutableMap = LinkedHashMap() val localClasses: MutableMap = LinkedHashMap() val localClassConstructors: MutableMap = LinkedHashMap() @@ -181,9 +154,9 @@ class LocalDeclarationsLowering( val oldParameterToNew: MutableMap = mutableMapOf() val newParameterToCaptured: MutableMap = mutableMapOf() - fun lowerLocalDeclarations(): List { + fun lowerLocalDeclarations() { collectLocalDeclarations() - if (localFunctions.isEmpty() && localClasses.isEmpty()) return listOf(memberDeclaration) + if (localFunctions.isEmpty() && localClasses.isEmpty()) return collectClosureForLocalDeclarations() @@ -191,34 +164,24 @@ class LocalDeclarationsLowering( rewriteDeclarations() - return collectRewrittenDeclarations().apply { - forEach { newDeclaration -> - newDeclaration.patchDeclarationParents(memberDeclaration.parent) + insertLoweredDeclarationForLocalFunctions() + } + + private fun insertLoweredDeclarationForLocalFunctions() { + localFunctions.values.forEach { + it.transformedDeclaration.apply { + val original = it.declaration + this.body = original.body + + original.valueParameters.filter { v -> v.defaultValue != null }.forEach { argument -> + val body = argument.defaultValue!! + oldParameterToNew[argument]!!.defaultValue = body + } } + it.ownerForLoweredDeclaration.addChild(it.transformedDeclaration) } } - private fun collectRewrittenDeclarations(): ArrayList = - ArrayList(localFunctions.size + localClasses.size + 1).apply { - localFunctions.values.mapTo(this) { - val original = it.declaration - it.transformedDeclaration.apply { - this.body = original.body - - original.valueParameters.filter { v -> v.defaultValue != null }.forEach { argument -> - val body = argument.defaultValue - oldParameterToNew[argument]!!.defaultValue = body - } - } - } - - localClasses.values.mapTo(this) { - it.declaration.parent = memberDeclaration.parent - it.declaration - } - - add(memberDeclaration) - } private inner class FunctionBodiesRewriter(val localContext: LocalContext?) : IrElementTransformerVoid() { override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) = @@ -226,8 +189,7 @@ class LocalDeclarationsLowering( declaration.delegate.transform(this, null) override fun visitClass(declaration: IrClass) = if (declaration in localClasses) { - // Replace local class definition with an empty composite. - IrCompositeImpl(declaration.startOffset, declaration.endOffset, context.irBuiltIns.unitType) + localClasses[declaration]!!.declaration } else { super.visitClass(declaration) } @@ -398,7 +360,7 @@ class LocalDeclarationsLowering( } } - private fun rewriteFunctionBody(irDeclaration: IrDeclaration, localContext: LocalContext?) { + private fun rewriteFunctionBody(irDeclaration: IrElement, localContext: LocalContext?) { irDeclaration.transformChildrenVoid(FunctionBodiesRewriter(localContext)) } @@ -451,7 +413,7 @@ class LocalDeclarationsLowering( rewriteClassMembers(it.declaration, it) } - rewriteFunctionBody(memberDeclaration, null) + rewriteFunctionBody(irFile, null) } private fun createNewCall(oldCall: IrCall, newCallee: IrFunction) = @@ -515,7 +477,7 @@ class LocalDeclarationsLowering( private fun createLiftedDeclaration(localFunctionContext: LocalFunctionContext) { val oldDeclaration = localFunctionContext.declaration - val memberOwner = memberDeclaration.parent + val memberOwner = localFunctionContext.ownerForLoweredDeclaration val newDescriptor = WrappedSimpleFunctionDescriptor(oldDeclaration.descriptor) val newSymbol = IrSimpleFunctionSymbolImpl(newDescriptor) val newName = generateNameForLiftedDeclaration(oldDeclaration, memberOwner) @@ -629,12 +591,11 @@ class LocalDeclarationsLowering( newDeclaration.parent = localClassContext.declaration newDeclaration.copyTypeParametersFrom(oldDeclaration) - // TODO: should dispatch receiver be copied? - newDeclaration.dispatchReceiverParameter = oldDeclaration.dispatchReceiverParameter?.copyTo(newDeclaration)?.also { - newParameterToOld.putAbsentOrSame(it, oldDeclaration.dispatchReceiverParameter!!) + oldDeclaration.dispatchReceiverParameter?.run { + throw AssertionError("Local class constructor can't have dispatch receiver: ${ir2string(oldDeclaration)}") } - newDeclaration.extensionReceiverParameter = oldDeclaration.extensionReceiverParameter?.run { - throw AssertionError("constructors can't have extension receiver") + oldDeclaration.extensionReceiverParameter?.run { + throw AssertionError("Local class constructor can't have extension receiver: ${ir2string(oldDeclaration)}") } newDeclaration.valueParameters += createTransformedValueParameters(capturedValues, oldDeclaration, newDeclaration) @@ -707,7 +668,8 @@ class LocalDeclarationsLowering( private fun collectClosureForLocalDeclarations() { - val annotator = ClosureAnnotator(memberDeclaration) + //TODO: maybe use for granular declarations + val annotator = ClosureAnnotator(irFile) localFunctions.forEach { (declaration, context) -> context.closure = annotator.getFunctionClosure(declaration) @@ -719,40 +681,49 @@ class LocalDeclarationsLowering( } private fun collectLocalDeclarations() { - memberDeclaration.acceptChildrenVoid(object : IrElementVisitorVoid { + class ScopeWithCounter(scope: Scope, irElement: IrElement) : ScopeWithIr(scope, irElement) { + // Continuous numbering across all declarations in the container. + var counter: Int = 0 + } + + irFile.acceptVoid(object : IrElementVisitorVoidWithContext() { override fun visitElement(element: IrElement) { element.acceptChildrenVoid(this) } + override fun createScope(declaration: IrSymbolOwner): ScopeWithIr { + return ScopeWithCounter(Scope(declaration.symbol), declaration) + } + override fun visitSimpleFunction(declaration: IrSimpleFunction) { super.visitSimpleFunction(declaration) if (declaration.visibility == Visibilities.LOCAL) { - val localFunctionContext = LocalFunctionContext(declaration) - - localFunctions[declaration] = localFunctionContext - - if (declaration.name.isSpecial) { - localFunctionContext.index = lambdasCount++ - } + val scopeWithIr = + (currentClass ?: currentFile /*file is required for K/N cause file declarations are not split by classes*/ + ?: error("No scope for ${declaration.dump()}")) + localFunctions[declaration] = + LocalFunctionContext( + declaration, + if (declaration.name.isSpecial) (scopeWithIr as ScopeWithCounter).counter++ else -1, + scopeWithIr.irElement as IrDeclarationContainer + ) } } override fun visitConstructor(declaration: IrConstructor) { super.visitConstructor(declaration) - assert(declaration.visibility != Visibilities.LOCAL) - - if ((declaration.parent as IrClass).isInner) return + if (!(declaration.parent as IrClass).isLocalNotInner()) return localClassConstructors[declaration] = LocalClassConstructorContext(declaration) } - override fun visitClass(declaration: IrClass) { - super.visitClass(declaration) + override fun visitClassNew(declaration: IrClass) { + super.visitClassNew(declaration) - if (declaration.isInner) return + if (!declaration.isLocalNotInner()) return val localClassContext = LocalClassContext(declaration) localClasses[declaration] = localClassContext @@ -762,3 +733,6 @@ class LocalDeclarationsLowering( } } + +// Local inner classes capture anything through outer +internal fun IrClass.isLocalNotInner(): Boolean = visibility == Visibilities.LOCAL && !isInner \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt index 7bf969ac220..3dcb4f54f36 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt @@ -179,6 +179,13 @@ private val localDeclarationsLoweringPhase = makeJsModulePhase( prerequisite = setOf(sharedVariablesLoweringPhase, localDelegatedPropertiesLoweringPhase) ) +private val localClassExtractionPhase = makeJsModulePhase( + ::LocalClassPopupLowering, + name = "LocalClassExtractionPhase", + description = "Move local declarations into nearest declaration container", + prerequisite = setOf(localDeclarationsLoweringPhase) +) + private val innerClassesLoweringPhase = makeJsModulePhase( ::InnerClassesLowering, name = "InnerClassesLowering", @@ -372,6 +379,7 @@ val jsPhases = namedIrModulePhase( sharedVariablesLoweringPhase then localDelegatedPropertiesLoweringPhase then localDeclarationsLoweringPhase then + localClassExtractionPhase then innerClassesLoweringPhase then innerClassConstructorCallsLoweringPhase then propertiesLoweringPhase then diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt index dc279e60f2b..9075bfa31e6 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt @@ -97,7 +97,7 @@ class JvmDeclarationFactory( oldConstructor.isInline, oldConstructor.isExternal, oldConstructor.isPrimary ).apply { newDescriptor.bind(this) - annotations.addAll(oldConstructor.annotations.map { it.deepCopyWithWrappedDescriptors(this) }) + annotations.addAll(oldConstructor.annotations.map { it.deepCopyWithSymbols(this) }) parent = oldConstructor.parent returnType = oldConstructor.returnType copyTypeParametersFrom(oldConstructor) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt index 610ee2645a4..9d82fe8e331 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl +import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols import org.jetbrains.kotlin.ir.util.hasAnnotation import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_OVERLOADS_FQ_NAME @@ -150,7 +151,7 @@ private class JvmOverloadsAnnotationLowering(val context: JvmBackendContext) : C } res.parent = oldFunction.parent - res.annotations.addAll(oldFunction.annotations.map { it.deepCopyWithWrappedDescriptors(res) }) + res.annotations.addAll(oldFunction.annotations.map { it.deepCopyWithSymbols(res) }) res.copyTypeParametersFrom(oldFunction) res.dispatchReceiverParameter = oldFunction.dispatchReceiverParameter?.copyTo(res) res.extensionReceiverParameter = oldFunction.extensionReceiverParameter?.copyTo(res) diff --git a/compiler/testData/codegen/box/callableReference/property/privateSetOuterClass.kt b/compiler/testData/codegen/box/callableReference/property/privateSetOuterClass.kt index c1d5b527f72..632b3d49dc5 100644 --- a/compiler/testData/codegen/box/callableReference/property/privateSetOuterClass.kt +++ b/compiler/testData/codegen/box/callableReference/property/privateSetOuterClass.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND: JVM_IR class A { var value: String = "fail1" private set diff --git a/compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForLocalClassInFunctionWithMangledName.kt b/compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForLocalClassInFunctionWithMangledName.kt index d8e77719264..c89652587d4 100644 --- a/compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForLocalClassInFunctionWithMangledName.kt +++ b/compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForLocalClassInFunctionWithMangledName.kt @@ -1,5 +1,4 @@ // !LANGUAGE: +InlineClasses -// IGNORE_BACKEND: JVM_IR // TARGET_BACKEND: JVM // WITH_REFLECT import kotlin.test.* diff --git a/compiler/testData/codegen/box/reflection/classes/qualifiedName.kt b/compiler/testData/codegen/box/reflection/classes/qualifiedName.kt index 7ff9bbe538e..b48029cb128 100644 --- a/compiler/testData/codegen/box/reflection/classes/qualifiedName.kt +++ b/compiler/testData/codegen/box/reflection/classes/qualifiedName.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND: JVM_IR // TARGET_BACKEND: JVM // WITH_REFLECT diff --git a/compiler/testData/codegen/box/reflection/enclosing/anonymousObjectInInlinedLambda.kt b/compiler/testData/codegen/box/reflection/enclosing/anonymousObjectInInlinedLambda.kt index 73bed26feae..3d578531deb 100644 --- a/compiler/testData/codegen/box/reflection/enclosing/anonymousObjectInInlinedLambda.kt +++ b/compiler/testData/codegen/box/reflection/enclosing/anonymousObjectInInlinedLambda.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND: JVM_IR // TARGET_BACKEND: JVM // WITH_REFLECT diff --git a/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalClassConstructor.kt b/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalClassConstructor.kt index 4565581ec9c..bee01e5a309 100644 --- a/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalClassConstructor.kt +++ b/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalClassConstructor.kt @@ -1,5 +1,5 @@ // TARGET_BACKEND: JVM - +// IGNORE_BACKEND: JVM_IR // WITH_REFLECT open class C diff --git a/compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectExpression.kt b/compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectExpression.kt index 314ea979d6b..3e4c30d6c02 100644 --- a/compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectExpression.kt +++ b/compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectExpression.kt @@ -1,5 +1,5 @@ // TARGET_BACKEND: JVM - +// IGNORE_BACKEND: JVM_IR // WITH_REFLECT interface C { diff --git a/compiler/testData/codegen/box/reflection/enclosing/localClassInTopLevelFunction.kt b/compiler/testData/codegen/box/reflection/enclosing/localClassInTopLevelFunction.kt index 5822be741fa..4356824e685 100644 --- a/compiler/testData/codegen/box/reflection/enclosing/localClassInTopLevelFunction.kt +++ b/compiler/testData/codegen/box/reflection/enclosing/localClassInTopLevelFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND: JVM_IR // TARGET_BACKEND: JVM // WITH_REFLECT