FIR: optimize classifier scope: don't search for nonexistent symbols

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

@@ -93,7 +93,11 @@ class JavaSymbolProvider(
         visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
     ): JavaClassUseSiteMemberScope {
         return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
-            val declaredScope = declaredMemberScope(regularClass, useLazyNestedClassifierScope = regularClass is FirJavaClass)
+            val declaredScope = declaredMemberScope(
+                regularClass,
+                useLazyNestedClassifierScope = regularClass is FirJavaClass,
+                existingNames = (regularClass as? FirJavaClass)?.existingNestedClassifierNames
+            )
             val superTypeEnhancementScopes =
                 lookupSuperTypes(regularClass, lookupInterfaces = true, deep = false, useSiteSession = useSiteSession)
                     .mapNotNull { useSiteSuperType ->
@@ -184,7 +188,8 @@ class JavaSymbolProvider(
                     javaClass.visibility, javaClass.modality,
                     javaClass.classKind, isTopLevel = isTopLevel,
                     isStatic = javaClass.isStatic,
-                    javaTypeParameterStack = javaTypeParameterStack
+                    javaTypeParameterStack = javaTypeParameterStack,
+                    existingNestedClassifierNames = javaClass.innerClassNames.toList()
                 ).apply {
                     this.typeParameters += foundClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
                     addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -37,7 +37,8 @@ class FirJavaClass internal constructor(
     override val classKind: ClassKind,
     isTopLevel: Boolean,
     isStatic: Boolean,
-    internal val javaTypeParameterStack: JavaTypeParameterStack
+    internal val javaTypeParameterStack: JavaTypeParameterStack,
+    internal val existingNestedClassifierNames: List<Name>
 ) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass<FirRegularClass> {
     override var status: FirDeclarationStatusImpl = FirDeclarationStatusImpl(visibility, modality)
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

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

@@ -19,9 +19,13 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirClassDeclaredMemberScope(klass: FirClass<*>, useLazyNestedClassifierScope: Boolean = false) : FirScope() {
+class FirClassDeclaredMemberScope(
+    klass: FirClass<*>,
+    useLazyNestedClassifierScope: Boolean = false,
+    existingNames: List<Name>? = null
+) : FirScope() {
     private val nestedClassifierScope = if (useLazyNestedClassifierScope) {
-        nestedClassifierScope(klass.symbol.classId, klass.session)
+        nestedClassifierScope(klass.symbol.classId, klass.session, existingNames)
     } else {
         nestedClassifierScope(klass)
     }

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

@@ -18,7 +18,8 @@ import org.jetbrains.kotlin.name.Name
 // (or make possible to calculate nested classifiers on-the-fly)
 class FirLazyNestedClassifierScope(
     val classId: ClassId,
-    session: FirSession
+    session: FirSession,
+    private val existingNames: List<Name>?
 ) : FirScope() {
 
     private val symbolProvider = session.firSymbolProvider
@@ -27,6 +28,9 @@ class FirLazyNestedClassifierScope(
         name: Name,
         processor: (FirClassifierSymbol<*>) -> ProcessorAction
     ): ProcessorAction {
+        if (existingNames != null && name !in existingNames) {
+            return ProcessorAction.NONE
+        }
         val child = classId.createNestedClassId(name)
         val symbol = symbolProvider.getClassLikeSymbolByFqName(child) ?: return ProcessorAction.NONE
 

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

@@ -8,10 +8,10 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.resolve.memberScopeProvider
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 
 class FirMemberScopeProvider : FirSessionComponent {
 
@@ -19,9 +19,13 @@ class FirMemberScopeProvider : FirSessionComponent {
     private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope>()
     private val selfImportingCache = mutableMapOf<FqName, FirSelfImportingScope>()
 
-    fun declaredMemberScope(klass: FirClass<*>, useLazyNestedClassifierScope: Boolean): FirClassDeclaredMemberScope {
+    fun declaredMemberScope(
+        klass: FirClass<*>,
+        useLazyNestedClassifierScope: Boolean,
+        existingNames: List<Name>?
+    ): FirClassDeclaredMemberScope {
         return declaredMemberCache.getOrPut(klass) {
-            FirClassDeclaredMemberScope(klass, useLazyNestedClassifierScope)
+            FirClassDeclaredMemberScope(klass, useLazyNestedClassifierScope, existingNames)
         }
     }
 
@@ -39,11 +43,15 @@ class FirMemberScopeProvider : FirSessionComponent {
     }
 }
 
-fun declaredMemberScope(klass: FirClass<*>, useLazyNestedClassifierScope: Boolean = false): FirClassDeclaredMemberScope {
+fun declaredMemberScope(
+    klass: FirClass<*>,
+    useLazyNestedClassifierScope: Boolean = false,
+    existingNames: List<Name>? = null
+): FirClassDeclaredMemberScope {
     return klass
         .session
         .memberScopeProvider
-        .declaredMemberScope(klass, useLazyNestedClassifierScope)
+        .declaredMemberScope(klass, useLazyNestedClassifierScope, existingNames)
 }
 
 fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope {
@@ -53,8 +61,8 @@ fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope {
         .nestedClassifierScope(klass)
 }
 
-fun nestedClassifierScope(classId: ClassId, session: FirSession): FirLazyNestedClassifierScope {
+fun nestedClassifierScope(classId: ClassId, session: FirSession, existingNames: List<Name>? = null): FirLazyNestedClassifierScope {
-    return FirLazyNestedClassifierScope(classId, session)
+    return FirLazyNestedClassifierScope(classId, session, existingNames)
 }
 
 fun selfImportingScope(fqName: FqName, session: FirSession): FirSelfImportingScope {