From ea346e3e0e0e25ebb1ab9e82c52d5a2fdd3f29be Mon Sep 17 00:00:00 2001 From: Marco Pennekamp Date: Wed, 23 Nov 2022 18:38:08 +0100 Subject: [PATCH] [AA] Rename `originalOverriddenSymbol` to `unwrapFakeOverrides` - `unwrap` signals that fake overrides will be unwrapped until the original symbol is recovered. - Also remove nullability of the returned `KtCallableSymbol`. If the given symbol cannot be unwrapped, it is most likely already the original symbol. - Remove the lazy resolve to `STATUS` in `KtFirOverrideInfoProvider`, as it's not needed to unwrap fake overrides. --- .../components/KtFe10OverrideInfoProvider.kt | 9 ++++----- .../fir/symbols/KtFirOverrideInfoProvider.kt | 18 +++++++----------- .../api/components/KtOverrideInfoProvider.kt | 17 +++++++++-------- 3 files changed, 20 insertions(+), 24 deletions(-) diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt index 1a43189f0ee..a8f4f1012ff 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken -import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility @@ -41,10 +40,10 @@ internal class KtFe10OverrideInfoProvider( throw NotImplementedError("Method is not implemented for FE 1.0") } - override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? { - val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null - val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null - return originalCallableDescriptor.toKtCallableSymbol(analysisContext) + override fun unwrapFakeOverrides(symbol: KtCallableSymbol): KtCallableSymbol { + val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return symbol + val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return symbol + return originalCallableDescriptor.toKtCallableSymbol(analysisContext) ?: symbol } override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt index 809159fa154..03f69c9a435 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt @@ -63,31 +63,27 @@ internal class KtFirOverrideInfoProvider( override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? { require(symbol is KtFirSymbol<*>) - symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS) val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration val containingClass = - getOriginalOverriddenSymbol(firDeclaration)?.containingClassLookupTag()?.toSymbol(rootModuleSession) ?: return null + unwrapFakeOverrides(firDeclaration).containingClassLookupTag()?.toSymbol(rootModuleSession) ?: return null return analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(containingClass.fir.symbol) as? KtClassOrObjectSymbol - } - override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? { + override fun unwrapFakeOverrides(symbol: KtCallableSymbol): KtCallableSymbol { require(symbol is KtFirSymbol<*>) - symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS) val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration - return getOriginalOverriddenSymbol(firDeclaration) - ?.buildSymbol(analysisSession.firSymbolBuilder) as KtCallableSymbol? + return unwrapFakeOverrides(firDeclaration).buildSymbol(analysisSession.firSymbolBuilder) as KtCallableSymbol } - private fun getOriginalOverriddenSymbol(member: FirCallableDeclaration): FirCallableDeclaration? { + private fun unwrapFakeOverrides(member: FirCallableDeclaration): FirCallableDeclaration { val originalForSubstitutionOverride = member.originalForSubstitutionOverride - if (originalForSubstitutionOverride != null) return getOriginalOverriddenSymbol(originalForSubstitutionOverride) + if (originalForSubstitutionOverride != null) return unwrapFakeOverrides(originalForSubstitutionOverride) val originalForIntersectionOverrideAttr = member.originalForIntersectionOverrideAttr - if (originalForIntersectionOverrideAttr != null) return getOriginalOverriddenSymbol(originalForIntersectionOverrideAttr) + if (originalForIntersectionOverrideAttr != null) return unwrapFakeOverrides(originalForIntersectionOverrideAttr) val delegatedWrapperData = member.delegatedWrapperData - if (delegatedWrapperData != null) return getOriginalOverriddenSymbol(delegatedWrapperData.wrapped) + if (delegatedWrapperData != null) return unwrapFakeOverrides(delegatedWrapperData.wrapped) return member } diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtOverrideInfoProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtOverrideInfoProvider.kt index 799f3cf5870..89b781b3e5a 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtOverrideInfoProvider.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtOverrideInfoProvider.kt @@ -17,7 +17,7 @@ public abstract class KtOverrideInfoProvider : KtAnalysisSessionComponent() { parentClassSymbol: KtClassOrObjectSymbol ): ImplementationStatus? - public abstract fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? + public abstract fun unwrapFakeOverrides(symbol: KtCallableSymbol): KtCallableSymbol public abstract fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? } @@ -35,8 +35,9 @@ public interface KtMemberSymbolProviderMixin : KtAnalysisSessionMixIn { withValidityAssertion { analysisSession.overrideInfoProvider.getImplementationStatus(this, parentClassSymbol) } /** - * Gets the original symbol for the given callable symbol. In a class scope, a symbol may be derived from symbols declared in super - * classes. For example, consider + * Unwraps fake override [KtCallableSymbol]s until an original declared symbol is uncovered. + * + * In a class scope, a symbol may be derived from symbols declared in super classes. For example, consider * * ``` * public interface A { @@ -48,17 +49,17 @@ public interface KtMemberSymbolProviderMixin : KtAnalysisSessionMixIn { * ``` * * In the class scope of `B`, there is a callable symbol `foo` that takes a `String`. This symbol is derived from the original symbol - * in `A` that takes the type parameter `T`. Given such a derived symbol, [originalOverriddenSymbol] recovers the original declared - * symbol. + * in `A` that takes the type parameter `T` (fake override). Given such a fake override symbol, [unwrapFakeOverrides] recovers the + * original declared symbol. * * Such situation can also happen for intersection symbols (in case of multiple super types containing symbols with identical signature * after specialization) and delegation. */ - public val KtCallableSymbol.originalOverriddenSymbol: KtCallableSymbol? - get() = withValidityAssertion { analysisSession.overrideInfoProvider.getOriginalOverriddenSymbol(this) } + public val KtCallableSymbol.unwrapFakeOverrides: KtCallableSymbol + get() = withValidityAssertion { analysisSession.overrideInfoProvider.unwrapFakeOverrides(this) } /** - * Gets the class symbol where the given callable symbol is declared. See [originalOverriddenSymbol] for more details. + * Gets the class symbol where the given callable symbol is declared. See [unwrapFakeOverrides] for more details. */ public val KtCallableSymbol.originalContainingClassForOverride: KtClassOrObjectSymbol? get() = withValidityAssertion { analysisSession.overrideInfoProvider.getOriginalContainingClassForOverride(this) }