diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index 136dd70509f..aad1c464d07 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/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 - arguments.size <= it.fir.valueParameters.size -> { + it !is FirConstructorSymbol -> {} + arguments.size <= it.fir.valueParameters.size && constructorSymbol == null -> { constructorSymbol = it - ProcessorAction.STOP } - else -> ProcessorAction.NEXT } } val foundConstructorSymbol = constructorSymbol ?: return null diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt index 0108ce3fd87..12dabe873ee 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt +++ b/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<*>>() - 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 { - return useSiteMemberScope.processClassifiersByName(name, processor) + override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) { + useSiteMemberScope.processClassifiersByName(name, processor) } private fun enhance( diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt index a6bb8ec3283..bac20c04d31 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt +++ b/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>() declaredMemberScope.processFunctionsByName(name) { overrideCandidates += it - NEXT } - - superTypesScope.processFunctionsByName(name) { it.getOverridden(overrideCandidates) - NEXT } } @@ -90,15 +83,15 @@ class JavaClassUseSiteMemberScope( propertyName: Name, getterNames: List, setterName: Name?, - processor: (FirCallableSymbol<*>) -> ProcessorAction - ): ProcessorAction { + processor: (FirCallableSymbol<*>) -> Unit + ): Unit { val overrideCandidates = mutableSetOf>() val klass = symbol.fir - if (!declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol -> - overrideCandidates += variableSymbol - processor(variableSymbol) - } - ) return STOP + declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol -> + overrideCandidates += variableSymbol + processor(variableSymbol) + } + 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) diff --git a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt index e9ae6c4f394..e1412094e42 100644 --- a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt +++ b/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> ) : 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 -> - val jvmSignature = symbol.fir.computeJvmDescriptor() - if (jvmSignature !in whiteListSignatures) { - ProcessorAction.NEXT - } else { - processor(symbol) - } + javaMappedClassUseSiteScope.processFunctionsByName(name) { symbol -> + val jvmSignature = symbol.fir.computeJvmDescriptor() + if (jvmSignature in whiteListSignatures) { + processor(symbol) } - ) return ProcessorAction.STOP + } - return declaredMemberScope.processFunctionsByName(name, processor) + + declaredMemberScope.processFunctionsByName(name, processor) } - override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { - return declaredMemberScope.processPropertiesByName(name, processor) + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> Unit) { + declaredMemberScope.processPropertiesByName(name, processor) } - override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> ProcessorAction): ProcessorAction { - return declaredMemberScope.processClassifiersByName(name, processor) + override fun processClassifiersByName(name: Name, processor: (FirClassifierSymbol<*>) -> Unit) { + declaredMemberScope.processClassifiersByName(name, processor) } companion object { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 6f7bbdd878b..66108c62337 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt index caaf3209b4f..fb858d9b788 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt +++ b/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>() - val processor: (FirCallableSymbol<*>) -> ProcessorAction = { + val processor: (FirCallableSymbol<*>) -> Unit = { result.add(it) - ProcessorAction.NEXT } declaredMemberScope.processFunctionsByName(name, processor) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt index 7f0fc643afd..1181009d929 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt +++ b/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 } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt index dbc52f7e434..e3dcd5513b6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt +++ b/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 -): 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, 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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt index 1560f0fe44c..2e4493590eb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt +++ b/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()) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt index a9ab376ac3c..cda94f5d1de 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt +++ b/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 - ): 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()?.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()?.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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerDataConsumers.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerDataConsumers.kt index 94ab40d11f8..146e4a74c3e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerDataConsumers.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerDataConsumers.kt @@ -159,7 +159,7 @@ class ExplicitReceiverTowerDataConsumer>( dispatchReceiverValue: ReceiverValue?, implicitExtensionReceiverValue: ImplicitReceiverValue<*>?, builtInExtensionFunctionReceiverValue: ReceiverValue? - ): ProcessorAction { + ) { resultCollector.consumeCandidate( group, candidateFactory.createCandidate( @@ -170,7 +170,6 @@ class ExplicitReceiverTowerDataConsumer>( builtInExtensionFunctionReceiverValue ) ) - return ProcessorAction.NEXT } } @@ -180,7 +179,7 @@ class ExplicitReceiverTowerDataConsumer>( 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>( ) ) ) { - return ProcessorAction.NEXT + return } } } @@ -214,7 +213,6 @@ class ExplicitReceiverTowerDataConsumer>( group, candidate ) - return ProcessorAction.NEXT } } } @@ -252,7 +250,7 @@ class NoExplicitReceiverTowerDataConsumer>( dispatchReceiverValue: ReceiverValue?, implicitExtensionReceiverValue: ImplicitReceiverValue<*>?, builtInExtensionFunctionReceiverValue: ReceiverValue? - ): ProcessorAction { + ) { resultCollector.consumeCandidate( group, candidateFactory.createCandidate( @@ -263,7 +261,6 @@ class NoExplicitReceiverTowerDataConsumer>( builtInExtensionFunctionReceiverValue ) ) - return ProcessorAction.NEXT } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt index 4a729dff622..255573f6164 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt +++ b/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 > processMembers( output: TowerScopeLevel.TowerScopeLevelProcessor, 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 } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt index d1b63748d69..0744e92c58f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt +++ b/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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 76909f4b287..11a163fbf47 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/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 - ): 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 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() 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt index 3547bece1c8..a9dbee08c33 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt +++ b/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() if (AbstractTypeChecker.isSubtypeOf(inferenceContext, argumentType!!, valueParameterType)) { resultSymbol = symbol - return@processFunctionsByName ProcessorAction.STOP + return@processFunctionsByName } - ProcessorAction.NEXT } // TODO: Maybe resultType = data? // check black box tests diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirTypeParameterScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirTypeParameterScope.kt index d81454500c5..e721d19ebfb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirTypeParameterScope.kt +++ b/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 - ): 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) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirUseSiteMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirUseSiteMemberScope.kt index 8dd9fa68847..7f16d67686c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirUseSiteMemberScope.kt +++ b/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>>() - 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> = mutableListOf>().apply { val overrideCandidates = mutableSetOf>() - 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt index 39d2500f724..db2d8819cd0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt +++ b/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, - 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 > processCallables( name: Name, token: TowerScopeLevel.Token, - 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) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt index e374c321e2e..700be72fc9f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt +++ b/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 - ): 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 > processCallables( name: Name, token: TowerScopeLevel.Token, - 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 } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt index 0191c15796e..d0afffa62de 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt +++ b/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 - ): 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 > processCallables( name: Name, token: TowerScopeLevel.Token, - 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 } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt index de035b6ca70..a68c7ad0d38 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt +++ b/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)) { - 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 06928f94fdf..1a80f88911b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/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 ) : 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteMemberScope.kt index 00533b87721..8ad3b5d10b6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteMemberScope.kt +++ b/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>() - 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 } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt index 10c4155ab95..2873b81201b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt +++ b/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 - ): 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 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() 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt index 052985dd2bc..7225e446449 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt +++ b/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 { - 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) { } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLazyNestedClassifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLazyNestedClassifierScope.kt index 42c907102d3..31f77ec1de3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLazyNestedClassifierScope.kt +++ b/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 - ): 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt index 409b8464e72..3e4e61aaf0a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt +++ b/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 } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt index 537c7d4967c..75a6cf2b9b5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt +++ b/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 - ): ProcessorAction { - val matchedClass = classIndex[name] ?: return ProcessorAction.NONE - return processor(matchedClass) + processor: (FirClassifierSymbol<*>) -> Unit + ) { + val matchedClass = classIndex[name] ?: return + processor(matchedClass) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirPackageMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirPackageMemberScope.kt index 7a63ca49e97..995096dc129 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirPackageMemberScope.kt +++ b/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 - ): 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 } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirQualifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirQualifierScope.kt index ed6eea705e9..d2bddeca81a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirQualifierScope.kt +++ b/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 - ): 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) } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStaticScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStaticScope.kt index c61f716c81a..903cfe335e6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStaticScope.kt +++ b/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 - ): 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 } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt index 7ded50988bc..5559e62a5f4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt +++ b/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 { - 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 > processCallablesByName( name: Name, - noinline processor: (D) -> ProcessorAction, + noinline processor: (D) -> Unit, absentNames: MutableSet, - 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 > 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>() val pending = mutableListOf>() 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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeResolveScopeForBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeResolveScopeForBodyResolve.kt index 14c9f3bd679..a889766b3b7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeResolveScopeForBodyResolve.kt +++ b/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 - ): 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 } } \ No newline at end of file diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index 70d0fe10dbe..1125bb0aa66 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/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) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt index bb8d4e2472a..f541b80f6ce 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt +++ b/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 - ): ProcessorAction = NEXT + processor: (FirClassifierSymbol<*>) -> Unit + ) {} open fun processFunctionsByName( name: Name, - processor: (FirFunctionSymbol<*>) -> ProcessorAction - ): ProcessorAction = NEXT + processor: (FirFunctionSymbol<*>) -> Unit + ) {} open fun processPropertiesByName( name: Name, // NB: it'd be great to write FirVariableSymbol<*> here, but there is FirAccessorSymbol :( - processor: (FirCallableSymbol<*>) -> ProcessorAction - ): ProcessorAction = NEXT + processor: (FirCallableSymbol<*>) -> Unit + ) {} } enum class ProcessorAction { diff --git a/compiler/testData/ir/irText/expressions/kt30020.fir.txt b/compiler/testData/ir/irText/expressions/kt30020.fir.txt index 5457c14e720..087e49dc391 100644 --- a/compiler/testData/ir/irText/expressions/kt30020.fir.txt +++ b/compiler/testData/ir/irText/expressions/kt30020.fir.txt @@ -111,12 +111,23 @@ FILE fqName: fileName:/kt30020.kt public abstract fun add (element: E of kotlin.collections.MutableList): kotlin.Boolean declared in kotlin.collections.MutableList $this: VALUE_PARAMETER name: 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: 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) returnType:kotlin.Boolean [fake_override] overridden: public abstract fun addAll (index: kotlin.Int, elements: kotlin.collections.Collection): kotlin.Boolean declared in kotlin.collections.MutableList $this: VALUE_PARAMETER name: type:kotlin.collections.MutableList VALUE_PARAMETER name:index index:0 type:kotlin.Int VALUE_PARAMETER name:elements index:1 type:kotlin.collections.Collection + FUN FAKE_OVERRIDE name:addAll visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, elements:kotlin.collections.Collection) returnType:kotlin.Boolean [fake_override] + overridden: + public abstract fun addAll (elements: kotlin.collections.Collection): kotlin.Boolean declared in kotlin.collections.MutableList + $this: VALUE_PARAMETER name: type:kotlin.collections.MutableList + VALUE_PARAMETER name:elements index:0 type:kotlin.collections.Collection 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: fileName:/kt30020.kt overridden: public abstract fun listIterator (): kotlin.collections.MutableListIterator declared in kotlin.collections.MutableList $this: VALUE_PARAMETER name: type:kotlin.collections.MutableList + FUN FAKE_OVERRIDE name:listIterator visibility:public modality:ABSTRACT <> ($this:kotlin.collections.MutableList, index:kotlin.Int) returnType:kotlin.collections.MutableListIterator [fake_override] + overridden: + public abstract fun listIterator (index: kotlin.Int): kotlin.collections.MutableListIterator declared in kotlin.collections.MutableList + $this: VALUE_PARAMETER name: 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 diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt index b87a98a88ff..eb0c492caff 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt +++ b/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<*>) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt index 89f2a4f60b4..ca482f00120 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt +++ b/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 } } }