Move buildDefaultUseSiteMemberScope to FirSymbolProvider

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt

@@ -144,7 +144,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     ): FirScope? {
         val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
 
-        return (symbol.fir as FirClass<*>).buildDefaultUseSiteMemberScope(session, scopeSession)
+        return buildDefaultUseSiteMemberScope((symbol.fir as FirClass<*>), session, scopeSession)
     }
 
     override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {

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

@@ -8,15 +8,19 @@ package org.jetbrains.kotlin.fir.resolve
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 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.declarations.classId
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.impl.FirClassUseSiteMemberScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirStandardOverrideChecker
+import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
+import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.scopes.jvm.JvmMappedScope
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.types.ConeClassErrorType
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -52,6 +56,53 @@ abstract class FirSymbolProvider : FirSessionComponent {
         scopeSession: ScopeSession
     ): FirScope?
 
+    protected fun wrapScopeWithJvmMapped(
+        classId: ClassId,
+        declaredMemberScope: FirScope,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirScope {
+        val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(classId.asSingleFqName().toUnsafe())
+            ?: return declaredMemberScope
+        val symbolProvider = useSiteSession.firSymbolProvider
+        val javaClass = symbolProvider.getClassLikeSymbolByFqName(javaClassId)?.fir as? FirRegularClass
+            ?: return declaredMemberScope
+        val preparedSignatures = JvmMappedScope.prepareSignatures(javaClass)
+        return if (preparedSignatures.isNotEmpty()) {
+            symbolProvider.getClassUseSiteMemberScope(javaClassId, useSiteSession, scopeSession)?.let {
+                JvmMappedScope(declaredMemberScope, it, preparedSignatures)
+            } ?: declaredMemberScope
+        } else {
+            declaredMemberScope
+        }
+    }
+
+    fun buildDefaultUseSiteMemberScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope {
+        return scopeSession.getOrBuild(klass.symbol, USE_SITE) {
+
+            val declaredScope = declaredMemberScope(klass)
+            val wrappedDeclaredScope = wrapScopeWithJvmMapped(
+                klass.classId, declaredScope, useSiteSession, scopeSession
+            )
+            val scopes = lookupSuperTypes(klass, lookupInterfaces = true, deep = false, useSiteSession = useSiteSession)
+                .mapNotNull { useSiteSuperType ->
+                    if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null
+                    val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
+                    if (symbol is FirRegularClassSymbol) {
+                        val useSiteMemberScope = symbol.fir.buildUseSiteMemberScope(useSiteSession, scopeSession)!!
+                        useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, useSiteMemberScope, symbol.fir, scopeSession)
+                    } else {
+                        null
+                    }
+                }
+            FirClassUseSiteMemberScope(
+                useSiteSession,
+                FirSuperTypeScope(useSiteSession, FirStandardOverrideChecker(useSiteSession), scopes),
+                wrappedDeclaredScope
+            )
+        }
+    }
+
     open fun getAllCallableNamesInPackage(fqName: FqName): Set<Name> = emptySet()
     open fun getClassNamesInPackage(fqName: FqName): Set<Name> = emptySet()
 
@@ -65,27 +116,6 @@ abstract class FirSymbolProvider : FirSessionComponent {
 
     companion object {
         fun getInstance(session: FirSession) = session.firSymbolProvider
-
-        fun wrapScopeWithJvmMapped(
-            classId: ClassId,
-            declaredMemberScope: FirScope,
-            useSiteSession: FirSession,
-            scopeSession: ScopeSession
-        ): FirScope {
-            val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(classId.asSingleFqName().toUnsafe())
-                ?: return declaredMemberScope
-            val symbolProvider = useSiteSession.firSymbolProvider
-            val javaClass = symbolProvider.getClassLikeSymbolByFqName(javaClassId)?.fir as? FirRegularClass
-                ?: return declaredMemberScope
-            val preparedSignatures = JvmMappedScope.prepareSignatures(javaClass)
-            return if (preparedSignatures.isNotEmpty()) {
-                symbolProvider.getClassUseSiteMemberScope(javaClassId, useSiteSession, scopeSession)?.let {
-                    JvmMappedScope(declaredMemberScope, it, preparedSignatures)
-                } ?: declaredMemberScope
-            } else {
-                declaredMemberScope
-            }
-        }
     }
 }
 

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

@@ -59,47 +59,21 @@ val USE_SITE = scopeSessionKey<FirScope>()
 data class SubstitutionScopeKey(val type: ConeClassLikeType) : ScopeSessionKey<FirClassSubstitutionScope>() {}
 
 fun FirClassSymbol<*>.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
-    when (this) {
+    return when (this) {
-        is FirAnonymousObjectSymbol -> return fir.buildDefaultUseSiteMemberScope(useSiteSession, builder)
+        is FirAnonymousObjectSymbol -> useSiteSession.firSymbolProvider.buildDefaultUseSiteMemberScope(fir, useSiteSession, builder)
-        is FirRegularClassSymbol -> return fir.buildUseSiteMemberScope(useSiteSession, builder)
+        is FirRegularClassSymbol -> fir.buildUseSiteMemberScope(useSiteSession, builder)
     }
 }
 
 fun FirClass<*>.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
     if (classId.isLocal) {
         // It's not possible to find local class by symbol
-        return buildDefaultUseSiteMemberScope(useSiteSession, builder)
+        return useSiteSession.firSymbolProvider.buildDefaultUseSiteMemberScope(this, useSiteSession, builder)
     }
     val symbolProvider = useSiteSession.firSymbolProvider
     return symbolProvider.getClassUseSiteMemberScope(classId, useSiteSession, builder)
 }
 
-fun FirClass<*>.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, scopeSession: ScopeSession): FirScope {
-    return scopeSession.getOrBuild(symbol, USE_SITE) {
-
-        val declaredScope = declaredMemberScope(this)
-        val wrappedDeclaredScope = FirSymbolProvider.wrapScopeWithJvmMapped(
-            classId, declaredScope, useSiteSession, scopeSession
-        )
-        val scopes = lookupSuperTypes(this, lookupInterfaces = true, deep = false, useSiteSession = useSiteSession)
-            .mapNotNull { useSiteSuperType ->
-                if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null
-                val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
-                if (symbol is FirRegularClassSymbol) {
-                    val useSiteMemberScope = symbol.fir.buildUseSiteMemberScope(useSiteSession, scopeSession)!!
-                    useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, useSiteMemberScope, symbol.fir, scopeSession)
-                } else {
-                    null
-                }
-            }
-        FirClassUseSiteMemberScope(
-            useSiteSession,
-            FirSuperTypeScope(useSiteSession, FirStandardOverrideChecker(useSiteSession), scopes),
-            wrappedDeclaredScope
-        )
-    }
-}
-
 private fun createSubstitution(
     typeParameters: List<FirTypeParameter>,
     typeArguments: Array<out ConeKotlinTypeProjection>,

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext
 import org.jetbrains.kotlin.fir.deserialization.deserializeClassToSymbol
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.buildDefaultUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.getOrPut
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope
@@ -130,7 +129,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
         scopeSession: ScopeSession
     ): FirScope? {
         val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
-        return symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
+        return buildDefaultUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession)
     }
 
     override fun getPackage(fqName: FqName): FqName? {

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.buildDefaultUseSiteMemberScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
@@ -220,8 +219,8 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
         scopeSession: ScopeSession
     ): FirScope? {
         return when (val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null) {
-            is FirRegularClassSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
+            is FirRegularClassSymbol -> buildDefaultUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession)
-            is FirAnonymousObjectSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
+            is FirAnonymousObjectSymbol -> buildDefaultUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession)
             is FirTypeAliasSymbol -> {
                 val expandedTypeRef = symbol.fir.expandedTypeRef as FirResolvedTypeRef
                 val expandedType = expandedTypeRef.type as? ConeLookupTagBasedType ?: return null