Use FirNamedFunctionSymbol around processOverriddenFunctions

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -152,7 +153,7 @@ fun FirSymbolOwner<*>.getContainingClass(context: CheckerContext): FirClassLikeD
  * Returns the FirClassLikeDeclaration the type alias is pointing
  * to provided `this` is a FirTypeAlias. Returns this otherwise.
  */
-fun FirClassLikeDeclaration<*>.followAlias(session: FirSession): FirClassLikeDeclaration<*>? {
+fun FirClassLikeDeclaration<*>.followAlias(session: FirSession): FirClassLikeDeclaration<*> {
     return this.safeAs<FirTypeAlias>()
         ?.expandedTypeRef
         ?.firClassLike(session)
@@ -199,6 +200,7 @@ fun FirSimpleFunction.overriddenFunctions(
     containingClass: FirClass<*>,
     context: CheckerContext
 ): List<FirFunctionSymbol<*>> {
+    val symbol = symbol as? FirNamedFunctionSymbol ?: return emptyList()
     val firTypeScope = containingClass.unsubstitutedScope(
         context.sessionHolder.session,
         context.sessionHolder.scopeSession,

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

@@ -140,26 +140,27 @@ fun FirReference.toSymbolForCall(
     }
 }
 
-private fun FirCallableSymbol<*>.toSymbolForCall(declarationStorage: Fir2IrDeclarationStorage, preferGetter: Boolean): IrSymbol? = when (this) {
+private fun FirCallableSymbol<*>.toSymbolForCall(declarationStorage: Fir2IrDeclarationStorage, preferGetter: Boolean): IrSymbol? =
-    is FirFunctionSymbol<*> -> declarationStorage.getIrFunctionSymbol(this)
+    when (this) {
-    is SyntheticPropertySymbol -> {
+        is FirFunctionSymbol<*> -> declarationStorage.getIrFunctionSymbol(this)
-        (fir as? FirSyntheticProperty)?.let { syntheticProperty ->
+        is SyntheticPropertySymbol -> {
-            val delegateSymbol = if (preferGetter) {
+            (fir as? FirSyntheticProperty)?.let { syntheticProperty ->
-                syntheticProperty.getter.delegate.symbol
+                val delegateSymbol = if (preferGetter) {
-            } else {
+                    syntheticProperty.getter.delegate.symbol
-                syntheticProperty.setter?.delegate?.symbol
+                } else {
-                    ?: throw AssertionError("Written synthetic property must have a setter")
+                    syntheticProperty.setter?.delegate?.symbol
-            }
+                        ?: throw AssertionError("Written synthetic property must have a setter")
-            delegateSymbol.unwrapCallRepresentative().toSymbolForCall(declarationStorage, preferGetter)
+                }
-        } ?: declarationStorage.getIrPropertySymbol(this)
+                delegateSymbol.unwrapCallRepresentative().toSymbolForCall(declarationStorage, preferGetter)
+            } ?: declarationStorage.getIrPropertySymbol(this)
+        }
+        is FirPropertySymbol -> declarationStorage.getIrPropertySymbol(this)
+        is FirFieldSymbol -> declarationStorage.getIrFieldSymbol(this)
+        is FirBackingFieldSymbol -> declarationStorage.getIrBackingFieldSymbol(this)
+        is FirDelegateFieldSymbol<*> -> declarationStorage.getIrBackingFieldSymbol(this)
+        is FirVariableSymbol<*> -> declarationStorage.getIrValueSymbol(this)
+        else -> null
     }
-    is FirPropertySymbol -> declarationStorage.getIrPropertySymbol(this)
-    is FirFieldSymbol -> declarationStorage.getIrFieldSymbol(this)
-    is FirBackingFieldSymbol -> declarationStorage.getIrBackingFieldSymbol(this)
-    is FirDelegateFieldSymbol<*> -> declarationStorage.getIrBackingFieldSymbol(this)
-    is FirVariableSymbol<*> -> declarationStorage.getIrValueSymbol(this)
-    else -> null
-}
 
 fun FirConstExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
     FirConstKind.IntegerLiteral -> {
@@ -249,8 +250,9 @@ internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(
     val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
     scope.processFunctionsByName(name) {}
     val overriddenSet = mutableSetOf<IrSimpleFunctionSymbol>()
+    val symbol = symbol as? FirNamedFunctionSymbol ?: return emptyList()
     scope.processDirectlyOverriddenFunctions(symbol) {
-        if ((it.fir as FirSimpleFunction).visibility == Visibilities.Private) {
+        if (it.fir.visibility == Visibilities.Private) {
             return@processDirectlyOverriddenFunctions ProcessorAction.NEXT
         }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaAnnotationSyntheticPropertiesScope.kt

@@ -55,8 +55,8 @@ class JavaAnnotationSyntheticPropertiesScope(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction {
         return ProcessorAction.NONE
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassMembersEnhancementScope.kt

@@ -36,7 +36,7 @@ class JavaClassMembersEnhancementScope(
     private val owner: FirRegularClassSymbol,
     private val useSiteMemberScope: JavaClassUseSiteMemberScope,
 ) : FirTypeScope() {
-    private val overriddenFunctions = mutableMapOf<FirFunctionSymbol<*>, Collection<FirFunctionSymbol<*>>>()
+    private val overriddenFunctions = mutableMapOf<FirNamedFunctionSymbol, Collection<FirNamedFunctionSymbol>>()
     private val overriddenProperties = mutableMapOf<FirPropertySymbol, Collection<FirPropertySymbol>>()
 
     private val overrideBindCache = mutableMapOf<Name, Map<FirCallableSymbol<*>?, List<FirCallableSymbol<*>>>>()
@@ -149,16 +149,11 @@ class JavaClassMembersEnhancementScope(
             val enhancedFunction = (symbol.fir as? FirSimpleFunction)?.changeSignatureIfErasedValueParameter()
             val enhancedFunctionSymbol = enhancedFunction?.symbol ?: symbol
 
-            val originalFunction = original.fir as? FirSimpleFunction
+            if (enhancedFunctionSymbol is FirNamedFunctionSymbol && original is FirNamedFunctionSymbol) {
-
+                overriddenFunctions[enhancedFunctionSymbol] = original.fir
-            overriddenFunctions[enhancedFunctionSymbol] =
+                    .overriddenMembers(enhancedFunctionSymbol.fir.name)
-                if (enhancedFunction != null && originalFunction != null)
+                    .mapNotNull { it.symbol as? FirNamedFunctionSymbol }
-                    originalFunction
+            }
-                        .overriddenMembers(enhancedFunction.name)
-                        .mapNotNull { it.symbol as? FirFunctionSymbol<*> }
-                else
-                    emptyList()
-
             processor(enhancedFunctionSymbol)
         }
 
@@ -188,8 +183,8 @@ class JavaClassMembersEnhancementScope(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction =
         doProcessDirectOverriddenCallables(
             functionSymbol, processor, overriddenFunctions, useSiteMemberScope,

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt

@@ -42,8 +42,8 @@ class JvmMappedScope(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ) = ProcessorAction.NONE
 
     override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/SessionUtils.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.types.ConeInferenceContext
 import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext
 
@@ -29,6 +30,7 @@ fun FirSimpleFunction.lowestVisibilityAmongOverrides(
     session: FirSession,
     scopeSession: ScopeSession
 ): Visibility {
+    val symbol = symbol as? FirNamedFunctionSymbol ?: return visibility
     val firTypeScope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
     var visibility = visibility
 
@@ -37,16 +39,7 @@ fun FirSimpleFunction.lowestVisibilityAmongOverrides(
     firTypeScope.processFunctionsByName(symbol.fir.name) { }
 
     firTypeScope.processOverriddenFunctions(symbol) {
-        val overriddenVisibility = when (val fir = it.fir) {
+        visibility = it.fir.visibility
-            is FirMemberDeclaration -> fir.visibility
-            is FirPropertyAccessor -> fir.visibility
-            else -> null
-        }
-
-        overriddenVisibility?.let { that ->
-            visibility = that
-        }
-
         ProcessorAction.NEXT
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirDefaultParametersResolver.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 
 class FirDefaultParametersResolver : FirSessionComponent {
     fun declaresDefaultValue(
@@ -23,9 +24,10 @@ class FirDefaultParametersResolver : FirSessionComponent {
     ): Boolean {
         if (valueParameter.defaultValue != null) return true
         if (originScope !is FirTypeScope) return false
+        val symbol = function.symbol as? FirNamedFunctionSymbol ?: return false
         var result = false
 
-        originScope.processOverriddenFunctions(function.symbol) { overridden ->
+        originScope.processOverriddenFunctions(symbol) { overridden ->
             if (overridden.fir.valueParameters[index].defaultValue != null) {
                 result = true
                 return@processOverriddenFunctions ProcessorAction.STOP

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt

@@ -56,7 +56,8 @@ class FirSyntheticPropertiesScope(
         getterSymbol: FirFunctionSymbol<*>,
         processor: (FirVariableSymbol<*>) -> Unit
     ) {
-        val getter = getterSymbol.fir as? FirSimpleFunction ?: return
+        if (getterSymbol !is FirNamedFunctionSymbol) return
+        val getter = getterSymbol.fir
 
         if (getter.typeParameters.isNotEmpty()) return
         if (getter.valueParameters.isNotEmpty()) return
@@ -121,7 +122,7 @@ class FirSyntheticPropertiesScope(
         processor(property.symbol)
     }
 
-    private fun FirFunctionSymbol<*>.hasJavaOverridden(): Boolean {
+    private fun FirNamedFunctionSymbol.hasJavaOverridden(): Boolean {
         var result = false
         baseScope.processOverriddenFunctionsAndSelf(this) {
             if (it.unwrapFakeOverrides().fir.origin == FirDeclarationOrigin.Enhancement) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -125,9 +126,11 @@ fun ConeKotlinType.findContributedInvokeSymbol(
         FakeOverrideTypeCalculator.DoNothing
     }
     val scope = scope(session, scopeSession, fakeOverrideTypeCalculator) ?: return null
-    var declaredInvoke: FirFunctionSymbol<*>? = null
+    var declaredInvoke: FirNamedFunctionSymbol? = null
     scope.processFunctionsByName(OperatorNameConventions.INVOKE) { functionSymbol ->
-        if (functionSymbol.fir.valueParameters.size == baseInvokeSymbol.fir.valueParameters.size) {
+        if (functionSymbol is FirNamedFunctionSymbol &&
+            functionSymbol.fir.valueParameters.size == baseInvokeSymbol.fir.valueParameters.size
+        ) {
             declaredInvoke = functionSymbol
             return@processFunctionsByName
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 
 class FirStatusResolver(
     val session: FirSession,
@@ -73,14 +74,14 @@ class FirStatusResolver(
             @Suppress("RemoveExplicitTypeArguments") // Workaround for KT-42175
             buildList<FirCallableMemberDeclaration<*>> {
                 val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
-                scope.processFunctionsByName(function.name) {}
+                val symbol = function.symbol
-                scope
+                if (symbol is FirNamedFunctionSymbol) {
-                    .processDirectOverriddenFunctionsWithBaseScope(function.symbol) { symbol, _ ->
+                    scope.processFunctionsByName(function.name) {}
-                        (symbol.fir as? FirCallableMemberDeclaration<*>)?.let {
+                    scope.processDirectOverriddenFunctionsWithBaseScope(symbol) { overriddenSymbol, _ ->
-                            this += it
+                        this += overriddenSymbol.fir
-                        }
                         ProcessorAction.NEXT
                     }
+                }
             }.mapNotNull {
                 it.status as? FirResolvedDeclarationStatus
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirUseSiteMemberScope.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -20,7 +19,7 @@ abstract class AbstractFirUseSiteMemberScope(
 ) : AbstractFirOverrideScope(session, overrideChecker) {
 
     private val functions = hashMapOf<Name, Collection<FirFunctionSymbol<*>>>()
-    private val directOverriddenFunctions = hashMapOf<FirFunctionSymbol<*>, Collection<FirFunctionSymbol<*>>>()
+    private val directOverriddenFunctions = hashMapOf<FirNamedFunctionSymbol, Collection<FirNamedFunctionSymbol>>()
     protected val directOverriddenProperties = hashMapOf<FirPropertySymbol, MutableList<FirPropertySymbol>>()
 
     override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
@@ -37,8 +36,10 @@ abstract class AbstractFirUseSiteMemberScope(
         val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
         declaredMemberScope.processFunctionsByName(name) { symbol ->
             if (symbol.isStatic) return@processFunctionsByName
-            val directOverridden = computeDirectOverridden(symbol)
+            if (symbol is FirNamedFunctionSymbol) {
-            this@AbstractFirUseSiteMemberScope.directOverriddenFunctions[symbol] = directOverridden
+                val directOverridden = computeDirectOverridden(symbol)
+                this@AbstractFirUseSiteMemberScope.directOverriddenFunctions[symbol] = directOverridden
+            }
             overrideCandidates += symbol
             add(symbol)
         }
@@ -53,13 +54,12 @@ abstract class AbstractFirUseSiteMemberScope(
         }
     }
 
-    private fun computeDirectOverridden(symbol: FirFunctionSymbol<*>): Collection<FirFunctionSymbol<*>> {
+    private fun computeDirectOverridden(symbol: FirNamedFunctionSymbol): Collection<FirNamedFunctionSymbol> {
-        val result = mutableListOf<FirFunctionSymbol<*>>()
+        val result = mutableListOf<FirNamedFunctionSymbol>()
-        val firSimpleFunction = symbol.fir as? FirSimpleFunction ?: return emptyList()
+        val firSimpleFunction = symbol.fir
         superTypesScope.processFunctionsByName(symbol.callableId.callableName) { superSymbol ->
-            val superFunctionFir = superSymbol.fir
+            if (superSymbol is FirNamedFunctionSymbol &&
-            if (superFunctionFir is FirSimpleFunction &&
+                overrideChecker.isOverriddenFunction(firSimpleFunction, superSymbol.fir)
-                overrideChecker.isOverriddenFunction(firSimpleFunction, superFunctionFir)
             ) {
                 result.add(superSymbol)
             }
@@ -69,8 +69,8 @@ abstract class AbstractFirUseSiteMemberScope(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction =
         doProcessDirectOverriddenCallables(
             functionSymbol, processor, directOverriddenFunctions, superTypesScope,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt

@@ -44,8 +44,8 @@ class FirClassSubstitutionScope(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction =
         processDirectOverriddenWithBaseScope(
             functionSymbol, processor, FirTypeScope::processDirectOverriddenFunctionsWithBaseScope, substitutionOverrideFunctions

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt

@@ -108,8 +108,8 @@ class FirDelegatedMemberScope(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction {
         return processDirectOverriddenWithBaseScope(
             functionSymbol, processor, FirTypeScope::processDirectOverriddenFunctionsWithBaseScope

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirScopeWithFakeOverrideTypeCalculator.kt

@@ -47,8 +47,8 @@ class FirScopeWithFakeOverrideTypeCalculator(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction {
         return delegate.processDirectOverriddenFunctionsWithBaseScope(functionSymbol) { symbol, scope ->
             updateReturnType(symbol.fir)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt

@@ -444,8 +444,8 @@ class FirTypeIntersectionScope private constructor(
     }
 
     override fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction =
         processDirectOverriddenCallablesWithBaseScope(
             functionSymbol, processor,

compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt

@@ -6,31 +6,32 @@
 package org.jetbrains.kotlin.fir.scopes
 
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirScope {
     open fun processClassifiersByNameWithSubstitution(
         name: Name,
         processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit
-    ) {}
+    ) {
+    }
 
     open fun processFunctionsByName(
         name: Name,
         processor: (FirFunctionSymbol<*>) -> Unit
-    ) {}
+    ) {
+    }
 
     open fun processPropertiesByName(
         name: Name,
         processor: (FirVariableSymbol<*>) -> Unit
-    ) {}
+    ) {
+    }
 
     open fun processDeclaredConstructors(
         processor: (FirConstructorSymbol) -> Unit
-    ) {}
+    ) {
+    }
 
     open fun mayContainName(name: Name) = true
 }
@@ -52,8 +53,8 @@ fun FirScope.getDeclaredConstructors(): List<FirConstructorSymbol> = mutableList
 }
 
 fun FirTypeScope.processOverriddenFunctionsAndSelf(
-    functionSymbol: FirFunctionSymbol<*>,
+    functionSymbol: FirNamedFunctionSymbol,
-    processor: (FirFunctionSymbol<*>) -> ProcessorAction
+    processor: (FirNamedFunctionSymbol) -> ProcessorAction
 ): ProcessorAction {
     if (!processor(functionSymbol)) return ProcessorAction.STOP
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirTypeScope.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.scopes
 
 import org.jetbrains.kotlin.fir.isIntersectionOverride
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name
@@ -29,8 +28,8 @@ abstract class FirTypeScope : FirScope(), FirContainingNamesAwareScope {
     // - It may silently do nothing on symbols originated from different scope instance
     // - It may return the same overridden symbols more then once in case of substitution
     abstract fun processDirectOverriddenFunctionsWithBaseScope(
-        functionSymbol: FirFunctionSymbol<*>,
+        functionSymbol: FirNamedFunctionSymbol,
-        processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+        processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
     ): ProcessorAction
 
     // ------------------------------------------------------------------------------------
@@ -44,8 +43,8 @@ abstract class FirTypeScope : FirScope(), FirContainingNamesAwareScope {
 
     object Empty : FirTypeScope() {
         override fun processDirectOverriddenFunctionsWithBaseScope(
-            functionSymbol: FirFunctionSymbol<*>,
+            functionSymbol: FirNamedFunctionSymbol,
-            processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction
+            processor: (FirNamedFunctionSymbol, FirTypeScope) -> ProcessorAction
         ): ProcessorAction = ProcessorAction.NEXT
 
         override fun processDirectOverriddenPropertiesWithBaseScope(
@@ -84,8 +83,8 @@ abstract class FirTypeScope : FirScope(), FirContainingNamesAwareScope {
 typealias ProcessOverriddenWithBaseScope<D> = FirTypeScope.(D, (D, FirTypeScope) -> ProcessorAction) -> ProcessorAction
 
 fun FirTypeScope.processOverriddenFunctions(
-    functionSymbol: FirFunctionSymbol<*>,
+    functionSymbol: FirNamedFunctionSymbol,
-    processor: (FirFunctionSymbol<*>) -> ProcessorAction
+    processor: (FirNamedFunctionSymbol) -> ProcessorAction
 ): ProcessorAction =
     doProcessAllOverriddenCallables(
         functionSymbol,
@@ -128,8 +127,8 @@ private fun <S : FirCallableSymbol<*>> FirTypeScope.doProcessAllOverriddenCallab
     doProcessAllOverriddenCallables(callableSymbol, { s, _ -> processor(s) }, processDirectOverriddenCallablesWithBaseScope, visited)
 
 inline fun FirTypeScope.processDirectlyOverriddenFunctions(
-    functionSymbol: FirFunctionSymbol<*>,
+    functionSymbol: FirNamedFunctionSymbol,
-    crossinline processor: (FirFunctionSymbol<*>) -> ProcessorAction
+    crossinline processor: (FirNamedFunctionSymbol) -> ProcessorAction
 ): ProcessorAction = processDirectOverriddenFunctionsWithBaseScope(functionSymbol) { overridden, _ ->
     processor(overridden)
 }
@@ -145,7 +144,6 @@ fun FirTypeScope.getDirectOverriddenFunctions(function: FirNamedFunctionSymbol):
     val overriddenFunctions = mutableSetOf<FirNamedFunctionSymbol>()
 
     processDirectlyOverriddenFunctions(function) {
-        if (it !is FirNamedFunctionSymbol) return@processDirectlyOverriddenFunctions ProcessorAction.NEXT
         overriddenFunctions.add(it)
         ProcessorAction.NEXT
     }