[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.

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?  {

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
     }

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<T> {
@@ -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) }