FIR: Get rid of hacks related to previous structure of FirDelegatedScope

^KT-47413 Fixed

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.fir.resolve.calls.varargElementType
 import org.jetbrains.kotlin.fir.resolve.inference.isSuspendFunctionType
 import org.jetbrains.kotlin.fir.resolve.inference.suspendFunctionTypeToFunctionTypeWithContinuation
 import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator
-import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.processAllFunctions
 import org.jetbrains.kotlin.fir.scopes.processAllProperties
 import org.jetbrains.kotlin.fir.serialization.constant.EnumValue
@@ -37,7 +36,6 @@ import org.jetbrains.kotlin.fir.serialization.constant.IntValue
 import org.jetbrains.kotlin.fir.serialization.constant.StringValue
 import org.jetbrains.kotlin.fir.serialization.constant.toConstantValue
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionCallableSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitNullableAnyTypeRef
@@ -225,29 +223,7 @@ class FirElementSerializer private constructor(
 
         fun addDeclarationIfNeeded(symbol: FirCallableSymbol<*>) {
             val declaration = symbol.fir as? FirCallableMemberDeclaration ?: return
-            if (declaration.isIntersectionOverride) {
+            if (declaration.isSubstitutionOrIntersectionOverride) return
-                // This part is a kind of hack for case like
-                //
-                // interface A {
-                //    fun foo(): String?
-                // }
-                //
-                // interface B : A {
-                //     override fun foo(): String?
-                // }
-                //
-                // abstract class C(a: A) : B, A by a
-                // We should serialize C::foo as it works almost like real declarations, but currently it's hidden behind intersection scope
-                // UseSiteScope(C) = DeclaredScope(C) + FirIntersectionScope(UseSiteScope(B), DelegatedScope(a))
-                //
-                // That should be fixed by putting delegated members closer to declared scope
-                // See KT-47413
-                (declaration.symbol as? FirIntersectionCallableSymbol)?.intersections?.firstOrNull {
-                    it.fir.delegatedWrapperData != null
-                }?.let(::addDeclarationIfNeeded)
-                return
-            }
-            if (declaration.isSubstitutionOverride) return
 
             // non-intersection or substitution fake override
             if (!declaration.isStatic && declaration.dispatchReceiverClassOrNull() != this@declarations.symbol.toLookupTag()) return

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
+import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.AccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -326,12 +327,8 @@ fun FirTypeScope.processOverriddenFunctionsFromSuperClasses(
     containingClass: FirClass,
     processor: (FirNamedFunctionSymbol) -> ProcessorAction
 ): ProcessorAction = processDirectOverriddenFunctionsWithBaseScope(functionSymbol) { overridden, baseScope ->
-    val unwrapped =
+    if (overridden.containingClass() == containingClass.symbol.toLookupTag()) {
-        overridden.fir.delegatedWrapperData?.takeIf { it.containingClass == containingClass.symbol.toLookupTag() }?.wrapped?.symbol
+        baseScope.processOverriddenFunctionsFromSuperClasses(overridden, containingClass, processor)
-            ?: overridden
-
-    if (unwrapped.containingClass() == containingClass.symbol.toLookupTag()) {
-        baseScope.processOverriddenFunctionsFromSuperClasses(unwrapped, containingClass, processor)
     } else {
         processor(overridden)
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt

@@ -7,11 +7,11 @@ package org.jetbrains.kotlin.fir.backend.generators
 
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.isIntersectionOverride
 import org.jetbrains.kotlin.fir.isJavaDefault
-import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.scopes.impl.unwrapDelegateTarget
+import org.jetbrains.kotlin.fir.scopes.processAllFunctions
+import org.jetbrains.kotlin.fir.scopes.processAllProperties
+import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -43,7 +43,7 @@ internal class DelegatedMemberGenerator(
         subClassScope.processAllFunctions { functionSymbol ->
             val unwrapped =
                 functionSymbol
-                    .unwrapDelegateTarget(subClassLookupTag, subClassScope::getDirectOverriddenFunctions, firField, firSubClass)
+                    .unwrapDelegateTarget(subClassLookupTag, firField)
                     ?: return@processAllFunctions
 
             val member =
@@ -67,7 +67,7 @@ internal class DelegatedMemberGenerator(
 
             val unwrapped =
                 propertySymbol
-                    .unwrapDelegateTarget(subClassLookupTag, subClassScope::getDirectOverriddenProperties, firField, firSubClass)
+                    .unwrapDelegateTarget(subClassLookupTag, firField)
                     ?: return@processAllProperties
 
             val member = declarationStorage.getIrPropertySymbol(unwrapped.symbol).owner as? IrProperty
@@ -203,14 +203,9 @@ internal class DelegatedMemberGenerator(
 
 private fun <S : FirCallableSymbol<D>, D : FirCallableMemberDeclaration> S.unwrapDelegateTarget(
     subClassLookupTag: ConeClassLikeLookupTag,
-    directOverridden: S.() -> List<S>,
     firField: FirField,
-    firSubClass: FirClass,
 ): D? {
-    firSubClass.hashCode()
+    val callable = this.fir as? D ?: return null
-    val unwrappedIntersectionSymbol = this.unwrapIntersectionOverride(directOverridden) ?: return null
-
-    val callable = unwrappedIntersectionSymbol.fir as? D ?: return null
 
     val delegatedWrapperData = callable.delegatedWrapperData ?: return null
     if (delegatedWrapperData.containingClass != subClassLookupTag) return null
@@ -224,8 +219,3 @@ private fun <S : FirCallableSymbol<D>, D : FirCallableMemberDeclaration> S.unwra
     @Suppress("UNCHECKED_CAST")
     return wrappedSymbol.unwrapCallRepresentative().fir as D
 }
-
-private fun <S : FirCallableSymbol<*>> S.unwrapIntersectionOverride(directOverridden: S.() -> List<S>): S? {
-    if (this.fir.isIntersectionOverride) return directOverridden().firstOrNull { it.fir.delegatedWrapperData != null }
-    return this
-}

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties
 import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
-import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -261,14 +260,10 @@ class FakeOverrideGenerator(
 
         return scope.directOverridden(symbol).map {
             // Unwrapping should happen only for fake overrides members from the same class, not from supertypes
-            if (it.dispatchReceiverClassOrNull() != containingClass) return@map it
+            if (it.fir.isSubstitutionOverride && it.dispatchReceiverClassOrNull() == containingClass)
-            when {
+                it.originalForSubstitutionOverride!!
-                it.fir.isSubstitutionOverride ->
+            else
-                    it.originalForSubstitutionOverride!!
+                it
-                it.fir.origin == FirDeclarationOrigin.Delegated ->
-                    it.fir.delegatedWrapperData?.wrapped?.symbol!! as S
-                else -> it
-            }
         }
     }