Unify API of FirScope.processClassifiersByName (use ProcessorAction)

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

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractImportingScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
-import org.jetbrains.kotlin.fir.scopes.processClassifiersByNameWithAction
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType
@@ -133,7 +132,7 @@ class MemberScopeTowerLevel(
                 this.processFunctionsByName(name, symbol.cast())
             }
             TowerScopeLevel.Token.Objects -> processMembers(processor, explicitExtensionReceiver) { symbol ->
-                this.processClassifiersByNameWithAction(name, FirPosition.OTHER, symbol.cast())
+                this.processClassifiersByName(name, FirPosition.OTHER, symbol.cast())
             }
         }
     }
@@ -199,7 +198,7 @@ class ScopeTowerLevel(
                     ProcessorAction.NEXT
                 }
             }
-            TowerScopeLevel.Token.Objects -> scope.processClassifiersByNameWithAction(name, FirPosition.OTHER) {
+            TowerScopeLevel.Token.Objects -> scope.processClassifiersByName(name, FirPosition.OTHER) {
                 processor.consumeCandidate(
                     it as T, dispatchReceiverValue = null,
                     implicitExtensionReceiverValue = null
@@ -247,7 +246,7 @@ class QualifiedReceiverTowerLevel(
         }
 
         return when (token) {
-            TowerScopeLevel.Token.Objects -> scope.processClassifiersByNameWithAction(name, FirPosition.OTHER) {
+            TowerScopeLevel.Token.Objects -> scope.processClassifiersByName(name, FirPosition.OTHER) {
                 @Suppress("UNCHECKED_CAST")
                 processor.consumeCandidate(it as T, null, null)
             }
@@ -308,7 +307,7 @@ private fun FirScope.processFunctionsAndConstructorsByName(
 
 private fun FirScope.getFirstClassifierOrNull(name: Name): FirClassifierSymbol<*>? {
     var result: FirClassifierSymbol<*>? = null
-    processClassifiersByNameWithAction(name, FirPosition.OTHER) {
+    processClassifiersByName(name, FirPosition.OTHER) {
         result = it
         ProcessorAction.STOP
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -63,7 +64,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver {
                         }
                         else -> error("!")
                     }
-                    resolvedSymbol == null
+                    if (resolvedSymbol == null) ProcessorAction.NEXT else ProcessorAction.STOP
                 }
 
                 // TODO: Imports

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirTypeParameterScope.kt

@@ -15,10 +15,13 @@ abstract class FirTypeParameterScope : FirScope() {
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean {
+    ): ProcessorAction {
-        val matchedTypeParameters = typeParameters[name] ?: return true
+        val matchedTypeParameters = typeParameters[name] ?: return ProcessorAction.NEXT
 
-        return matchedTypeParameters.all { processor(it.symbol) }
+        return when {
+            matchedTypeParameters.all { processor(it.symbol) == ProcessorAction.NEXT } -> ProcessorAction.NEXT
+            else -> ProcessorAction.STOP
+        }
     }
 }

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

@@ -37,7 +37,11 @@ abstract class AbstractFirUseSiteScope(
         }
     }
 
-    override fun processClassifiersByName(name: Name, position: FirPosition, processor: (FirClassifierSymbol<*>) -> Boolean): Boolean {
+    override fun processClassifiersByName(
+        name: Name,
+        position: FirPosition,
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
+    ): ProcessorAction {
         return declaredMemberScope.processClassifiersByName(name, position, processor)
     }
 }

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

@@ -27,10 +27,10 @@ abstract class FirAbstractSimpleImportingScope(
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean {
+    ): ProcessorAction {
-        val imports = simpleImports[name] ?: return true
+        val imports = simpleImports[name] ?: return ProcessorAction.NONE
-        if (imports.isEmpty()) return true
+        if (imports.isEmpty()) return ProcessorAction.NONE
         val provider = FirSymbolProvider.getInstance(session)
         for (import in imports) {
             val importedName = import.importedName ?: continue
@@ -39,10 +39,10 @@ abstract class FirAbstractSimpleImportingScope(
                     ?: ClassId.topLevel(import.packageFqName.child(importedName))
             val symbol = provider.getClassLikeSymbolByFqName(classId) ?: continue
             if (!processor(symbol)) {
-                return false
+                return ProcessorAction.STOP
             }
         }
-        return true
+        return ProcessorAction.NEXT
     }
 
     override fun <T : FirCallableSymbol<*>> processCallables(

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

@@ -29,29 +29,29 @@ abstract class FirAbstractStarImportingScope(
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean {
+    ): ProcessorAction {
         if (starImports.isEmpty() || name in absentClassifierNames) {
-            return true
+            return ProcessorAction.NONE
         }
         var empty = true
         for (import in starImports) {
             val relativeClassName = import.relativeClassName
             val classId = when {
-                !name.isSpecial && name.identifier.isEmpty() -> return true
+                !name.isSpecial && name.identifier.isEmpty() -> return ProcessorAction.NEXT
                 relativeClassName == null -> ClassId(import.packageFqName, name)
                 else -> ClassId(import.packageFqName, relativeClassName.child(name), false)
             }
             val symbol = provider.getClassLikeSymbolByFqName(classId) ?: continue
             empty = false
             if (!processor(symbol)) {
-                return false
+                return ProcessorAction.STOP
             }
         }
         if (empty) {
             absentClassifierNames += name
         }
-        return true
+        return ProcessorAction.NEXT
     }
 
 

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

@@ -85,10 +85,14 @@ class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() {
         return NEXT
     }
 
-    override fun processClassifiersByName(name: Name, position: FirPosition, processor: (FirClassifierSymbol<*>) -> Boolean): Boolean {
+    override fun processClassifiersByName(
+        name: Name,
+        position: FirPosition,
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
+    ): ProcessorAction {
         val matchedClass = classIndex[name]
         if (matchedClass != null && !processor(matchedClass)) {
-            return false
+            return STOP
         }
 
         return super.processClassifiersByName(name, position, processor)

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

@@ -23,16 +23,16 @@ class FirCompositeScope(
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean {
+    ): ProcessorAction {
         val scopes = if (reversedPriority) scopes.asReversed() else scopes
         for (scope in scopes) {
             if (!position.allowTypeParameters && scope is FirTypeParameterScope) continue
             if (!scope.processClassifiersByName(name, position, processor)) {
-                return false
+                return STOP
             }
         }
-        return true
+        return NEXT
     }
 
     private inline fun <T> processComposite(

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -20,11 +21,11 @@ class FirNestedClassifierScope(
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean {
+    ): ProcessorAction {
         val child = classId.createNestedClassId(name)
-        val symbol = symbolProvider.getClassLikeSymbolByFqName(child)
+        val symbol = symbolProvider.getClassLikeSymbolByFqName(child) ?: return ProcessorAction.NONE
 
-        return symbol == null || processor(symbol)
+        return processor(symbol)
     }
 }

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

@@ -27,9 +27,9 @@ class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirSc
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean {
+    ): ProcessorAction {
-        if (name.asString().isEmpty()) return true
+        if (name.asString().isEmpty()) return ProcessorAction.NONE
 
 
         val symbol = cache.getOrPut(name) {
@@ -40,7 +40,7 @@ class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirSc
         return if (symbol != null) {
             processor(symbol)
         } else {
-            true
+            ProcessorAction.NONE
         }
     }
 

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

@@ -6,22 +6,17 @@
 package org.jetbrains.kotlin.fir.scopes
 
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirScope {
-    @Deprecated(
-        "obsolete",
-        replaceWith = ReplaceWith("processClassifiersByNameWithAction(name, position) { if (processor()) ProcessorAction.NEXT else ProcessorAction.STOP }.next()")
-    )
     open fun processClassifiersByName(
         name: Name,
         position: FirPosition,
-        processor: (FirClassifierSymbol<*>) -> Boolean
+        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): Boolean = true
+    ): ProcessorAction = NEXT
 
     open fun processFunctionsByName(
         name: Name,
@@ -35,18 +30,6 @@ abstract class FirScope {
     ): ProcessorAction = NEXT
 }
 
-
-inline fun FirScope.processClassifiersByNameWithAction(
-    name: Name,
-    position: FirPosition,
-    crossinline processor: (FirClassifierSymbol<*>) -> ProcessorAction
-): ProcessorAction {
-    val result = processClassifiersByName(name, position) {
-        processor(it).next()
-    }
-    return if (result) NEXT else STOP
-}
-
 enum class FirPosition(val allowTypeParameters: Boolean = true) {
     SUPER_TYPE_OR_EXPANSION(allowTypeParameters = false),
     OTHER