From 71def0666e7aa27fa8e080d937fd08f869d916e8 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 28 Jul 2021 15:17:17 +0300 Subject: [PATCH] [FIR] Introduce special phase for resolve of enums and class literals --- ...TouchedTilContractsPhaseTestGenerated.java | 5 + ...nDeclarationWithDifferentArguments.fir.txt | 54 ++++++++ ...tionOnDeclarationWithDifferentArguments.kt | 30 +++++ .../runners/FirDiagnosticTestGenerated.java | 6 + ...DiagnosticsWithLightTreeTestGenerated.java | 6 + .../jetbrains/kotlin/fir/FirCallResolver.kt | 16 +++ .../resolve/transformers/ResolvePhaseUtils.kt | 2 +- .../FirExpressionsResolveTransformer.kt | 11 +- .../FirAnnotationArgumentsResolveProcessor.kt | 5 - ...irAnnotationArgumentsResolveTransformer.kt | 125 ++++++++++++------ .../fir/declarations/FirResolvePhase.kt | 2 +- ...nosisCompilerFirTestdataTestGenerated.java | 6 + 12 files changed, 218 insertions(+), 50 deletions(-) create mode 100644 compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.fir.txt create mode 100644 compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt diff --git a/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java b/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java index 44a7dd48851..bd7d02a1b0f 100644 --- a/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java +++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java @@ -29,6 +29,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @TestMetadata("annotationOnDeclarationWithDifferentArguments.kt") + public void testAnnotationOnDeclarationWithDifferentArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt"); + } + @TestMetadata("annotationUsedAsAnnotationArgument.kt") public void testAnnotationUsedAsAnnotationArgument() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt"); diff --git a/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.fir.txt b/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.fir.txt new file mode 100644 index 00000000000..8ff22ecd0f6 --- /dev/null +++ b/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.fir.txt @@ -0,0 +1,54 @@ +FILE: annotationOnDeclarationWithDifferentArguments.kt + public final enum class SomeEnum : R|kotlin/Enum| { + private constructor(): R|SomeEnum| { + super|>() + } + + public final static enum entry A: R|SomeEnum| + public final static enum entry B: R|SomeEnum| + public final static fun values(): R|kotlin/Array| { + } + + public final static fun valueOf(value: R|kotlin/String|): R|SomeEnum| { + } + + } + public final annotation class MyAnnotation : R|kotlin/Annotation| { + public constructor(intValue: R|kotlin/Int|, stringValue: R|kotlin/String|, enumValue: R|SomeEnum|, kClasses: R|kotlin/Array>|, annotation: R|MyOtherAnnotation|): R|MyAnnotation| { + super() + } + + public final val intValue: R|kotlin/Int| = R|/intValue| + public get(): R|kotlin/Int| + + public final val stringValue: R|kotlin/String| = R|/stringValue| + public get(): R|kotlin/String| + + public final val enumValue: R|SomeEnum| = R|/enumValue| + public get(): R|SomeEnum| + + public final val kClasses: R|kotlin/Array>| = R|/kClasses| + public get(): R|kotlin/Array>| + + public final val annotation: R|MyOtherAnnotation| = R|/annotation| + public get(): R|MyOtherAnnotation| + + } + public final annotation class MyOtherAnnotation : R|kotlin/Annotation| { + public constructor(intValue: R|kotlin/Int|, stringValue: R|kotlin/String|): R|MyOtherAnnotation| { + super() + } + + public final val intValue: R|kotlin/Int| = R|/intValue| + public get(): R|kotlin/Int| + + public final val stringValue: R|kotlin/String| = R|/stringValue| + public get(): R|kotlin/String| + + } + public final const val constInt: R|kotlin/Int| = Int(10) + public get(): R|kotlin/Int| + public final const val constString: R|kotlin/String| = String() + public get(): R|kotlin/String| + @R|MyAnnotation|(intValue = Int(10), stringValue = R|/constString|, enumValue = Q|SomeEnum|.R|/SomeEnum.A|, kClasses = ((Q|kotlin/String|), (R|/constString|)), annotation = R|/MyOtherAnnotation.MyOtherAnnotation|(intValue = R|/constInt|, stringValue = String(hello))) public final fun foo(): R|kotlin/Unit| { + } diff --git a/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt b/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt new file mode 100644 index 00000000000..e7d4b1a3414 --- /dev/null +++ b/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt @@ -0,0 +1,30 @@ +import kotlin.reflect.KClass + +enum class SomeEnum { + A, B +} + +annotation class MyAnnotation( + val intValue: Int, + val stringValue: String, + val enumValue: SomeEnum, + val kClasses: Array>, + val annotation: MyOtherAnnotation +) +annotation class MyOtherAnnotation(val intValue: Int, val stringValue: String) + +const val constInt = 10 +const val constString = "" + +@MyAnnotation( + intValue = 10, + stringValue = constString, + enumValue = SomeEnum.A, + kClasses = [String::class, constString::class], + + annotation = MyOtherAnnotation( + intValue = constInt, + stringValue = "hello" + ) +) +fun foo() {} diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java index bd470b9b4bb..451e205f86a 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java @@ -26,6 +26,12 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test + @TestMetadata("annotationOnDeclarationWithDifferentArguments.kt") + public void testAnnotationOnDeclarationWithDifferentArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt"); + } + @Test @TestMetadata("annotationUsedAsAnnotationArgument.kt") public void testAnnotationUsedAsAnnotationArgument() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java index d6e10bcac35..915b54cb650 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java @@ -26,6 +26,12 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test + @TestMetadata("annotationOnDeclarationWithDifferentArguments.kt") + public void testAnnotationOnDeclarationWithDifferentArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt"); + } + @Test @TestMetadata("annotationUsedAsAnnotationArgument.kt") public void testAnnotationUsedAsAnnotationArgument() throws Exception { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 2519f87d0da..6b53d49e41f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -200,6 +200,20 @@ class FirCallResolver( } fun resolveVariableAccessAndSelectCandidate(qualifiedAccess: T): FirStatement { + return resolveVariableAccessAndSelectCandidateImpl(qualifiedAccess) { true } + } + + fun resolveOnlyEnumOrQualifierAccessAndSelectCandidate(qualifiedAccess: FirQualifiedAccessExpression): FirStatement { + return resolveVariableAccessAndSelectCandidateImpl(qualifiedAccess) accept@{ candidates -> + val symbol = candidates.singleOrNull()?.symbol ?: return@accept false + symbol is FirEnumEntrySymbol || symbol is FirRegularClassSymbol + } + } + + private fun resolveVariableAccessAndSelectCandidateImpl( + qualifiedAccess: T, + acceptCandidates: (Collection) -> Boolean + ): FirStatement { val callee = qualifiedAccess.calleeReference as? FirSimpleNamedReference ?: return qualifiedAccess qualifiedResolver.initProcessingQualifiedAccess(callee, qualifiedAccess.typeArguments) @@ -233,6 +247,8 @@ class FirCallResolver( } val reducedCandidates = result.candidates + if (!acceptCandidates(reducedCandidates)) return qualifiedAccess + val nameReference = createResolvedNamedReference( callee, callee.name, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt index dbc68dbef1c..47e0dac3d3a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt @@ -28,7 +28,7 @@ fun FirResolvePhase.createCompilerProcessorByPhase( SUPER_TYPES -> FirSupertypeResolverProcessor(session, scopeSession) SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsProcessor(session, scopeSession) TYPES -> FirTypeResolveProcessor(session, scopeSession) - ARGUMENTS_OF_PLUGIN_ANNOTATIONS -> FirAnnotationArgumentsResolveProcessor(session, scopeSession) + ARGUMENTS_OF_ANNOTATIONS -> FirAnnotationArgumentsResolveProcessor(session, scopeSession) EXTENSION_STATUS_UPDATE -> FirGlobalExtensionStatusProcessor(session, scopeSession) STATUS -> FirStatusResolveProcessor(session, scopeSession) CONTRACTS -> FirContractResolveProcessor(session, scopeSession) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 5a01fa04e48..1b341aa3328 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -121,7 +121,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform qualifiedAccessExpression } else -> { - val transformedCallee = callResolver.resolveVariableAccessAndSelectCandidate(qualifiedAccessExpression) + val transformedCallee = resolveQualifiedAccessAndSelectCandidate(qualifiedAccessExpression) // NB: here we can get raw expression because of dropped qualifiers (see transform callee), // so candidate existence must be checked before calling completion if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) { @@ -147,6 +147,10 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform return result } + protected open fun resolveQualifiedAccessAndSelectCandidate(qualifiedAccessExpression: FirQualifiedAccessExpression): FirStatement { + return callResolver.resolveVariableAccessAndSelectCandidate(qualifiedAccessExpression) + } + fun transformSuperReceiver( superReference: FirSuperReference, superReferenceContainer: FirQualifiedAccessExpression, @@ -833,6 +837,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform symbol.constructType(emptyArray(), isNullable = false) } else -> { + if (!shouldComputeTypeOfGetClassCallWithNotQualifierInLhs(getClassCall)) return transformedGetClassCall val resultType = lhs.resultType if (resultType is FirErrorTypeRef) { resultType.coneType @@ -850,6 +855,10 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform return transformedGetClassCall } + protected open fun shouldComputeTypeOfGetClassCallWithNotQualifierInLhs(getClassCall: FirGetClassCall): Boolean { + return true + } + override fun transformConstExpression( constExpression: FirConstExpression, data: ResolutionMode, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt index df19e9c7338..6b829fdf65b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt @@ -8,8 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.plugin import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider -import org.jetbrains.kotlin.fir.extensions.registeredPluginAnnotations import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor @@ -27,15 +25,12 @@ class FirAnnotationArgumentsResolveProcessor( @AdapterForResolveProcessor class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { private val transformer = FirAnnotationArgumentsResolveTransformer(session, scopeSession) - private val hasAnnotations = session.registeredPluginAnnotations.annotations.isNotEmpty() - private val predicateBasedProvider = session.predicateBasedProvider override fun transformElement(element: E, data: Any?): E { return element } override fun transformFile(file: FirFile, data: Any?): FirFile { - if (!hasAnnotations || !predicateBasedProvider.fileHasPluginAnnotations(file)) return file return file.transform(transformer, ResolutionMode.ContextIndependent) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt index b1e00909511..5e0fec43f54 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt @@ -8,8 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.plugin import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.extensions.AnnotationFqn -import org.jetbrains.kotlin.fir.extensions.registeredPluginAnnotations import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -17,8 +15,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveCon import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer -import org.jetbrains.kotlin.fir.types.ConeClassLikeType -import org.jetbrains.kotlin.fir.types.coneTypeSafe class FirAnnotationArgumentsResolveTransformer( session: FirSession, @@ -26,15 +22,12 @@ class FirAnnotationArgumentsResolveTransformer( outerBodyResolveContext: BodyResolveContext? = null ) : FirBodyResolveTransformer( session, - FirResolvePhase.ARGUMENTS_OF_PLUGIN_ANNOTATIONS, + FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS, implicitTypeOnly = false, scopeSession, outerBodyResolveContext = outerBodyResolveContext ) { - override val expressionsTransformer: FirExpressionsResolveTransformer = FirExpressionsResolveTransformerForSpecificAnnotations( - this, - session.registeredPluginAnnotations.annotations - ) + override val expressionsTransformer: FirExpressionsResolveTransformer = FirExpressionsResolveTransformerForSpecificAnnotations(this) override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsResolveTransformerForArgumentAnnotations(this) } @@ -42,15 +35,16 @@ class FirAnnotationArgumentsResolveTransformer( private class FirDeclarationsResolveTransformerForArgumentAnnotations( transformer: FirBodyResolveTransformer ) : FirDeclarationsResolveTransformer(transformer) { - override fun transformWrappedDelegateExpression( - wrappedDelegateExpression: FirWrappedDelegateExpression, - data: ResolutionMode - ): FirStatement { - return wrappedDelegateExpression - } - override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { - return regularClass.transformAnnotations(this, data).transformDeclarations(this, data) + regularClass.transformAnnotations(this, data) + context.withContainingClass(regularClass) { + regularClass + .transformTypeParameters(transformer, data) + .transformSuperTypeRefs(transformer, data) + .transformDeclarations(transformer, data) + .transformCompanionObject(transformer, data) + } + return regularClass } override fun transformAnonymousInitializer( @@ -64,21 +58,38 @@ private class FirDeclarationsResolveTransformerForArgumentAnnotations( simpleFunction: FirSimpleFunction, data: ResolutionMode ): FirSimpleFunction { - return simpleFunction.transformAnnotations(this, data) + simpleFunction + .transformReturnTypeRef(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformValueParameters(transformer, data) + .transformAnnotations(transformer, data) + return simpleFunction } override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor { - return constructor.transformAnnotations(this, data) + constructor + .transformReturnTypeRef(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformValueParameters(transformer, data) + .transformAnnotations(transformer, data) + return constructor } override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement { - return valueParameter.transformAnnotations(this, data) + valueParameter + .transformAnnotations(transformer, data) + .transformReturnTypeRef(transformer, data) + return valueParameter } override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { - property.transformAnnotations(this, data) - property.transformGetter(this, data) - property.transformSetter(this, data) + property + .transformAnnotations(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformGetter(transformer, data) + .transformSetter(transformer, data) + .transformTypeParameters(transformer, data) return property } @@ -86,42 +97,63 @@ private class FirDeclarationsResolveTransformerForArgumentAnnotations( propertyAccessor: FirPropertyAccessor, data: ResolutionMode ): FirPropertyAccessor { - propertyAccessor.transformAnnotations(this, data) + propertyAccessor + .transformValueParameters(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformAnnotations(transformer, data) return propertyAccessor } + + override fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: ResolutionMode): FirDeclarationStatus { + return declarationStatus + } + + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry { + context.forEnumEntry { + enumEntry + .transformAnnotations(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformTypeParameters(transformer, data) + } + return enumEntry + } + + override fun transformField(field: FirField, data: ResolutionMode): FirField { + return field.transformAnnotations(transformer, data) + } + + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias { + typeAlias.transformAnnotations(transformer, data) + return typeAlias + } } private class FirExpressionsResolveTransformerForSpecificAnnotations( - transformer: FirBodyResolveTransformer, - private val annotations: Set + transformer: FirBodyResolveTransformer ) : FirExpressionsResolveTransformer(transformer) { - private var annotationArgumentsMode: Boolean = false override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { - if (annotationArgumentsMode) { - return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved) - } - - annotationCall.transformAnnotationTypeRef(transformer, data) - val classId = annotationCall.annotationTypeRef.coneTypeSafe()?.lookupTag?.classId - ?: return annotationCall - if (classId.asSingleFqName() !in annotations) { - return annotationCall - } - annotationArgumentsMode = true - return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved).also { - annotationArgumentsMode = false - } + dataFlowAnalyzer.enterAnnotationCall(annotationCall) + annotationCall.transformChildren(transformer, ResolutionMode.ContextDependent) + dataFlowAnalyzer.exitAnnotationCall(annotationCall) + return annotationCall } override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { - return expression + return expression.transformChildren(transformer, data) as FirStatement } override fun FirQualifiedAccessExpression.isAcceptableResolvedQualifiedAccess(): Boolean { return calleeReference !is FirErrorNamedReference } + override fun resolveQualifiedAccessAndSelectCandidate(qualifiedAccessExpression: FirQualifiedAccessExpression): FirStatement { + return callResolver.resolveOnlyEnumOrQualifierAccessAndSelectCandidate(qualifiedAccessExpression) + } + override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement { return functionCall } @@ -192,4 +224,13 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations( ): FirStatement { return augmentedArraySetCall } + + override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ResolutionMode): FirStatement { + arrayOfCall.transformChildren(transformer, data) + return arrayOfCall + } + + override fun shouldComputeTypeOfGetClassCallWithNotQualifierInLhs(getClassCall: FirGetClassCall): Boolean { + return false + } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt index 85a28870865..92dfcd2bfdc 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt @@ -13,7 +13,7 @@ enum class FirResolvePhase(val pluginPhase: Boolean = false, val noProcessor: Bo SUPER_TYPES, SEALED_CLASS_INHERITORS, TYPES, - ARGUMENTS_OF_PLUGIN_ANNOTATIONS(pluginPhase = true), + ARGUMENTS_OF_ANNOTATIONS, EXTENSION_STATUS_UPDATE(pluginPhase = true), STATUS, CONTRACTS, diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerFirTestdataTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerFirTestdataTestGenerated.java index cf951400bf0..7d22a81d5ba 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerFirTestdataTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerFirTestdataTestGenerated.java @@ -26,6 +26,12 @@ public class DiagnosisCompilerFirTestdataTestGenerated extends AbstractDiagnosis KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test + @TestMetadata("annotationOnDeclarationWithDifferentArguments.kt") + public void testAnnotationOnDeclarationWithDifferentArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt"); + } + @Test @TestMetadata("annotationUsedAsAnnotationArgument.kt") public void testAnnotationUsedAsAnnotationArgument() throws Exception {