[FIR] Get rid of processors in FirScope

2020-01-09 18:47:47 +03:00
parent 224b2acdcc
commit a3ab763f0b
38 changed files with 311 additions and 468 deletions
@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressions
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.transformers.phasedFir
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -311,7 +310,6 @@ class FirCallResolver(
            if (it is FirConstructorSymbol) {
                candidates += candidateFactory.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER)
            }
-            ProcessorAction.NEXT
        }
        return callResolver.selectCandidateFromGivenCandidates(delegatedConstructorCall, className, candidates)
    }
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.resolve
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
@@ -64,9 +63,8 @@ fun FirSymbolProvider.getClassDeclaredCallableSymbols(classId: ClassId, name: Na
    val classSymbol = getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol ?: return emptyList()
    val declaredMemberScope = declaredMemberScope(classSymbol.fir)
    val result = mutableListOf<FirCallableSymbol<*>>()
-    val processor: (FirCallableSymbol<*>) -> ProcessorAction = {
+    val processor: (FirCallableSymbol<*>) -> Unit = {
        result.add(it)
-        ProcessorAction.NEXT
    }

    declaredMemberScope.processFunctionsByName(name, processor)
@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.inferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
@@ -256,9 +255,6 @@ private fun FirRegularClass.findSingleAbstractMethodByNames(
        classUseSiteMemberScope.processPropertiesByName(candidateName) {
            if ((it as? FirPropertySymbol)?.fir?.modality == Modality.ABSTRACT) {
                metIncorrectMember = true
-                ProcessorAction.STOP
-            } else {
-                ProcessorAction.NEXT
            }
        }

@@ -273,14 +269,12 @@ private fun FirRegularClass.findSingleAbstractMethodByNames(

            if (firFunction.modality != Modality.ABSTRACT || firFunction
                    .isPublicInObject(checkOnlyName = false)
-            ) return@processFunctionsByName ProcessorAction.NEXT
+            ) return@processFunctionsByName

            if (resultMethod != null) {
                metIncorrectMember = true
-                ProcessorAction.STOP
            } else {
                resultMethod = firFunction
-                ProcessorAction.NEXT
            }
        }
    }
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.scopes.scope
@@ -30,42 +29,39 @@ internal fun FirScope.processFunctionsAndConstructorsByName(
    session: FirSession,
    bodyResolveComponents: BodyResolveComponents,
    noInnerConstructors: Boolean = false,
-    processor: (FirCallableSymbol<*>) -> ProcessorAction
-): ProcessorAction {
+    processor: (FirCallableSymbol<*>) -> Unit
+) {
+    // TODO: Handle case with two or more accessible classifiers
    val matchedClassSymbol = getFirstClassifierOrNull(name) as? FirClassLikeSymbol<*>

-    if (processConstructors(
-            matchedClassSymbol,
-            processor,
-            session,
-            bodyResolveComponents.scopeSession,
-            name,
+    processConstructors(
+        matchedClassSymbol,
+        processor,
+        session,
+        bodyResolveComponents.scopeSession,
+        name,
            noInnerConstructors
-        ).stop()
-    ) {
-        return ProcessorAction.STOP
-    }
+        )

-    if (processSyntheticConstructors(
-            matchedClassSymbol,
-            processor,
-            bodyResolveComponents
-        ).stop()
-    ) {
-        return ProcessorAction.STOP
-    }
+    processSyntheticConstructors(
+        matchedClassSymbol,
+        processor,
+        bodyResolveComponents
+    )

-    return processFunctionsByName(name) {
-        if (it is FirConstructorSymbol) ProcessorAction.NEXT
-        else processor(it)
+    processFunctionsByName(name) {
+        if (it !is FirConstructorSymbol) {
+            processor(it)
+        }
    }
 }

 private fun FirScope.getFirstClassifierOrNull(name: Name): FirClassifierSymbol<*>? {
    var result: FirClassifierSymbol<*>? = null
    processClassifiersByName(name) {
-        result = it
-        ProcessorAction.STOP
+        if (result == null) {
+            result = it
+        }
    }

    return result
@@ -83,13 +79,13 @@ private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession):

 private fun processSyntheticConstructors(
    matchedSymbol: FirClassLikeSymbol<*>?,
-    processor: (FirFunctionSymbol<*>) -> ProcessorAction,
+    processor: (FirFunctionSymbol<*>) -> Unit,
    bodyResolveComponents: BodyResolveComponents
-): ProcessorAction {
+) {
    val samConstructor = matchedSymbol.findSAMConstructor(bodyResolveComponents)
-    if (samConstructor != null) return processor(samConstructor.symbol)
-
-    return ProcessorAction.NEXT
+    if (samConstructor != null) {
+        processor(samConstructor.symbol)
+    }
 }

 private fun FirClassLikeSymbol<*>?.findSAMConstructor(
@@ -132,12 +128,12 @@ private fun FirTypeAliasSymbol.findSAMConstructorForTypeAlias(

 private fun processConstructors(
    matchedSymbol: FirClassLikeSymbol<*>?,
-    processor: (FirFunctionSymbol<*>) -> ProcessorAction,
+    processor: (FirFunctionSymbol<*>) -> Unit,
    session: FirSession,
    scopeSession: ScopeSession,
    name: Name,
    noInner: Boolean
-): ProcessorAction {
+) {
    try {
        if (matchedSymbol != null) {
            val scope = when (matchedSymbol) {
@@ -148,30 +144,24 @@ private fun processConstructors(
                    if (basicScope != null && type.typeArguments.isNotEmpty()) {
                        prepareSubstitutingScopeForTypeAliasConstructors(
                            matchedSymbol, type, session, basicScope
-                        ) ?: return ProcessorAction.STOP
+                        ) ?: return
                    } else basicScope
                }
                is FirClassSymbol -> (matchedSymbol.fir as FirClass<*>).scope(ConeSubstitutor.Empty, session, scopeSession)
            }

            val constructorName = when (matchedSymbol) {
-                is FirTypeAliasSymbol -> finalExpansionName(matchedSymbol, session) ?: return ProcessorAction.NEXT
+                is FirTypeAliasSymbol -> finalExpansionName(matchedSymbol, session) ?: return
                is FirClassSymbol -> name
            }

            //TODO: why don't we use declared member scope at this point?
-            if (scope != null && scope.processFunctionsByName(constructorName) {
-                    if (!noInner || (it as? FirConstructorSymbol)?.fir?.isInner != true) {
-                        processor(it)
-                    } else {
-                        ProcessorAction.NEXT
-                    }
-                } == ProcessorAction.STOP
-            ) {
-                return ProcessorAction.STOP
+            scope?.processFunctionsByName(constructorName) {
+                if (!noInner || (it as? FirConstructorSymbol)?.fir?.isInner != true) {
+                    processor(it)
+                }
            }
        }
-        return ProcessorAction.NEXT
    } catch (e: ProcessCanceledException) {
        throw e
    } catch (e: Throwable) {
@@ -183,8 +173,8 @@ private class TypeAliasConstructorsSubstitutingScope(
    private val typeAliasConstructorsSubstitutor: TypeAliasConstructorsSubstitutor<FirConstructor>,
    private val delegatingScope: FirScope
 ) : FirScope() {
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
-        return delegatingScope.processFunctionsByName(name) {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+        delegatingScope.processFunctionsByName(name) {
            val toProcess = if (it is FirConstructorSymbol) {
                typeAliasConstructorsSubstitutor.substitute(it.fir).symbol
            } else {
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.resolve.transformQualifiedAccessUsingSmartcastIn
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NONE
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
@@ -277,19 +276,16 @@ class FirTowerResolver(
            CallKind.VariableAccess -> {
                qualifierScope.processPropertiesByName(info.name) {
                    collector.consumeCandidate(0, candidateFactory.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER))
-                    ProcessorAction.NEXT
                }
                qualifierScope.processClassifiersByName(info.name) {
                    if (it is FirClassSymbol<*> && it.fir.classKind == ClassKind.OBJECT) {
                        collector.consumeCandidate(0, candidateFactory.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER))
                    }
-                    ProcessorAction.NEXT
                }
            }
            CallKind.Function -> {
                qualifierScope.processFunctionsAndConstructorsByName(info.name, session, components) {
                    collector.consumeCandidate(0, candidateFactory.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER))
-                    ProcessorAction.NEXT
                }

                val invokeReceiverCollector = CandidateCollector(components, components.resolutionStageRunner)
@@ -302,7 +298,6 @@ class FirTowerResolver(
                    invokeReceiverCollector.consumeCandidate(
                        0, invokeReceiverCandidateFactory.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER)
                    )
-                    ProcessorAction.NEXT
                }
                if (invokeReceiverCollector.isSuccess()) {
                    for (invokeReceiverCandidate in invokeReceiverCollector.bestCandidates()) {
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.isStatic
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.AccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
@@ -44,14 +43,14 @@ class FirSyntheticPropertiesScope(
    private fun checkGetAndCreateSynthetic(
        name: Name,
        symbol: FirFunctionSymbol<*>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        val fir = symbol.fir as? FirSimpleFunction ?: return ProcessorAction.NEXT
+        processor: (FirCallableSymbol<*>) -> Unit
+    ) {
+        val fir = symbol.fir as? FirSimpleFunction ?: return

-        if (fir.typeParameters.isNotEmpty()) return ProcessorAction.NEXT
-        if (fir.valueParameters.isNotEmpty()) return ProcessorAction.NEXT
-        if (fir.isStatic) return ProcessorAction.NEXT
-        if (fir.returnTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == StandardClassIds.Unit) return ProcessorAction.NEXT
+        if (fir.typeParameters.isNotEmpty()) return
+        if (fir.valueParameters.isNotEmpty()) return
+        if (fir.isStatic) return
+        if (fir.returnTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == StandardClassIds.Unit) return

        val synthetic = SyntheticPropertySymbol(
            accessorId = symbol.callableId,
@@ -59,18 +58,16 @@ class FirSyntheticPropertiesScope(
        )
        synthetic.bind(fir)

-        return processor(synthetic)
+        processor(synthetic)
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        val getterNames = possibleGetterNamesByPropertyName(name)
        for (getterName in getterNames) {
-            if (baseScope.processFunctionsByName(getterName) {
-                    checkGetAndCreateSynthetic(name, it, processor)
-                }.stop()
-            ) return ProcessorAction.STOP
+            baseScope.processFunctionsByName(getterName) {
+                checkGetAndCreateSynthetic(name, it, processor)
+            }
        }
-        return ProcessorAction.NEXT
    }

    companion object {
@@ -159,7 +159,7 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
            dispatchReceiverValue: ReceiverValue?,
            implicitExtensionReceiverValue: ImplicitReceiverValue<*>?,
            builtInExtensionFunctionReceiverValue: ReceiverValue?
-        ): ProcessorAction {
+        ) {
            resultCollector.consumeCandidate(
                group,
                candidateFactory.createCandidate(
@@ -170,7 +170,6 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
                    builtInExtensionFunctionReceiverValue
                )
            )
-            return ProcessorAction.NEXT
        }
    }

@@ -180,7 +179,7 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
            dispatchReceiverValue: ReceiverValue?,
            implicitExtensionReceiverValue: ImplicitReceiverValue<*>?,
            builtInExtensionFunctionReceiverValue: ReceiverValue?
-        ): ProcessorAction {
+        ) {
            if (symbol is FirNamedFunctionSymbol && symbol.callableId.packageName.startsWith(defaultPackage)) {
                val explicitReceiverType = explicitReceiver.type
                if (dispatchReceiverValue == null && explicitReceiverType is ConeClassLikeType) {
@@ -197,7 +196,7 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
                                )
                            )
                        ) {
-                            return ProcessorAction.NEXT
+                            return
                        }
                    }
                }
@@ -214,7 +213,6 @@ class ExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
                group,
                candidate
            )
-            return ProcessorAction.NEXT
        }
    }
 }
@@ -252,7 +250,7 @@ class NoExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
            dispatchReceiverValue: ReceiverValue?,
            implicitExtensionReceiverValue: ImplicitReceiverValue<*>?,
            builtInExtensionFunctionReceiverValue: ReceiverValue?
-        ): ProcessorAction {
+        ) {
            resultCollector.consumeCandidate(
                group,
                candidateFactory.createCandidate(
@@ -263,7 +261,6 @@ class NoExplicitReceiverTowerDataConsumer<T : AbstractFirBasedSymbol<*>>(
                    builtInExtensionFunctionReceiverValue
                )
            )
-            return ProcessorAction.NEXT
        }
    }
 }
@@ -49,7 +49,7 @@ interface TowerScopeLevel {
            dispatchReceiverValue: ReceiverValue?,
            implicitExtensionReceiverValue: ImplicitReceiverValue<*>?,
            builtInExtensionFunctionReceiverValue: ReceiverValue? = null
-        ): ProcessorAction
+        )
    }

    abstract class StubTowerScopeLevel : TowerScopeLevel {
@@ -102,42 +102,36 @@ class MemberScopeTowerLevel(
    private fun <T : AbstractFirBasedSymbol<*>> processMembers(
        output: TowerScopeLevel.TowerScopeLevelProcessor<T>,
        explicitExtensionReceiver: AbstractExplicitReceiver<*>?,
-        processScopeMembers: FirScope.(processor: (T) -> ProcessorAction) -> ProcessorAction
-    ): ProcessorAction {
-        if (implicitExtensionReceiver != null && explicitExtensionReceiver != null) return ProcessorAction.NEXT
+        processScopeMembers: FirScope.(processor: (T) -> Unit) -> Unit
+    ) {
+        if (implicitExtensionReceiver != null && explicitExtensionReceiver != null) return
        val extensionReceiver = implicitExtensionReceiver ?: explicitExtensionReceiver
-        val scope = dispatchReceiver.scope(session, scopeSession) ?: return ProcessorAction.NEXT
-        if (scope.processScopeMembers { candidate ->
-                if (candidate is FirCallableSymbol<*> &&
-                    (implicitExtensionInvokeMode || candidate.hasConsistentExtensionReceiver(extensionReceiver))
-                ) {
-                    val dispatchReceiverValue = NotNullableReceiverValue(dispatchReceiver)
-                    if (implicitExtensionInvokeMode) {
-                        if (output.consumeCandidate(
-                                candidate, dispatchReceiverValue,
-                                implicitExtensionReceiverValue = implicitExtensionReceiver
-                            ).stop()
-                        ) {
-                            ProcessorAction.STOP
-                        } else {
-                            output.consumeCandidate(
-                                candidate, dispatchReceiverValue,
-                                implicitExtensionReceiverValue = null,
-                                builtInExtensionFunctionReceiverValue = implicitExtensionReceiver
-                            )
-                        }
-                    } else {
-                        output.consumeCandidate(candidate, dispatchReceiverValue, implicitExtensionReceiver, null)
-                    }
-                } else if (candidate is FirClassLikeSymbol<*>) {
-                    output.consumeCandidate(candidate, null, implicitExtensionReceiver, null)
+        val scope = dispatchReceiver.scope(session, scopeSession) ?: return
+        scope.processScopeMembers { candidate ->
+            if (candidate is FirCallableSymbol<*> &&
+                (implicitExtensionInvokeMode || candidate.hasConsistentExtensionReceiver(extensionReceiver))
+            ) {
+                val dispatchReceiverValue = NotNullableReceiverValue(dispatchReceiver)
+                if (implicitExtensionInvokeMode) {
+                    output.consumeCandidate(
+                        candidate, dispatchReceiverValue,
+                        implicitExtensionReceiverValue = implicitExtensionReceiver
+                    )
+                    output.consumeCandidate(
+                        candidate, dispatchReceiverValue,
+                        implicitExtensionReceiverValue = null,
+                        builtInExtensionFunctionReceiverValue = implicitExtensionReceiver
+                    )
                } else {
-                    ProcessorAction.NEXT
+                    output.consumeCandidate(candidate, dispatchReceiverValue, implicitExtensionReceiver, null)
                }
-            }.stop()
-        ) return ProcessorAction.STOP
+            } else if (candidate is FirClassLikeSymbol<*>) {
+                output.consumeCandidate(candidate, null, implicitExtensionReceiver, null)
+            }
+        }
+
        val withSynthetic = FirSyntheticPropertiesScope(session, scope)
-        return withSynthetic.processScopeMembers { symbol ->
+        withSynthetic.processScopeMembers { symbol ->
            output.consumeCandidate(symbol, NotNullableReceiverValue(dispatchReceiver), implicitExtensionReceiver, null)
        }
    }
@@ -154,7 +148,7 @@ class MemberScopeTowerLevel(
        }
        val explicitExtensionReceiver = if (dispatchReceiver == explicitReceiver) null else explicitReceiver
        val noInnerConstructors = dispatchReceiver is QualifierReceiver
-        return when (token) {
+        when (token) {
            TowerScopeLevel.Token.Properties -> processMembers(processor, explicitExtensionReceiver) { symbol ->
                this.processPropertiesByName(name, symbol.cast())
            }
@@ -165,6 +159,7 @@ class MemberScopeTowerLevel(
                this.processClassifiersByName(name, symbol.cast())
            }
        }
+        return ProcessorAction.NEXT
    }
 }

@@ -201,15 +196,13 @@ class ScopeTowerLevel(
        }
        val extensionReceiver = explicitReceiver ?: implicitExtensionReceiver
        @Suppress("UNCHECKED_CAST")
-        return when (token) {
+        when (token) {
            TowerScopeLevel.Token.Properties -> scope.processPropertiesByName(name) { candidate ->
                if (candidate.hasConsistentReceivers(extensionReceiver)) {
                    processor.consumeCandidate(
                        candidate as T, dispatchReceiverValue = null,
                        implicitExtensionReceiverValue = implicitExtensionReceiver
                    )
-                } else {
-                    ProcessorAction.NEXT
                }
            }
            TowerScopeLevel.Token.Functions -> scope.processFunctionsAndConstructorsByName(
@@ -222,8 +215,6 @@ class ScopeTowerLevel(
                        candidate as T, dispatchReceiverValue = null,
                        implicitExtensionReceiverValue = implicitExtensionReceiver
                    )
-                } else {
-                    ProcessorAction.NEXT
                }
            }
            TowerScopeLevel.Token.Objects -> scope.processClassifiersByName(name) {
@@ -233,6 +224,7 @@ class ScopeTowerLevel(
                )
            }
        }
+        return ProcessorAction.NEXT
    }
 }

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 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
@@ -52,6 +51,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver {

                var resolvedSymbol: FirClassifierSymbol<*>? = null
                scope.processClassifiersByName(typeRef.qualifier.first().name) { symbol ->
+                    if (resolvedSymbol != null) return@processClassifiersByName
                    resolvedSymbol = when (symbol) {
                        is FirClassLikeSymbol<*> -> {
                            if (typeRef.qualifier.size == 1) {
@@ -66,7 +66,6 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver {
                        }
                        else -> error("!")
                    }
-                    if (resolvedSymbol == null) ProcessorAction.NEXT else ProcessorAction.STOP
                }

                // TODO: Imports
@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.createImportingScopes
 import org.jetbrains.kotlin.fir.scopes.impl.FirMemberTypeParameterScope
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
@@ -385,42 +384,33 @@ private class FirImmutableCompositeScope(

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
        for (scope in scopes) {
-            if (!scope.processClassifiersByName(name, processor)) {
-                return ProcessorAction.STOP
-            }
+            scope.processClassifiersByName(name, processor)
        }
-        return ProcessorAction.NEXT
    }

    private inline fun <T> processComposite(
-        process: FirScope.(Name, (T) -> ProcessorAction) -> ProcessorAction,
+        process: FirScope.(Name, (T) -> Unit) -> Unit,
        name: Name,
-        noinline processor: (T) -> ProcessorAction
-    ): ProcessorAction {
+        noinline processor: (T) -> Unit
+    ) {
        val unique = mutableSetOf<T>()
        for (scope in scopes) {
-            if (!scope.process(name) {
-                    if (unique.add(it)) {
-                        processor(it)
-                    } else {
-                        ProcessorAction.NEXT
-                    }
+            scope.process(name) {
+                if (unique.add(it)) {
+                    processor(it)
                }
-            ) {
-                return ProcessorAction.STOP
            }
        }
-        return ProcessorAction.NEXT
    }

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        return processComposite(FirScope::processFunctionsByName, name, processor)
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        return processComposite(FirScope::processPropertiesByName, name, processor)
    }
 }
@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.resolve.calls.ConeInferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperator
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCall
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
@@ -59,17 +58,19 @@ class IntegerLiteralTypeApproximationTransformer(
        val scope = declaredMemberScope((symbolProvider.getClassLikeSymbolByFqName(receiverClassId) as FirRegularClassSymbol).fir)
        var resultSymbol: FirFunctionSymbol<*>? = null
        scope.processFunctionsByName(operator.name) { symbol ->
+            if (resultSymbol != null) {
+                return@processFunctionsByName
+            }
            if (operator.kind.unary) {
                resultSymbol = symbol
-                return@processFunctionsByName ProcessorAction.STOP
+                return@processFunctionsByName
            }
            val function = symbol.fir
            val valueParameterType = function.valueParameters.first().returnTypeRef.coneTypeUnsafe<ConeClassLikeType>()
            if (AbstractTypeChecker.isSubtypeOf(inferenceContext, argumentType!!, valueParameterType)) {
                resultSymbol = symbol
-                return@processFunctionsByName ProcessorAction.STOP
+                return@processFunctionsByName
            }
-            ProcessorAction.NEXT
        }
        // TODO: Maybe resultType = data?
        //   check black box tests
@@ -14,13 +14,10 @@ abstract class FirTypeParameterScope : FirScope() {

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        val matchedTypeParameters = typeParameters[name] ?: return ProcessorAction.NEXT
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
+        val matchedTypeParameters = typeParameters[name] ?: return

-        return when {
-            matchedTypeParameters.all { processor(it.symbol) == ProcessorAction.NEXT } -> ProcessorAction.NEXT
-            else -> ProcessorAction.STOP
-        }
+        matchedTypeParameters.forEach { processor(it.symbol) }
    }
 }
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.scopes.FirOverrideChecker
 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.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -30,34 +29,29 @@ abstract class AbstractFirUseSiteMemberScope(

    private val functions = hashMapOf<Name, Collection<FirFunctionSymbol<*>>>()

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        functions.getOrPut(name) {
            doProcessFunctions(name)
        }.forEach {
-            if (processor(it) == ProcessorAction.STOP) return ProcessorAction.STOP
+            processor(it)
        }
-
-        return ProcessorAction.NEXT
    }

    private fun doProcessFunctions(
        name: Name
    ): Collection<FirFunctionSymbol<*>> = mutableListOf<FirFunctionSymbol<*>>().apply {
        val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
-        if (!declaredMemberScope.processFunctionsByName(name) {
-                val symbol = processInheritedDefaultParameters(it)
-                overrideCandidates += symbol
-                add(symbol)
-                ProcessorAction.NEXT
-            }
-        ) return@apply
+        declaredMemberScope.processFunctionsByName(name) {
+            val symbol = processInheritedDefaultParameters(it)
+            overrideCandidates += symbol
+            add(symbol)
+        }

        superTypesScope.processFunctionsByName(name) {
            val overriddenBy = it.getOverridden(overrideCandidates)
            if (overriddenBy == null) {
                add(it)
            }
-            ProcessorAction.NEXT
        }
    }

@@ -68,13 +62,12 @@ abstract class AbstractFirUseSiteMemberScope(
        var foundFir: FirFunction<*>? = null
        superTypesScope.processFunctionsByName(symbol.callableId.callableName) { superSymbol ->
            val superFunctionFir = superSymbol.fir
-            if (superFunctionFir is FirSimpleFunction && overrideChecker.isOverriddenFunction(firSimpleFunction, superFunctionFir) &&
+            if (foundFir == null &&
+                superFunctionFir is FirSimpleFunction &&
+                overrideChecker.isOverriddenFunction(firSimpleFunction, superFunctionFir) &&
                superFunctionFir.valueParameters.any { parameter -> parameter.defaultValue != null }
            ) {
                foundFir = superFunctionFir
-                ProcessorAction.STOP
-            } else {
-                ProcessorAction.NEXT
            }
        }

@@ -127,11 +120,9 @@ abstract class AbstractFirUseSiteMemberScope(

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        if (!declaredMemberScope.processClassifiersByName(name, processor)) {
-            return ProcessorAction.STOP
-        }
-        return superTypesScope.processClassifiersByName(name, processor)
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
+        declaredMemberScope.processClassifiersByName(name, processor)
+        superTypesScope.processClassifiersByName(name, processor)
    }
 }
@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -46,16 +45,15 @@ abstract class FirAbstractImportingScope(
        import: FirResolvedImport,
        name: Name,
        token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirCallableSymbol<*>) -> Unit
+    ): Unit {
        val callableId = CallableId(import.packageFqName, import.relativeClassName, name)

        val classId = import.resolvedClassId
        if (classId != null) {
-            val scope = getStaticsScope(classId) ?: return ProcessorAction.NEXT
+            val scope = getStaticsScope(classId) ?: return

-
-            val action = when (token) {
+            when (token) {
                TowerScopeLevel.Token.Functions -> scope.processFunctionsByName(
                    callableId.callableName,
                    processor.cast()
@@ -64,45 +62,38 @@ abstract class FirAbstractImportingScope(
                    callableId.callableName,
                    processor.cast()
                )
-                else -> ProcessorAction.NEXT
-            }
-            if (action.stop()) {
-                return ProcessorAction.STOP
            }
        } else if (name.isSpecial || name.identifier.isNotEmpty()) {
            val symbols = provider.getTopLevelCallableSymbols(callableId.packageName, callableId.callableName)
            if (symbols.isEmpty()) {
-                return ProcessorAction.NONE
+                return
            }

            for (symbol in symbols) {
-                if (processor(symbol).stop()) {
-                    return ProcessorAction.STOP
-                }
+                processor(symbol)
            }
        }

-        return ProcessorAction.NEXT
    }

    abstract fun <T : FirCallableSymbol<*>> processCallables(
        name: Name,
        token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
+    )

-    final override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    final override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        return processCallables(
            name,
            TowerScopeLevel.Token.Functions
-        ) { if (it is FirFunctionSymbol<*>) processor(it) else ProcessorAction.NEXT }
+        ) { if (it is FirFunctionSymbol<*>) processor(it) }
    }

-    final override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    final override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        return processCallables(
            name,
            TowerScopeLevel.Token.Properties
-        ) { if (it is FirVariableSymbol<*>) processor(it) else ProcessorAction.NEXT }
+        ) { if (it is FirVariableSymbol<*>) processor(it) }
    }

 }
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.ClassId
@@ -25,10 +24,10 @@ abstract class FirAbstractSimpleImportingScope(

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        val imports = simpleImports[name] ?: return ProcessorAction.NONE
-        if (imports.isEmpty()) return ProcessorAction.NONE
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
+        val imports = simpleImports[name] ?: return
+        if (imports.isEmpty()) return
        val provider = FirSymbolProvider.getInstance(session)
        for (import in imports) {
            val importedName = import.importedName ?: continue
@@ -36,26 +35,20 @@ abstract class FirAbstractSimpleImportingScope(
                import.resolvedClassId?.createNestedClassId(importedName)
                    ?: ClassId.topLevel(import.packageFqName.child(importedName))
            val symbol = provider.getClassLikeSymbolByFqName(classId) ?: continue
-            if (!processor(symbol)) {
-                return ProcessorAction.STOP
-            }
+            processor(symbol)
        }
-        return ProcessorAction.NEXT
    }

    override fun <T : FirCallableSymbol<*>> processCallables(
        name: Name,
        token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        val imports = simpleImports[name] ?: return ProcessorAction.NONE
-        if (imports.isEmpty()) return ProcessorAction.NONE
+        processor: (FirCallableSymbol<*>) -> Unit
+    ) {
+        val imports = simpleImports[name] ?: return
+        if (imports.isEmpty()) return

        for (import in imports) {
-            if (processCallables(import, import.importedName!!, token, processor).stop()) {
-                return ProcessorAction.STOP
-            }
+            processCallables(import, import.importedName!!, token, processor)
        }
-        return ProcessorAction.NEXT
    }
 }
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.ClassId
@@ -27,45 +26,39 @@ abstract class FirAbstractStarImportingScope(

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
        if (starImports.isEmpty() || name in absentClassifierNames) {
-            return ProcessorAction.NONE
+            return
        }
        var empty = true
        for (import in starImports) {
            val relativeClassName = import.relativeClassName
            val classId = when {
-                !name.isSpecial && name.identifier.isEmpty() -> return ProcessorAction.NEXT
+                !name.isSpecial && name.identifier.isEmpty() -> return
                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 ProcessorAction.STOP
-            }
+            processor(symbol)
        }
        if (empty) {
            absentClassifierNames += name
        }
-        return ProcessorAction.NEXT
    }


    override fun <T : FirCallableSymbol<*>> processCallables(
        name: Name,
        token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirCallableSymbol<*>) -> Unit
+    ) {
        if (starImports.isEmpty()) {
-            return ProcessorAction.NONE
+            return
        }
        for (import in starImports) {
-            if (processCallables(import, name, token, processor).stop()) {
-                return ProcessorAction.STOP
-            }
+            processCallables(import, name, token, processor)
        }
-        return ProcessorAction.NEXT
    }
 }
@@ -11,9 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-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
@@ -48,28 +45,26 @@ class FirClassDeclaredMemberScope(
        result
    }

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        val symbols = callablesIndex[name] ?: emptyList()
        for (symbol in symbols) {
-            if (symbol is FirFunctionSymbol<*> && !processor(symbol)) {
-                return STOP
+            if (symbol is FirFunctionSymbol<*>) {
+                processor(symbol)
            }
        }
-        return NEXT
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        val symbols = callablesIndex[name] ?: emptyList()
        for (symbol in symbols) {
-            if (symbol is FirVariableSymbol && !processor(symbol)) {
-                return STOP
+            if (symbol is FirVariableSymbol) {
+                processor(symbol)
            }
        }
-        return NEXT
    }

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction = nestedClassifierScope.processClassifiersByName(name, processor)
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) = nestedClassifierScope.processClassifiersByName(name, processor)
 }
@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorWithJump
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -44,7 +43,7 @@ class FirClassSubstitutionScope(
        substitution: Map<FirTypeParameterSymbol, ConeKotlinType>
    ) : this(session, useSiteMemberScope, scopeSession, substitutorByMap(substitution))

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        useSiteMemberScope.processFunctionsByName(name) process@{ original ->

            val function = fakeOverrideFunctions.getOrPut(original) { createFakeOverrideFunction(original) }
@@ -55,7 +54,7 @@ class FirClassSubstitutionScope(
        return super.processFunctionsByName(name, processor)
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        return useSiteMemberScope.processPropertiesByName(name) process@{ original ->
            when (original) {
                is FirPropertySymbol -> {
@@ -77,8 +76,8 @@ class FirClassSubstitutionScope(
        }
    }

-    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction {
-        return useSiteMemberScope.processClassifiersByName(name, processor)
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
+        useSiteMemberScope.processClassifiersByName(name, processor)
    }

    private val typeCalculator by lazy { ReturnTypeCalculatorWithJump(session, scopeSession) }
@@ -7,9 +7,6 @@ package org.jetbrains.kotlin.fir.scopes.impl

 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-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.name.Name

@@ -19,21 +16,18 @@ class FirClassUseSiteMemberScope(
    declaredMemberScope: FirScope
 ) : AbstractFirUseSiteMemberScope(session, FirStandardOverrideChecker(session), superTypesScope, declaredMemberScope) {

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        val seen = mutableSetOf<FirCallableSymbol<*>>()
-        if (!declaredMemberScope.processPropertiesByName(name) {
-                seen += it
-                processor(it)
-            }
-        ) return STOP
+        declaredMemberScope.processPropertiesByName(name) {
+            seen += it
+            processor(it)
+        }

-        return superTypesScope.processPropertiesByName(name) {

+        superTypesScope.processPropertiesByName(name) {
            val overriddenBy = it.getOverridden(seen)
            if (overriddenBy == null) {
                processor(it)
-            } else {
-                NEXT
            }
        }
    }
@@ -6,9 +6,6 @@
 package org.jetbrains.kotlin.fir.scopes.impl

 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-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
@@ -22,44 +19,35 @@ class FirCompositeScope(

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
        val scopes = if (reversedPriority) scopes.asReversed() else scopes
        for (scope in scopes) {
-            if (!scope.processClassifiersByName(name, processor)) {
-                return STOP
-            }
+            scope.processClassifiersByName(name, processor)
        }
-        return NEXT
    }

    private inline fun <T> processComposite(
-        process: FirScope.(Name, (T) -> ProcessorAction) -> ProcessorAction,
+        process: FirScope.(Name, (T) -> Unit) -> Unit,
        name: Name,
-        noinline processor: (T) -> ProcessorAction
-    ): ProcessorAction {
+        noinline processor: (T) -> Unit
+    ) {
        val unique = mutableSetOf<T>()
        val scopes = if (reversedPriority) scopes.asReversed() else scopes
        for (scope in scopes) {
-            if (!scope.process(name) {
-                    if (unique.add(it)) {
-                        processor(it)
-                    } else {
-                        NEXT
-                    }
+            scope.process(name) {
+                if (unique.add(it)) {
+                    processor(it)
                }
-            ) {
-                return STOP
            }
        }
-        return NEXT
    }

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        return processComposite(FirScope::processFunctionsByName, name, processor)
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        return processComposite(FirScope::processPropertiesByName, name, processor)
    }

@@ -20,11 +20,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.resolve.scopeSessionKey
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
@@ -114,19 +111,18 @@ class FirIntegerLiteralTypeScope(private val session: FirSession) : FirScope() {
        resolvePhase = FirResolvePhase.BODY_RESOLVE
    }

-    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction {
-        return ProcessorAction.NONE
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
+
    }

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        val symbol = BINARY_OPERATOR_SYMBOLS[name]
            ?: UNARY_OPERATOR_SYMBOLS[name]
-            ?: return ProcessorAction.NONE
-        return processor(symbol)
+            ?: return
+        processor(symbol)
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
-        return ProcessorAction.NONE
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
    }
 }

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.scopes.impl

 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 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
@@ -23,14 +22,14 @@ class FirLazyNestedClassifierScope(

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
        if (name !in existingNames) {
-            return ProcessorAction.NONE
+            return
        }
        val child = classId.createNestedClassId(name)
-        val symbol = symbolProvider.getClassLikeSymbolByFqName(child) ?: return ProcessorAction.NONE
+        val symbol = symbolProvider.getClassLikeSymbolByFqName(child) ?: return

-        return processor(symbol)
+        processor(symbol)
    }
 }
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.NAME_FOR_BACKING_FIELD
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name

@@ -30,27 +29,25 @@ class FirLocalScope : FirScope() {
        properties[NAME_FOR_BACKING_FIELD] = property.backingFieldSymbol
    }

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        val function = functions[name]
        if (function != null) {
-            return processor(function)
+            processor(function)
        }
-        return ProcessorAction.NONE
+
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        val property = properties[name]
        if (property != null) {
-            return processor(property)
+            processor(property)
        }
-        return ProcessorAction.NONE
    }

-    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
        val klass = classes[name]
        if (klass != null) {
-            return processor(klass)
+            processor(klass)
        }
-        return ProcessorAction.NONE
    }
 }
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 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.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.name.Name
@@ -27,9 +26,9 @@ class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope() {

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        val matchedClass = classIndex[name] ?: return ProcessorAction.NONE
-        return processor(matchedClass)
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
+        val matchedClass = classIndex[name] ?: return
+        processor(matchedClass)
    }
 }
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -27,9 +26,9 @@ class FirPackageMemberScope(val fqName: FqName, val session: FirSession) : FirSc

    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        if (name.asString().isEmpty()) return ProcessorAction.NONE
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
+        if (name.asString().isEmpty()) return


        val symbol = classifierCache.getOrPut(name) {
@@ -37,34 +36,30 @@ class FirPackageMemberScope(val fqName: FqName, val session: FirSession) : FirSc
            symbolProvider.getClassLikeSymbolByFqName(unambiguousFqName)
        }

-        return if (symbol != null) {
+        if (symbol != null) {
            processor(symbol)
-        } else {
-            ProcessorAction.NONE
        }
    }

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
        val symbols = callableCache.getOrPut(name) {
            symbolProvider.getTopLevelCallableSymbols(fqName, name)
        }
        for (symbol in symbols) {
-            if (symbol is FirFunctionSymbol<*> && !processor(symbol)) {
-                return ProcessorAction.STOP
+            if (symbol is FirFunctionSymbol<*>) {
+                processor(symbol)
            }
        }
-        return ProcessorAction.NEXT
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
        val symbols = callableCache.getOrPut(name) {
            symbolProvider.getTopLevelCallableSymbols(fqName, name)
        }
        for (symbol in symbols) {
-            if (symbol is FirPropertySymbol && !processor(symbol)) {
-                return ProcessorAction.STOP
+            if (symbol is FirPropertySymbol) {
+                processor(symbol)
            }
        }
-        return ProcessorAction.NEXT
    }
 }
@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.scopes.impl

 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -19,28 +18,26 @@ class FirQualifierScope(
 ) : FirScope() {
    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        return delegateClassifiersScope?.processClassifiersByName(name) {
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
+        delegateClassifiersScope?.processClassifiersByName(name) {
            if (it is FirRegularClassSymbol) {
                processor(it)
-            } else {
-                ProcessorAction.NEXT
            }
-        } ?: ProcessorAction.NEXT
+        }
    }

    override fun processFunctionsByName(
        name: Name,
-        processor: (FirFunctionSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        return delegateCallablesScope?.processFunctionsByName(name, processor) ?: ProcessorAction.NEXT
+        processor: (FirFunctionSymbol<*>) -> Unit
+    ) {
+        delegateCallablesScope?.processFunctionsByName(name, processor)
    }

    override fun processPropertiesByName(
        name: Name,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        return delegateCallablesScope?.processPropertiesByName(name, processor) ?: ProcessorAction.NEXT
+        processor: (FirCallableSymbol<*>) -> Unit
+    ) {
+        delegateCallablesScope?.processPropertiesByName(name, processor)
    }
 }
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.isStatic
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
@@ -18,26 +17,22 @@ class FirStaticScope(private val delegateScope: FirScope) : FirScope() {

    override fun processFunctionsByName(
        name: Name,
-        processor: (FirFunctionSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        return delegateScope.processFunctionsByName(name) {
+        processor: (FirFunctionSymbol<*>) -> Unit
+    ) {
+        delegateScope.processFunctionsByName(name) {
            if ((it.fir as? FirSimpleFunction)?.isStatic == true) {
                processor(it)
-            } else {
-                ProcessorAction.NEXT
            }
        }
    }

    override fun processPropertiesByName(
        name: Name,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
-        return delegateScope.processPropertiesByName(name) {
+        processor: (FirCallableSymbol<*>) -> Unit
+    ) {
+        delegateScope.processPropertiesByName(name) {
            if ((it.fir as? FirCallableMemberDeclaration<*>)?.isStatic == true) {
                processor(it)
-            } else {
-                ProcessorAction.NEXT
            }
        }
    }
@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.scopes.FirOverrideChecker
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
@@ -42,24 +41,26 @@ class FirSuperTypeScope private constructor(

    private val typeContext = ConeTypeCheckerContext(isErrorTypeEqualsToAnything = false, isStubTypeEqualsToAnything = false, session)

-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
-        processCallablesByName(name, processor, absentFunctions, FirScope::processFunctionsByName)?.let { return it }
-        return super.processFunctionsByName(name, processor)
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
+        if(!processCallablesByName(name, processor, absentFunctions, FirScope::processFunctionsByName)) {
+            super.processFunctionsByName(name, processor)
+        }
    }

-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
-        processCallablesByName(name, processor, absentProperties, FirScope::processPropertiesByName)?.let { return it }
-        return super.processPropertiesByName(name, processor)
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
+        if(!processCallablesByName(name, processor, absentProperties, FirScope::processPropertiesByName)) {
+            super.processPropertiesByName(name, processor)
+        }
    }

    private inline fun <D : FirCallableSymbol<*>> processCallablesByName(
        name: Name,
-        noinline processor: (D) -> ProcessorAction,
+        noinline processor: (D) -> Unit,
        absentNames: MutableSet<Name>,
-        processCallables: FirScope.(Name, (D) -> ProcessorAction) -> ProcessorAction
-    ): ProcessorAction? {
+        processCallables: FirScope.(Name, (D) -> Unit) -> Unit
+    ): Boolean {
        if (name in absentNames) {
-            return ProcessorAction.NONE
+            return false
        }

        val membersByScope = scopes.mapNotNull { scope ->
@@ -68,7 +69,6 @@ class FirSuperTypeScope private constructor(
                if (it !is FirConstructorSymbol) {
                    resultForScope.add(it)
                }
-                ProcessorAction.NEXT
            }

            resultForScope.takeIf { it.isNotEmpty() }
@@ -76,15 +76,15 @@ class FirSuperTypeScope private constructor(

        if (membersByScope.isEmpty()) {
            absentNames.add(name)
-            return ProcessorAction.NONE
+            return false
        }

        membersByScope.singleOrNull()?.let { members ->
            for (member in members) {
-                if (processor(member).stop()) return ProcessorAction.STOP
+                processor(member)
            }

-            return ProcessorAction.NEXT
+            return false
        }

        val allMembers = membersByScope.flattenTo(LinkedList())
@@ -95,10 +95,10 @@ class FirSuperTypeScope private constructor(

            val mostSpecific = selectMostSpecificMember(extractedOverrides)

-            if (processor(mostSpecific).stop()) return ProcessorAction.STOP
+            processor(mostSpecific)
        }

-        return null
+        return true
    }

    private fun <D : FirCallableSymbol<*>> selectMostSpecificMember(
@@ -217,25 +217,20 @@ class FirSuperTypeScope private constructor(
        return result
    }

-    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
        if (name in absentClassifiers) {
-            return ProcessorAction.NEXT
+            return
        }
        val accepted = HashSet<FirClassifierSymbol<*>>()
        val pending = mutableListOf<FirClassifierSymbol<*>>()
        var empty = true
        for (scope in scopes) {
-            if (scope.processClassifiersByName(name) {
-                    empty = false
-                    if (it !in accepted) {
-                        pending += it
-                        processor(it)
-                    } else {
-                        ProcessorAction.NEXT
-                    }
-                }.stop()
-            ) {
-                return ProcessorAction.STOP
+            scope.processClassifiersByName(name) {
+                empty = false
+                if (it !in accepted) {
+                    pending += it
+                    processor(it)
+                }
            }
            accepted += pending
            pending.clear()
@@ -243,7 +238,7 @@ class FirSuperTypeScope private constructor(
        if (empty) {
            absentClassifiers += name
        }
-        return super.processClassifiersByName(name, processor)
+        super.processClassifiersByName(name, processor)
    }

    companion object {
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStack
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitExtensionReceiverValue
 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.Name

@@ -19,24 +18,17 @@ class FirTypeResolveScopeForBodyResolve(
 ) : FirScope() {
    override fun processClassifiersByName(
        name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
-    ): ProcessorAction {
+        processor: (FirClassifierSymbol<*>) -> Unit
+    ) {
        for (scope in localScopes.asReversed()) {
-            if (!scope.processClassifiersByName(name, processor)) {
-                return ProcessorAction.STOP
-            }
+            scope.processClassifiersByName(name, processor)
        }
        for (receiverValue in implicitReceiverStack.receiversAsReversed()) {
            if (receiverValue is ImplicitExtensionReceiverValue) continue
-            if (receiverValue.implicitScope?.processClassifiersByName(name, processor) == ProcessorAction.STOP) {
-                return ProcessorAction.STOP
-            }
+            receiverValue.implicitScope?.processClassifiersByName(name, processor)
        }
        for (scope in topLevelScopes.asReversed()) {
-            if (!scope.processClassifiersByName(name, processor)) {
-                return ProcessorAction.STOP
-            }
+            scope.processClassifiersByName(name, processor)
        }
-        return ProcessorAction.NEXT
    }
 }
@@ -34,7 +34,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -196,7 +195,6 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                                        renderer.newLine()
                                        renderedDeclarations += enhanced
                                    }
-                                    ProcessorAction.NEXT
                                }
                                is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol ->
                                    val enhanced = symbol.fir
@@ -205,7 +203,6 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                                        renderer.newLine()
                                        renderedDeclarations += enhanced
                                    }
-                                    ProcessorAction.NEXT
                                }
                                is FirJavaField -> enhancementScope.processPropertiesByName(declaration.name) { symbol ->
                                    val enhanced = symbol.fir
@@ -214,7 +211,6 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                                        renderer.newLine()
                                        renderedDeclarations += enhanced
                                    }
-                                    ProcessorAction.NEXT
                                }
                                else -> {
                                    declaration.accept(renderer, null)