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