FIR resolve: use lazy nested classifier scopes for Java classes

It's necessary because JavaSymbolProvider adds nested classifiers lazily.
Commit slows things down due to relatively slow search in symbol providers

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

@@ -57,6 +57,7 @@ class JavaSymbolProvider(
     override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> =
         emptyList()
 
+    // NB: looks like it's better not to use this function at all...
     override fun getClassDeclaredMemberScope(classId: ClassId): FirScope? {
         val classSymbol = getClassLikeSymbolByFqName(classId) ?: return null
         return declaredMemberScope(classSymbol.fir)
@@ -92,7 +93,7 @@ class JavaSymbolProvider(
         visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
     ): JavaClassUseSiteMemberScope {
         return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
-            val declaredScope = declaredMemberScope(regularClass)
+            val declaredScope = declaredMemberScope(regularClass, useLazyNestedClassifierScope = regularClass is FirJavaClass)
             val superTypeEnhancementScopes =
                 lookupSuperTypes(regularClass, lookupInterfaces = true, deep = false, useSiteSession = useSiteSession)
                     .mapNotNull { useSiteSuperType ->

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

@@ -19,8 +19,12 @@ 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<*>) : FirScope() {
-    private val nestedClassifierScope = nestedClassifierScope(klass)
+class FirClassDeclaredMemberScope(klass: FirClass<*>, useLazyNestedClassifierScope: Boolean = false) : FirScope() {
+    private val nestedClassifierScope = if (useLazyNestedClassifierScope) {
+        nestedClassifierScope(klass.symbol.classId, klass.session)
+    } else {
+        nestedClassifierScope(klass)
+    }
 
     private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
         val result = mutableMapOf<Name, MutableList<FirCallableSymbol<*>>>()

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

@@ -19,9 +19,9 @@ class FirMemberScopeProvider : FirSessionComponent {
     private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope>()
     private val selfImportingCache = mutableMapOf<FqName, FirSelfImportingScope>()
 
-    fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
+    fun declaredMemberScope(klass: FirClass<*>, useLazyNestedClassifierScope: Boolean): FirClassDeclaredMemberScope {
         return declaredMemberCache.getOrPut(klass) {
-            FirClassDeclaredMemberScope(klass)
+            FirClassDeclaredMemberScope(klass, useLazyNestedClassifierScope)
         }
     }
 
@@ -39,11 +39,11 @@ class FirMemberScopeProvider : FirSessionComponent {
     }
 }
 
-fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
+fun declaredMemberScope(klass: FirClass<*>, useLazyNestedClassifierScope: Boolean = false): FirClassDeclaredMemberScope {
     return klass
         .session
         .memberScopeProvider
-        .declaredMemberScope(klass)
+        .declaredMemberScope(klass, useLazyNestedClassifierScope)
 }
 
 fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope {

compiler/fir/resolve/testData/resolve/stdlib/j+k/StaticClassConstructorFromBaseClass.kt

@@ -10,10 +10,10 @@ public abstract class AbstractClass {
 
 class User : AbstractClass() {
     fun foo() {
-        val sc = <!UNRESOLVED_REFERENCE!>StaticClass<!>()
+        val sc = StaticClass()
     }
 }
 
 fun test() {
-    AbstractClass.<!UNRESOLVED_REFERENCE!>StaticClass<!>()
+    AbstractClass.StaticClass()
 }

compiler/fir/resolve/testData/resolve/stdlib/j+k/StaticClassConstructorFromBaseClass.txt

@@ -5,10 +5,10 @@ FILE: User.kt
         }
 
         public final fun foo(): R|kotlin/Unit| {
-            lval sc: <ERROR TYPE REF: Unresolved name: StaticClass> = <Unresolved name: StaticClass>#()
+            lval sc: R|AbstractClass.StaticClass| = R|/AbstractClass.StaticClass.StaticClass|()
         }
 
     }
     public final fun test(): R|kotlin/Unit| {
-        Q|AbstractClass|.<Unresolved name: StaticClass>#()
+        Q|AbstractClass|.R|/AbstractClass.StaticClass.StaticClass|()
     }

compiler/testData/ir/irText/stubs/javaInnerClass.fir.txt

@@ -6,15 +6,15 @@ FILE fqName:<root> fileName:/javaInnerClass.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in <root>.J'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[<root>.J]'
     PROPERTY name:test visibility:public modality:FINAL [val]
-      FIELD PROPERTY_BACKING_FIELD name:test type:IrErrorType visibility:private [final]
+      FIELD PROPERTY_BACKING_FIELD name:test type:<root>.J.JInner visibility:private [final]
         EXPRESSION_BODY
-          ERROR_CALL 'Unresolved reference: <Unresolved name: JInner>#' type=IrErrorType
-      FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test> visibility:public modality:FINAL <> ($this:<root>.Test1) returnType:IrErrorType
+          CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in <root>.J.JInner' type=<root>.J.JInner origin=null
+      FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test> visibility:public modality:FINAL <> ($this:<root>.Test1) returnType:<root>.J.JInner
         correspondingProperty: PROPERTY name:test visibility:public modality:FINAL [val]
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1
         BLOCK_BODY
-          RETURN type=kotlin.Nothing from='public final fun <get-test> (): IrErrorType declared in <root>.Test1'
-            GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:test type:IrErrorType visibility:private [final]' type=IrErrorType origin=null
+          RETURN type=kotlin.Nothing from='public final fun <get-test> (): <root>.J.JInner declared in <root>.Test1'
+            GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:test type:<root>.J.JInner visibility:private [final]' type=<root>.J.JInner origin=null
               receiver: GET_VAR '<this>: <root>.Test1 declared in <root>.Test1.<get-test>' type=<root>.Test1 origin=null
     FUN FAKE_OVERRIDE name:bar visibility:public modality:OPEN <> ($this:<root>.J) returnType:kotlin.Unit [fake_override]
       overridden: