From 73cc73115e88c07863d1a216e782171e6aa3dd2d Mon Sep 17 00:00:00 2001 From: Ivan Kylchik Date: Fri, 28 Apr 2023 18:01:40 +0200 Subject: [PATCH] [FIR2IR] Simplify logic around `annotationMode` #KT-58005 Fixed --- .../kotlin/fir/backend/Fir2IrVisitor.kt | 67 +++++++++---------- .../generators/CallAndReferenceGenerator.kt | 38 +++++------ .../generators/ClassMemberGenerator.kt | 10 +-- ...LightTreeBlackBoxCodegenTestGenerated.java | 6 ++ .../FirPsiBlackBoxCodegenTestGenerated.java | 6 ++ .../box/involvesIrInterpreter/kt58005.kt | 66 ++++++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 6 ++ .../IrBlackBoxCodegenTestGenerated.java | 6 ++ ...kBoxCodegenWithIrInlinerTestGenerated.java | 6 ++ .../LightAnalysisModeTestGenerated.java | 5 ++ 10 files changed, 156 insertions(+), 60 deletions(-) create mode 100644 compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index ee6b6ad7bad..937a490bacd 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -69,10 +69,24 @@ class Fir2IrVisitor( private val operatorGenerator = OperatorExpressionGenerator(components, this, conversionScope) + private var _annotationMode: Boolean = false + public val annotationMode: Boolean + get() = _annotationMode + private fun FirTypeRef.toIrType(): IrType = with(typeConverter) { toIrType() } private fun applyParentFromStackTo(declaration: T): T = conversionScope.applyParentFromStackTo(declaration) + internal inline fun withAnnotationMode(enableAnnotationMode: Boolean = true, block: () -> T): T { + val oldAnnotationMode = _annotationMode + _annotationMode = enableAnnotationMode + try { + return block() + } finally { + _annotationMode = oldAnnotationMode + } + } + override fun visitElement(element: FirElement, data: Any?): IrElement { TODO("Should not be here: ${element::class} ${element.render()}") } @@ -412,33 +426,32 @@ class Fir2IrVisitor( endOffset, varargArgumentsExpression.typeRef.toIrType(), varargArgumentsExpression.varargElementType.toIrType(), - varargArgumentsExpression.arguments.map { it.convertToIrVarargElement(annotationMode = false) } + varargArgumentsExpression.arguments.map { it.convertToIrVarargElement() } ) } } - private fun FirExpression.convertToIrVarargElement(annotationMode: Boolean): IrVarargElement = + private fun FirExpression.convertToIrVarargElement(): IrVarargElement = if (this is FirSpreadArgumentExpression || this is FirNamedArgumentExpression && this.isSpread) { IrSpreadElementImpl( source?.startOffset ?: UNDEFINED_OFFSET, source?.endOffset ?: UNDEFINED_OFFSET, - convertToIrExpression(this, annotationMode) + convertToIrExpression(this) ) - } else convertToIrExpression(this, annotationMode) + } else convertToIrExpression(this) - private fun convertToIrCall(functionCall: FirFunctionCall, annotationMode: Boolean): IrExpression { + private fun convertToIrCall(functionCall: FirFunctionCall): IrExpression { if (functionCall.isCalleeDynamic && functionCall.calleeReference.name == OperatorNameConventions.SET && functionCall.calleeReference.source?.kind == KtFakeSourceElementKind.ArrayAccessNameReference ) { - return convertToIrArrayAccessDynamicCall(functionCall, annotationMode) + return convertToIrArrayAccessDynamicCall(functionCall) } - return convertToIrCall(functionCall, annotationMode, dynamicOperator = null) + return convertToIrCall(functionCall, dynamicOperator = null) } private fun convertToIrCall( functionCall: FirFunctionCall, - annotationMode: Boolean, dynamicOperator: IrDynamicOperator? ): IrExpression { val explicitReceiverExpression = convertToIrReceiverExpression(functionCall.explicitReceiver, functionCall.calleeReference) @@ -446,21 +459,19 @@ class Fir2IrVisitor( functionCall, functionCall.typeRef, explicitReceiverExpression, - annotationMode, dynamicOperator ) } - private fun convertToIrArrayAccessDynamicCall(functionCall: FirFunctionCall, annotationMode: Boolean): IrExpression { + private fun convertToIrArrayAccessDynamicCall(functionCall: FirFunctionCall): IrExpression { val explicitReceiverExpression = convertToIrCall( - functionCall, annotationMode, dynamicOperator = IrDynamicOperator.ARRAY_ACCESS + functionCall, dynamicOperator = IrDynamicOperator.ARRAY_ACCESS ) if (explicitReceiverExpression is IrDynamicOperatorExpression) { explicitReceiverExpression.arguments.removeLast() } val result = callGenerator.convertToIrCall( functionCall, functionCall.typeRef, explicitReceiverExpression, - annotationMode = annotationMode, dynamicOperator = IrDynamicOperator.EQ ) if (result is IrDynamicOperatorExpression) { @@ -474,7 +485,7 @@ class Fir2IrVisitor( } override fun visitFunctionCall(functionCall: FirFunctionCall, data: Any?): IrExpression = whileAnalysing(session, functionCall) { - return convertToIrCall(functionCall = functionCall, annotationMode = false) + return convertToIrCall(functionCall = functionCall) } override fun visitSafeCallExpression( @@ -521,13 +532,12 @@ class Fir2IrVisitor( private fun convertQualifiedAccessExpression( qualifiedAccessExpression: FirQualifiedAccessExpression, - annotationMode: Boolean = false ): IrExpression = whileAnalysing(session, qualifiedAccessExpression) { val explicitReceiverExpression = convertToIrReceiverExpression( qualifiedAccessExpression.explicitReceiver, qualifiedAccessExpression.calleeReference ) return callGenerator.convertToIrCall( - qualifiedAccessExpression, qualifiedAccessExpression.typeRef, explicitReceiverExpression, annotationMode = annotationMode + qualifiedAccessExpression, qualifiedAccessExpression.typeRef, explicitReceiverExpression ) } @@ -678,7 +688,6 @@ class Fir2IrVisitor( internal fun convertToIrExpression( expression: FirExpression, - annotationMode: Boolean = false, isDelegate: Boolean = false ): IrExpression { return when (expression) { @@ -691,20 +700,9 @@ class Fir2IrVisitor( ) } else -> { - val unwrappedExpression = expression.unwrapArgument() - if (annotationMode) { - when (unwrappedExpression) { - is FirFunctionCall -> convertToIrCall(unwrappedExpression, true) - is FirArrayOfCall -> convertToArrayOfCall(unwrappedExpression, true) - is FirCallableReferenceAccess -> convertCallableReferenceAccess(unwrappedExpression, isDelegate) - is FirQualifiedAccessExpression -> convertQualifiedAccessExpression(unwrappedExpression, true) - else -> expression.accept(this, null) as IrExpression - } - } else { - when (unwrappedExpression) { - is FirCallableReferenceAccess -> convertCallableReferenceAccess(unwrappedExpression, isDelegate) - else -> expression.accept(this, null) as IrExpression - } + when (val unwrappedExpression = expression.unwrapArgument()) { + is FirCallableReferenceAccess -> convertCallableReferenceAccess(unwrappedExpression, isDelegate) + else -> expression.accept(this, null) as IrExpression } } }.let { @@ -881,11 +879,10 @@ class Fir2IrVisitor( qualifiedAccess, qualifiedAccess.typeRef, convertToIrReceiverExpression(receiverExpression, qualifiedAccess.calleeReference), - annotationMode = false ) } return callGenerator.convertToIrCall( - operationCall, operationCall.typeRef, explicitReceiverExpression, annotationMode = false + operationCall, operationCall.typeRef, explicitReceiverExpression ) } @@ -1364,7 +1361,7 @@ class Fir2IrVisitor( classifierStorage.getIrClassSymbol(it) } - private fun convertToArrayOfCall(arrayOfCall: FirArrayOfCall, annotationMode: Boolean): IrVararg { + private fun convertToArrayOfCall(arrayOfCall: FirArrayOfCall): IrVararg { return arrayOfCall.convertWithOffsets { startOffset, endOffset -> val arrayType = arrayOfCall.typeRef.toIrType() val elementType = if (arrayOfCall.typeRef is FirResolvedTypeRef) { @@ -1376,13 +1373,13 @@ class Fir2IrVisitor( startOffset, endOffset, type = arrayType, varargElementType = elementType, - elements = arrayOfCall.arguments.map { it.convertToIrVarargElement(annotationMode) } + elements = arrayOfCall.arguments.map { it.convertToIrVarargElement() } ) } } override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: Any?): IrElement = whileAnalysing(session, arrayOfCall) { - return convertToArrayOfCall(arrayOfCall, annotationMode = false) + return convertToArrayOfCall(arrayOfCall) } override fun visitAugmentedArraySetCall( diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index a4985f0d7c5..a3d35bce1be 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -294,7 +294,6 @@ class CallAndReferenceGenerator( type: IrType, calleeReference: FirReference, symbol: FirBasedSymbol<*>, - annotationMode: Boolean = false, dynamicOperator: IrDynamicOperator? = null, noArguments: Boolean = false, ): IrExpression { @@ -332,14 +331,13 @@ class CallAndReferenceGenerator( } } .applyTypeArguments(qualifiedAccess) - .applyCallArguments((qualifiedAccess as? FirCall)?.takeIf { !noArguments }, annotationMode) + .applyCallArguments((qualifiedAccess as? FirCall)?.takeIf { !noArguments }) } fun convertToIrCall( qualifiedAccess: FirQualifiedAccessExpression, typeRef: FirTypeRef, explicitReceiverExpression: IrExpression?, - annotationMode: Boolean = false, dynamicOperator: IrDynamicOperator? = null, variableAsFunctionMode: Boolean = false, noArguments: Boolean = false @@ -362,7 +360,6 @@ class CallAndReferenceGenerator( type, calleeReference, firSymbol ?: error("Must have had a symbol"), - annotationMode, dynamicOperator, noArguments, ) @@ -445,7 +442,7 @@ class CallAndReferenceGenerator( } } - is IrFieldSymbol -> if (annotationMode) { + is IrFieldSymbol -> if (visitor.annotationMode) { val resolvedSymbol = calleeReference.toResolvedCallableSymbol() ?: error("should have resolvedSymbol") val returnType = resolvedSymbol.resolvedReturnTypeRef.toIrType() val firConstExpression = (resolvedSymbol.fir as FirVariable).initializer as? FirConstExpression<*> @@ -474,7 +471,7 @@ class CallAndReferenceGenerator( else -> generateErrorCallExpression(startOffset, endOffset, calleeReference, type) } }.applyTypeArguments(qualifiedAccess).applyReceivers(qualifiedAccess, convertedExplicitReceiver) - .applyCallArguments(qualifiedAccess, annotationMode) + .applyCallArguments(qualifiedAccess) } catch (e: Throwable) { throw IllegalStateException( "Error while translating ${qualifiedAccess.render()} " + @@ -647,7 +644,7 @@ class CallAndReferenceGenerator( ?.fullyExpandedType(session) as? ConeLookupTagBasedType val type = coneType?.toIrType() val symbol = type?.classifierOrNull - return annotation.convertWithOffsets { startOffset, endOffset -> + val irConstructorCall = annotation.convertWithOffsets { startOffset, endOffset -> when (symbol) { is IrClassSymbol -> { val irClass = symbol.owner @@ -694,7 +691,10 @@ class CallAndReferenceGenerator( ) } } - }.applyCallArguments(annotation.toAnnotationCall(), annotationMode = true) + } + return visitor.withAnnotationMode { + irConstructorCall.applyCallArguments(annotation.toAnnotationCall()) + } } private fun FirAnnotation.toAnnotationCall(): FirAnnotationCall? { @@ -779,7 +779,6 @@ class CallAndReferenceGenerator( internal fun IrExpression.applyCallArguments( statement: FirStatement?, - annotationMode: Boolean ): IrExpression { val call = statement as? FirCall return when (this) { @@ -790,11 +789,10 @@ class CallAndReferenceGenerator( if (argumentsCount <= valueArgumentsCount) { apply { val (valueParameters, argumentMapping, substitutor) = extractArgumentsMapping(call) - if (argumentMapping != null && (annotationMode || argumentMapping.isNotEmpty())) { + if (argumentMapping != null && (visitor.annotationMode || argumentMapping.isNotEmpty())) { if (valueParameters != null) { return applyArgumentsWithReorderingIfNeeded( - argumentMapping, valueParameters, substitutor, annotationMode, - contextReceiverCount, + argumentMapping, valueParameters, substitutor, contextReceiverCount, ) } } @@ -828,12 +826,12 @@ class CallAndReferenceGenerator( is IrDynamicOperatorExpression -> apply { if (call == null) return@apply val (valueParameters, argumentMapping, substitutor) = extractArgumentsMapping(call) - if (argumentMapping != null && (annotationMode || argumentMapping.isNotEmpty())) { + if (argumentMapping != null && (visitor.annotationMode || argumentMapping.isNotEmpty())) { if (valueParameters != null) { val dynamicCallVarargArgument = argumentMapping.keys.firstOrNull() as? FirVarargArgumentsExpression ?: error("Dynamic call must have a single vararg argument") for (argument in dynamicCallVarargArgument.arguments) { - val irArgument = convertArgument(argument, null, substitutor, annotationMode) + val irArgument = convertArgument(argument, null, substitutor) arguments.add(irArgument) } } @@ -870,15 +868,14 @@ class CallAndReferenceGenerator( argumentMapping: Map, valueParameters: List, substitutor: ConeSubstitutor, - annotationMode: Boolean, contextReceiverCount: Int, ): IrExpression { val converted = argumentMapping.entries.map { (argument, parameter) -> - parameter to convertArgument(argument, parameter, substitutor, annotationMode) + parameter to convertArgument(argument, parameter, substitutor) } // If none of the parameters have side effects, the evaluation order doesn't matter anyway. // For annotations, this is always true, since arguments have to be compile-time constants. - if (!annotationMode && !converted.all { (_, irArgument) -> irArgument.hasNoSideEffects() } && + if (!visitor.annotationMode && !converted.all { (_, irArgument) -> irArgument.hasNoSideEffects() } && needArgumentReordering(argumentMapping.values, valueParameters) ) { return IrBlockImpl(startOffset, endOffset, type, IrStatementOrigin.ARGUMENTS_REORDERING_FOR_CALL).apply { @@ -903,12 +900,12 @@ class CallAndReferenceGenerator( for ((parameter, irArgument) in converted) { putValueArgument(valueParameters.indexOf(parameter) + contextReceiverCount, irArgument) } - if (annotationMode) { + if (visitor.annotationMode) { for ((index, parameter) in valueParameters.withIndex()) { if (parameter.isVararg && !argumentMapping.containsValue(parameter)) { val defaultValue = parameter.defaultValue val value = if (defaultValue != null) { - convertArgument(defaultValue, parameter, ConeSubstitutor.Empty, annotationMode = true) + convertArgument(defaultValue, parameter, ConeSubstitutor.Empty) } else { val elementType = parameter.returnTypeRef.toIrType() IrVarargImpl( @@ -945,9 +942,8 @@ class CallAndReferenceGenerator( argument: FirExpression, parameter: FirValueParameter?, substitutor: ConeSubstitutor, - annotationMode: Boolean = false ): IrExpression { - var irArgument = visitor.convertToIrExpression(argument, annotationMode) + var irArgument = visitor.convertToIrExpression(argument) if (parameter != null) { with(visitor.implicitCastInserter) { irArgument = irArgument.cast(argument, argument.typeRef, parameter.returnTypeRef) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt index d600143d345..f1d39ab0bc3 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt @@ -111,7 +111,9 @@ internal class ClassMemberGenerator( val irParameters = valueParameters.drop(firFunction.contextReceivers.size) val annotationMode = containingClass?.classKind == ClassKind.ANNOTATION_CLASS && irFunction is IrConstructor for ((valueParameter, firValueParameter) in irParameters.zip(firFunction.valueParameters)) { - valueParameter.setDefaultValue(firValueParameter, annotationMode) + visitor.withAnnotationMode(enableAnnotationMode = annotationMode) { + valueParameter.setDefaultValue(firValueParameter) + } } annotationGenerator.generate(irFunction, firFunction) } @@ -389,7 +391,7 @@ internal class ClassMemberGenerator( } with(callGenerator) { declarationStorage.enterScope(irConstructorSymbol.owner) - val result = it.applyCallArguments(this@toIrDelegatingConstructorCall, annotationMode = false) + val result = it.applyCallArguments(this@toIrDelegatingConstructorCall) declarationStorage.leaveScope(irConstructorSymbol.owner) result } @@ -397,10 +399,10 @@ internal class ClassMemberGenerator( } } - private fun IrValueParameter.setDefaultValue(firValueParameter: FirValueParameter, annotationMode: Boolean) { + private fun IrValueParameter.setDefaultValue(firValueParameter: FirValueParameter) { val firDefaultValue = firValueParameter.defaultValue if (firDefaultValue != null) { - this.defaultValue = factory.createExpressionBody(visitor.convertToIrExpression(firDefaultValue, annotationMode)) + this.defaultValue = factory.createExpressionBody(visitor.convertToIrExpression(firDefaultValue)) } } } diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java index c9635873bbe..8ebbfc4662c 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java @@ -28351,6 +28351,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt57313.kt"); } + @Test + @TestMetadata("kt58005.kt") + public void testKt58005() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt"); + } + @Test @TestMetadata("longOperations.kt") public void testLongOperations() throws Exception { diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java index 285e47a022c..5ad89913815 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java @@ -28351,6 +28351,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt57313.kt"); } + @Test + @TestMetadata("kt58005.kt") + public void testKt58005() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt"); + } + @Test @TestMetadata("longOperations.kt") public void testLongOperations() throws Exception { diff --git a/compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt b/compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt new file mode 100644 index 00000000000..4ab1b84aca0 --- /dev/null +++ b/compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt @@ -0,0 +1,66 @@ +// TARGET_BACKEND: JVM + +// FILE: ComponentScans.java +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface ComponentScans { + ComponentScan[] value(); +} + +// FILE: ComponentScan.java +import java.lang.annotation.ElementType; +import java.lang.annotation.Repeatable; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +@Repeatable(ComponentScans.class) +public @interface ComponentScan { + String[] a() default {}; + String[] b() default {}; + String[] c() default {}; +} + +// FILE: main.kt +@ComponentScans( + value = [ + ComponentScan( + a = ["String" + "A"], + c = ["String" + "C"], + b = ["String" + "B"], + ) + ] +) +class JavaTest + +annotation class KtComponentScans( + val value: Array = [], +) + +annotation class KtComponentScan( + val a: Array = [], + val b: Array = [], + val c: Array = [], +) + +@ComponentScans( + value = [ + ComponentScan( + a = ["String" + "A"], + c = ["String" + "C"], + b = ["String" + "B"], + ) + ] +) +class KtTest + +fun box(): String { + return "OK" +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java index 52c56d7a392..190ea310c56 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java @@ -27211,6 +27211,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt57028.kt"); } + @Test + @TestMetadata("kt58005.kt") + public void testKt58005() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt"); + } + @Nested @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter/intrinsicConst") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index 613bfa9e30c..dd02a566621 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java @@ -28351,6 +28351,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt57313.kt"); } + @Test + @TestMetadata("kt58005.kt") + public void testKt58005() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt"); + } + @Test @TestMetadata("longOperations.kt") public void testLongOperations() throws Exception { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java index df3c0d1a309..8ffda066cff 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java @@ -28351,6 +28351,12 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt57313.kt"); } + @Test + @TestMetadata("kt58005.kt") + public void testKt58005() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt"); + } + @Test @TestMetadata("longOperations.kt") public void testLongOperations() throws Exception { diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 22b9dbca199..600874977e7 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -22962,6 +22962,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt57028.kt"); } + @TestMetadata("kt58005.kt") + public void testKt58005() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt58005.kt"); + } + @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter/intrinsicConst") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)