[FIR] Properly use FirContainingNamesAwareScope in all places

Split some delegating scopes to basic and name aware implementations

Also get rid of getContainingCallableNamesIfPresent and
  getContainingClassifierNamesIfPresent functions because they are not
  needed anymore

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt

@@ -87,7 +87,6 @@ internal class KtFirScopeProvider(
         val firScope = symbol.withFirForScope { fir ->
             fir.scopeProvider.getStaticScope(fir, analysisSession.rootModuleSession, ScopeSession())
         } ?: return KtFirEmptyMemberScope(symbol)
-        check(firScope is FirContainingNamesAwareScope)
         return KtFirDelegatingScopeImpl(firScope, builder, token)
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirStarImportingScope.kt

@@ -7,15 +7,9 @@ package org.jetbrains.kotlin.analysis.api.fir.scopes
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
-import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
-import org.jetbrains.kotlin.fir.scopes.getContainingClassifierNamesIfPresent
-import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractStarImportingScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirDefaultStarImportingScope
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.scopes.Import
 import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 import org.jetbrains.kotlin.analysis.api.scopes.KtStarImportingScope
@@ -25,6 +19,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
+import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractStarImportingScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirDefaultStarImportingScope
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirStarImportingScope(
@@ -67,7 +64,7 @@ internal class KtFirStarImportingScope(
                         declarationProvider.getPropertyNamesInPackage(import.packageFqName)
             } else { //member
                 val classId = import.resolvedClassId ?: error("Class id should not be null as relativeClassName is not null")
-                firScope.getStaticsScope(classId)?.getContainingCallableNamesIfPresent().orEmpty()
+                firScope.getStaticsScope(classId)?.getCallableNames().orEmpty()
             }
         }
     }
@@ -79,9 +76,9 @@ internal class KtFirStarImportingScope(
                         declarationProvider.getTypeAliasNamesInPackage(import.packageFqName)
             } else {
                 val classId = import.resolvedClassId ?: error("Class id should not be null as relativeClassName is not null")
-                firScope.getStaticsScope(classId)?.getContainingClassifierNamesIfPresent().orEmpty()
+                firScope.getStaticsScope(classId)?.getClassifierNames().orEmpty()
             }
         }
     }
 
-}
+}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/KtDeclarationAndFirDeclarationEqualityChecker.kt

@@ -6,19 +6,19 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
 import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.createEmptySession
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
+import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.createEmptySession
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtTypeReference
@@ -195,11 +195,11 @@ object KtDeclarationAndFirDeclarationEqualityChecker {
             klass: FirClass,
             useSiteSession: FirSession,
             scopeSession: ScopeSession
-        ): FirScope? {
+        ): FirContainingNamesAwareScope? {
             shouldNotBeCalled()
         }
 
-        override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
+        override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirContainingNamesAwareScope? {
             shouldNotBeCalled()
         }
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt

@@ -6,19 +6,19 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import junit.framework.TestCase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirNonLocalDeclarationBuilder
+import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirNonLocalDeclarationBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
@@ -99,10 +99,10 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractLowLevelApiSingleF
                 klass: FirClass,
                 useSiteSession: FirSession,
                 scopeSession: ScopeSession
-            ): FirScope =
+            ): FirContainingNamesAwareScope? =
                 error("Should not be called")
 
-            override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope =
+            override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirContainingNamesAwareScope? =
                 error("Should not be called")
         }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.scopes.*
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
@@ -68,7 +68,7 @@ object JavaScopeProvider : FirScopeProvider() {
         }
     }
 
-    private fun buildDeclaredMemberScope(useSiteSession: FirSession, regularClass: FirRegularClass): FirScope {
+    private fun buildDeclaredMemberScope(useSiteSession: FirSession, regularClass: FirRegularClass): FirContainingNamesAwareScope {
         return if (regularClass is FirJavaClass) useSiteSession.declaredMemberScopeWithLazyNestedScope(
             regularClass,
             existingNames = regularClass.existingNestedClassifierNames,
@@ -112,9 +112,9 @@ object JavaScopeProvider : FirScopeProvider() {
         klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ): FirScope? {
+    ): FirContainingNamesAwareScope? {
         val scope = getStaticMemberScopeForCallables(klass, useSiteSession, scopeSession, hashSetOf()) ?: return null
-        return FirOnlyCallablesScope(FirStaticScope(scope))
+        return FirNameAwareOnlyCallablesScope(FirStaticScope(scope))
     }
 
     private fun getStaticMemberScopeForCallables(
@@ -193,7 +193,11 @@ object JavaScopeProvider : FirScopeProvider() {
         return result
     }
 
-    override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
+    override fun getNestedClassifierScope(
+        klass: FirClass,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirContainingNamesAwareScope? {
         return lazyNestedClassifierScope(
             klass.classId,
             (klass as FirJavaClass).existingNestedClassifierNames,

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

@@ -8,8 +8,6 @@ package org.jetbrains.kotlin.fir.java.scopes
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isStatic
@@ -18,9 +16,9 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 
 class JavaClassStaticUseSiteScope internal constructor(
     session: FirSession,
-    private val declaredMemberScope: FirScope,
+    private val declaredMemberScope: FirContainingNamesAwareScope,
-    private val superClassScope: FirScope,
+    private val superClassScope: FirContainingNamesAwareScope,
-    private val superTypesScopes: List<FirScope>,
+    private val superTypesScopes: List<FirContainingNamesAwareScope>,
     javaTypeParameterStack: JavaTypeParameterStack,
 ) : FirContainingNamesAwareScope() {
     private val functions = hashMapOf<Name, Collection<FirNamedFunctionSymbol>>()
@@ -84,9 +82,9 @@ class JavaClassStaticUseSiteScope internal constructor(
     @OptIn(ExperimentalStdlibApi::class)
     override fun getCallableNames(): Set<Name> {
         return buildSet {
-            addAll(declaredMemberScope.getContainingCallableNamesIfPresent())
+            addAll(declaredMemberScope.getCallableNames())
             for (superTypesScope in superTypesScopes) {
-                addAll(superTypesScope.getContainingCallableNamesIfPresent())
+                addAll(superTypesScope.getCallableNames())
             }
         }
     }
@@ -94,9 +92,9 @@ class JavaClassStaticUseSiteScope internal constructor(
     @OptIn(ExperimentalStdlibApi::class)
     override fun getClassifierNames(): Set<Name> {
         return buildSet {
-            addAll(declaredMemberScope.getContainingCallableNamesIfPresent())
+            addAll(declaredMemberScope.getClassifierNames())
             for (superTypesScope in superTypesScopes) {
-                addAll(superTypesScope.getContainingCallableNamesIfPresent())
+                addAll(superTypesScope.getClassifierNames())
             }
         }
     }

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

@@ -41,7 +41,7 @@ class JavaClassUseSiteMemberScope(
     klass: FirJavaClass,
     session: FirSession,
     superTypesScope: FirTypeScope,
-    declaredMemberScope: FirScope
+    declaredMemberScope: FirContainingNamesAwareScope
 ) : AbstractFirUseSiteMemberScope(
     session,
     JavaOverrideChecker(session, klass.javaTypeParameterStack),
@@ -55,13 +55,13 @@ class JavaClassUseSiteMemberScope(
     private val canUseSpecialGetters: Boolean by lazy { !klass.hasKotlinSuper(session) }
 
     private val callableNamesCached by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        declaredMemberScope.getContainingCallableNamesIfPresent() + superTypesScope.getCallableNames()
+        declaredMemberScope.getCallableNames() + superTypesScope.getCallableNames()
     }
 
     override fun getCallableNames(): Set<Name> = callableNamesCached
 
     override fun getClassifierNames(): Set<Name> {
-        return declaredMemberScope.getContainingClassifierNamesIfPresent() + superTypesScope.getClassifierNames()
+        return declaredMemberScope.getClassifierNames() + superTypesScope.getClassifierNames()
     }
 
     private fun generateAccessorSymbol(

compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/scopes/JvmMappedScopes.kt

@@ -12,20 +12,19 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.scopes.jvm.JvmMappedScope
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 
-
 fun wrapScopeWithJvmMapped(
     klass: FirClass,
-    declaredMemberScope: FirScope,
+    declaredMemberScope: FirContainingNamesAwareScope,
     useSiteSession: FirSession,
     scopeSession: ScopeSession
-): FirScope {
+): FirContainingNamesAwareScope {
     val classId = klass.classId
     val kotlinUnsafeFqName = classId.asSingleFqName().toUnsafe()
     val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(kotlinUnsafeFqName)

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

@@ -13,7 +13,9 @@ import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
-import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -26,7 +28,7 @@ class JvmMappedScope(
     private val session: FirSession,
     private val firKotlinClass: FirClass,
     private val firJavaClass: FirRegularClass,
-    private val declaredMemberScope: FirScope,
+    private val declaredMemberScope: FirContainingNamesAwareScope,
     private val javaMappedClassUseSiteScope: FirTypeScope,
     private val signatures: Signatures
 ) : FirTypeScope() {
@@ -116,11 +118,11 @@ class JvmMappedScope(
     }
 
     override fun getCallableNames(): Set<Name> {
-        return declaredMemberScope.getContainingCallableNamesIfPresent() + signatures.visibleMethodSignaturesByName.keys
+        return declaredMemberScope.getCallableNames() + signatures.visibleMethodSignaturesByName.keys
     }
 
     override fun getClassifierNames(): Set<Name> {
-        return declaredMemberScope.getContainingClassifierNamesIfPresent()
+        return declaredMemberScope.getClassifierNames()
     }
 
     companion object {

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/StubFirScopeProvider.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.builder
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 
@@ -25,11 +25,11 @@ object StubFirScopeProvider : FirScopeProvider() {
         klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ): FirScope? {
+    ): FirContainingNamesAwareScope? {
         return null
     }
 
-    override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
+    override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirContainingNamesAwareScope? {
         return null
     }
 }

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

@@ -72,7 +72,7 @@ class PackageQualifierReceiver(
     useSiteSession: FirSession
 ) : QualifierReceiver(explicitReceiver) {
     val scope = FirPackageMemberScope(explicitReceiver.packageFqName, useSiteSession)
-    override fun classifierScope(): FirScope? {
+    override fun classifierScope(): FirScope {
         return FirOnlyClassifiersScope(scope)
     }
 

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

@@ -20,15 +20,17 @@ import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.ConeClassErrorType
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 
 class FirKotlinScopeProvider(
     val declaredMemberScopeDecorator: (
         klass: FirClass,
-        declaredMemberScope: FirScope,
+        declaredMemberScope: FirContainingNamesAwareScope,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ) -> FirScope = { _, declaredMemberScope, _, _ -> declaredMemberScope }
+    ) -> FirContainingNamesAwareScope = { _, declaredMemberScope, _, _ -> declaredMemberScope }
 ) : FirScopeProvider(), FirSessionComponent {
     override fun getUseSiteMemberScope(
         klass: FirClass,
@@ -68,14 +70,18 @@ class FirKotlinScopeProvider(
         klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ): FirScope? {
+    ): FirContainingNamesAwareScope? {
         return when (klass.classKind) {
-            ClassKind.ENUM_CLASS -> FirOnlyCallablesScope(FirStaticScope(useSiteSession.declaredMemberScope(klass)))
+            ClassKind.ENUM_CLASS -> FirNameAwareOnlyCallablesScope(FirStaticScope(useSiteSession.declaredMemberScope(klass)))
             else -> null
         }
     }
 
-    override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
+    override fun getNestedClassifierScope(
+        klass: FirClass,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirContainingNamesAwareScope? {
         return useSiteSession.nestedClassifierScope(klass)
     }
 }

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

@@ -9,7 +9,9 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.packageFqName
-import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.scopeSessionKey
+import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.name.FqName
@@ -72,7 +74,7 @@ private fun doCreateImportingScopes(
     )
 }
 
-fun ConeClassLikeLookupTag.getNestedClassifierScope(session: FirSession, scopeSession: ScopeSession): FirScope? {
+fun ConeClassLikeLookupTag.getNestedClassifierScope(session: FirSession, scopeSession: ScopeSession): FirContainingNamesAwareScope? {
     val klass = toSymbol(session)?.fir as? FirRegularClass ?: return null
     return klass.scopeProvider.getNestedClassifierScope(klass, session, scopeSession)
 }

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

@@ -7,7 +7,10 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
+import org.jetbrains.kotlin.fir.scopes.FirOverrideChecker
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name
 
@@ -15,7 +18,7 @@ abstract class AbstractFirUseSiteMemberScope(
     session: FirSession,
     overrideChecker: FirOverrideChecker,
     protected val superTypesScope: FirTypeScope,
-    protected val declaredMemberScope: FirScope
+    protected val declaredMemberScope: FirContainingNamesAwareScope
 ) : AbstractFirOverrideScope(session, overrideChecker) {
 
     private val functions = hashMapOf<Name, Collection<FirNamedFunctionSymbol>>()
@@ -23,7 +26,7 @@ abstract class AbstractFirUseSiteMemberScope(
     protected val directOverriddenProperties = hashMapOf<FirPropertySymbol, MutableList<FirPropertySymbol>>()
 
     private val callableNamesCached by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        declaredMemberScope.getContainingCallableNamesIfPresent() + superTypesScope.getCallableNames()
+        declaredMemberScope.getCallableNames() + superTypesScope.getCallableNames()
     }
 
     override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
@@ -97,6 +100,6 @@ abstract class AbstractFirUseSiteMemberScope(
     override fun getCallableNames(): Set<Name> = callableNamesCached
 
     override fun getClassifierNames(): Set<Name> {
-        return declaredMemberScope.getContainingClassifierNamesIfPresent() + superTypesScope.getClassifierNames()
+        return declaredMemberScope.getClassifierNames() + superTypesScope.getClassifierNames()
     }
 }

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.moduleVisibilityChecker
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolvedForCalls
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.ClassId
@@ -60,7 +60,7 @@ abstract class FirAbstractImportingScope(
             is FirClassSymbol<*> -> this
         }
 
-    private fun FirClassSymbol<*>.getStaticsScope(): FirScope? =
+    private fun FirClassSymbol<*>.getStaticsScope(): FirContainingNamesAwareScope? =
         if (fir.classKind == ClassKind.OBJECT) {
             FirObjectImportedCallableScope(
                 classId, fir.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
@@ -69,7 +69,7 @@ abstract class FirAbstractImportingScope(
             fir.scopeProvider.getStaticScope(fir, session, scopeSession)
         }
 
-    fun getStaticsScope(classId: ClassId): FirScope? =
+    fun getStaticsScope(classId: ClassId): FirContainingNamesAwareScope? =
         provider.getClassLikeSymbolByClassId(classId)?.fullyExpandedSymbol?.getStaticsScope()
 
     protected fun findSingleClassifierSymbolByName(name: Name?, imports: List<FirResolvedImport>): FirClassLikeSymbol<*>? {

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

@@ -11,8 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isSynthetic
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingClassifierNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
@@ -26,7 +24,7 @@ class FirClassDeclaredMemberScopeImpl(
     existingNames: List<Name>? = null,
     symbolProvider: FirSymbolProvider? = null
 ) : FirClassDeclaredMemberScope() {
-    private val nestedClassifierScope: FirScope? = if (useLazyNestedClassifierScope) {
+    private val nestedClassifierScope: FirContainingNamesAwareScope? = if (useLazyNestedClassifierScope) {
         lazyNestedClassifierScope(klass.symbol.classId, existingNames!!, symbolProvider!!)
     } else {
         useSiteSession.nestedClassifierScope(klass)
@@ -85,6 +83,6 @@ class FirClassDeclaredMemberScopeImpl(
     }
 
     override fun getClassifierNames(): Set<Name> {
-        return nestedClassifierScope?.getContainingClassifierNamesIfPresent().orEmpty()
+        return nestedClassifierScope?.getClassifierNames().orEmpty()
     }
 }

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.Name
 class FirClassUseSiteMemberScope(
     session: FirSession,
     superTypesScope: FirTypeScope,
-    declaredMemberScope: FirScope
+    declaredMemberScope: FirContainingNamesAwareScope
 ) : AbstractFirUseSiteMemberScope(session, FirStandardOverrideChecker(session), superTypesScope, declaredMemberScope) {
 
     override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.resolve.declaredMemberScopeProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
+import org.jetbrains.kotlin.fir.scopes.FirNameAwareCompositeScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -67,7 +68,7 @@ class FirDeclaredMemberScopeProvider(val useSiteSession: FirSession) : FirSessio
                     symbolProvider
                 )
                 if (extensions.any { it.needToGenerateAdditionalMembersInClass(klass) }) {
-                    FirCompositeScope(
+                    FirNameAwareCompositeScope(
                         listOf(baseScope, FirGeneratedClassDeclaredMemberScope(useSiteSession, klass, needNestedClassifierScope = false))
                     )
                 } else {

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

@@ -15,9 +15,9 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeFlexibleType
@@ -31,7 +31,7 @@ class FirDelegatedMemberScope(
     private val session: FirSession,
     private val scopeSession: ScopeSession,
     private val containingClass: FirClass,
-    private val declaredMemberScope: FirScope,
+    private val declaredMemberScope: FirContainingNamesAwareScope,
     private val delegateFields: List<FirField>,
 ) : FirContainingNamesAwareScope() {
     private val dispatchReceiverType = containingClass.defaultType()
@@ -175,7 +175,7 @@ class FirDelegatedMemberScope(
     @OptIn(ExperimentalStdlibApi::class)
     private val callableNamesLazy: Set<Name> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         buildSet {
-            addAll(declaredMemberScope.getContainingCallableNamesIfPresent())
+            addAll(declaredMemberScope.getCallableNames())
 
             delegateFields.flatMapTo(this) {
                 buildScope(it)?.getCallableNames() ?: emptySet()
@@ -186,7 +186,7 @@ class FirDelegatedMemberScope(
     @OptIn(ExperimentalStdlibApi::class)
     private val classifierNamesLazy: Set<Name> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         buildSet {
-            addAll(declaredMemberScope.getContainingClassifierNamesIfPresent())
+            addAll(declaredMemberScope.getClassifierNames())
 
             delegateFields.flatMapTo(this) {
                 buildScope(it)?.getClassifierNames() ?: emptySet()

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

@@ -9,13 +9,14 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.resolve.createSubstitutionForSupertype
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
+import org.jetbrains.kotlin.fir.scopes.getSingleClassifier
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.name.Name
 
 private class FirNestedClassifierScopeWithSubstitution(
-    private val scope: FirScope,
+    private val scope: FirContainingNamesAwareScope,
     private val substitutor: ConeSubstitutor
 ) : FirContainingNamesAwareScope() {
 
@@ -41,17 +42,17 @@ private class FirNestedClassifierScopeWithSubstitution(
         processor(matchedClass, substitutor)
     }
 
-    override fun getCallableNames(): Set<Name> = scope.getContainingCallableNamesIfPresent()
+    override fun getCallableNames(): Set<Name> = scope.getCallableNames()
-    override fun getClassifierNames(): Set<Name> = scope.getContainingClassifierNamesIfPresent()
+    override fun getClassifierNames(): Set<Name> = scope.getClassifierNames()
 
     override val scopeOwnerLookupNames: List<String>
         get() = scope.scopeOwnerLookupNames
 }
 
-fun FirScope.wrapNestedClassifierScopeWithSubstitutionForSuperType(
+fun FirContainingNamesAwareScope.wrapNestedClassifierScopeWithSubstitutionForSuperType(
     superType: ConeClassLikeType,
     session: FirSession
-): FirScope {
+): FirContainingNamesAwareScope {
     val substitutor = createSubstitutionForSupertype(superType, session)
     return FirNestedClassifierScopeWithSubstitution(this, substitutor)
 }

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

@@ -7,12 +7,24 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirOnlyCallablesScope(val delegate: FirScope) : FirContainingNamesAwareScope() {
+class FirOnlyCallablesScope(val delegate: FirScope) : FirScope() {
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
+        return delegate.processFunctionsByName(name, processor)
+    }
+
+    override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
+        return delegate.processPropertiesByName(name, processor)
+    }
+
+    override val scopeOwnerLookupNames: List<String>
+        get() = delegate.scopeOwnerLookupNames
+}
+
+class FirNameAwareOnlyCallablesScope(val delegate: FirContainingNamesAwareScope) : FirContainingNamesAwareScope() {
     override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
         return delegate.processFunctionsByName(name, processor)
     }
@@ -24,7 +36,7 @@ class FirOnlyCallablesScope(val delegate: FirScope) : FirContainingNamesAwareSco
     override val scopeOwnerLookupNames: List<String>
         get() = delegate.scopeOwnerLookupNames
 
-    override fun getCallableNames(): Set<Name> = delegate.getContainingCallableNamesIfPresent()
+    override fun getCallableNames(): Set<Name> = delegate.getCallableNames()
 
     override fun getClassifierNames(): Set<Name> = emptySet()
 }

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

@@ -8,16 +8,21 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingClassifierNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirOnlyClassifiersScope(val delegate: FirScope) : FirContainingNamesAwareScope() {
+class FirOnlyClassifiersScope(val delegate: FirScope) : FirScope() {
+    override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
+        return delegate.processClassifiersByNameWithSubstitution(name, processor)
+    }
+}
+
+class FirNameAwareOnlyClassifiersScope(val delegate: FirContainingNamesAwareScope) : FirContainingNamesAwareScope() {
     override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
         return delegate.processClassifiersByNameWithSubstitution(name, processor)
     }
 
     override fun getCallableNames(): Set<Name> = emptySet()
 
-    override fun getClassifierNames(): Set<Name> = delegate.getContainingClassifierNamesIfPresent()
+    override fun getClassifierNames(): Set<Name> = delegate.getClassifierNames()
 }

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

@@ -10,15 +10,12 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.getContainingCallableNamesIfPresent
-import org.jetbrains.kotlin.fir.scopes.getContainingClassifierNamesIfPresent
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirStaticScope(private val delegateScope: FirScope) : FirContainingNamesAwareScope() {
+class FirStaticScope(private val delegateScope: FirContainingNamesAwareScope) : FirContainingNamesAwareScope() {
     override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
         delegateScope.processClassifiersByNameWithSubstitution(name, processor)
     }
@@ -41,10 +38,10 @@ class FirStaticScope(private val delegateScope: FirScope) : FirContainingNamesAw
 
 
     override fun getCallableNames(): Set<Name> {
-        return delegateScope.getContainingCallableNamesIfPresent()
+        return delegateScope.getCallableNames()
     }
 
     override fun getClassifierNames(): Set<Name> {
-        return delegateScope.getContainingClassifierNamesIfPresent()
+        return delegateScope.getClassifierNames()
     }
 }

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

@@ -12,8 +12,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirCompositeScope(val scopes: Iterable<FirScope>) : FirContainingNamesAwareScope() {
+class FirCompositeScope(val scopes: Iterable<FirScope>) : FirScope() {
-
     override fun processClassifiersByNameWithSubstitution(
         name: Name,
         processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit
@@ -64,15 +63,41 @@ class FirCompositeScope(val scopes: Iterable<FirScope>) : FirContainingNamesAwar
         processComposite(FirScope::processDeclaredConstructors, processor)
     }
 
-    override fun getCallableNames(): Set<Name> {
-        return scopes.flatMapTo(hashSetOf()) { it.getContainingCallableNamesIfPresent() }
-    }
-
-    override fun getClassifierNames(): Set<Name> {
-        return scopes.flatMapTo(hashSetOf()) { it.getContainingClassifierNamesIfPresent() }
-    }
-
     override val scopeOwnerLookupNames: List<String> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         scopes.flatMap { it.scopeOwnerLookupNames }
     }
 }
+
+class FirNameAwareCompositeScope(val scopes: Iterable<FirContainingNamesAwareScope>) : FirContainingNamesAwareScope() {
+    private val delegate = FirCompositeScope(scopes)
+
+    override fun processClassifiersByNameWithSubstitution(
+        name: Name,
+        processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit
+    ) {
+        delegate.processClassifiersByNameWithSubstitution(name, processor)
+    }
+
+    override fun processFunctionsByName(name: Name, processor: (FirNamedFunctionSymbol) -> Unit) {
+        delegate.processFunctionsByName(name, processor)
+    }
+
+    override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
+        delegate.processPropertiesByName(name, processor)
+    }
+
+    override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {
+        delegate.processDeclaredConstructors(processor)
+    }
+
+    override val scopeOwnerLookupNames: List<String>
+        get() = delegate.scopeOwnerLookupNames
+
+    override fun getCallableNames(): Set<Name> {
+        return scopes.flatMapTo(hashSetOf()) { it.getCallableNames() }
+    }
+
+    override fun getClassifierNames(): Set<Name> {
+        return scopes.flatMapTo(hashSetOf()) { it.getClassifierNames() }
+    }
+}

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

@@ -15,12 +15,6 @@ abstract class FirContainingNamesAwareScope : FirScope() {
     abstract fun getClassifierNames(): Set<Name>
 }
 
-fun FirScope.getContainingCallableNamesIfPresent(): Set<Name> =
-    if (this is FirContainingNamesAwareScope) getCallableNames() else emptySet()
-
-fun FirScope.getContainingClassifierNamesIfPresent(): Set<Name> =
-    if (this is FirContainingNamesAwareScope) getClassifierNames() else emptySet()
-
 fun FirContainingNamesAwareScope.processAllFunctions(processor: (FirNamedFunctionSymbol) -> Unit) {
     for (name in getCallableNames()) {
         processFunctionsByName(name, processor)

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

@@ -20,25 +20,25 @@ abstract class FirScopeProvider {
         klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ): FirScope?
+    ): FirContainingNamesAwareScope?
 
     abstract fun getNestedClassifierScope(
         klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ): FirScope?
+    ): FirContainingNamesAwareScope?
 
     fun getStaticScope(
         klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
-    ): FirScope? {
+    ): FirContainingNamesAwareScope? {
         val nestedClassifierScope = getNestedClassifierScope(klass, useSiteSession, scopeSession)
         val callableScope = getStaticMemberScopeForCallables(klass, useSiteSession, scopeSession)
 
         return when {
             nestedClassifierScope != null && callableScope != null ->
-                FirCompositeScope(listOf(nestedClassifierScope, callableScope))
+                FirNameAwareCompositeScope(listOf(nestedClassifierScope, callableScope))
             else -> nestedClassifierScope ?: callableScope
         }
     }

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

@@ -102,11 +102,11 @@ class FirUnstableSmartcastTypeScope(
     }
 
     override fun getCallableNames(): Set<Name> {
-        return scopes.flatMapTo(hashSetOf()) { it.getContainingCallableNamesIfPresent() }
+        return scopes.flatMapTo(hashSetOf()) { it.getCallableNames() }
     }
 
     override fun getClassifierNames(): Set<Name> {
-        return scopes.flatMapTo(hashSetOf()) { it.getContainingClassifierNamesIfPresent() }
+        return scopes.flatMapTo(hashSetOf()) { it.getClassifierNames() }
     }
 
     override val scopeOwnerLookupNames: List<String> by lazy(LazyThreadSafetyMode.PUBLICATION) {