Rename: Fir...UseSiteScope -> Fir...UseSiteMemberScope

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -195,11 +195,11 @@ class Fir2IrVisitor(
     private fun IrClass.addFakeOverrides(klass: FirClass, processedCallableNames: MutableList<Name>) {
         if (fakeOverrideMode == FakeOverrideMode.NONE) return
         val superTypesCallableNames = klass.collectCallableNamesFromSupertypes()
-        val useSiteScope = (klass as? FirRegularClass)?.buildUseSiteScope(session, ScopeSession()) ?: return
+        val useSiteMemberScope = (klass as? FirRegularClass)?.buildUseSiteMemberScope(session, ScopeSession()) ?: return
         for (name in superTypesCallableNames) {
             if (name in processedCallableNames) continue
             processedCallableNames += name
-            useSiteScope.processFunctionsByName(name) { functionSymbol ->
+            useSiteMemberScope.processFunctionsByName(name) { functionSymbol ->
                 // TODO: think about overloaded functions. May be we should process all names.
                 if (functionSymbol is FirNamedFunctionSymbol) {
                     val originalFunction = functionSymbol.fir
@@ -228,7 +228,7 @@ class Fir2IrVisitor(
                 }
                 ProcessorAction.STOP
             }
-            useSiteScope.processPropertiesByName(name) { propertySymbol ->
+            useSiteMemberScope.processPropertiesByName(name) { propertySymbol ->
                 if (propertySymbol is FirPropertySymbol) {
                     val originalProperty = propertySymbol.fir
                     val origin = IrDeclarationOrigin.FAKE_OVERRIDE

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

@@ -9,13 +9,11 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
-import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.declarations.visibility
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
@@ -23,7 +21,7 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
-import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteScope
+import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
@@ -82,16 +80,16 @@ class JavaSymbolProvider(
         visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
     ): JavaClassEnhancementScope {
         return scopeSession.getOrBuild(symbol, JAVA_ENHANCEMENT) {
-            JavaClassEnhancementScope(useSiteSession, buildJavaUseSiteScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols))
+            JavaClassEnhancementScope(useSiteSession, buildJavaUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols))
         }
     }
 
-    private fun buildJavaUseSiteScope(
+    private fun buildJavaUseSiteMemberScope(
         regularClass: FirRegularClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession,
         visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
-    ): JavaClassUseSiteScope {
+    ): JavaClassUseSiteMemberScope {
         return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
             val declaredScope = declaredMemberScope(regularClass)
             val superTypeEnhancementScopes =
@@ -108,7 +106,7 @@ class JavaSymbolProvider(
                             null
                         }
                     }
-            JavaClassUseSiteScope(
+            JavaClassUseSiteMemberScope(
                 regularClass, useSiteSession,
                 FirSuperTypeScope(useSiteSession, superTypeEnhancementScopes), declaredScope
             )
@@ -312,4 +310,4 @@ fun FqName.topLevelName() =
 
 
 private val JAVA_ENHANCEMENT = scopeSessionKey<JavaClassEnhancementScope>()
-private val JAVA_USE_SITE = scopeSessionKey<JavaClassUseSiteScope>()
+private val JAVA_USE_SITE = scopeSessionKey<JavaClassUseSiteMemberScope>()

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

@@ -71,7 +71,7 @@ internal fun FirTypeRef.toNotNullConeKotlinType(
             val javaType = type
             javaType.toNotNullConeKotlinType(session, javaTypeParameterStack)
         }
-        else -> ConeKotlinErrorType("Unexpected type reference in JavaClassUseSiteScope: ${this::class.java}")
+        else -> ConeKotlinErrorType("Unexpected type reference in JavaClassUseSiteMemberScope: ${this::class.java}")
     }
 
 internal fun JavaType?.toNotNullConeKotlinType(

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

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.java.createConstant
 import org.jetbrains.kotlin.fir.java.topLevelName
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.references.impl.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.*
@@ -143,7 +142,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     ): FirScope? {
         val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
 
-        return symbol.fir.buildDefaultUseSiteScope(session, scopeSession)
+        return symbol.fir.buildDefaultUseSiteMemberScope(session, scopeSession)
     }
 
     override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {

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

@@ -36,9 +36,9 @@ import org.jetbrains.kotlin.utils.Jsr305State
 
 class JavaClassEnhancementScope(
     private val session: FirSession,
-    private val useSiteScope: JavaClassUseSiteScope
+    private val useSiteMemberScope: JavaClassUseSiteMemberScope
 ) : FirScope() {
-    private val owner: FirRegularClass = useSiteScope.symbol.fir
+    private val owner: FirRegularClass = useSiteMemberScope.symbol.fir
 
     private val javaTypeParameterStack: JavaTypeParameterStack =
         if (owner is FirJavaClass) owner.javaTypeParameterStack else JavaTypeParameterStack.EMPTY
@@ -53,7 +53,7 @@ class JavaClassEnhancementScope(
     private val enhancements = mutableMapOf<FirCallableSymbol<*>, FirCallableSymbol<*>>()
 
     override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
-        useSiteScope.processPropertiesByName(name) process@{ original ->
+        useSiteMemberScope.processPropertiesByName(name) process@{ original ->
 
             val field = enhancements.getOrPut(original) { enhance(original, name) }
             processor(field)
@@ -63,7 +63,7 @@ class JavaClassEnhancementScope(
     }
 
     override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
-        useSiteScope.processFunctionsByName(name) process@{ original ->
+        useSiteMemberScope.processFunctionsByName(name) process@{ original ->
 
             val function = enhancements.getOrPut(original) { enhance(original, name) }
             processor(function as FirFunctionSymbol<*>)
@@ -348,8 +348,8 @@ class JavaClassEnhancementScope(
 
     private fun FirCallableMemberDeclaration<*>.overriddenMembers(): List<FirCallableMemberDeclaration<*>> {
         val backMap = overrideBindCache.getOrPut(this.name) {
-            useSiteScope.bindOverrides(this.name)
+            useSiteMemberScope.bindOverrides(this.name)
-            useSiteScope
+            useSiteMemberScope
                 .overrideByBase
                 .toList()
                 .groupBy({ (_, key) -> key }, { (value) -> value })

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

@@ -16,7 +16,7 @@ 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.ProcessorAction.*
-import org.jetbrains.kotlin.fir.scopes.impl.AbstractFirUseSiteScope
+import org.jetbrains.kotlin.fir.scopes.impl.AbstractFirUseSiteMemberScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -24,12 +24,12 @@ import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.name.Name
 
-class JavaClassUseSiteScope(
+class JavaClassUseSiteMemberScope(
     klass: FirRegularClass,
     session: FirSession,
     superTypesScope: FirSuperTypeScope,
     declaredMemberScope: FirScope
-) : AbstractFirUseSiteScope(session, superTypesScope, declaredMemberScope) {
+) : AbstractFirUseSiteMemberScope(session, superTypesScope, declaredMemberScope) {
     internal val symbol = klass.symbol
 
     private val javaTypeParameterStack: JavaTypeParameterStack =

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

@@ -20,7 +20,7 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         is ConeClassLikeType -> {
             // TODO: for ConeClassLikeType they might be a type alias instead of a regular class
             val fir = this.lookupTag.toSymbol(useSiteSession)?.fir as? FirRegularClass ?: return null
-            wrapSubstitutionScopeIfNeed(useSiteSession, fir.buildUseSiteScope(useSiteSession, scopeSession)!!, fir, scopeSession)
+            wrapSubstitutionScopeIfNeed(useSiteSession, fir.buildUseSiteMemberScope(useSiteSession, scopeSession)!!, fir, scopeSession)
         }
         is ConeTypeParameterType -> {
             // TODO: support LibraryTypeParameterSymbol or get rid of it

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

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirClassUseSiteScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirClassUseSiteMemberScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -51,19 +51,19 @@ val USE_SITE = scopeSessionKey<FirScope>()
 
 data class SubstitutionScopeKey(val type: ConeClassLikeType) : ScopeSessionKey<FirClassSubstitutionScope>() {}
 
-fun FirRegularClass.buildUseSiteScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
+fun FirRegularClass.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
     val symbolProvider = useSiteSession.firSymbolProvider
     return symbolProvider.getClassUseSiteMemberScope(this.classId, useSiteSession, builder)
 }
 
-fun FirTypeAlias.buildUseSiteScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
+fun FirTypeAlias.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
     val type = expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()
     return type.scope(useSiteSession, builder)?.let {
         type.wrapSubstitutionScopeIfNeed(useSiteSession, it, this, builder)
     }
 }
 
-fun FirRegularClass.buildDefaultUseSiteScope(useSiteSession: FirSession, builder: ScopeSession): FirScope {
+fun FirRegularClass.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope {
     return builder.getOrBuild(symbol, USE_SITE) {
 
         val declaredScope = declaredMemberScope(this)
@@ -72,30 +72,30 @@ fun FirRegularClass.buildDefaultUseSiteScope(useSiteSession: FirSession, builder
                 if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null
                 val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
                 if (symbol is FirClassSymbol) {
-                    val useSiteScope = symbol.fir.buildUseSiteScope(useSiteSession, builder)!!
+                    val useSiteMemberScope = symbol.fir.buildUseSiteMemberScope(useSiteSession, builder)!!
-                    useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, useSiteScope, symbol.fir, builder)
+                    useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, useSiteMemberScope, symbol.fir, builder)
                 } else {
                     null
                 }
             }
-        FirClassUseSiteScope(useSiteSession, FirSuperTypeScope(useSiteSession, scopes), declaredScope)
+        FirClassUseSiteMemberScope(useSiteSession, FirSuperTypeScope(useSiteSession, scopes), declaredScope)
     }
 }
 
 fun ConeClassLikeType.wrapSubstitutionScopeIfNeed(
     session: FirSession,
-    useSiteScope: FirScope,
+    useSiteMemberScope: FirScope,
     declaration: FirClassLikeDeclaration<*>,
     builder: ScopeSession
 ): FirScope {
-    if (this.typeArguments.isEmpty()) return useSiteScope
+    if (this.typeArguments.isEmpty()) return useSiteMemberScope
     return builder.getOrBuild(declaration.symbol, SubstitutionScopeKey(this)) {
         @Suppress("UNCHECKED_CAST")
         val substitution = declaration.typeParameters.zip(this.typeArguments) { typeParameter, typeArgument ->
             typeParameter.symbol to (typeArgument as? ConeTypedProjection)?.type
         }.filter { (_, type) -> type != null }.toMap() as Map<FirTypeParameterSymbol, ConeKotlinType>
 
-        FirClassSubstitutionScope(session, useSiteScope, builder, substitution)
+        FirClassSubstitutionScope(session, useSiteMemberScope, builder, substitution)
     }
 }
 

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

@@ -350,8 +350,8 @@ private fun processConstructors(
     try {
         if (matchedSymbol != null) {
             val scope = when (matchedSymbol) {
-                is FirTypeAliasSymbol -> matchedSymbol.fir.buildUseSiteScope(session, scopeSession)
+                is FirTypeAliasSymbol -> matchedSymbol.fir.buildUseSiteMemberScope(session, scopeSession)
-                is FirClassSymbol -> matchedSymbol.fir.buildUseSiteScope(session, scopeSession)
+                is FirClassSymbol -> matchedSymbol.fir.buildUseSiteMemberScope(session, scopeSession)
             }
 
 

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

@@ -19,7 +19,7 @@ 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.buildDefaultUseSiteScope
+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 +130,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
         scopeSession: ScopeSession
     ): FirScope? {
         val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
-        return symbol.fir.buildDefaultUseSiteScope(useSiteSession, scopeSession)
+        return symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
     }
 
     override fun getPackage(fqName: FqName): FqName? {

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

@@ -11,7 +11,7 @@ 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.buildDefaultUseSiteScope
+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
@@ -216,7 +216,7 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
         scopeSession: ScopeSession
     ): FirScope? {
         return when (val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null) {
-            is FirClassSymbol -> symbol.fir.buildDefaultUseSiteScope(useSiteSession, scopeSession)
+            is FirClassSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
             is FirTypeAliasSymbol -> {
                 val expandedTypeRef = symbol.fir.expandedTypeRef as FirResolvedTypeRef
                 val expandedType = expandedTypeRef.type as? ConeLookupTagBasedType ?: return null

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
-abstract class AbstractFirUseSiteScope(
+abstract class AbstractFirUseSiteMemberScope(
     session: FirSession,
     protected val superTypesScope: FirSuperTypeScope,
     protected val declaredMemberScope: FirScope

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.Name
 
 class FirClassSubstitutionScope(
     private val session: FirSession,
-    private val useSiteScope: FirScope,
+    private val useSiteMemberScope: FirScope,
     scopeSession: ScopeSession,
     substitution: Map<FirTypeParameterSymbol, ConeKotlinType>
 ) : FirScope() {
@@ -35,7 +35,7 @@ class FirClassSubstitutionScope(
     private val substitutor = substitutorByMap(substitution)
 
     override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
-        useSiteScope.processFunctionsByName(name) process@{ original ->
+        useSiteMemberScope.processFunctionsByName(name) process@{ original ->
 
             val function = fakeOverrideFunctions.getOrPut(original) { createFakeOverrideFunction(original) }
             processor(function)
@@ -46,7 +46,7 @@ class FirClassSubstitutionScope(
     }
 
     override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
-        return useSiteScope.processPropertiesByName(name) process@{ original ->
+        return useSiteMemberScope.processPropertiesByName(name) process@{ original ->
             if (original is FirPropertySymbol) {
                 val property = fakeOverrideProperties.getOrPut(original) { createFakeOverrideProperty(original) }
                 processor(property)

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

@@ -13,11 +13,11 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirClassUseSiteScope(
+class FirClassUseSiteMemberScope(
     session: FirSession,
     superTypesScope: FirSuperTypeScope,
     declaredMemberScope: FirScope
-) : AbstractFirUseSiteScope(session, superTypesScope, declaredMemberScope) {
+) : AbstractFirUseSiteMemberScope(session, superTypesScope, declaredMemberScope) {
 
     override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         val seen = mutableSetOf<FirCallableSymbol<*>>()