Use FirNamedFunctionSymbol in FirScope.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)
         }