FIR: make simplification around class substitution scope

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAccessResolveTransformer.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
 import org.jetbrains.kotlin.fir.scopes.impl.*
@@ -39,8 +38,7 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
     }
 
     private fun ConeClassLikeType.buildSubstitutionScope(
-        useSiteSession: FirSession,
+        useSiteScope: FirClassUseSiteScope,
-        unsubstituted: FirScope,
         regularClass: FirRegularClass
     ): FirClassSubstitutionScope? {
         if (this.typeArguments.isEmpty()) return null
@@ -50,7 +48,7 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
             typeParameter.symbol to (typeArgument as? ConeTypedProjection)?.type
         }.filter { (_, type) -> type != null }.toMap() as Map<ConeTypeParameterSymbol, ConeKotlinType>
 
-        return FirClassSubstitutionScope(useSiteSession, unsubstituted, substitution, true)
+        return FirClassSubstitutionScope(useSiteScope, substitution)
     }
 
     private fun FirRegularClass.buildUseSiteScope(useSiteSession: FirSession = session): FirClassUseSiteScope {
@@ -61,13 +59,13 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
                 if (useSiteSuperType is ConeClassErrorType) return@mapNotNullTo null
                 val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
                 if (symbol is FirClassSymbol) {
-                    val scope = symbol.fir.buildUseSiteScope(useSiteSession)
+                    val useSiteScope = symbol.fir.buildUseSiteScope(useSiteSession)
-                    useSiteSuperType.buildSubstitutionScope(useSiteSession, scope, symbol.fir) ?: scope
+                    useSiteSuperType.buildSubstitutionScope(useSiteScope, symbol.fir) ?: useSiteScope
                 } else {
                     null
                 }
             }
-        return FirClassUseSiteScope(useSiteSession, superTypeScope, declaredScope, true)
+        return FirClassUseSiteScope(useSiteSession, superTypeScope, declaredScope)
     }
 
     override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirNamedFunction
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirMemberFunctionImpl
@@ -21,13 +20,11 @@ import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.name.Name
 
 class FirClassSubstitutionScope(
-    session: FirSession,
+    private val useSiteScope: FirClassUseSiteScope,
-    private val unsubstituted: FirScope,
+    private val substitution: Map<ConeTypeParameterSymbol, ConeKotlinType>
-    private val substitution: Map<ConeTypeParameterSymbol, ConeKotlinType>,
+) : FirScope {
-    lookupInFir: Boolean
-) : FirAbstractProviderBasedScope(session, lookupInFir) {
 
-    val fakeOverrides = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol>()
+    private val fakeOverrides = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol>()
 
     private fun wrapProjection(old: ConeKotlinTypeProjection, newType: ConeKotlinType): ConeKotlinTypeProjection {
         return when (old) {
@@ -83,7 +80,7 @@ class FirClassSubstitutionScope(
 
 
     override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
-        unsubstituted.processFunctionsByName(name) process@{ original ->
+        useSiteScope.processFunctionsByName(name) process@{ original ->
 
             val function = fakeOverrides.getOrPut(original) { createFakeOverride(original, name) }
             processor(function as ConeFunctionSymbol)
@@ -94,7 +91,7 @@ class FirClassSubstitutionScope(
     }
 
     override fun processPropertiesByName(name: Name, processor: (ConePropertySymbol) -> ProcessorAction): ProcessorAction {
-        return unsubstituted.processPropertiesByName(name, processor)
+        return useSiteScope.processPropertiesByName(name, processor)
     }
 
     private fun createFakeOverride(

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

@@ -30,9 +30,8 @@ import org.jetbrains.kotlin.utils.addToStdlib.cast
 class FirClassUseSiteScope(
     session: FirSession,
     private val superTypesScope: FirScope,
-    private val declaredMemberScope: FirClassDeclaredMemberScope,
+    private val declaredMemberScope: FirScope
-    lookupInFir: Boolean
+) : FirAbstractProviderBasedScope(session, lookupInFir = true) {
-) : FirAbstractProviderBasedScope(session, lookupInFir) {
     //base symbol as key
     val overrides = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol?>()