[FIR] Get rid of processors in FirScope

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

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.fir.resolve.calls.SyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.IntegerLiteralTypeApproximationTransformer
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperator
 import org.jetbrains.kotlin.fir.symbols.AccessorSymbol
@@ -217,7 +216,6 @@ class Fir2IrVisitor(
             if (name in processedCallableNames) continue
             processedCallableNames += name
             useSiteMemberScope.processFunctionsByName(name) { functionSymbol ->
-                // TODO: think about overloaded functions. May be we should process all names.
                 if (functionSymbol is FirNamedFunctionSymbol) {
                     val originalFunction = functionSymbol.fir
                     val origin = IrDeclarationOrigin.FAKE_OVERRIDE
@@ -244,7 +242,6 @@ class Fir2IrVisitor(
                         }
                     }
                 }
-                ProcessorAction.STOP
             }
             useSiteMemberScope.processPropertiesByName(name) { propertySymbol ->
                 if (propertySymbol is FirPropertySymbol) {
@@ -273,7 +270,6 @@ class Fir2IrVisitor(
                         }
                     }
                 }
-                ProcessorAction.STOP
             }
         }
     }
@@ -442,12 +438,10 @@ class Fir2IrVisitor(
             classId.shortClassName
         ) {
             when {
-                it !is FirConstructorSymbol -> ProcessorAction.NEXT
+                it !is FirConstructorSymbol -> {}
-                arguments.size <= it.fir.valueParameters.size -> {
+                arguments.size <= it.fir.valueParameters.size && constructorSymbol == null -> {
                     constructorSymbol = it
-                    ProcessorAction.STOP
                 }
-                else -> ProcessorAction.NEXT
             }
         }
         val foundConstructorSymbol = constructorSymbol ?: return null

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.java.enhancement.*
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.jvm.computeJvmDescriptor
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -52,7 +51,7 @@ class JavaClassEnhancementScope(
 
     private val enhancements = mutableMapOf<FirCallableSymbol<*>, FirCallableSymbol<*>>()
 
-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
         useSiteMemberScope.processPropertiesByName(name) process@{ original ->
 
             val field = enhancements.getOrPut(original) { enhance(original, name) }
@@ -62,7 +61,7 @@ class JavaClassEnhancementScope(
         return super.processPropertiesByName(name, processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
         useSiteMemberScope.processFunctionsByName(name) process@{ original ->
 
             val function = enhancements.getOrPut(original) { enhance(original, name) }
@@ -72,8 +71,8 @@ class JavaClassEnhancementScope(
         return super.processFunctionsByName(name, processor)
     }
 
-    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
-        return useSiteMemberScope.processClassifiersByName(name, processor)
+        useSiteMemberScope.processClassifiersByName(name, processor)
     }
 
     private fun enhance(

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

@@ -16,9 +16,6 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope
 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.scopes.impl.AbstractFirUseSiteMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
@@ -45,13 +42,9 @@ class JavaClassUseSiteMemberScope(
         val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
         declaredMemberScope.processFunctionsByName(name) {
             overrideCandidates += it
-            NEXT
         }
-
-
         superTypesScope.processFunctionsByName(name) {
             it.getOverridden(overrideCandidates)
-            NEXT
         }
     }
 
@@ -90,15 +83,15 @@ class JavaClassUseSiteMemberScope(
         propertyName: Name,
         getterNames: List<Name>,
         setterName: Name?,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ): Unit {
         val overrideCandidates = mutableSetOf<FirCallableSymbol<*>>()
         val klass = symbol.fir
-        if (!declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol ->
+        declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol ->
-                overrideCandidates += variableSymbol
+            overrideCandidates += variableSymbol
-                processor(variableSymbol)
+            processor(variableSymbol)
-            }
+        }
-        ) return STOP
+
         if (klass is FirJavaClass) {
             for (getterName in getterNames) {
                 declaredMemberScope.processFunctionsByName(getterName) { functionSymbol ->
@@ -109,12 +102,11 @@ class JavaClassUseSiteMemberScope(
                         // NB: accessor should not be processed directly unless we find matching property symbol in supertype
                         overrideCandidates += accessorSymbol
                     }
-                    NEXT
                 }
             }
         }
 
-        return superTypesScope.processPropertiesByName(propertyName) {
+        superTypesScope.processPropertiesByName(propertyName) {
             val firCallableMember = it.fir as? FirCallableMemberDeclaration<*>
             if (firCallableMember?.isStatic == true) {
                 processor(it)
@@ -122,7 +114,6 @@ class JavaClassUseSiteMemberScope(
                 when (val overriddenBy = it.getOverridden(overrideCandidates)) {
                     null -> processor(it)
                     is FirAccessorSymbol -> processor(overriddenBy)
-                    else -> NEXT
                 }
             }
         }
@@ -153,7 +144,7 @@ class JavaClassUseSiteMemberScope(
         )
     }
 
-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
         // Do not generate accessors at all?
         if (name.isSpecial) {
             return processAccessorFunctionsAndPropertiesByName(name, emptyList(), null, processor)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.jvm
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSettings
 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.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -20,28 +19,26 @@ class JvmMappedScope(
     private val whiteListSignaturesByName: Map<Name, List<String>>
 ) : FirScope() {
 
-    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
         val whiteListSignatures = whiteListSignaturesByName[name]
             ?: return declaredMemberScope.processFunctionsByName(name, processor)
-        if (!javaMappedClassUseSiteScope.processFunctionsByName(name) { symbol ->
+        javaMappedClassUseSiteScope.processFunctionsByName(name) { symbol ->
-                val jvmSignature = symbol.fir.computeJvmDescriptor()
+            val jvmSignature = symbol.fir.computeJvmDescriptor()
-                if (jvmSignature !in whiteListSignatures) {
+            if (jvmSignature in whiteListSignatures) {
-                    ProcessorAction.NEXT
+                processor(symbol)
-                } else {
-                    processor(symbol)
-                }
             }
-        ) return ProcessorAction.STOP
+        }
 
-        return declaredMemberScope.processFunctionsByName(name, processor)
+
+        declaredMemberScope.processFunctionsByName(name, processor)
     }
 
-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
-        return declaredMemberScope.processPropertiesByName(name, processor)
+        declaredMemberScope.processPropertiesByName(name, processor)
     }
 
-    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
-        return declaredMemberScope.processClassifiersByName(name, processor)
+        declaredMemberScope.processClassifiersByName(name, processor)
     }
 
     companion object {

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

@@ -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)
     }

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

@@ -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)

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

@@ -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
             }
         }
     }

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

@@ -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
+    processor: (FirCallableSymbol<*>) -> Unit
-): ProcessorAction {
+) {
+    // TODO: Handle case with two or more accessible classifiers
     val matchedClassSymbol = getFirstClassifierOrNull(name) as? FirClassLikeSymbol<*>
 
-    if (processConstructors(
+    processConstructors(
-            matchedClassSymbol,
+        matchedClassSymbol,
-            processor,
+        processor,
-            session,
+        session,
-            bodyResolveComponents.scopeSession,
+        bodyResolveComponents.scopeSession,
-            name,
+        name,
             noInnerConstructors
-        ).stop()
+        )
-    ) {
-        return ProcessorAction.STOP
-    }
 
-    if (processSyntheticConstructors(
+    processSyntheticConstructors(
-            matchedClassSymbol,
+        matchedClassSymbol,
-            processor,
+        processor,
-            bodyResolveComponents
+        bodyResolveComponents
-        ).stop()
+    )
-    ) {
-        return ProcessorAction.STOP
-    }
 
-    return processFunctionsByName(name) {
+    processFunctionsByName(name) {
-        if (it is FirConstructorSymbol) ProcessorAction.NEXT
+        if (it !is FirConstructorSymbol) {
-        else processor(it)
+            processor(it)
+        }
     }
 }
 
 private fun FirScope.getFirstClassifierOrNull(name: Name): FirClassifierSymbol<*>? {
     var result: FirClassifierSymbol<*>? = null
     processClassifiersByName(name) {
-        result = it
+        if (result == null) {
-        ProcessorAction.STOP
+            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)
+    if (samConstructor != null) {
-
+        processor(samConstructor.symbol)
-    return ProcessorAction.NEXT
+    }
 }
 
 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) {
+            scope?.processFunctionsByName(constructorName) {
-                    if (!noInner || (it as? FirConstructorSymbol)?.fir?.isInner != true) {
+                if (!noInner || (it as? FirConstructorSymbol)?.fir?.isInner != true) {
-                        processor(it)
+                    processor(it)
-                    } else {
+                }
-                        ProcessorAction.NEXT
-                    }
-                } == ProcessorAction.STOP
-            ) {
-                return ProcessorAction.STOP
             }
         }
-        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 {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
-        return delegatingScope.processFunctionsByName(name) {
+        delegatingScope.processFunctionsByName(name) {
             val toProcess = if (it is FirConstructorSymbol) {
                 typeAliasConstructorsSubstitutor.substitute(it.fir).symbol
             } else {

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

@@ -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()) {

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

@@ -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
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        val fir = symbol.fir as? FirSimpleFunction ?: return ProcessorAction.NEXT
+        val fir = symbol.fir as? FirSimpleFunction ?: return
 
-        if (fir.typeParameters.isNotEmpty()) return ProcessorAction.NEXT
+        if (fir.typeParameters.isNotEmpty()) return
-        if (fir.valueParameters.isNotEmpty()) return ProcessorAction.NEXT
+        if (fir.valueParameters.isNotEmpty()) return
-        if (fir.isStatic) return ProcessorAction.NEXT
+        if (fir.isStatic) return
-        if (fir.returnTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == StandardClassIds.Unit) return ProcessorAction.NEXT
+        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) {
+            baseScope.processFunctionsByName(getterName) {
-                    checkGetAndCreateSynthetic(name, it, processor)
+                checkGetAndCreateSynthetic(name, it, processor)
-                }.stop()
+            }
-            ) return ProcessorAction.STOP
         }
-        return ProcessorAction.NEXT
     }
 
     companion object {

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

@@ -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
         }
     }
 }

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

@@ -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
+        processScopeMembers: FirScope.(processor: (T) -> Unit) -> Unit
-    ): ProcessorAction {
+    ) {
-        if (implicitExtensionReceiver != null && explicitExtensionReceiver != null) return ProcessorAction.NEXT
+        if (implicitExtensionReceiver != null && explicitExtensionReceiver != null) return
         val extensionReceiver = implicitExtensionReceiver ?: explicitExtensionReceiver
-        val scope = dispatchReceiver.scope(session, scopeSession) ?: return ProcessorAction.NEXT
+        val scope = dispatchReceiver.scope(session, scopeSession) ?: return
-        if (scope.processScopeMembers { candidate ->
+        scope.processScopeMembers { candidate ->
-                if (candidate is FirCallableSymbol<*> &&
+            if (candidate is FirCallableSymbol<*> &&
-                    (implicitExtensionInvokeMode || candidate.hasConsistentExtensionReceiver(extensionReceiver))
+                (implicitExtensionInvokeMode || candidate.hasConsistentExtensionReceiver(extensionReceiver))
-                ) {
+            ) {
-                    val dispatchReceiverValue = NotNullableReceiverValue(dispatchReceiver)
+                val dispatchReceiverValue = NotNullableReceiverValue(dispatchReceiver)
-                    if (implicitExtensionInvokeMode) {
+                if (implicitExtensionInvokeMode) {
-                        if (output.consumeCandidate(
+                    output.consumeCandidate(
-                                candidate, dispatchReceiverValue,
+                        candidate, dispatchReceiverValue,
-                                implicitExtensionReceiverValue = implicitExtensionReceiver
+                        implicitExtensionReceiverValue = implicitExtensionReceiver
-                            ).stop()
+                    )
-                        ) {
+                    output.consumeCandidate(
-                            ProcessorAction.STOP
+                        candidate, dispatchReceiverValue,
-                        } else {
+                        implicitExtensionReceiverValue = null,
-                            output.consumeCandidate(
+                        builtInExtensionFunctionReceiverValue = implicitExtensionReceiver
-                                candidate, dispatchReceiverValue,
+                    )
-                                implicitExtensionReceiverValue = null,
-                                builtInExtensionFunctionReceiverValue = implicitExtensionReceiver
-                            )
-                        }
-                    } else {
-                        output.consumeCandidate(candidate, dispatchReceiverValue, implicitExtensionReceiver, null)
-                    }
-                } else if (candidate is FirClassLikeSymbol<*>) {
-                    output.consumeCandidate(candidate, null, implicitExtensionReceiver, null)
                 } else {
-                    ProcessorAction.NEXT
+                    output.consumeCandidate(candidate, dispatchReceiverValue, implicitExtensionReceiver, null)
                 }
-            }.stop()
+            } else if (candidate is FirClassLikeSymbol<*>) {
-        ) return ProcessorAction.STOP
+                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
     }
 }
 

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

@@ -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

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
         for (scope in scopes) {
-            if (!scope.processClassifiersByName(name, processor)) {
+            scope.processClassifiersByName(name, processor)
-                return ProcessorAction.STOP
-            }
         }
-        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
+        noinline processor: (T) -> Unit
-    ): ProcessorAction {
+    ) {
         val unique = mutableSetOf<T>()
         for (scope in scopes) {
-            if (!scope.process(name) {
+            scope.process(name) {
-                    if (unique.add(it)) {
+                if (unique.add(it)) {
-                        processor(it)
+                    processor(it)
-                    } else {
-                        ProcessorAction.NEXT
-                    }
                 }
-            ) {
-                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)
     }
 }

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

@@ -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

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

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

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

@@ -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) {
+        declaredMemberScope.processFunctionsByName(name) {
-                val symbol = processInheritedDefaultParameters(it)
+            val symbol = processInheritedDefaultParameters(it)
-                overrideCandidates += symbol
+            overrideCandidates += symbol
-                add(symbol)
+            add(symbol)
-                ProcessorAction.NEXT
+        }
-            }
-        ) return@apply
 
         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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        if (!declaredMemberScope.processClassifiersByName(name, processor)) {
+        declaredMemberScope.processClassifiersByName(name, processor)
-            return ProcessorAction.STOP
+        superTypesScope.processClassifiersByName(name, processor)
-        }
-        return superTypesScope.processClassifiersByName(name, processor)
     }
 }

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

@@ -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
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ): 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
 
-
+            when (token) {
-            val action = 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()) {
+                processor(symbol)
-                    return ProcessorAction.STOP
-                }
             }
         }
 
-        return ProcessorAction.NEXT
     }
 
     abstract fun <T : FirCallableSymbol<*>> processCallables(
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction
+    )
 
-    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) }
     }
 
 }

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        val imports = simpleImports[name] ?: return ProcessorAction.NONE
+        val imports = simpleImports[name] ?: return
-        if (imports.isEmpty()) return ProcessorAction.NONE
+        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)) {
+            processor(symbol)
-                return ProcessorAction.STOP
-            }
         }
-        return ProcessorAction.NEXT
     }
 
     override fun <T : FirCallableSymbol<*>> processCallables(
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        val imports = simpleImports[name] ?: return ProcessorAction.NONE
+        val imports = simpleImports[name] ?: return
-        if (imports.isEmpty()) return ProcessorAction.NONE
+        if (imports.isEmpty()) return
 
         for (import in imports) {
-            if (processCallables(import, import.importedName!!, token, processor).stop()) {
+            processCallables(import, import.importedName!!, token, processor)
-                return ProcessorAction.STOP
-            }
         }
-        return ProcessorAction.NEXT
     }
 }

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
         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)) {
+            processor(symbol)
-                return ProcessorAction.STOP
-            }
         }
         if (empty) {
             absentClassifierNames += name
         }
-        return ProcessorAction.NEXT
     }
 
 
     override fun <T : FirCallableSymbol<*>> processCallables(
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
         if (starImports.isEmpty()) {
-            return ProcessorAction.NONE
+            return
         }
         for (import in starImports) {
-            if (processCallables(import, name, token, processor).stop()) {
+            processCallables(import, name, token, processor)
-                return ProcessorAction.STOP
-            }
         }
-        return ProcessorAction.NEXT
     }
 }

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

@@ -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)) {
+            if (symbol is FirFunctionSymbol<*>) {
-                return STOP
+                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)) {
+            if (symbol is FirVariableSymbol) {
-                return STOP
+                processor(symbol)
             }
         }
-        return NEXT
     }
 
     override fun processClassifiersByName(
         name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction = nestedClassifierScope.processClassifiersByName(name, processor)
+    ) = nestedClassifierScope.processClassifiersByName(name, processor)
 }

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

@@ -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 {
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
-        return useSiteMemberScope.processClassifiersByName(name, processor)
+        useSiteMemberScope.processClassifiersByName(name, processor)
     }
 
     private val typeCalculator by lazy { ReturnTypeCalculatorWithJump(session, scopeSession) }

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

@@ -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) {
+        declaredMemberScope.processPropertiesByName(name) {
-                seen += it
+            seen += it
-                processor(it)
+            processor(it)
-            }
+        }
-        ) return STOP
 
-        return superTypesScope.processPropertiesByName(name) {
 
+        superTypesScope.processPropertiesByName(name) {
             val overriddenBy = it.getOverridden(seen)
             if (overriddenBy == null) {
                 processor(it)
-            } else {
-                NEXT
             }
         }
     }

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
         val scopes = if (reversedPriority) scopes.asReversed() else scopes
         for (scope in scopes) {
-            if (!scope.processClassifiersByName(name, processor)) {
+            scope.processClassifiersByName(name, processor)
-                return STOP
-            }
         }
-        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
+        noinline processor: (T) -> Unit
-    ): ProcessorAction {
+    ) {
         val unique = mutableSetOf<T>()
         val scopes = if (reversedPriority) scopes.asReversed() else scopes
         for (scope in scopes) {
-            if (!scope.process(name) {
+            scope.process(name) {
-                    if (unique.add(it)) {
+                if (unique.add(it)) {
-                        processor(it)
+                    processor(it)
-                    } else {
-                        NEXT
-                    }
                 }
-            ) {
-                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)
     }
 

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

@@ -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 {
+    override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) {
-        return ProcessorAction.NONE
+
     }
 
-    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
-        return processor(symbol)
+        processor(symbol)
     }
 
-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
-        return ProcessorAction.NONE
     }
 }
 

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
         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)
     }
 }

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

@@ -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
     }
 }

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        val matchedClass = classIndex[name] ?: return ProcessorAction.NONE
+        val matchedClass = classIndex[name] ?: return
-        return processor(matchedClass)
+        processor(matchedClass)
     }
 }

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        if (name.asString().isEmpty()) return ProcessorAction.NONE
+        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)) {
+            if (symbol is FirFunctionSymbol<*>) {
-                return ProcessorAction.STOP
+                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)) {
+            if (symbol is FirPropertySymbol) {
-                return ProcessorAction.STOP
+                processor(symbol)
             }
         }
-        return ProcessorAction.NEXT
     }
 }

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        return delegateClassifiersScope?.processClassifiersByName(name) {
+        delegateClassifiersScope?.processClassifiersByName(name) {
             if (it is FirRegularClassSymbol) {
                 processor(it)
-            } else {
-                ProcessorAction.NEXT
             }
-        } ?: ProcessorAction.NEXT
+        }
     }
 
     override fun processFunctionsByName(
         name: Name,
-        processor: (FirFunctionSymbol<*>) -> ProcessorAction
+        processor: (FirFunctionSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        return delegateCallablesScope?.processFunctionsByName(name, processor) ?: ProcessorAction.NEXT
+        delegateCallablesScope?.processFunctionsByName(name, processor)
     }
 
     override fun processPropertiesByName(
         name: Name,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        return delegateCallablesScope?.processPropertiesByName(name, processor) ?: ProcessorAction.NEXT
+        delegateCallablesScope?.processPropertiesByName(name, processor)
     }
 }

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

@@ -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
+        processor: (FirFunctionSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        return delegateScope.processFunctionsByName(name) {
+        delegateScope.processFunctionsByName(name) {
             if ((it.fir as? FirSimpleFunction)?.isStatic == true) {
                 processor(it)
-            } else {
-                ProcessorAction.NEXT
             }
         }
     }
 
     override fun processPropertiesByName(
         name: Name,
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
-        return delegateScope.processPropertiesByName(name) {
+        delegateScope.processPropertiesByName(name) {
             if ((it.fir as? FirCallableMemberDeclaration<*>)?.isStatic == true) {
                 processor(it)
-            } else {
-                ProcessorAction.NEXT
             }
         }
     }

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

@@ -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 {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
-        processCallablesByName(name, processor, absentFunctions, FirScope::processFunctionsByName)?.let { return it }
+        if(!processCallablesByName(name, processor, absentFunctions, FirScope::processFunctionsByName)) {
-        return super.processFunctionsByName(name, processor)
+            super.processFunctionsByName(name, processor)
+        }
     }
 
-    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) {
-        processCallablesByName(name, processor, absentProperties, FirScope::processPropertiesByName)?.let { return it }
+        if(!processCallablesByName(name, processor, absentProperties, FirScope::processPropertiesByName)) {
-        return super.processPropertiesByName(name, processor)
+            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
+        processCallables: FirScope.(Name, (D) -> Unit) -> Unit
-    ): ProcessorAction? {
+    ): 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) {
+            scope.processClassifiersByName(name) {
-                    empty = false
+                empty = false
-                    if (it !in accepted) {
+                if (it !in accepted) {
-                        pending += it
+                    pending += it
-                        processor(it)
+                    processor(it)
-                    } else {
+                }
-                        ProcessorAction.NEXT
-                    }
-                }.stop()
-            ) {
-                return ProcessorAction.STOP
             }
             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 {

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

@@ -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
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction {
+    ) {
         for (scope in localScopes.asReversed()) {
-            if (!scope.processClassifiersByName(name, processor)) {
+            scope.processClassifiersByName(name, processor)
-                return ProcessorAction.STOP
-            }
         }
         for (receiverValue in implicitReceiverStack.receiversAsReversed()) {
             if (receiverValue is ImplicitExtensionReceiverValue) continue
-            if (receiverValue.implicitScope?.processClassifiersByName(name, processor) == ProcessorAction.STOP) {
+            receiverValue.implicitScope?.processClassifiersByName(name, processor)
-                return ProcessorAction.STOP
-            }
         }
         for (scope in topLevelScopes.asReversed()) {
-            if (!scope.processClassifiersByName(name, processor)) {
+            scope.processClassifiersByName(name, processor)
-                return ProcessorAction.STOP
-            }
         }
-        return ProcessorAction.NEXT
     }
 }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -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)

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.scopes
 
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -14,19 +13,19 @@ import org.jetbrains.kotlin.name.Name
 abstract class FirScope {
     open fun processClassifiersByName(
         name: Name,
-        processor: (FirClassifierSymbol<*>) -> ProcessorAction
+        processor: (FirClassifierSymbol<*>) -> Unit
-    ): ProcessorAction = NEXT
+    ) {}
 
     open fun processFunctionsByName(
         name: Name,
-        processor: (FirFunctionSymbol<*>) -> ProcessorAction
+        processor: (FirFunctionSymbol<*>) -> Unit
-    ): ProcessorAction = NEXT
+    ) {}
 
     open fun processPropertiesByName(
         name: Name,
         // NB: it'd be great to write FirVariableSymbol<*> here, but there is FirAccessorSymbol :(
-        processor: (FirCallableSymbol<*>) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> Unit
-    ): ProcessorAction = NEXT
+    ) {}
 }
 
 enum class ProcessorAction {

compiler/testData/ir/irText/expressions/kt30020.fir.txt

@@ -111,12 +111,23 @@ FILE fqName:<root> fileName:/kt30020.kt
         public abstract fun add (element: E of kotlin.collections.MutableList): kotlin.Boolean declared in kotlin.collections.MutableList
       $this: VALUE_PARAMETER name:<this> type:kotlin.collections.MutableList
       VALUE_PARAMETER name:element index:0 type:kotlin.Int
+    FUN FAKE_OVERRIDE name:add visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, index:kotlin.Int, element:kotlin.Int) returnType:kotlin.Unit [fake_override]
+      overridden:
+        public abstract fun add (index: kotlin.Int, element: E of kotlin.collections.MutableList): kotlin.Unit declared in kotlin.collections.MutableList
+      $this: VALUE_PARAMETER name:<this> type:kotlin.collections.MutableList
+      VALUE_PARAMETER name:index index:0 type:kotlin.Int
+      VALUE_PARAMETER name:element index:1 type:kotlin.Int
     FUN FAKE_OVERRIDE name:addAll visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, index:kotlin.Int, elements:kotlin.collections.Collection<kotlin.Int>) returnType:kotlin.Boolean [fake_override]
       overridden:
         public abstract fun addAll (index: kotlin.Int, elements: kotlin.collections.Collection<E of kotlin.collections.MutableList>): kotlin.Boolean declared in kotlin.collections.MutableList
       $this: VALUE_PARAMETER name:<this> type:kotlin.collections.MutableList
       VALUE_PARAMETER name:index index:0 type:kotlin.Int
       VALUE_PARAMETER name:elements index:1 type:kotlin.collections.Collection<kotlin.Int>
+    FUN FAKE_OVERRIDE name:addAll visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, elements:kotlin.collections.Collection<kotlin.Int>) returnType:kotlin.Boolean [fake_override]
+      overridden:
+        public abstract fun addAll (elements: kotlin.collections.Collection<E of kotlin.collections.MutableList>): kotlin.Boolean declared in kotlin.collections.MutableList
+      $this: VALUE_PARAMETER name:<this> type:kotlin.collections.MutableList
+      VALUE_PARAMETER name:elements index:0 type:kotlin.collections.Collection<kotlin.Int>
     FUN FAKE_OVERRIDE name:clear visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList) returnType:kotlin.Unit [fake_override]
       overridden:
         public abstract fun clear (): kotlin.Unit declared in kotlin.collections.MutableList
@@ -125,6 +136,11 @@ FILE fqName:<root> fileName:/kt30020.kt
       overridden:
         public abstract fun listIterator (): kotlin.collections.MutableListIterator<E of kotlin.collections.MutableList> declared in kotlin.collections.MutableList
       $this: VALUE_PARAMETER name:<this> type:kotlin.collections.MutableList
+    FUN FAKE_OVERRIDE name:listIterator visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, index:kotlin.Int) returnType:kotlin.collections.MutableListIterator<kotlin.Int> [fake_override]
+      overridden:
+        public abstract fun listIterator (index: kotlin.Int): kotlin.collections.MutableListIterator<E of kotlin.collections.MutableList> declared in kotlin.collections.MutableList
+      $this: VALUE_PARAMETER name:<this> type:kotlin.collections.MutableList
+      VALUE_PARAMETER name:index index:0 type:kotlin.Int
     FUN FAKE_OVERRIDE name:remove visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, element:kotlin.Int) returnType:kotlin.Boolean [fake_override]
       overridden:
         public abstract fun remove (element: E of kotlin.collections.MutableList): kotlin.Boolean declared in kotlin.collections.MutableList

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.getClassDeclaredCallableSymbols
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.runResolve
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -55,11 +54,8 @@ private fun FirFile.findCallableMember(
     var result: FirCallableDeclaration<*>? = null
     val processor = { symbol: FirCallableSymbol<*> ->
         val fir = symbol.fir
-        if (fir.psi == callableMember) {
+        if (result == null && fir.psi == callableMember) {
             result = fir
-            ProcessorAction.STOP
-        } else {
-            ProcessorAction.NEXT
         }
     }
     if (callableMember is KtNamedFunction || callableMember is KtConstructor<*>) {

idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
@@ -180,7 +179,6 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
                                             renderer.newLine()
                                             renderedDeclarations += enhanced
                                         }
-                                        ProcessorAction.NEXT
                                     }
                                 }
                             }