From 61d2e338a40684f94a1468f813aec7cd6ea86b5b Mon Sep 17 00:00:00 2001 From: Nikolay Lunyak Date: Wed, 26 Jul 2023 16:26:26 +0300 Subject: [PATCH] [FIR] Prevent compiler crash on lambdas in annotations ^KT-59110 Fixed --- .../LLFirAbstractBodyTargetResolver.kt | 14 +-- .../LLFirAnnotationArgumentsLazyResolver.kt | 8 +- ...CompilerTestFE10TestdataTestGenerated.java | 6 + ...sticCompilerFE10TestDataTestGenerated.java | 6 + ...eeOldFrontendDiagnosticsTestGenerated.java | 6 + ...siOldFrontendDiagnosticsTestGenerated.java | 6 + ...bstractBodyResolveTransformerDispatcher.kt | 109 +++++++++--------- ...ControlFlowStatementsResolveTransformer.kt | 2 +- .../FirDeclarationsResolveTransformer.kt | 6 +- ...FirSpecificAnnotationResolveTransformer.kt | 2 +- .../tests/invalidTargetCrashesCompiler.fir.kt | 5 + .../tests/invalidTargetCrashesCompiler.kt | 5 + .../test/runners/DiagnosticTestGenerated.java | 6 + 13 files changed, 108 insertions(+), 73 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.fir.kt create mode 100644 compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt index 793c17dca06..71b2f6cd3fb 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt @@ -47,22 +47,16 @@ internal abstract class LLFirAbstractBodyTargetResolver( override fun withFile(firFile: FirFile, action: () -> Unit) { transformer.context.withFile(firFile, transformer.components) { - transformer.firResolveContextCollector?.let { collector -> - collector.addFileContext(firFile, transformer.context.towerDataContext) - } - + transformer.firResolveContextCollector?.addFileContext(firFile, transformer.context.towerDataContext) action() } } @Deprecated("Should never be called directly, only for override purposes, please use withRegularClass", level = DeprecationLevel.ERROR) override fun withRegularClassImpl(firClass: FirRegularClass, action: () -> Unit) { - transformer.declarationsTransformer.context.withContainingClass(firClass) { - transformer.declarationsTransformer.withRegularClass(firClass) { - transformer.firResolveContextCollector?.let { collector -> - collector.addDeclarationContext(firClass, transformer.context) - } - + transformer.declarationsTransformer?.context?.withContainingClass(firClass) { + transformer.declarationsTransformer?.withRegularClass(firClass) { + transformer.firResolveContextCollector?.addDeclarationContext(firClass, transformer.context) action() firClass } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt index 10f3778052d..238b423294f 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt @@ -103,10 +103,10 @@ private class LLFirAnnotationArgumentsTargetResolver( internal fun LLFirAbstractBodyTargetResolver.transformAnnotations(target: FirElementWithResolveState) { when { - target is FirRegularClass -> { - target.transformAnnotations(transformer.declarationsTransformer, ResolutionMode.ContextIndependent) - target.transformTypeParameters(transformer.declarationsTransformer, ResolutionMode.ContextIndependent) - target.transformSuperTypeRefs(transformer.declarationsTransformer, ResolutionMode.ContextIndependent) + target is FirRegularClass -> transformer.declarationsTransformer?.let { declarationsTransformer -> + target.transformAnnotations(declarationsTransformer, ResolutionMode.ContextIndependent) + target.transformTypeParameters(declarationsTransformer, ResolutionMode.ContextIndependent) + target.transformSuperTypeRefs(declarationsTransformer, ResolutionMode.ContextIndependent) } target.isRegularDeclarationWithAnnotation -> { diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java index 4e241db93b3..2c7f7357710 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java @@ -483,6 +483,12 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia runTest("compiler/testData/diagnostics/tests/inlineDeprecationsOnImplicitCalls.kt"); } + @Test + @TestMetadata("invalidTargetCrashesCompiler.kt") + public void testInvalidTargetCrashesCompiler() throws Exception { + runTest("compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt"); + } + @Test @TestMetadata("invisibleClassInsteadOfFun.kt") public void testInvisibleClassInsteadOfFun() throws Exception { diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java index 3e959b1dec0..1001f6964a6 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java @@ -483,6 +483,12 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated runTest("compiler/testData/diagnostics/tests/inlineDeprecationsOnImplicitCalls.kt"); } + @Test + @TestMetadata("invalidTargetCrashesCompiler.kt") + public void testInvalidTargetCrashesCompiler() throws Exception { + runTest("compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt"); + } + @Test @TestMetadata("invisibleClassInsteadOfFun.kt") public void testInvisibleClassInsteadOfFun() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java index 95aae2fcaff..6d015f5dd8c 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java @@ -483,6 +483,12 @@ public class FirLightTreeOldFrontendDiagnosticsTestGenerated extends AbstractFir runTest("compiler/testData/diagnostics/tests/inlineDeprecationsOnImplicitCalls.kt"); } + @Test + @TestMetadata("invalidTargetCrashesCompiler.kt") + public void testInvalidTargetCrashesCompiler() throws Exception { + runTest("compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt"); + } + @Test @TestMetadata("invisibleClassInsteadOfFun.kt") public void testInvisibleClassInsteadOfFun() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java index aa0f60a628d..f13b2bc8f0e 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java @@ -483,6 +483,12 @@ public class FirPsiOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiDia runTest("compiler/testData/diagnostics/tests/inlineDeprecationsOnImplicitCalls.kt"); } + @Test + @TestMetadata("invalidTargetCrashesCompiler.kt") + public void testInvalidTargetCrashesCompiler() throws Exception { + runTest("compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt"); + } + @Test @TestMetadata("invisibleClassInsteadOfFun.kt") public void testInvisibleClassInsteadOfFun() throws Exception { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt index 32262f46256..845480b4d2f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt @@ -38,9 +38,9 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( final override val resolutionContext: ResolutionContext = ResolutionContext(session, components, context) - abstract val expressionsTransformer: FirExpressionsResolveTransformer + abstract val expressionsTransformer: FirExpressionsResolveTransformer? - abstract val declarationsTransformer: FirDeclarationsResolveTransformer + abstract val declarationsTransformer: FirDeclarationsResolveTransformer? private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this) @@ -49,19 +49,17 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( return context.withFile(file, components) { withFileAnalysisExceptionWrapping(file) { firResolveContextCollector?.addFileContext(file, context.towerDataContext) - - @Suppress("UNCHECKED_CAST") transformDeclarationContent(file, data) as FirFile } } } override fun transformScript(script: FirScript, data: ResolutionMode): FirScript { - return declarationsTransformer.transformScript(script, data) + return declarationsTransformer?.transformScript(script, data) ?: script } override fun transformCodeFragment(codeFragment: FirCodeFragment, data: ResolutionMode): FirCodeFragment { - return declarationsTransformer.transformCodeFragment(codeFragment, data) + return declarationsTransformer?.transformCodeFragment(codeFragment, data) ?: codeFragment } override fun transformElement(element: E, data: ResolutionMode): E { @@ -103,7 +101,7 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( // ------------------------------------- Expressions ------------------------------------- override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformExpression(expression, data) + return expressionsTransformer?.transformExpression(expression, data) ?: expression } override fun transformWrappedArgumentExpression( @@ -117,178 +115,180 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( qualifiedAccessExpression: FirQualifiedAccessExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data) + return expressionsTransformer?.transformQualifiedAccessExpression(qualifiedAccessExpression, data) ?: qualifiedAccessExpression } override fun transformPropertyAccessExpression( propertyAccessExpression: FirPropertyAccessExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformQualifiedAccessExpression(propertyAccessExpression, data) + return expressionsTransformer?.transformQualifiedAccessExpression(propertyAccessExpression, data) ?: propertyAccessExpression } override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformFunctionCall(functionCall, data) + return expressionsTransformer?.transformFunctionCall(functionCall, data) ?: functionCall } override fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformStringConcatenationCall(stringConcatenationCall, data) + return expressionsTransformer?.transformStringConcatenationCall(stringConcatenationCall, data) ?: stringConcatenationCall } override fun transformCallableReferenceAccess( callableReferenceAccess: FirCallableReferenceAccess, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data) + return expressionsTransformer?.transformCallableReferenceAccess(callableReferenceAccess, data) ?: callableReferenceAccess } override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformBlock(block, data) + return expressionsTransformer?.transformBlock(block, data) ?: block } override fun transformThisReceiverExpression( thisReceiverExpression: FirThisReceiverExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data) + return expressionsTransformer?.transformThisReceiverExpression(thisReceiverExpression, data) ?: thisReceiverExpression } override fun transformComparisonExpression( comparisonExpression: FirComparisonExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformComparisonExpression(comparisonExpression, data) + return expressionsTransformer?.transformComparisonExpression(comparisonExpression, data) ?: comparisonExpression } override fun transformTypeOperatorCall( typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data) + return expressionsTransformer?.transformTypeOperatorCall(typeOperatorCall, data) ?: typeOperatorCall } override fun transformAssignmentOperatorStatement( assignmentOperatorStatement: FirAssignmentOperatorStatement, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformAssignmentOperatorStatement(assignmentOperatorStatement, data) + return expressionsTransformer?.transformAssignmentOperatorStatement(assignmentOperatorStatement, data) + ?: assignmentOperatorStatement } override fun transformIncrementDecrementExpression( incrementDecrementExpression: FirIncrementDecrementExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformIncrementDecrementExpression(incrementDecrementExpression, data) + return expressionsTransformer?.transformIncrementDecrementExpression(incrementDecrementExpression, data) + ?: incrementDecrementExpression } override fun transformEqualityOperatorCall( equalityOperatorCall: FirEqualityOperatorCall, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformEqualityOperatorCall(equalityOperatorCall, data) + return expressionsTransformer?.transformEqualityOperatorCall(equalityOperatorCall, data) ?: equalityOperatorCall } override fun transformCheckNotNullCall( checkNotNullCall: FirCheckNotNullCall, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformCheckNotNullCall(checkNotNullCall, data) + return expressionsTransformer?.transformCheckNotNullCall(checkNotNullCall, data) ?: checkNotNullCall } override fun transformBinaryLogicExpression( binaryLogicExpression: FirBinaryLogicExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data) + return expressionsTransformer?.transformBinaryLogicExpression(binaryLogicExpression, data) ?: binaryLogicExpression } override fun transformDesugaredAssignmentValueReferenceExpression( desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformDesugaredAssignmentValueReferenceExpression( + return expressionsTransformer?.transformDesugaredAssignmentValueReferenceExpression( desugaredAssignmentValueReferenceExpression, data, - ) + ) ?: desugaredAssignmentValueReferenceExpression } override fun transformVariableAssignment( variableAssignment: FirVariableAssignment, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformVariableAssignment(variableAssignment, data) + return expressionsTransformer?.transformVariableAssignment(variableAssignment, data) ?: variableAssignment } override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformGetClassCall(getClassCall, data) + return expressionsTransformer?.transformGetClassCall(getClassCall, data) ?: getClassCall } override fun transformWrappedDelegateExpression( wrappedDelegateExpression: FirWrappedDelegateExpression, data: ResolutionMode ): FirStatement { - return declarationsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data) + return declarationsTransformer?.transformWrappedDelegateExpression(wrappedDelegateExpression, data) ?: wrappedDelegateExpression } override fun transformConstExpression( constExpression: FirConstExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformConstExpression(constExpression, data) + return expressionsTransformer?.transformConstExpression(constExpression, data) ?: constExpression } override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformAnnotation(annotation, data) + return expressionsTransformer?.transformAnnotation(annotation, data) ?: annotation } override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformAnnotationCall(annotationCall, data) + return expressionsTransformer?.transformAnnotationCall(annotationCall, data) ?: annotationCall } override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformErrorAnnotationCall(errorAnnotationCall, data) + return expressionsTransformer?.transformErrorAnnotationCall(errorAnnotationCall, data) ?: errorAnnotationCall } override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data) + return expressionsTransformer?.transformDelegatedConstructorCall(delegatedConstructorCall, data) ?: delegatedConstructorCall } override fun transformAugmentedArraySetCall( augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data) + return expressionsTransformer?.transformAugmentedArraySetCall(augmentedArraySetCall, data) ?: augmentedArraySetCall } override fun transformSafeCallExpression( safeCallExpression: FirSafeCallExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformSafeCallExpression(safeCallExpression, data) + return expressionsTransformer?.transformSafeCallExpression(safeCallExpression, data) ?: safeCallExpression } override fun transformCheckedSafeCallSubject( checkedSafeCallSubject: FirCheckedSafeCallSubject, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) + return expressionsTransformer?.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) ?: checkedSafeCallSubject } override fun transformArrayLiteral(arrayLiteral: FirArrayLiteral, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformArrayLiteral(arrayLiteral, data) + return expressionsTransformer?.transformArrayLiteral(arrayLiteral, data) ?: arrayLiteral } override fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: ResolutionMode): FirStatement { - return expressionsTransformer.transformSmartCastExpression(smartCastExpression, data) + return expressionsTransformer?.transformSmartCastExpression(smartCastExpression, data) ?: smartCastExpression } // ------------------------------------- Declarations ------------------------------------- override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration { - return declarationsTransformer.transformDeclaration(declaration, data) + return declarationsTransformer?.transformDeclaration(declaration, data) ?: declaration } open fun transformDeclarationContent( @@ -301,95 +301,96 @@ abstract class FirAbstractBodyResolveTransformerDispatcher( declarationStatus: FirDeclarationStatus, data: ResolutionMode ): FirDeclarationStatus { - return declarationsTransformer.transformDeclarationStatus(declarationStatus, data) + return declarationsTransformer?.transformDeclarationStatus(declarationStatus, data) ?: declarationStatus } override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry { - return declarationsTransformer.transformEnumEntry(enumEntry, data) + return declarationsTransformer?.transformEnumEntry(enumEntry, data) ?: enumEntry } override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { - return declarationsTransformer.transformProperty(property, data) + return declarationsTransformer?.transformProperty(property, data) ?: property } override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: ResolutionMode): FirStatement { - return declarationsTransformer.transformPropertyAccessor(propertyAccessor, data) + return declarationsTransformer?.transformPropertyAccessor(propertyAccessor, data) ?: propertyAccessor } override fun transformBackingField( backingField: FirBackingField, data: ResolutionMode ): FirStatement { - return declarationsTransformer.transformBackingField(backingField, data) + return declarationsTransformer?.transformBackingField(backingField, data) ?: backingField } override fun transformField(field: FirField, data: ResolutionMode): FirField { - return declarationsTransformer.transformField(field, data) + return declarationsTransformer?.transformField(field, data) ?: field } override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { - return declarationsTransformer.transformRegularClass(regularClass, data) + return declarationsTransformer?.transformRegularClass(regularClass, data) ?: regularClass } override fun transformAnonymousObject( anonymousObject: FirAnonymousObject, data: ResolutionMode ): FirStatement { - return declarationsTransformer.transformAnonymousObject(anonymousObject, data) + return declarationsTransformer?.transformAnonymousObject(anonymousObject, data) ?: anonymousObject } override fun transformAnonymousObjectExpression( anonymousObjectExpression: FirAnonymousObjectExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformAnonymousObjectExpression(anonymousObjectExpression, data) + return expressionsTransformer?.transformAnonymousObjectExpression(anonymousObjectExpression, data) ?: anonymousObjectExpression } override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: ResolutionMode ): FirSimpleFunction { - return declarationsTransformer.transformSimpleFunction(simpleFunction, data) + return declarationsTransformer?.transformSimpleFunction(simpleFunction, data) ?: simpleFunction } override fun transformFunction( function: FirFunction, data: ResolutionMode ): FirStatement { - return declarationsTransformer.transformFunction(function, data) + return declarationsTransformer?.transformFunction(function, data) ?: function } override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor { - return declarationsTransformer.transformConstructor(constructor, data) + return declarationsTransformer?.transformConstructor(constructor, data) ?: constructor } override fun transformAnonymousInitializer( anonymousInitializer: FirAnonymousInitializer, data: ResolutionMode ): FirAnonymousInitializer { - return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data) + return declarationsTransformer?.transformAnonymousInitializer(anonymousInitializer, data) ?: anonymousInitializer } override fun transformAnonymousFunction( anonymousFunction: FirAnonymousFunction, data: ResolutionMode ): FirStatement { - return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data) + return declarationsTransformer?.transformAnonymousFunction(anonymousFunction, data) ?: anonymousFunction } override fun transformAnonymousFunctionExpression( anonymousFunctionExpression: FirAnonymousFunctionExpression, data: ResolutionMode ): FirStatement { - return expressionsTransformer.transformAnonymousFunctionExpression(anonymousFunctionExpression, data) + return expressionsTransformer?.transformAnonymousFunctionExpression(anonymousFunctionExpression, data) + ?: anonymousFunctionExpression } override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement { - return declarationsTransformer.transformValueParameter(valueParameter, data) + return declarationsTransformer?.transformValueParameter(valueParameter, data) ?: valueParameter } override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias { - return declarationsTransformer.transformTypeAlias(typeAlias, data) + return declarationsTransformer?.transformTypeAlias(typeAlias, data) ?: typeAlias } // ------------------------------------- Control flow statements ------------------------------------- diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index 4d46f007e5a..e44c1d32892 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt @@ -42,7 +42,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirAbstractBodyRes val context = ResolutionMode.ContextIndependent doWhileLoop.also(dataFlowAnalyzer::enterDoWhileLoop) .also { - transformer.expressionsTransformer.transformBlockInCurrentScope(it.block, context) + transformer.expressionsTransformer?.transformBlockInCurrentScope(it.block, context) } .also(dataFlowAnalyzer::enterDoWhileLoopCondition) .transformCondition(transformer, withExpectedType(session.builtinTypes.booleanType)) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 53a9ad669a3..07eb003e1fc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -59,11 +59,11 @@ open class FirDeclarationsResolveTransformer( } private inline fun withFirArrayOfCallTransformer(block: () -> T): T { - transformer.expressionsTransformer.enableArrayOfCallTransformation = true + transformer.expressionsTransformer?.enableArrayOfCallTransformation = true return try { block() } finally { - transformer.expressionsTransformer.enableArrayOfCallTransformation = false + transformer.expressionsTransformer?.enableArrayOfCallTransformation = false } } @@ -355,7 +355,7 @@ open class FirDeclarationsResolveTransformer( // Resolve call for provideDelegate, without completion // TODO: this generates some nodes in the control flow graph which we don't want if we // end up not selecting this option, KT-59684 - transformer.expressionsTransformer.transformFunctionCallInternal( + transformer.expressionsTransformer?.transformFunctionCallInternal( provideDelegateCall, ResolutionMode.ContextIndependent, provideDelegate = true ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt index 2809be8dc26..6e8dd557a87 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt @@ -91,7 +91,7 @@ abstract class AbstractFirSpecificAnnotationResolveTransformer( implicitTypeOnly = false, ) { override val expressionsTransformer: FirExpressionsResolveTransformer = FirEnumAnnotationArgumentsTransformer(this) - override val declarationsTransformer: FirDeclarationsResolveTransformer get() = throw NotImplementedError() + override val declarationsTransformer: FirDeclarationsResolveTransformer? = null } /** diff --git a/compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.fir.kt b/compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.fir.kt new file mode 100644 index 00000000000..9363350903c --- /dev/null +++ b/compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.fir.kt @@ -0,0 +1,5 @@ +// ISSUE: KT-59110 + +@Target({}) +interface SomeInterface { +} diff --git a/compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt b/compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt new file mode 100644 index 00000000000..5550b389d05 --- /dev/null +++ b/compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt @@ -0,0 +1,5 @@ +// ISSUE: KT-59110 + +@Target({}) +interface SomeInterface { +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index be781041429..b70ca74ec04 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -483,6 +483,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/inlineDeprecationsOnImplicitCalls.kt"); } + @Test + @TestMetadata("invalidTargetCrashesCompiler.kt") + public void testInvalidTargetCrashesCompiler() throws Exception { + runTest("compiler/testData/diagnostics/tests/invalidTargetCrashesCompiler.kt"); + } + @Test @TestMetadata("invisibleClassInsteadOfFun.kt") public void testInvisibleClassInsteadOfFun() throws Exception {