From 34998473f57060911cbca65c8b12c83c83bb6638 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 1 Mar 2022 17:18:22 +0300 Subject: [PATCH] FIR: Move deprecation resolve earlier --- ...edAnnotationArgumentsResolveTransformer.kt | 2 +- ...DesignatedAnnotationsResolveTransformed.kt | 74 +++++++++++++++++ .../transformers/LazyTransformerFactory.kt | 5 ++ .../extensions/FirPredicateBasedProvider.kt | 5 +- .../FirStatusResolveTransformer.kt | 8 -- ...FirAbstractAnnotationResolveTransformer.kt | 18 +++- .../FirAnnotationArgumentsResolveProcessor.kt | 3 +- ...irAnnotationArgumentsResolveTransformer.kt | 3 +- ...erRequiredAnnotationsResolveTransformer.kt | 82 ++++++++++++++++--- .../fir/symbols/impl/FirClassLikeSymbol.kt | 2 +- 10 files changed, 176 insertions(+), 26 deletions(-) create mode 100644 analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt index cca68cee1aa..1987d41a82e 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt @@ -20,7 +20,7 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer( private val designation: FirDeclarationDesignationWithFile, session: FirSession, scopeSession: ScopeSession, -) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession) { +) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) { private fun moveNextDeclaration(designationIterator: Iterator) { if (!designationIterator.hasNext()) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt new file mode 100644 index 00000000000..4a862bb5760 --- /dev/null +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt @@ -0,0 +1,74 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers + +import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.resolve.ResolutionMode +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompilerRequiredAnnotationsResolveTransformer + +internal class LLFirDesignatedAnnotationsResolveTransformed( + private val designation: FirDeclarationDesignationWithFile, + session: FirSession, + scopeSession: ScopeSession, +) : LLFirLazyTransformer, FirCompilerRequiredAnnotationsResolveTransformer(session, scopeSession) { + + private fun moveNextDeclaration(designationIterator: Iterator) { + if (!designationIterator.hasNext()) { + val declaration = designation.declaration + if (declaration is FirRegularClass || declaration is FirTypeAlias) { + declaration.transform(this, ResolutionMode.ContextIndependent) + } + return + } + when (val nextElement = designationIterator.next()) { + is FirFile -> { + withFileAndScopes(nextElement) { + moveNextDeclaration(designationIterator) + } + } + is FirRegularClass -> { + moveNextDeclaration(designationIterator) + } + else -> { + error("Unexpected declaration in designation: ${nextElement::class.qualifiedName}") + } + } + } + + override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { + if (designation.declaration.resolvePhase >= FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) return + + val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator() + + ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) { + phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) { + moveNextDeclaration(designationIterator) + } + } + + LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) + ensureResolved(designation.declaration) + ensureResolvedDeep(designation.declaration) + } + + override fun ensureResolved(declaration: FirDeclaration) { + when (declaration) { + is FirClass, is FirTypeAlias -> + declaration.ensurePhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) + is FirFunction, is FirProperty, is FirEnumEntry, is FirField, is FirAnonymousInitializer -> + Unit + else -> + error("Unexpected type: ${declaration::class.simpleName}") + } + } + +} \ No newline at end of file diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt index 7a042b89a65..8acc8171995 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt @@ -48,6 +48,11 @@ internal object LazyTransformerFactory { designation.firFile.moduleData.session, scopeSession, ) + FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS -> LLFirDesignatedAnnotationsResolveTransformed( + designation, + designation.firFile.moduleData.session, + scopeSession, + ) FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS -> LLFirDesignatedAnnotationArgumentsResolveTransformer( designation, designation.firFile.moduleData.session, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt index 38a3a8baca5..68cbee577c9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt @@ -28,6 +28,9 @@ abstract class FirPredicateBasedProvider : FirSessionComponent { abstract fun fileHasPluginAnnotations(file: FirFile): Boolean abstract fun matches(predicate: DeclarationPredicate, declaration: FirDeclaration): Boolean + open fun registerAnnotatedDeclaration(declaration: FirDeclaration, owners: PersistentList) { + } + fun matches(predicates: List, declaration: FirDeclaration): Boolean { return predicates.any { matches(it, declaration) } } @@ -51,7 +54,7 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic return file in cache.filesWithPluginAnnotations } - fun registerAnnotatedDeclaration(declaration: FirDeclaration, owners: PersistentList) { + override fun registerAnnotatedDeclaration(declaration: FirDeclaration, owners: PersistentList) { cache.ownersForDeclaration[declaration] = owners registerOwnersDeclarations(declaration, owners) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index ba4c94e8ec8..968eab1772b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -112,7 +112,6 @@ open class FirStatusResolveTransformer( */ if (computationStatus != StatusComputationSession.StatusComputationStatus.Computed) { regularClass.transformStatus(this, statusResolver.resolveStatus(regularClass, containingClass, isLocal = false)) - calculateDeprecations(regularClass) } return transformClass(regularClass, data).also { statusComputationSession.endComputing(regularClass) @@ -310,7 +309,6 @@ abstract class AbstractFirStatusResolveTransformer( ): FirStatement { typeAlias.typeParameters.forEach { transformDeclaration(it, data) } typeAlias.transformStatus(this, statusResolver.resolveStatus(typeAlias, containingClass, isLocal = false)) - calculateDeprecations(typeAlias) return transformDeclaration(typeAlias, data) as FirTypeAlias } @@ -554,12 +552,6 @@ abstract class AbstractFirStatusResolveTransformer( return block } - protected fun calculateDeprecations(regularClass: FirClassLikeDeclaration) { - if (regularClass.deprecation == null) { - regularClass.replaceDeprecation(regularClass.getDeprecationInfos(session.languageVersionSettings.apiVersion)) - } - } - protected fun calculateDeprecations(simpleFunction: FirCallableDeclaration) { if (simpleFunction.deprecation == null) { simpleFunction.replaceDeprecation(simpleFunction.getDeprecationInfos(session.languageVersionSettings.apiVersion)) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt index 3f51e6380e5..725e3ff345b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt @@ -25,11 +25,23 @@ internal abstract class FirAbstractAnnotationResolveTransformer( protected lateinit var scopes: List - override fun transformFile(file: FirFile, data: D): FirFile { + inline fun withFileScopes(file: FirFile, f: () -> T): T { scopes = createImportingScopes(file, session, scopeSession, useCaching = false) val state = beforeTransformingChildren(file) - file.transformDeclarations(this, data) - afterTransformingChildren(state) + try { + return f() + } finally { + afterTransformingChildren(state) + } + } + + override fun transformFile(file: FirFile, data: D): FirFile { + withFileScopes(file) { + scopes = createImportingScopes(file, session, scopeSession, useCaching = false) + val state = beforeTransformingChildren(file) + file.transformDeclarations(this, data) + afterTransformingChildren(state) + } return transformDeclaration(file, data) as FirFile } 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 6b829fdf65b..9db793ddc05 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,6 +8,7 @@ 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.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor @@ -24,7 +25,7 @@ class FirAnnotationArgumentsResolveProcessor( @AdapterForResolveProcessor class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { - private val transformer = FirAnnotationArgumentsResolveTransformer(session, scopeSession) + private val transformer = FirAnnotationArgumentsResolveTransformer(session, scopeSession, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) override fun transformElement(element: E, data: Any?): E { return element 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 fce6b491e59..116fe2c4f57 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 @@ -19,10 +19,11 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressions open class FirAnnotationArgumentsResolveTransformer( session: FirSession, scopeSession: ScopeSession, + resolvePhase: FirResolvePhase, outerBodyResolveContext: BodyResolveContext? = null ) : FirBodyResolveTransformer( session, - FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS, + resolvePhase, implicitTypeOnly = false, scopeSession, outerBodyResolveContext = outerBodyResolveContext diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirCompilerRequiredAnnotationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirCompilerRequiredAnnotationsResolveTransformer.kt index 7fb0a7e66db..9e9f12840a9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirCompilerRequiredAnnotationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirCompilerRequiredAnnotationsResolveTransformer.kt @@ -13,15 +13,23 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.extensions.* +import org.jetbrains.kotlin.fir.languageVersionSettings +import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.fqName import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals import org.jetbrains.kotlin.fir.resolve.transformers.* +import org.jetbrains.kotlin.fir.types.ConeClassLikeType +import org.jetbrains.kotlin.fir.types.FirUserTypeRef +import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.StandardClassIds.Annotations.Deprecated +import org.jetbrains.kotlin.name.StandardClassIds.Annotations.DeprecatedSinceKotlin class FirCompilerRequiredAnnotationsResolveProcessor( session: FirSession, @@ -40,10 +48,10 @@ class FirCompilerRequiredAnnotationsResolveProcessor( } } -class FirCompilerRequiredAnnotationsResolveTransformer( - override val session: FirSession, +open class FirCompilerRequiredAnnotationsResolveTransformer( + final override val session: FirSession, scopeSession: ScopeSession -) : FirAbstractPhaseTransformer(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) { +) : FirAbstractPhaseTransformer(COMPILER_REQUIRED_ANNOTATIONS) { private val annotationTransformer = FirAnnotationResolveTransformer(session, scopeSession) private val importTransformer = FirPartialImportResolveTransformer(session) @@ -55,7 +63,6 @@ class FirCompilerRequiredAnnotationsResolveTransformer( override fun transformFile(file: FirFile, data: Any?): FirFile { checkSessionConsistency(file) val registeredPluginAnnotations = session.registeredPluginAnnotations - if (!registeredPluginAnnotations.hasRegisteredAnnotations) return file val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations) if (!newAnnotations.isEmpty) { for (metaAnnotation in newAnnotations.keySet()) { @@ -67,6 +74,22 @@ class FirCompilerRequiredAnnotationsResolveTransformer( return file } + fun withFile(file: FirFile, f: () -> T): T = annotationTransformer.withFile(file, f) + + fun withFileAndScopes(file: FirFile, f: () -> T): T { + annotationTransformer.withFile(file) { + return annotationTransformer.withFileScopes(file, f) + } + } + + override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): FirStatement { + return annotationTransformer.transformRegularClass(regularClass, LinkedHashMultimap.create()) + } + + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Any?): FirStatement { + return annotationTransformer.transformTypeAlias(typeAlias, LinkedHashMultimap.create()) + } + private fun FirFile.resolveAnnotations( annotations: Set, metaAnnotations: Set @@ -74,6 +97,7 @@ class FirCompilerRequiredAnnotationsResolveTransformer( importTransformer.acceptableFqNames = annotations this.transformImports(importTransformer, null) + annotationTransformer.acceptableFqNames = annotations annotationTransformer.metaAnnotations = metaAnnotations val newAnnotations = LinkedHashMultimap.create() this.transform>(annotationTransformer, newAnnotations) @@ -83,7 +107,7 @@ class FirCompilerRequiredAnnotationsResolveTransformer( private class FirPartialImportResolveTransformer( session: FirSession -) : FirImportResolveTransformer(session, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) { +) : FirImportResolveTransformer(session, COMPILER_REQUIRED_ANNOTATIONS) { var acceptableFqNames: Set = emptySet() override val FqName.isAcceptable: Boolean @@ -93,15 +117,20 @@ private class FirPartialImportResolveTransformer( private class FirAnnotationResolveTransformer( session: FirSession, scopeSession: ScopeSession -) : FirAbstractAnnotationResolveTransformer, PersistentList>(session, scopeSession) { - private val predicateBasedProvider = session.predicateBasedProvider as FirPredicateBasedProviderImpl +) : FirAbstractAnnotationResolveTransformer, PersistentList>( + session, scopeSession +) { + private val predicateBasedProvider = session.predicateBasedProvider + var acceptableFqNames: Set = emptySet() var metaAnnotations: Set = emptySet() private val typeResolverTransformer: FirSpecificTypeResolverTransformer = FirSpecificTypeResolverTransformer( session, errorTypeAsResolved = false ) + private val argumentsTransformer = FirAnnotationArgumentsResolveTransformer(session, scopeSession, COMPILER_REQUIRED_ANNOTATIONS) + private var owners: PersistentList = persistentListOf() private val classDeclarationsStack = ArrayDeque() @@ -124,10 +153,22 @@ private class FirAnnotationResolveTransformer( annotation: FirAnnotation, data: Multimap ): FirStatement { - return annotation.transformAnnotationTypeRef( + val annotationTypeRef = annotation.annotationTypeRef + if (annotationTypeRef !is FirUserTypeRef) return annotation + val name = annotationTypeRef.qualifier.last().name + if (name != Deprecated.shortClassName && name != DeprecatedSinceKotlin.shortClassName && + acceptableFqNames.none { it.shortName() == name } + ) return annotation + + val transformedAnnotation = annotation.transformAnnotationTypeRef( typeResolverTransformer, - ScopeClassDeclaration(scopes, classDeclarationsStack) + ScopeClassDeclaration(scopes.asReversed(), classDeclarationsStack) ) + // TODO: what if we have type alias here? + if (transformedAnnotation.annotationTypeRef.coneTypeSafe()?.lookupTag?.classId == Deprecated) { + argumentsTransformer.transformAnnotation(transformedAnnotation, ResolutionMode.ContextDependent) + } + return transformedAnnotation } override fun transformRegularClass( @@ -142,10 +183,17 @@ private class FirAnnotationResolveTransformer( data.put(annotation, regularClass) } } + calculateDeprecations(regularClass) } } } + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Multimap): FirTypeAlias { + return super.transformTypeAlias(typeAlias, data).also { + calculateDeprecations(typeAlias) + } + } + override fun transformDeclaration(declaration: FirDeclaration, data: Multimap): FirDeclaration { return super.transformDeclaration(declaration, data).also { predicateBasedProvider.registerAnnotatedDeclaration(declaration, owners) @@ -153,8 +201,22 @@ private class FirAnnotationResolveTransformer( } override fun transformFile(file: FirFile, data: Multimap): FirFile { - typeResolverTransformer.withFile(file) { + withFile(file) { return super.transformFile(file, data) } } + + inline fun withFile(file: FirFile, f: () -> T): T { + typeResolverTransformer.withFile(file) { + argumentsTransformer.context.withFile(file, argumentsTransformer.components) { + return f() + } + } + } + + private fun calculateDeprecations(classLikeDeclaration: FirClassLikeDeclaration) { + if (classLikeDeclaration.deprecation == null) { + classLikeDeclaration.replaceDeprecation(classLikeDeclaration.getDeprecationInfos(session.languageVersionSettings.apiVersion)) + } + } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt index d47d3ca1ad1..00224e826d1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt @@ -26,7 +26,7 @@ sealed class FirClassLikeSymbol( val deprecation: DeprecationsPerUseSite? get() { - ensureResolved(FirResolvePhase.STATUS) + ensureResolved(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) return fir.deprecation }