Use FirNamedFunctionSymbol in FirScope.processFunctionsByName

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

@@ -156,9 +156,7 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) {
                             withForcedTypeCalculator = true
                         ).processFunctionsByName(name) {
                             val declaration = it.fir
-                            if (declaration is FirSimpleFunction &&
+                            if (declaration.matchesDataClassSyntheticMemberSignatures) {
-                                declaration.matchesDataClassSyntheticMemberSignatures
-                            ) {
                                 putIfAbsent(declaration.name, declaration)
                             }
                         }

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

@@ -42,8 +42,6 @@ internal class DelegatedMemberGenerator(
 
         val subClassScope = firSubClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
         subClassScope.processAllFunctions { functionSymbol ->
-            if (functionSymbol !is FirNamedFunctionSymbol) return@processAllFunctions
-
             val unwrapped =
                 functionSymbol
                     .unwrapDelegateTarget(subClassLookupTag, subClassScope::getDirectOverriddenFunctions, firField, firSubClass)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt

@@ -139,7 +139,7 @@ class Fir2IrLazyClass(
                             result += declarationStorage.getIrFunctionSymbol(declaration.symbol).owner
                         } else {
                             scope.processFunctionsByName(declaration.name) {
-                                if (it is FirNamedFunctionSymbol && it.dispatchReceiverClassOrNull() == fir.symbol.toLookupTag()) {
+                                if (it.dispatchReceiverClassOrNull() == fir.symbol.toLookupTag()) {
                                     if (it.isAbstractMethodOfAny()) {
                                         return@processFunctionsByName
                                     }

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

@@ -24,13 +24,13 @@ class JavaAnnotationSyntheticPropertiesScope(
 ) : FirTypeScope() {
     private val classId: ClassId = owner.classId
     private val names: Set<Name> = owner.fir.declarations.mapNotNullTo(mutableSetOf()) { (it as? FirSimpleFunction)?.name }
-    private val syntheticPropertiesCache = mutableMapOf<FirFunctionSymbol<*>, FirVariableSymbol<*>>()
+    private val syntheticPropertiesCache = mutableMapOf<FirNamedFunctionSymbol, FirVariableSymbol<*>>()
 
     override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {
         delegateScope.processDeclaredConstructors(processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         if (name in names) return
         delegateScope.processFunctionsByName(name, processor)
     }
@@ -38,7 +38,7 @@ class JavaAnnotationSyntheticPropertiesScope(
     override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
         if (name !in names) return
         delegateScope.processFunctionsByName(name) { functionSymbol ->
-            val function = functionSymbol.fir as? FirSimpleFunction ?: return@processFunctionsByName
+            val function = functionSymbol.fir
             val symbol = syntheticPropertiesCache.getOrPut(functionSymbol) {
                 val callableId = CallableId(classId, name)
                 FirAccessorSymbol(callableId, callableId).also {

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

@@ -143,18 +143,18 @@ class JavaClassMembersEnhancementScope(
         return this
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         useSiteMemberScope.processFunctionsByName(name) process@{ original ->
             val symbol = signatureEnhancement.enhancedFunction(original, name)
             val enhancedFunction = (symbol.fir as? FirSimpleFunction)?.changeSignatureIfErasedValueParameter()
             val enhancedFunctionSymbol = enhancedFunction?.symbol ?: symbol
 
-            if (enhancedFunctionSymbol is FirNamedFunctionSymbol && original is FirNamedFunctionSymbol) {
+            if (enhancedFunctionSymbol is FirNamedFunctionSymbol) {
                 overriddenFunctions[enhancedFunctionSymbol] = original.fir
                     .overriddenMembers(enhancedFunctionSymbol.fir.name)
                     .mapNotNull { it.symbol as? FirNamedFunctionSymbol }
+                processor(enhancedFunctionSymbol)
             }
-            processor(enhancedFunctionSymbol)
         }
 
         return super.processFunctionsByName(name, processor)

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

@@ -30,10 +30,12 @@ class JavaClassStaticEnhancementScope(
         return super.processPropertiesByName(name, processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         useSiteStaticScope.processFunctionsByName(name) process@{ original ->
             val enhancedFunction = signatureEnhancement.enhancedFunction(original, name)
-            processor(enhancedFunction)
+            if (enhancedFunction is FirNamedFunctionSymbol) {
+                processor(enhancedFunction)
+            }
         }
 
         return super.processFunctionsByName(name, processor)

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

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isStatic
@@ -24,11 +23,11 @@ class JavaClassStaticUseSiteScope internal constructor(
     private val superTypesScopes: List<FirScope>,
     javaTypeParameterStack: JavaTypeParameterStack,
 ) : FirScope(), FirContainingNamesAwareScope {
-    private val functions = hashMapOf<Name, Collection<FirFunctionSymbol<*>>>()
+    private val functions = hashMapOf<Name, Collection<FirNamedFunctionSymbol>>()
     private val properties = hashMapOf<Name, Collection<FirVariableSymbol<*>>>()
     private val overrideChecker = JavaOverrideChecker(session, javaTypeParameterStack)
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         functions.getOrPut(name) {
             computeFunctions(name)
         }.forEach(processor)
@@ -43,7 +42,7 @@ class JavaClassStaticUseSiteScope internal constructor(
         val result = mutableListOf<FirNamedFunctionSymbol>()
 
         declaredMemberScope.processFunctionsByName(name) l@{ functionSymbol ->
-            if (functionSymbol !is FirNamedFunctionSymbol || !functionSymbol.isStatic) return@l
+            if (!functionSymbol.isStatic) return@l
 
             result.add(functionSymbol)
             superClassSymbols.removeAll { superClassSymbol ->

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

@@ -41,7 +41,7 @@ class JavaClassUseSiteMemberScope(
     internal val symbol = klass.symbol
 
     internal fun bindOverrides(name: Name) {
-        val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
+        val overrideCandidates = mutableSetOf<FirNamedFunctionSymbol>()
         declaredMemberScope.processFunctionsByName(name) {
             overrideCandidates += it
         }
@@ -93,7 +93,7 @@ class JavaClassUseSiteMemberScope(
                 var getterSymbol: FirNamedFunctionSymbol? = null
                 var setterSymbol: FirNamedFunctionSymbol? = null
                 declaredMemberScope.processFunctionsByName(getterName) { functionSymbol ->
-                    if (getterSymbol == null && functionSymbol is FirNamedFunctionSymbol) {
+                    if (getterSymbol == null) {
                         val function = functionSymbol.fir
                         if (!function.isStatic && function.valueParameters.isEmpty()) {
                             getterSymbol = functionSymbol
@@ -103,7 +103,7 @@ class JavaClassUseSiteMemberScope(
                 val setterName = session.syntheticNamesProvider.setterNameByGetterName(getterName)
                 if (getterSymbol != null && setterName != null) {
                     declaredMemberScope.processFunctionsByName(setterName) { functionSymbol ->
-                        if (setterSymbol == null && functionSymbol is FirNamedFunctionSymbol) {
+                        if (setterSymbol == null) {
                             val function = functionSymbol.fir
                             if (!function.isStatic && function.valueParameters.size == 1) {
                                 val returnTypeRef = function.returnTypeRef
@@ -152,7 +152,7 @@ class JavaClassUseSiteMemberScope(
         return processAccessorFunctionsAndPropertiesByName(name, getterNames, processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         if (symbol.fir !is FirJavaClass) {
             return super.processFunctionsByName(name, processor)
         }

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.utils.addIfNotNull
 
 class JvmMappedScope(
     private val declaredMemberScope: FirScope,
@@ -19,13 +18,13 @@ class JvmMappedScope(
     private val signatures: Signatures
 ) : FirTypeScope() {
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         val visibleMethods = signatures.visibleMethodSignaturesByName[name]
             ?: return declaredMemberScope.processFunctionsByName(name, processor)
 
         val declared = mutableListOf<FirNamedFunctionSymbol>()
         declaredMemberScope.processFunctionsByName(name) { symbol ->
-            declared.addIfNotNull(symbol as FirNamedFunctionSymbol)
+            declared += symbol
             processor(symbol)
         }
 
@@ -91,7 +90,7 @@ class JvmMappedScope(
 
         // NOTE: No-arg constructors
         @OptIn(ExperimentalStdlibApi::class)
-        private val additionalHiddenConstructors = buildSet<String> {
+        private val additionalHiddenConstructors = buildSet {
             // kotlin.text.String pseudo-constructors should be used instead of java.lang.String constructors
             listOf(
                 "",

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

@@ -288,13 +288,8 @@ private fun FirRegularClass.findSingleAbstractMethodByNames(
 
         classUseSiteMemberScope.processFunctionsByName(candidateName) { functionSymbol ->
             val firFunction = functionSymbol.fir
-            require(firFunction is FirSimpleFunction) {
+            if (firFunction.modality != Modality.ABSTRACT ||
-                "${functionSymbol.callableId
+                firFunction.isPublicInObject(checkOnlyName = false)
-                    .callableName} is expected to be _root_ide_package_.org.jetbrains.kotlin.fir.declarations.FirSimpleFunction, but ${functionSymbol::class} was found"
-            }
-
-            if (firFunction.modality != Modality.ABSTRACT || firFunction
-                    .isPublicInObject(checkOnlyName = false)
             ) return@processFunctionsByName
 
             if (resultMethod != null) {

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
@@ -124,7 +123,7 @@ private inline fun BodyResolveComponents.resolveSupertypesByMembers(
 private fun BodyResolveComponents.getFunctionMembers(type: ConeKotlinType, name: Name): Collection<FirCallableMemberDeclaration<*>> =
     buildList {
         type.scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)?.processFunctionsByName(name) {
-            addIfNotNull(it.fir as? FirSimpleFunction)
+            add(it.fir)
         }
     }
 

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

@@ -124,10 +124,10 @@ fun ConeKotlinType.findSubtypeOfNonSuspendFunctionalType(session: FirSession, ex
     }
 }
 
-fun ConeClassLikeType.findBaseInvokeSymbol(session: FirSession, scopeSession: ScopeSession): FirFunctionSymbol<*>? {
+fun ConeClassLikeType.findBaseInvokeSymbol(session: FirSession, scopeSession: ScopeSession): FirNamedFunctionSymbol? {
     require(this.isBuiltinFunctionalType(session))
     val functionN = (lookupTag.toSymbol(session)?.fir as? FirClass<*>) ?: return null
-    var baseInvokeSymbol: FirFunctionSymbol<*>? = null
+    var baseInvokeSymbol: FirNamedFunctionSymbol? = null
     functionN.unsubstitutedScope(
         session,
         scopeSession,
@@ -155,9 +155,7 @@ fun ConeKotlinType.findContributedInvokeSymbol(
     val scope = scope(session, scopeSession, fakeOverrideTypeCalculator) ?: return null
     var declaredInvoke: FirNamedFunctionSymbol? = null
     scope.processFunctionsByName(OperatorNameConventions.INVOKE) { functionSymbol ->
-        if (functionSymbol is FirNamedFunctionSymbol &&
+        if (functionSymbol.fir.valueParameters.size == baseInvokeSymbol.fir.valueParameters.size) {
-            functionSymbol.fir.valueParameters.size == baseInvokeSymbol.fir.valueParameters.size
-        ) {
             declaredInvoke = functionSymbol
             return@processFunctionsByName
         }

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

@@ -8,12 +8,10 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
 import org.jetbrains.kotlin.fir.scopes.FirOverrideChecker
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 
 abstract class AbstractFirOverrideScope(
     val session: FirSession,

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

@@ -18,11 +18,11 @@ abstract class AbstractFirUseSiteMemberScope(
     protected val declaredMemberScope: FirScope
 ) : AbstractFirOverrideScope(session, overrideChecker) {
 
-    private val functions = hashMapOf<Name, Collection<FirFunctionSymbol<*>>>()
+    private val functions = hashMapOf<Name, Collection<FirNamedFunctionSymbol>>()
     private val directOverriddenFunctions = hashMapOf<FirNamedFunctionSymbol, Collection<FirNamedFunctionSymbol>>()
     protected val directOverriddenProperties = hashMapOf<FirPropertySymbol, MutableList<FirPropertySymbol>>()
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         functions.getOrPut(name) {
             doProcessFunctions(name)
         }.forEach {
@@ -32,24 +32,20 @@ abstract class AbstractFirUseSiteMemberScope(
 
     private fun doProcessFunctions(
         name: Name
-    ): Collection<FirFunctionSymbol<*>> = mutableListOf<FirFunctionSymbol<*>>().apply {
+    ): Collection<FirNamedFunctionSymbol> = mutableListOf<FirNamedFunctionSymbol>().apply {
         val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
         declaredMemberScope.processFunctionsByName(name) { symbol ->
             if (symbol.isStatic) return@processFunctionsByName
-            if (symbol is FirNamedFunctionSymbol) {
+            val directOverridden = computeDirectOverridden(symbol)
-                val directOverridden = computeDirectOverridden(symbol)
+            this@AbstractFirUseSiteMemberScope.directOverriddenFunctions[symbol] = directOverridden
-                this@AbstractFirUseSiteMemberScope.directOverriddenFunctions[symbol] = directOverridden
-            }
             overrideCandidates += symbol
             add(symbol)
         }
 
         superTypesScope.processFunctionsByName(name) {
-            if (it !is FirConstructorSymbol) {
+            val overriddenBy = it.getOverridden(overrideCandidates)
-                val overriddenBy = it.getOverridden(overrideCandidates)
+            if (overriddenBy == null) {
-                if (overriddenBy == null) {
+                add(it)
-                    add(it)
-                }
             }
         }
     }
@@ -58,9 +54,7 @@ abstract class AbstractFirUseSiteMemberScope(
         val result = mutableListOf<FirNamedFunctionSymbol>()
         val firSimpleFunction = symbol.fir
         superTypesScope.processFunctionsByName(symbol.callableId.callableName) { superSymbol ->
-            if (superSymbol is FirNamedFunctionSymbol &&
+            if (overrideChecker.isOverriddenFunction(firSimpleFunction, superSymbol.fir)) {
-                overrideChecker.isOverriddenFunction(firSimpleFunction, superSymbol.fir)
-            ) {
                 result.add(superSymbol)
             }
         }

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

@@ -88,11 +88,11 @@ abstract class FirAbstractImportingScope(
         processor: (FirCallableSymbol<*>) -> Unit
     )
 
-    final override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    final override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         return processCallables(
             name,
             TowerScopeLevel.Token.Functions
-        ) { if (it is FirFunctionSymbol<*>) processor(it) }
+        ) { if (it is FirNamedFunctionSymbol) processor(it) }
     }
 
     final override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {

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

@@ -45,7 +45,7 @@ class FirClassDeclaredMemberScope(
         result
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         if (name == CONSTRUCTOR_NAME) return
         processCallables(name, processor)
     }

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

@@ -28,13 +28,13 @@ class FirClassSubstitutionScope(
     private val makeExpect: Boolean = false
 ) : FirTypeScope() {
 
-    private val substitutionOverrideFunctions = mutableMapOf<FirFunctionSymbol<*>, FirFunctionSymbol<*>>()
+    private val substitutionOverrideFunctions = mutableMapOf<FirNamedFunctionSymbol, FirNamedFunctionSymbol>()
     private val substitutionOverrideConstructors = mutableMapOf<FirConstructorSymbol, FirConstructorSymbol>()
     private val substitutionOverrideVariables = mutableMapOf<FirVariableSymbol<*>, FirVariableSymbol<*>>()
 
     private val newOwnerClassId = dispatchReceiverTypeForSubstitutedMembers.lookupTag.classId
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         useSiteMemberScope.processFunctionsByName(name) process@{ original ->
             val function = substitutionOverrideFunctions.getOrPut(original) { createSubstitutionOverrideFunction(original) }
             processor(function)
@@ -110,13 +110,9 @@ class FirClassSubstitutionScope(
         return substitutor.substituteOrNull(this)
     }
 
-    private fun createSubstitutionOverrideFunction(original: FirFunctionSymbol<*>): FirFunctionSymbol<*> {
+    private fun createSubstitutionOverrideFunction(original: FirNamedFunctionSymbol): FirNamedFunctionSymbol {
         if (substitutor == ConeSubstitutor.Empty) return original
-        val member = when (original) {
+        val member = original.fir
-            is FirNamedFunctionSymbol -> original.fir
-            is FirConstructorSymbol -> return original
-            else -> throw AssertionError("Should not be here")
-        }
         if (skipPrivateMembers && member.visibility == Visibilities.Private) return original
 
         val (newTypeParameters, newReceiverType, newReturnType, newSubstitutor, fakeOverrideSubstitution) = createSubstitutedData(member)

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

@@ -33,9 +33,9 @@ class FirDelegatedMemberScope(
     private val dispatchReceiverType = containingClass.defaultType()
     private val overrideChecker = FirStandardOverrideChecker(session)
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         useSiteScope.processFunctionsByName(name) processor@{ functionSymbol ->
-            if (functionSymbol !is FirNamedFunctionSymbol || functionSymbol.fir.isPublicInAny()) {
+            if (functionSymbol.fir.isPublicInAny()) {
                 processor(functionSymbol)
                 return@processor
             }
@@ -46,7 +46,7 @@ class FirDelegatedMemberScope(
                 return@processor
             }
 
-            if (declaredMemberScope.getFunctions(name).any { it is FirNamedFunctionSymbol && overrideChecker.isOverriddenFunction(it.fir, original) }) {
+            if (declaredMemberScope.getFunctions(name).any { overrideChecker.isOverriddenFunction(it.fir, original) }) {
                 processor(functionSymbol)
                 return@processor
             }

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.name.Name
 
 class FirLocalScope private constructor(
     val properties: PersistentMap<Name, FirVariableSymbol<*>>,
-    val functions: PersistentMultimap<Name, FirFunctionSymbol<*>>,
+    val functions: PersistentMultimap<Name, FirNamedFunctionSymbol>,
     val classes: PersistentMap<Name, FirRegularClassSymbol>
 ) : FirScope(), FirContainingNamesAwareScope {
     constructor() : this(persistentMapOf(), PersistentMultimap(), persistentMapOf())
@@ -50,7 +50,7 @@ class FirLocalScope private constructor(
         )
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         for (function in functions[name]) {
             processor(function)
         }

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

@@ -20,7 +20,7 @@ private class FirNestedClassifierScopeWithSubstitution(
     private val substitutor: ConeSubstitutor
 ) : FirScope() {
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         scope.processFunctionsByName(name, processor)
     }
 

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

@@ -20,12 +20,8 @@ class FirObjectImportedCallableScope(
     private val importedClassId: ClassId,
     private val objectUseSiteScope: FirTypeScope
 ) : FirScope(), FirContainingNamesAwareScope {
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         objectUseSiteScope.processFunctionsByName(name) wrapper@{ symbol ->
-            if (symbol !is FirNamedFunctionSymbol) {
-                processor(symbol)
-                return@wrapper
-            }
             val function = symbol.fir
             val syntheticFunction = buildSimpleFunctionCopy(function) {
                 origin = FirDeclarationOrigin.ImportedFromObject

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

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirOnlyCallablesScope(val delegate: FirScope) : FirScope() {
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         return delegate.processFunctionsByName(name, processor)
     }
 

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

@@ -10,10 +10,7 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolvedForCalls
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -39,7 +36,7 @@ class FirPackageMemberScope(val fqName: FqName, val session: FirSession) : FirSc
         }
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         processCallables(name, processor)
     }
 

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

@@ -24,7 +24,7 @@ class FirScopeWithFakeOverrideTypeCalculator(
         delegate.processClassifiersByNameWithSubstitution(name, processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         delegate.processFunctionsByName(name) {
             updateReturnType(it.fir)
             processor(it)

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

@@ -10,9 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.isStatic
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
@@ -21,7 +20,7 @@ class FirStaticScope(private val delegateScope: FirScope) : FirScope() {
         delegateScope.processClassifiersByNameWithSubstitution(name, processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         delegateScope.processFunctionsByName(name) {
             if ((it.fir as? FirSimpleFunction)?.isStatic == true) {
                 processor(it)

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

@@ -40,7 +40,7 @@ class FirTypeIntersectionScope private constructor(
 
     private val intersectionOverrides: MutableMap<FirCallableSymbol<*>, MemberWithBaseScope<out FirCallableSymbol<*>>> = mutableMapOf()
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         if (!processCallablesByName(name, processor, absentFunctions, FirScope::processFunctionsByName)) {
             super.processFunctionsByName(name, processor)
         }

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

@@ -7,7 +7,7 @@ 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.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
@@ -37,7 +37,7 @@ class FirCompositeScope(val scopes: Iterable<FirScope>) : FirScope(), FirContain
         }
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         return processComposite(FirScope::processFunctionsByName, name, processor)
     }
 

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.scopes
 
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
@@ -21,7 +22,7 @@ fun FirScope.getContainingCallableNamesIfPresent(): Set<Name> =
 fun FirScope.getContainingClassifierNamesIfPresent(): Set<Name> =
     if (this is FirContainingNamesAwareScope) getClassifierNames() else emptySet()
 
-fun <S> S.processAllFunctions(processor: (FirFunctionSymbol<*>) -> Unit) where S : FirScope, S : FirContainingNamesAwareScope {
+fun <S> S.processAllFunctions(processor: (FirNamedFunctionSymbol) -> Unit) where S : FirScope, S : FirContainingNamesAwareScope {
     for (name in getCallableNames()) {
         processFunctionsByName(name, processor)
     }
@@ -33,12 +34,6 @@ fun <S> S.processAllProperties(processor: (FirVariableSymbol<*>) -> Unit) where
     }
 }
 
-fun <S> S.collectAllFunctions(): Collection<FirFunctionSymbol<*>> where S : FirScope, S : FirContainingNamesAwareScope {
-    return mutableListOf<FirFunctionSymbol<*>>().apply {
-        processAllFunctions(this::add)
-    }
-}
-
 fun <S> S.collectAllProperties(): Collection<FirVariableSymbol<*>> where S : FirScope, S : FirContainingNamesAwareScope {
     return mutableListOf<FirVariableSymbol<*>>().apply {
         processAllProperties(this::add)

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

@@ -18,7 +18,7 @@ abstract class FirScope {
 
     open fun processFunctionsByName(
         name: Name,
-        processor: (FirFunctionSymbol<*>) -> Unit
+        processor: (FirNamedFunctionSymbol) -> Unit
     ) {
     }
 
@@ -40,7 +40,7 @@ fun FirScope.getSingleClassifier(name: Name): FirClassifierSymbol<*>? = mutableL
     processClassifiersByName(name, this::add)
 }.singleOrNull()
 
-fun FirScope.getFunctions(name: Name): List<FirFunctionSymbol<*>> = mutableListOf<FirFunctionSymbol<*>>().apply {
+fun FirScope.getFunctions(name: Name): List<FirNamedFunctionSymbol> = mutableListOf<FirNamedFunctionSymbol>().apply {
     processFunctionsByName(name, this::add)
 }
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirDelegatingScope.kt

@@ -5,13 +5,10 @@
 
 package org.jetbrains.kotlin.idea.frontend.api.fir.scopes
 
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
-import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
@@ -62,9 +59,7 @@ internal fun FirScope.getCallableSymbols(callableNames: Collection<Name>, builde
     callableNames.forEach { name ->
         val callables = mutableListOf<KtCallableSymbol>()
         processFunctionsByName(name) { firSymbol ->
-            (firSymbol.fir as? FirSimpleFunction)?.let { fir ->
+            callables.add(builder.buildFunctionSymbol(firSymbol.fir))
-                callables.add(builder.buildFunctionSymbol(fir))
-            }
         }
         processPropertiesByName(name) { firSymbol ->
             val symbol = when {