[FIR] Refactoring: create use-site scopes via scope provider

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -161,10 +161,11 @@ abstract class AbstractSimpleFileBenchmark {
         val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
                 .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSession(env, scope)
-        val builder = RawFirBuilder(session, stubMode = false)
+        val firProvider = session.firProvider as FirProviderImpl
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
         val totalTransformer = FirTotalResolveTransformer()
-        val firFile = builder.buildFirFile(file).also((session.firProvider as FirProviderImpl)::recordFile)
+        val firFile = builder.buildFirFile(file).also(firProvider::recordFile)
 
         for (transformer in totalTransformer.transformers) {
             transformer.transformFile(firFile, null)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -325,11 +325,12 @@ object KotlinToJVMBytecodeCompiler {
                 )
 
             }
-            val builder = RawFirBuilder(session, stubMode = false)
+            val firProvider = (session.firProvider as FirProviderImpl)
+            val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
             val resolveTransformer = FirTotalResolveTransformer()
             val firFiles = ktFiles.map {
                 val firFile = builder.buildFirFile(it)
-                (session.firProvider as FirProviderImpl).recordFile(firFile)
+                firProvider.recordFile(firFile)
                 firFile
             }.also {
                 try {

compiler/fir/cones/src/org/jetbrains/kotlin/fir/resolve/substitution/ConeSubstitutor.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.resolve.substitution
+
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker
+
+abstract class ConeSubstitutor : TypeSubstitutorMarker {
+    open fun substituteOrSelf(type: ConeKotlinType): ConeKotlinType = substituteOrNull(type) ?: type
+    abstract fun substituteOrNull(type: ConeKotlinType): ConeKotlinType?
+
+    object Empty : ConeSubstitutor() {
+        override fun substituteOrSelf(type: ConeKotlinType): ConeKotlinType {
+            return type
+        }
+
+        override fun substituteOrNull(type: ConeKotlinType): ConeKotlinType? {
+            return null
+        }
+
+    }
+}
+
+fun ConeSubstitutor.substituteOrNull(type: ConeKotlinType?): ConeKotlinType? {
+    return type?.let { substituteOrNull(it) }
+}

compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/AbstractFir2IrTextTest.kt

@@ -76,12 +76,13 @@ abstract class AbstractFir2IrTextTest : AbstractIrTextTestCase() {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
         val session = createSession(myEnvironment, scope)
 
-        val builder = RawFirBuilder(session, stubMode = false)
+        val firProvider = (session.firProvider as FirProviderImpl)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
         val resolveTransformer = FirTotalResolveTransformer()
         val firFiles = psiFiles.map {
             val firFile = builder.buildFirFile(it)
-            (session.firProvider as FirProviderImpl).recordFile(firFile)
+            firProvider.recordFile(firFile)
             firFile
         }.also {
             try {

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

@@ -23,6 +23,8 @@ import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirDependenciesSymbolProviderImpl
 import org.jetbrains.kotlin.fir.resolve.impl.FirLibrarySymbolProviderImpl
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.FirMemberScopeProvider
 import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
 import org.jetbrains.kotlin.load.java.JavaClassFinder
@@ -41,7 +43,10 @@ class FirJavaModuleBasedSession(
 
     init {
         sessionProvider.sessionCache[moduleInfo] = this
-        val firProvider = FirProviderImpl(this)
+
+        val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
+
+        val firProvider = FirProviderImpl(this, kotlinScopeProvider)
         registerComponent(FirProvider::class, firProvider)
 
         registerComponent(
@@ -84,17 +89,20 @@ class FirLibrarySession private constructor(
     init {
         val javaSymbolProvider = JavaSymbolProvider(this, sessionProvider.project, scope)
 
+        val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
+
         registerComponent(
             FirSymbolProvider::class,
             FirCompositeSymbolProvider(
                 listOf(
-                    FirLibrarySymbolProviderImpl(this),
+                    FirLibrarySymbolProviderImpl(this, kotlinScopeProvider),
                     KotlinDeserializedJvmSymbolsProvider(
                         this, sessionProvider.project,
                         packagePartProvider,
                         javaSymbolProvider,
                         kotlinClassFinder,
-                        javaClassFinder
+                        javaClassFinder,
+                        kotlinScopeProvider
                     ),
                     javaSymbolProvider,
                     FirDependenciesSymbolProviderImpl(this)

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.java
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
+import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
+import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteMemberScope
+import org.jetbrains.kotlin.fir.java.scopes.JavaOverrideChecker
+import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.scopes.ConeSubstitutionScopeKey
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
+import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
+import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScopeWithLazyNestedScope
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.types.ConeClassErrorType
+
+class JavaScopeProvider(
+    val declaredMemberScopeDecorator: (
+        klass: FirClass<*>,
+        declaredMemberScope: FirScope,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ) -> FirScope = { _, declaredMemberScope, _, _ -> declaredMemberScope },
+    val symbolProvider: JavaSymbolProvider
+) : FirScopeProvider() {
+    override fun getUseSiteMemberScope(
+        klass: FirClass<*>,
+        substitutor: ConeSubstitutor,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirScope {
+        val baseScope = buildJavaEnhancementScope(useSiteSession, klass.symbol as FirRegularClassSymbol, scopeSession, mutableSetOf())
+        if (substitutor == ConeSubstitutor.Empty) return baseScope
+        return scopeSession.getOrBuild(klass, ConeSubstitutionScopeKey(substitutor)) {
+            FirClassSubstitutionScope(useSiteSession, baseScope, scopeSession, substitutor)
+        }
+    }
+
+    private fun buildJavaEnhancementScope(
+        useSiteSession: FirSession,
+        symbol: FirRegularClassSymbol,
+        scopeSession: ScopeSession,
+        visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
+    ): JavaClassEnhancementScope {
+        return scopeSession.getOrBuild(symbol, JAVA_ENHANCEMENT) {
+            JavaClassEnhancementScope(
+                useSiteSession,
+                buildUseSiteMemberScopeWithJavaTypes(symbol.fir, useSiteSession, scopeSession, visitedSymbols)
+            )
+        }
+    }
+
+    private fun buildUseSiteMemberScopeWithJavaTypes(
+        regularClass: FirRegularClass,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession,
+        visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
+    ): JavaClassUseSiteMemberScope {
+        return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
+            val declaredScope = if (regularClass is FirJavaClass) declaredMemberScopeWithLazyNestedScope(
+                regularClass,
+                existingNames = regularClass.existingNestedClassifierNames,
+                symbolProvider = symbolProvider
+            ) else declaredMemberScope(regularClass)
+            val wrappedDeclaredScope = declaredMemberScopeDecorator(regularClass, declaredScope, useSiteSession, scopeSession)
+            val superTypeEnhancementScopes =
+                lookupSuperTypes(regularClass, 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 && visitedSymbols.add(symbol)) {
+                            // We need JavaClassEnhancementScope here to have already enhanced signatures from supertypes
+                            val scope = buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, visitedSymbols)
+                            visitedSymbols.remove(symbol)
+                            useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, scope, symbol.fir, scopeSession)
+                        } else {
+                            null
+                        }
+                    }
+            JavaClassUseSiteMemberScope(
+                regularClass, useSiteSession,
+                FirSuperTypeScope.prepareSupertypeScope(
+                    useSiteSession,
+                    JavaOverrideChecker(
+                        useSiteSession,
+                        if (regularClass is FirJavaClass) regularClass.javaTypeParameterStack
+                        else JavaTypeParameterStack.EMPTY
+                    ),
+                    superTypeEnhancementScopes
+                ), wrappedDeclaredScope
+            )
+        }
+    }
+
+
+}
+
+
+private val JAVA_ENHANCEMENT = scopeSessionKey<FirRegularClassSymbol, JavaClassEnhancementScope>()
+private val JAVA_USE_SITE = scopeSessionKey<FirRegularClassSymbol, JavaClassUseSiteMemberScope>()

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

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteMemberScope
 import org.jetbrains.kotlin.fir.java.scopes.JavaOverrideChecker
 import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.symbols.CallableId
@@ -53,6 +54,8 @@ class JavaSymbolProvider(
     private val searchScope: GlobalSearchScope
 ) : AbstractFirSymbolProvider<FirRegularClassSymbol>() {
 
+    private val scopeProvider = JavaScopeProvider(::wrapScopeWithJvmMapped, this)
+
     private val facade: KotlinJavaPsiFacade get() = KotlinJavaPsiFacade.getInstance(project)
 
     private fun findClass(
@@ -77,71 +80,6 @@ class JavaSymbolProvider(
         }
     }
 
-    override fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
-        return buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, mutableSetOf())
-    }
-
-    private fun buildJavaEnhancementScope(
-        useSiteSession: FirSession,
-        symbol: FirRegularClassSymbol,
-        scopeSession: ScopeSession,
-        visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
-    ): JavaClassEnhancementScope {
-        return scopeSession.getOrBuild(symbol, JAVA_ENHANCEMENT) {
-            JavaClassEnhancementScope(
-                useSiteSession,
-                buildJavaUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols)
-            )
-        }
-    }
-
-    private fun buildJavaUseSiteMemberScope(
-        regularClass: FirRegularClass,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession,
-        visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
-    ): JavaClassUseSiteMemberScope {
-        return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
-            val declaredScope = if (regularClass is FirJavaClass) declaredMemberScopeWithLazyNestedScope(
-                regularClass,
-                existingNames = regularClass.existingNestedClassifierNames,
-                symbolProvider = this
-            ) else declaredMemberScope(regularClass)
-            val wrappedDeclaredScope = wrapScopeWithJvmMapped(regularClass, declaredScope, useSiteSession, scopeSession)
-            val superTypeEnhancementScopes =
-                lookupSuperTypes(regularClass, 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 && visitedSymbols.add(symbol)) {
-                            // We need JavaClassEnhancementScope here to have already enhanced signatures from supertypes
-                            val scope = buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, visitedSymbols)
-                            visitedSymbols.remove(symbol)
-                            useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, scope, symbol.fir, scopeSession)
-                        } else {
-                            null
-                        }
-                    }
-            JavaClassUseSiteMemberScope(
-                regularClass, useSiteSession,
-                FirSuperTypeScope.prepareSupertypeScope(
-                    useSiteSession,
-                    JavaOverrideChecker(
-                        useSiteSession,
-                        if (regularClass is FirJavaClass) regularClass.javaTypeParameterStack
-                        else JavaTypeParameterStack.EMPTY
-                    ),
-                    superTypeEnhancementScopes
-                ), wrappedDeclaredScope
-            )
-        }
-    }
-
     private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameter {
         val stored = javaTypeParameterStack.safeGet(this)
         if (stored != null) return stored.fir
@@ -218,7 +156,8 @@ class JavaSymbolProvider(
                     javaClass.classKind, isTopLevel = isTopLevel,
                     isStatic = javaClass.isStatic,
                     javaTypeParameterStack = javaTypeParameterStack,
-                    existingNestedClassifierNames = javaClass.innerClassNames.toList()
+                    existingNestedClassifierNames = javaClass.innerClassNames.toList(),
+                    scopeProvider = scopeProvider
                 ).apply {
                     this.typeParameters += foundClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
                     addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack)
@@ -356,5 +295,3 @@ fun FqName.topLevelName() =
     asString().substringBefore(".")
 
 
-private val JAVA_ENHANCEMENT = scopeSessionKey<FirRegularClassSymbol, JavaClassEnhancementScope>()
-private val JAVA_USE_SITE = scopeSessionKey<FirRegularClassSymbol, JavaClassUseSiteMemberScope>()

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -37,6 +38,7 @@ class FirJavaClass internal constructor(
     override val classKind: ClassKind,
     isTopLevel: Boolean,
     isStatic: Boolean,
+    override val scopeProvider: FirScopeProvider,
     internal val javaTypeParameterStack: JavaTypeParameterStack,
     internal val existingNestedClassifierNames: List<Name>
 ) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass<FirRegularClass> {

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

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -60,7 +61,8 @@ class KotlinDeserializedJvmSymbolsProvider(
     private val packagePartProvider: PackagePartProvider,
     private val javaSymbolProvider: JavaSymbolProvider,
     private val kotlinClassFinder: KotlinClassFinder,
-    private val javaClassFinder: JavaClassFinder
+    private val javaClassFinder: JavaClassFinder,
+    private val kotlinScopeProvider: KotlinScopeProvider
 ) : AbstractFirSymbolProvider<FirClassLikeSymbol<*>>() {
     private val classesCache = HashMap<ClassId, FirRegularClassSymbol>()
     private val typeAliasCache = HashMap<ClassId, FirTypeAliasSymbol?>()
@@ -141,16 +143,6 @@ class KotlinDeserializedJvmSymbolsProvider(
     private val KotlinJvmBinaryClass.isPreReleaseInvisible: Boolean
         get() = classHeader.isPreRelease
 
-    override fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
-        if (classId in handledByJava) return null
-        return buildDefaultUseSiteMemberScope((symbol.fir as FirClass<*>), useSiteSession, scopeSession)
-    }
-
     override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
         return findAndDeserializeClass(classId) ?: findAndDeserializeTypeAlias(classId)
     }
@@ -345,6 +337,7 @@ class KotlinDeserializedJvmSymbolsProvider(
             deserializeClassToSymbol(
                 classId, classProto, symbol, nameResolver, session,
                 JvmBinaryAnnotationDeserializer(session),
+                kotlinScopeProvider,
                 parentContext, this::findAndDeserializeClass
             )
             symbol.fir.declarations.filterIsInstance<FirEnumEntryImpl>().forEach {

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/scopes/JvmMappedScopes.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.resolve.scopes
+
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
+import org.jetbrains.kotlin.fir.FirSession
+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.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.constructType
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.resolve.wrapSubstitutionScopeIfNeed
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.jvm.JvmMappedScope
+import org.jetbrains.kotlin.fir.scopes.scope
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
+
+
+fun wrapScopeWithJvmMapped(
+    klass: FirClass<*>,
+    declaredMemberScope: FirScope,
+    useSiteSession: FirSession,
+    scopeSession: ScopeSession
+): FirScope {
+    val classId = klass.classId
+    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()) {
+        javaClass.scope(ConeSubstitutor.Empty, useSiteSession, scopeSession).let { javaClassUseSiteScope ->
+            val jvmMappedScope = JvmMappedScope(declaredMemberScope, javaClassUseSiteScope, preparedSignatures)
+            if (klass !is FirRegularClass) {
+                jvmMappedScope
+            } else {
+                // We should substitute Java type parameters with base Kotlin type parameters to match overrides properly
+                // It's necessary for MutableMap, which has *two* JavaMappedScope inside (one for itself and another for base Map)
+                (klass.symbol.constructType(
+                    klass.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
+                    false
+                ) as ConeClassLikeType).wrapSubstitutionScopeIfNeed(useSiteSession, jvmMappedScope, klass, scopeSession)
+            }
+        }
+    } else {
+        declaredMemberScope
+    }
+}

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.lightTree.converter.DeclarationsConverter
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.lexer.KotlinLexer
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.parsing.KotlinLightParser
@@ -22,6 +23,7 @@ import java.nio.file.Path
 
 class LightTree2Fir(
     val session: FirSession = object : FirSessionBase(null) {},
+    private val scopeProvider: FirScopeProvider,
     private val stubMode: Boolean = false
 ) {
     //private val ktDummyFile = KtFile(SingleRootFileViewProvider(PsiManager.getInstance(project), LightVirtualFile()), false)
@@ -64,7 +66,7 @@ class LightTree2Fir(
     fun buildFirFile(code: String, fileName: String): FirFile {
         val lightTree = buildLightTree(code)
 
-        return DeclarationsConverter(session, stubMode, lightTree)
+        return DeclarationsConverter(session, scopeProvider, stubMode, lightTree)
             .convertFile(lightTree.root, fileName)
     }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.TypeModifier
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.TypeParameterModifier
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.TypeProjectionModifier
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
@@ -43,6 +44,7 @@ import org.jetbrains.kotlin.name.SpecialNames
 
 class DeclarationsConverter(
     session: FirSession,
+    val scopeProvider: FirScopeProvider,
     private val stubMode: Boolean,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
     context: Context = Context()
@@ -372,6 +374,7 @@ class DeclarationsConverter(
                     className,
                     status,
                     classKind,
+                    scopeProvider,
                     FirRegularClassSymbol(context.currentClassId)
                 )
             } else {
@@ -381,6 +384,7 @@ class DeclarationsConverter(
                     className,
                     status,
                     classKind,
+                    scopeProvider,
                     FirRegularClassSymbol(context.currentClassId)
                 )
             }
@@ -485,7 +489,7 @@ class DeclarationsConverter(
         val delegatedType = delegatedSuperTypeRef ?: implicitAnyType
 
         return withChildClassName(ANONYMOUS_OBJECT_NAME) {
-            FirAnonymousObjectImpl(null, session, FirAnonymousObjectSymbol()).apply {
+            FirAnonymousObjectImpl(null, session, scopeProvider, FirAnonymousObjectSymbol()).apply {
                 annotations += modifiers.annotations
                 this.superTypeRefs += superTypeRefs
                 this.typeRef = superTypeRefs.first()
@@ -536,6 +540,7 @@ class DeclarationsConverter(
                 null,
                 session,
                 enumEntryName,
+                scopeProvider,
                 FirRegularClassSymbol(context.currentClassId)
             )
             firEnumEntry.annotations += modifiers.annotations
@@ -1123,7 +1128,7 @@ class DeclarationsConverter(
         }
         return if (!stubMode) {
             val blockTree = LightTree2Fir.buildLightTreeBlockExpression(block.asText)
-            return DeclarationsConverter(session, stubMode, blockTree, context).convertBlockExpression(blockTree.root)
+            return DeclarationsConverter(session, scopeProvider, stubMode, blockTree, context).convertBlockExpression(blockTree.root)
         } else {
             FirSingleExpressionBlock(
                 FirExpressionStub(null).toReturn()

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/AbstractLightTree2FirConverterTestCase.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.lightTree
 
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
+import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
@@ -15,7 +16,7 @@ import java.nio.file.Paths
 abstract class AbstractLightTree2FirConverterTestCase : AbstractRawFirBuilderTestCase() {
 
     override fun doTest(filePath: String) {
-        val firFile = LightTree2Fir(stubMode = false).buildFirFile(Paths.get(filePath))
+        val firFile = LightTree2Fir(scopeProvider = StubFirScopeProvider, stubMode = false).buildFirFile(Paths.get(filePath))
         val firDump = firFile.render()
 
         val expectedFile = File(filePath.replace(".kt", ".txt"))

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/SimpleTestCase.kt

@@ -14,6 +14,7 @@ import com.intellij.testFramework.TestDataPath
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.FirSessionBase
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
+import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.fir.lightTree.converter.DeclarationsConverter
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.parsing.*
@@ -62,6 +63,7 @@ class SimpleTestCase : AbstractRawFirBuilderTestCase() {
 
         val firFromLightTreeFile = DeclarationsConverter(
             object : FirSessionBase(null) {},
+            StubFirScopeProvider,
             true,
             builder.lightTree
         ).convertFile(builder.lightTree.root)

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/TotalKotlinTest.kt

@@ -12,6 +12,7 @@ import com.intellij.testFramework.TestDataPath
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
+import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners
 import org.junit.runner.RunWith
@@ -46,7 +47,7 @@ class TotalKotlinTest : AbstractRawFirBuilderTestCase() {
         var counter = 0
         var time = 0L
 
-        val lightTreeConverter = LightTree2Fir(stubMode = true)
+        val lightTreeConverter = LightTree2Fir(scopeProvider = StubFirScopeProvider, stubMode = true)
 
         if (onlyLightTree) println("LightTree generation") else println("Fir from LightTree converter")
         println("BASE PATH: $path")

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/benchmark/generators/LightTree2FirGenerator.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.lightTree.benchmark.generators
 import com.intellij.psi.impl.DebugUtil
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
+import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.openjdk.jmh.annotations.Scope
 import org.openjdk.jmh.annotations.State
@@ -16,13 +17,13 @@ import java.io.File
 @State(Scope.Benchmark)
 open class LightTree2FirGenerator : TreeGenerator, AbstractRawFirBuilderTestCase() {
     override fun generateBaseTree(text: String, file: File) {
-        val lightTreeConverter = LightTree2Fir(stubMode = false)
+        val lightTreeConverter = LightTree2Fir(scopeProvider = StubFirScopeProvider, stubMode = false)
         val lightTree = lightTreeConverter.buildLightTree(text)
         DebugUtil.lightTreeToString(lightTree, false)
     }
 
     override fun generateFir(text: String, file: File, stubMode: Boolean) {
-        val lightTreeConverter = LightTree2Fir(stubMode = stubMode)
+        val lightTreeConverter = LightTree2Fir(scopeProvider = StubFirScopeProvider, stubMode = stubMode)
         val firFile = lightTreeConverter.buildFirFile(text, file.name)
         StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString()
     }

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/compare/TreesCompareTest.kt

@@ -12,6 +12,7 @@ import com.intellij.util.PathUtil
 import junit.framework.TestCase
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
+import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.lightTree.walkTopDown
 import org.jetbrains.kotlin.fir.lightTree.walkTopDownWithTestData
@@ -43,7 +44,7 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     }
 
     private fun compareAll(stubMode: Boolean) {
-        val lightTreeConverter = LightTree2Fir(stubMode = stubMode)
+        val lightTreeConverter = LightTree2Fir(scopeProvider = StubFirScopeProvider, stubMode = stubMode)
         compareBase(System.getProperty("user.dir"), withTestData = false) { file ->
             val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
 
@@ -61,7 +62,7 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     }
 
     fun testCompareDiagnostics() {
-        val lightTreeConverter = LightTree2Fir(stubMode = false)
+        val lightTreeConverter = LightTree2Fir(scopeProvider = StubFirScopeProvider, stubMode = false)
         compareBase("compiler/testData/diagnostics/tests", withTestData = true) { file ->
             val notEditedText = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
             val text = notEditedText.replace("(<!>)|(<!.*?!>)".toRegex(), "").replaceAfter(".java", "")

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.dump.MultiModuleHtmlFirDump
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.test.ConfigurationKind
@@ -58,11 +60,12 @@ class FirResolveModularizedTotalKotlinTest : AbstractModularizedTest() {
         val session = createSession(environment, scope, librariesScope, moduleData.qualifiedName)
         val totalTransformer = FirTotalResolveTransformer()
 
+        val firProvider = session.firProvider as FirProviderImpl
         val firFiles = if (useLightTree) {
-            val lightTree2Fir = LightTree2Fir(session, stubMode = false)
+            val lightTree2Fir = LightTree2Fir(session, firProvider.kotlinScopeProvider, stubMode = false)
             bench.buildFiles(lightTree2Fir, moduleData.sources.filter { it.extension == "kt" })
         } else {
-            val builder = RawFirBuilder(session, stubMode = false)
+            val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
             bench.buildFiles(builder, ktFiles)
         }
 

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.references.impl.*
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.ClassId
@@ -37,7 +38,7 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder<PsiElement>(session) {
+class RawFirBuilder(session: FirSession, val scopeProvider: FirScopeProvider, val stubMode: Boolean) : BaseFirBuilder<PsiElement>(session) {
 
     fun buildFirFile(file: KtFile): FirFile {
         return file.accept(Visitor(), Unit) as FirFile
@@ -459,6 +460,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     enumEntry.toFirSourceElement(),
                     session,
                     enumEntry.nameAsSafeName,
+                    scopeProvider,
                     FirRegularClassSymbol(context.currentClassId)
                 )
                 enumEntry.extractAnnotationsTo(firEnumEntry)
@@ -506,6 +508,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                         classOrObject.nameAsSafeName,
                         status,
                         classKind,
+                        scopeProvider,
                         FirRegularClassSymbol(context.currentClassId)
                     )
                 } else {
@@ -515,6 +518,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                         classOrObject.nameAsSafeName,
                         status,
                         classKind,
+                        scopeProvider,
                         FirRegularClassSymbol(context.currentClassId)
                     )
                 }
@@ -564,7 +568,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression, data: Unit): FirElement {
             val objectDeclaration = expression.objectDeclaration
             return withChildClassName(ANONYMOUS_OBJECT_NAME) {
-                FirAnonymousObjectImpl(expression.toFirSourceElement(), session, FirAnonymousObjectSymbol()).apply {
+                FirAnonymousObjectImpl(expression.toFirSourceElement(), session, scopeProvider, FirAnonymousObjectSymbol()).apply {
                     objectDeclaration.extractAnnotationsTo(this)
                     objectDeclaration.extractSuperTypeListEntriesTo(this, null, ClassKind.CLASS)
                     this.typeRef = superTypeRefs.first() // TODO

compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -72,7 +72,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
     }
 
     protected fun KtFile.toFirFile(stubMode: Boolean): FirFile =
-        RawFirBuilder(object : FirSessionBase(null) {}, stubMode).buildFirFile(this)
+        RawFirBuilder(object : FirSessionBase(null) {}, StubFirScopeProvider, stubMode).buildFirFile(this)
 
     private fun FirElement.traverseChildren(result: MutableSet<FirElement> = hashSetOf()): MutableSet<FirElement> {
         if (!result.add(this)) {

compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/StubFirScopeProvider.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.builder
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+
+object StubFirScopeProvider : FirScopeProvider() {
+    override fun getUseSiteMemberScope(
+        klass: FirClass<*>,
+        substitutor: ConeSubstitutor,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirScope {
+        error("Stub")
+    }
+}

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

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.phasedFir
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -291,7 +292,7 @@ class FirCallResolver(
         symbol: FirClassSymbol<*>,
         typeArguments: List<FirTypeProjection>
     ): FirDelegatedConstructorCall? {
-        val scope = symbol.fir.buildUseSiteMemberScope(session, scopeSession) ?: return null
+        val scope = symbol.fir.scope(ConeSubstitutor.Empty, session, scopeSession) ?: return null
         val callInfo = CallInfo(
             CallKind.Function,
             explicitReceiver = null,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -34,6 +35,7 @@ fun deserializeClassToSymbol(
     nameResolver: NameResolver,
     session: FirSession,
     defaultAnnotationDeserializer: AbstractAnnotationDeserializer?,
+    scopeProvider: KotlinScopeProvider,
     parentContext: FirDeserializationContext? = null,
     deserializeNestedClass: (ClassId, FirDeserializationContext) -> FirRegularClassSymbol?
 ) {
@@ -59,6 +61,7 @@ fun deserializeClassToSymbol(
             classId.shortClassName,
             status,
             ProtoEnumFlags.classKind(kind),
+            scopeProvider,
             symbol
         )
     } else {
@@ -68,6 +71,7 @@ fun deserializeClassToSymbol(
             classId.shortClassName,
             status,
             ProtoEnumFlags.classKind(kind),
+            scopeProvider,
             symbol
         )
     }
@@ -120,7 +124,7 @@ fun deserializeClassToSymbol(
                 val enumEntryId = classId.createNestedClassId(enumEntryName)
 
                 val symbol = FirRegularClassSymbol(enumEntryId)
-                FirEnumEntryImpl(null, session, enumEntryId.shortClassName, symbol).apply {
+                FirEnumEntryImpl(null, session, enumEntryId.shortClassName, scopeProvider, symbol).apply {
                     resolvePhase = FirResolvePhase.DECLARATIONS
                     superTypeRefs += FirResolvedTypeRefImpl(
                         null,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt

@@ -114,7 +114,9 @@ class FirDeserializationContext(
 }
 
 // TODO: Move something here
-class FirDeserializationComponents
+class FirDeserializationComponents {
+
+}
 
 class FirMemberDeserializer(private val c: FirDeserializationContext) {
     private val contractDeserializer = FirContractDeserializer(c)

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

@@ -58,68 +58,8 @@ abstract class FirSymbolProvider : FirSessionComponent {
 
     abstract fun getNestedClassifierScope(classId: ClassId): FirScope?
 
-    abstract fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope?
-
-    protected fun wrapScopeWithJvmMapped(
-        klass: FirClass<*>,
-        declaredMemberScope: FirScope,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope {
-        val classId = klass.classId
-        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 { javaClassUseSiteScope ->
-                val jvmMappedScope = JvmMappedScope(declaredMemberScope, javaClassUseSiteScope, preparedSignatures)
-                if (klass !is FirRegularClass) {
-                    jvmMappedScope
-                } else {
-                    // We should substitute Java type parameters with base Kotlin type parameters to match overrides properly
-                    // It's necessary for MutableMap, which has *two* JavaMappedScope inside (one for itself and another for base Map)
-                    (klass.symbol.constructType(
-                        klass.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
-                        false
-                    ) as ConeClassLikeType).wrapSubstitutionScopeIfNeed(useSiteSession, jvmMappedScope, klass, scopeSession)
-                }
-            } ?: declaredMemberScope
-        } else {
-            declaredMemberScope
-        }
-    }
-
     fun buildDefaultUseSiteMemberScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope {
-        return scopeSession.getOrBuild(klass.symbol, USE_SITE) {
+        TODO("REMOVE")
-
-            val declaredScope = declaredMemberScope(klass)
-            val wrappedDeclaredScope = wrapScopeWithJvmMapped(
-                klass, 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.prepareSupertypeScope(useSiteSession, FirStandardOverrideChecker(useSiteSession), scopes),
-                wrappedDeclaredScope
-            )
-        }
     }
 
     open fun getAllCallableNamesInPackage(fqName: FqName): Set<Name> = emptySet()

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

@@ -16,8 +16,10 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.inferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -245,7 +247,7 @@ private fun FirRegularClass.findSingleAbstractMethodByNames(
     var resultMethod: FirSimpleFunction? = null
     var metIncorrectMember = false
 
-    val classUseSiteMemberScope = session.firSymbolProvider.getClassUseSiteMemberScope(classId, session, scopeSession)
+    val classUseSiteMemberScope = this.scope(ConeSubstitutor.Empty, session, scopeSession)
 
     for (candidateName in samCandidateNames) {
         if (classUseSiteMemberScope == null) break

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

@@ -9,8 +9,11 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
+import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -21,12 +24,13 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         is ConeClassLikeType -> {
             val fullyExpandedType = fullyExpandedType(useSiteSession)
             val fir = fullyExpandedType.lookupTag.toSymbol(useSiteSession)?.fir as? FirClass<*> ?: return null
-            fullyExpandedType.wrapSubstitutionScopeIfNeed(
+
-                useSiteSession,
+            val substitution = when (fir) {
-                fir.buildUseSiteMemberScope(useSiteSession, scopeSession)!!,
+                is FirTypeParametersOwner -> createSubstitution(fir.typeParameters, fullyExpandedType.typeArguments, useSiteSession)
-                fir,
+                else -> emptyMap()
-                scopeSession
+            }
-            )
+
+            fir.scope(substitutorByMap(substitution), useSiteSession, scopeSession)
         }
         is ConeTypeParameterType -> {
             // TODO: support LibraryTypeParameterSymbol or get rid of it
@@ -46,12 +50,14 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         )
         is ConeDefinitelyNotNullType -> original.scope(useSiteSession, scopeSession)
         is ConeIntegerLiteralType -> {
+
+            @Suppress("USELESS_CAST") // TODO: remove once fixed: https://youtrack.jetbrains.com/issue/KT-35635
             scopeSession.getOrBuild(
                 FirIntegerLiteralTypeScope.ILT_SYMBOL,
                 FirIntegerLiteralTypeScope.SCOPE_SESSION_KEY
             ) {
                 FirIntegerLiteralTypeScope(useSiteSession)
-            }
+            } as FirScope
         }
         else -> error("Failed type $this")
     }

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

@@ -13,6 +13,9 @@ import org.jetbrains.kotlin.fir.inferenceContext
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.inferenceContext
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.types.*
 
 abstract class SupertypeSupplier {
@@ -46,22 +49,15 @@ val USE_SITE = scopeSessionKey<FirClassSymbol<*>, FirScope>()
 data class SubstitutionScopeKey(val type: ConeClassLikeType) : ScopeSessionKey<FirClassLikeSymbol<*>, FirClassSubstitutionScope>()
 
 fun FirClassSymbol<*>.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
-    return when (this) {
+    return this.fir.buildUseSiteMemberScope(useSiteSession, builder)
-        is FirAnonymousObjectSymbol -> useSiteSession.firSymbolProvider.buildDefaultUseSiteMemberScope(fir, useSiteSession, builder)
-        is FirRegularClassSymbol -> fir.buildUseSiteMemberScope(useSiteSession, builder)
-    }
 }
 
 fun FirClass<*>.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
-    if (classId.isLocal) {
+    return this.scope(ConeSubstitutor.Empty, useSiteSession, builder)
-        // It's not possible to find local class by symbol
-        return useSiteSession.firSymbolProvider.buildDefaultUseSiteMemberScope(this, useSiteSession, builder)
-    }
-    val symbolProvider = useSiteSession.firSymbolProvider
-    return symbolProvider.getClassUseSiteMemberScope(classId, useSiteSession, builder)
 }
 
-private fun createSubstitution(
+/* TODO REMOVE */
+fun createSubstitution(
     typeParameters: List<FirTypeParameter>,
     typeArguments: Array<out ConeKotlinTypeProjection>,
     session: FirSession

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -147,7 +148,7 @@ private fun processConstructors(
                         ) ?: return ProcessorAction.STOP
                     } else basicScope
                 }
-                is FirClassSymbol -> matchedSymbol.buildUseSiteMemberScope(session, scopeSession)
+                is FirClassSymbol -> (matchedSymbol.fir as FirClass<*>).scope(ConeSubstitutor.Empty, session, scopeSession)
             }
 
             val constructorName = when (matchedSymbol) {

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

@@ -13,7 +13,9 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirThisReceiverExpressionImpl
 import org.jetbrains.kotlin.fir.references.impl.FirImplicitThisReference
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -90,10 +92,10 @@ class ImplicitDispatchReceiverValue(
 ) : ImplicitReceiverValue<FirClassSymbol<*>>(boundSymbol, type, useSiteSession, scopeSession) {
     val implicitCompanionScopes: List<FirScope> = run {
         val klass = boundSymbol.fir as? FirRegularClass ?: return@run emptyList()
-        listOfNotNull(klass.companionObject?.buildUseSiteMemberScope(useSiteSession, scopeSession)) +
+        listOfNotNull(klass.companionObject?.scope(ConeSubstitutor.Empty, useSiteSession, scopeSession)) +
                 lookupSuperTypes(klass, lookupInterfaces = false, deep = true, useSiteSession = useSiteSession).mapNotNull {
                     val superClass = (it as? ConeClassLikeType)?.lookupTag?.toSymbol(useSiteSession)?.fir as? FirRegularClass
-                    superClass?.companionObject?.buildUseSiteMemberScope(useSiteSession, scopeSession)
+                    superClass?.companionObject?.scope(ConeSubstitutor.Empty, useSiteSession, scopeSession)
                 }
     }
 }

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

@@ -12,14 +12,21 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.scope
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractImportingScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
+import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.ConeNullability
+import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
 import org.jetbrains.kotlin.fir.types.isExtensionFunctionType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -262,8 +269,13 @@ class QualifiedReceiverTowerLevel(
                 )
             }
             else -> {
-                session.firSymbolProvider.getClassUseSiteMemberScope(classId, session, bodyResolveComponents.scopeSession)
+                val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(classId) ?: return ProcessorAction.NEXT
-                    ?: return ProcessorAction.NEXT
+                when (symbol) {
+                    is FirClassSymbol<*> -> symbol.fir.scope(ConeSubstitutor.Empty, session, bodyResolveComponents.scopeSession)
+                    is FirTypeAliasSymbol ->
+                        symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeKotlinType>()
+                            .scope(session, bodyResolveComponents.scopeSession) ?: return ProcessorAction.NEXT
+                }
             }
         }
 

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

@@ -17,14 +17,6 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
 class FirCompositeSymbolProvider(val providers: List<FirSymbolProvider>) : FirSymbolProvider() {
-    override fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope? {
-        return providers.firstNotNullResult { it.getClassUseSiteMemberScope(classId, useSiteSession, scopeSession) }
-    }
-
     override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         return providers.flatMap { it.getTopLevelCallableSymbols(packageFqName, name) }
     }

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

@@ -48,14 +48,6 @@ open class FirDependenciesSymbolProviderImpl(val session: FirSession) : Abstract
         }
     }
 
-    override fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope? {
-        return dependencyProviders.firstNotNullResult { it.getClassUseSiteMemberScope(classId, useSiteSession, scopeSession) }
-    }
-
     override fun getPackage(fqName: FqName): FqName? {
         return packageCache.lookupCacheOrCalculate(fqName) {
             for (provider in dependencyProviders) {

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

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.getOrPut
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -40,8 +41,11 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import java.io.InputStream
 
-class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider() {
+class FirLibrarySymbolProviderImpl(val session: FirSession, val kotlinScopeProvider: KotlinScopeProvider) : FirSymbolProvider() {
-    private class BuiltInsPackageFragment(stream: InputStream, val fqName: FqName, val session: FirSession) {
+    private class BuiltInsPackageFragment(
+        stream: InputStream, val fqName: FqName, val session: FirSession,
+        val kotlinScopeProvider: KotlinScopeProvider
+    ) {
         lateinit var version: BuiltInsBinaryVersion
 
         val packageProto: ProtoBuf.PackageFragment = run {
@@ -92,7 +96,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
             }
             return lookup.getOrPut(classId, { FirRegularClassSymbol(classId) }) { symbol ->
                 if (shouldBeEnumEntry) {
-                    FirEnumEntryImpl(null, session, classId.shortClassName, symbol).apply {
+                    FirEnumEntryImpl(null, session, classId.shortClassName, kotlinScopeProvider, symbol).apply {
                         resolvePhase = FirResolvePhase.DECLARATIONS
                     }
                 } else {
@@ -101,7 +105,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
 
                     deserializeClassToSymbol(
                         classId, classProto, symbol, nameResolver, session,
-                        null, parentContext,
+                        null, kotlinScopeProvider, parentContext,
                         this::findAndDeserializeClass
                     )
                 }
@@ -123,15 +127,6 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
         }
     }
 
-    override fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
-        return buildDefaultUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession)
-    }
-
     override fun getPackage(fqName: FqName): FqName? {
         if (allPackageFragments.containsKey(fqName)) return fqName
         return null
@@ -145,7 +140,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
         return packageFqNames.map { fqName ->
             val resourcePath = BuiltInSerializerProtocol.getBuiltInsFilePath(fqName)
             val inputStream = streamProvider(resourcePath) ?: throw IllegalStateException("Resource not found in classpath: $resourcePath")
-            BuiltInsPackageFragment(inputStream, fqName, session)
+            BuiltInsPackageFragment(inputStream, fqName, session, kotlinScopeProvider)
         }
     }
 
@@ -177,6 +172,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
                         relativeClassName.shortName(),
                         status,
                         ClassKind.INTERFACE,
+                        kotlinScopeProvider,
                         this
                     ).apply klass@{
                         resolvePhase = FirResolvePhase.DECLARATIONS

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

@@ -12,6 +12,7 @@ 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.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
@@ -23,7 +24,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
-class FirProviderImpl(val session: FirSession) : FirProvider() {
+class FirProviderImpl(val session: FirSession, val kotlinScopeProvider: KotlinScopeProvider) : FirProvider() {
     override fun getFirCallableContainerFile(symbol: FirCallableSymbol<*>): FirFile? {
         symbol.overriddenSymbol?.let {
             return getFirCallableContainerFile(it)
@@ -215,25 +216,6 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
             state.setFrom(newState)
         }
     }
-
-    override fun getClassUseSiteMemberScope(
-        classId: ClassId,
-        useSiteSession: FirSession,
-        scopeSession: ScopeSession
-    ): FirScope? {
-        return when (val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null) {
-            is FirRegularClassSymbol -> buildDefaultUseSiteMemberScope(symbol.fir, 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
-                val lookupTag = expandedType.lookupTag as? ConeClassLikeLookupTag ?: return null
-                getClassUseSiteMemberScope(lookupTag.classId, useSiteSession, scopeSession)
-            }
-            else -> throw IllegalArgumentException("Unexpected FIR symbol in getClassUseSiteMemberScope: $symbol")
-        }
-    }
-
 }
 
 private const val rebuildIndex = true

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt

@@ -9,28 +9,6 @@ import org.jetbrains.kotlin.fir.resolve.withNullability
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
-import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker
-
-
-abstract class ConeSubstitutor : TypeSubstitutorMarker {
-    open fun substituteOrSelf(type: ConeKotlinType): ConeKotlinType = substituteOrNull(type) ?: type
-    abstract fun substituteOrNull(type: ConeKotlinType): ConeKotlinType?
-
-    object Empty : ConeSubstitutor() {
-        override fun substituteOrSelf(type: ConeKotlinType): ConeKotlinType {
-            return type
-        }
-
-        override fun substituteOrNull(type: ConeKotlinType): ConeKotlinType? {
-            return null
-        }
-
-    }
-}
-
-fun ConeSubstitutor.substituteOrNull(type: ConeKotlinType?): ConeKotlinType? {
-    return type?.let { substituteOrNull(it) }
-}
 
 abstract class AbstractConeSubstitutor : ConeSubstitutor() {
     protected fun wrapProjection(old: ConeKotlinTypeProjection, newType: ConeKotlinType): ConeKotlinTypeProjection {
@@ -140,14 +118,14 @@ fun substitutorByMap(substitution: Map<FirTypeParameterSymbol, ConeKotlinType>):
     return ConeSubstitutorByMap(substitution)
 }
 
-class ChainedSubstitutor(private val first: ConeSubstitutor, private val second: ConeSubstitutor) : ConeSubstitutor() {
+data class ChainedSubstitutor(private val first: ConeSubstitutor, private val second: ConeSubstitutor) : ConeSubstitutor() {
     override fun substituteOrNull(type: ConeKotlinType): ConeKotlinType? {
         first.substituteOrNull(type)?.let { return second.substituteOrSelf(it) }
         return second.substituteOrNull(type)
     }
 }
 
-class ConeSubstitutorByMap(val substitution: Map<FirTypeParameterSymbol, ConeKotlinType>) : AbstractConeSubstitutor() {
+data class ConeSubstitutorByMap(val substitution: Map<FirTypeParameterSymbol, ConeKotlinType>) : AbstractConeSubstitutor() {
     override fun substituteType(type: ConeKotlinType): ConeKotlinType? {
         if (type !is ConeTypeParameterType) return null
         return makeNullableIfNeed(type.isMarkedNullable, substitution[type.lookupTag.symbol])

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.scopes
+
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.inferenceContext
+import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
+import org.jetbrains.kotlin.fir.scopes.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.types.*
+
+class KotlinScopeProvider(
+    val declaredMemberScopeDecorator: (
+        klass: FirClass<*>,
+        declaredMemberScope: FirScope,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ) -> FirScope = { _, declaredMemberScope, _, _ -> declaredMemberScope }
+) : FirScopeProvider() {
+
+
+    private fun substitutor(symbol: FirRegularClassSymbol, type: ConeClassLikeType, useSiteSession: FirSession): ConeSubstitutor {
+        if (type.typeArguments.isEmpty()) return ConeSubstitutor.Empty
+        val originalSubstitution = createSubstitution(symbol.fir.typeParameters, type.typeArguments, useSiteSession)
+        return substitutorByMap(originalSubstitution)
+    }
+
+    private fun buildRawUseSiteScope(
+        klass: FirClass<*>,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirScope {
+        return scopeSession.getOrBuild(klass.symbol, USE_SITE) {
+            val declaredScope = declaredMemberScope(klass)
+            val decoratedDeclaredMemberScope =
+                declaredMemberScopeDecorator(klass, 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) {
+                        symbol.fir.scope(substitutor(symbol, useSiteSuperType, useSiteSession), useSiteSession, scopeSession)
+                    } else {
+                        null
+                    }
+                }
+            FirClassUseSiteMemberScope(
+                useSiteSession,
+                FirSuperTypeScope.prepareSupertypeScope(useSiteSession, FirStandardOverrideChecker(useSiteSession), scopes),
+                decoratedDeclaredMemberScope
+            )
+        }
+    }
+
+    override fun getUseSiteMemberScope(
+        klass: FirClass<*>,
+        substitutor: ConeSubstitutor,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirScope {
+        if (substitutor == ConeSubstitutor.Empty) return buildRawUseSiteScope(klass, useSiteSession, scopeSession)
+        return scopeSession.getOrBuild(
+            klass, ConeSubstitutionScopeKey(substitutor)
+        ) {
+            FirClassSubstitutionScope(useSiteSession, buildRawUseSiteScope(klass, useSiteSession, scopeSession), scopeSession, substitutor)
+        }
+    }
+}
+
+
+data class ConeSubstitutionScopeKey(val substitutor: ConeSubstitutor) : ScopeSessionKey<FirClass<*>, FirClassSubstitutionScope>() {}
+
+fun FirClass<*>.scope(substitutor: ConeSubstitutor, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope {
+    return scopeProvider.getUseSiteMemberScope(
+        this, substitutor, useSiteSession, scopeSession
+    )
+}

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

@@ -10,9 +10,11 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.declarations.expandedConeType
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 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.scope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.ClassId
@@ -25,14 +27,16 @@ abstract class FirAbstractImportingScope(
     lookupInFir: Boolean
 ) : FirAbstractProviderBasedScope(session, lookupInFir) {
 
+    // TODO: Rewrite somehow?
     private fun getStaticsScope(classId: ClassId): FirScope? {
-        provider.getClassUseSiteMemberScope(classId, session, scopeSession)?.let { return it }
         val symbol = provider.getClassLikeSymbolByFqName(classId) ?: return null
         if (symbol is FirTypeAliasSymbol) {
             val expansionSymbol = symbol.fir.expandedConeType?.lookupTag?.toSymbol(session)
             if (expansionSymbol != null) {
                 return getStaticsScope(expansionSymbol.classId)
             }
+        } else {
+            return (symbol as FirClassSymbol<*>).fir.scope(ConeSubstitutor.Empty, session, scopeSession)
         }
 
         return null

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

@@ -31,7 +31,7 @@ class FirClassSubstitutionScope(
     private val session: FirSession,
     private val useSiteMemberScope: FirScope,
     scopeSession: ScopeSession,
-    substitution: Map<FirTypeParameterSymbol, ConeKotlinType>
+    private val substitutor: ConeSubstitutor
 ) : FirScope() {
 
     private val fakeOverrideFunctions = mutableMapOf<FirFunctionSymbol<*>, FirFunctionSymbol<*>>()
@@ -39,7 +39,10 @@ class FirClassSubstitutionScope(
     private val fakeOverrideFields = mutableMapOf<FirFieldSymbol, FirFieldSymbol>()
     private val fakeOverrideAccessors = mutableMapOf<FirAccessorSymbol, FirAccessorSymbol>()
 
-    private val substitutor = substitutorByMap(substitution)
+    constructor(
+        session: FirSession, useSiteMemberScope: FirScope, scopeSession: ScopeSession,
+        substitution: Map<FirTypeParameterSymbol, ConeKotlinType>
+    ) : this(session, useSiteMemberScope, scopeSession, substitutorByMap(substitution))
 
     override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         useSiteMemberScope.processFunctionsByName(name) process@{ original ->

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt

@@ -101,18 +101,19 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
     }
 
     private fun mapKtFilesToFirFiles(session: FirSession, ktFiles: List<KtFile>, firFiles: MutableList<FirFile>, useLightTree: Boolean) {
+        val firProvider = (session.firProvider as FirProviderImpl)
         if (useLightTree) {
-            val lightTreeBuilder = LightTree2Fir(session, stubMode = false)
+            val lightTreeBuilder = LightTree2Fir(session, firProvider.kotlinScopeProvider, stubMode = false)
             ktFiles.mapTo(firFiles) {
                 val firFile = lightTreeBuilder.buildFirFile(it.text, it.name)
                 (session.firProvider as FirProviderImpl).recordFile(firFile)
                 firFile
             }
         } else {
-            val firBuilder = RawFirBuilder(session, false)
+            val firBuilder = RawFirBuilder(session, firProvider.kotlinScopeProvider, false)
             ktFiles.mapTo(firFiles) {
                 val firFile = firBuilder.buildFirFile(it)
-                (session.firProvider as FirProviderImpl).recordFile(firFile)
+                firProvider.recordFile(firFile)
                 firFile
             }
         }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -25,13 +25,13 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.createSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.classId
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 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.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
@@ -172,7 +172,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
             val processedJavaClasses = mutableSetOf<FirJavaClass>()
             for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
                 if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
-                val enhancementScope = javaProvider.getClassUseSiteMemberScope(javaClass.classId, session, ScopeSession()).let {
+                val enhancementScope = javaClass.buildUseSiteMemberScope(session, ScopeSession()).let {
                     when (it) {
                         is FirCompositeScope -> it.scopes.filterIsInstance<JavaClassEnhancementScope>().first()
                         is JavaClassEnhancementScope -> it

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -28,6 +29,7 @@ abstract class FirAnonymousObject : FirPureAbstractElement(), FirClass<FirAnonym
     abstract override val superTypeRefs: List<FirTypeRef>
     abstract override val declarations: List<FirDeclaration>
     abstract override val annotations: List<FirAnnotationCall>
+    abstract override val scopeProvider: FirScopeProvider
     abstract override val typeRef: FirTypeRef
     abstract override val symbol: FirAnonymousObjectSymbol
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClass.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -29,6 +30,7 @@ interface FirClass<F : FirClass<F>> : FirClassLikeDeclaration<F>, FirStatement,
     val superTypeRefs: List<FirTypeRef>
     val declarations: List<FirDeclaration>
     override val annotations: List<FirAnnotationCall>
+    val scopeProvider: FirScopeProvider
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
@@ -31,6 +32,7 @@ abstract class FirEnumEntry : FirPureAbstractElement(), FirRegularClass {
     abstract override val status: FirDeclarationStatus
     abstract override val classKind: ClassKind
     abstract override val declarations: List<FirDeclaration>
+    abstract override val scopeProvider: FirScopeProvider
     abstract override val symbol: FirRegularClassSymbol
     abstract override val companionObject: FirRegularClass?
     abstract override val superTypeRefs: List<FirTypeRef>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
@@ -29,6 +30,7 @@ interface FirRegularClass : FirMemberDeclaration, FirTypeParametersOwner, FirCla
     override val status: FirDeclarationStatus
     override val classKind: ClassKind
     override val declarations: List<FirDeclaration>
+    override val scopeProvider: FirScopeProvider
     override val symbol: FirRegularClassSymbol
     val companionObject: FirRegularClass?
     override val superTypeRefs: List<FirTypeRef>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.ClassId
@@ -31,6 +32,7 @@ abstract class FirSealedClass : FirPureAbstractElement(), FirRegularClass {
     abstract override val status: FirDeclarationStatus
     abstract override val classKind: ClassKind
     abstract override val declarations: List<FirDeclaration>
+    abstract override val scopeProvider: FirScopeProvider
     abstract override val symbol: FirRegularClassSymbol
     abstract override val companionObject: FirRegularClass?
     abstract override val superTypeRefs: List<FirTypeRef>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
@@ -26,6 +27,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 class FirAnonymousObjectImpl(
     override val source: FirSourceElement?,
     override val session: FirSession,
+    override val scopeProvider: FirScopeProvider,
     override val symbol: FirAnonymousObjectSymbol
 ) : FirAnonymousObject(), FirModifiableClass<FirAnonymousObject>, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
@@ -32,6 +33,7 @@ class FirClassImpl(
     override val name: Name,
     override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
+    override val scopeProvider: FirScopeProvider,
     override val symbol: FirRegularClassSymbol
 ) : FirPureAbstractElement(), FirRegularClass, FirModifiableRegularClass, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
@@ -33,6 +34,7 @@ class FirEnumEntryImpl(
     override val source: FirSourceElement?,
     override val session: FirSession,
     override val name: Name,
+    override val scopeProvider: FirScopeProvider,
     override val symbol: FirRegularClassSymbol
 ) : FirEnumEntry(), FirModifiableClass<FirRegularClass>, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -31,6 +32,7 @@ interface FirModifiableClass<F : FirClass<F>>  : FirClass<F>, FirAbstractAnnotat
     override val superTypeRefs: MutableList<FirTypeRef>
     override val declarations: MutableList<FirDeclaration>
     override val annotations: MutableList<FirAnnotationCall>
+    override val scopeProvider: FirScopeProvider
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass<F>
 
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
@@ -35,6 +36,7 @@ interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass<FirReg
     override var status: FirDeclarationStatus
     override val classKind: ClassKind
     override val declarations: MutableList<FirDeclaration>
+    override val scopeProvider: FirScopeProvider
     override val symbol: FirRegularClassSymbol
     override var companionObject: FirRegularClass?
     override val superTypeRefs: MutableList<FirTypeRef>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.ClassId
@@ -33,6 +34,7 @@ class FirSealedClassImpl(
     override val name: Name,
     override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
+    override val scopeProvider: FirScopeProvider,
     override val symbol: FirRegularClassSymbol
 ) : FirSealedClass(), FirModifiableRegularClass, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR

compiler/fir/tree/src/org/jetbrains/kotlin/fir/resolve/ScopeSession.kt

@@ -9,8 +9,13 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 
 class ScopeSession {
     private val scopes = hashMapOf<Any, HashMap<ScopeSessionKey<*, *>, FirScope>>()
-    fun <ID : Any, FS : FirScope> getOrBuild(id: ID, key: ScopeSessionKey<ID, FS>, build: () -> FS): FS {
+
-        return scopes.getOrPut(id) {
+    @Deprecated(level = DeprecationLevel.ERROR, message = "Only for getOrBuild")
+    fun scopes() = scopes
+
+    inline fun <reified ID : Any, reified FS : FirScope> getOrBuild(id: ID, key: ScopeSessionKey<ID, FS>, build: () -> FS): FS {
+        @Suppress("DEPRECATION_ERROR")
+        return scopes().getOrPut(id) {
             hashMapOf()
         }.getOrPut(key) {
             build()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScopeProvider.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.scopes
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+
+abstract class FirScopeProvider {
+    abstract fun getUseSiteMemberScope(
+        klass: FirClass<*>,
+        substitutor: ConeSubstitutor,
+        useSiteSession: FirSession,
+        scopeSession: ScopeSession
+    ): FirScope
+}

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FieldSets.kt

@@ -76,4 +76,6 @@ object FieldSets {
     val visibility = field(visibilityType)
 
     val modality = field(modalityType, nullable = true)
+
+    val scopeProvider = field("scopeProvider", firScopeProviderType)
 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.tree.generator.FieldSets.modality
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.name
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.receivers
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.returnTypeRef
+import org.jetbrains.kotlin.fir.tree.generator.FieldSets.scopeProvider
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.status
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.superTypeRefs
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.symbol
@@ -216,6 +217,7 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +superTypeRefs(withReplace = true)
             +declarations
             +annotations
+            +scopeProvider
         }
 
         regularClass.configure {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -60,7 +60,10 @@ val delegateFieldSymbolType = type("fir.symbols.impl", "FirDelegateFieldSymbol")
 val classSymbolType = type("fir.symbols.impl", "FirClassSymbol")
 val typeParameterSymbolType = type("fir.symbols.impl", "FirTypeParameterSymbol")
 
+val firScopeProviderType = type("fir.scopes", "FirScopeProvider")
+
 val pureAbstractElementType = generatedType("FirPureAbstractElement")
 val effectDeclarationType = type("fir.contracts.description", "ConeEffectDeclaration")
 val emptyContractDescriptionType = generatedType("contracts.impl", "FirEmptyContractDescription")
-val firDiagnosticType = generatedType("diagnostics", "FirDiagnostic")
+val firDiagnosticType = generatedType("diagnostics", "FirDiagnostic")
+

compiler/testData/diagnostics/tests/inner/kt6026.fir.kt

@@ -4,5 +4,5 @@ val oo = object {
     // Forbidden in KT-13510
     class Nested
 
-    fun f1() = <!UNRESOLVED_REFERENCE!>Nested<!>(11)
+    fun f1() = <!INAPPLICABLE_CANDIDATE!>Nested<!>(11)
 }

compiler/testData/diagnostics/tests/typealias/javaStaticMembersViaTypeAlias.fir.kt

@@ -25,15 +25,15 @@ typealias KT = KTest
 typealias IT = ITest
 
 // Referencing Java class static members via type alias should be ok
-val testFoo: String = JT.<!UNRESOLVED_REFERENCE!>foo<!>()
+val testFoo: String = JT.foo()
 val seeAlsoFoo: String = JTest.foo()
 // Referencing base Java class static members via type alias for derived Java class should be ok
-val testDerivedFoo: String = JD.<!UNRESOLVED_REFERENCE!>foo<!>()
+val testDerivedFoo: String = JD.foo()
 val seeAlsoDerivedFoo: String = JDerived.foo()
 
 // Referencing nested classes via type alias should be prohibited
 // (in type position and in expression position)
-val testNested1: JT.Nested = JT.<!UNRESOLVED_REFERENCE!>Nested<!>()
+val testNested1: JT.Nested = JT.Nested()
 val testNested2: KT.Nested = KT.Nested()
 val testNested3: IT.Nested = IT.Nested()
 val testInner1: JT.Inner = JT.<!UNRESOLVED_REFERENCE!>Inner<!>()

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -112,11 +112,12 @@ object GenerationUtils {
         val librariesScope = ProjectScope.getLibrariesScope(project)
         val session = createSession(project, scope, librariesScope, "main", packagePartProvider)
 
-        val builder = RawFirBuilder(session, stubMode = false)
+        val firProvider = (session.firProvider as FirProviderImpl)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
         val resolveTransformer = FirTotalResolveTransformer()
         val firFiles = files.map {
             val firFile = builder.buildFirFile(it)
-            (session.firProvider as FirProviderImpl).recordFile(firFile)
+            firProvider.recordFile(firFile)
             firFile
         }.also {
             try {

compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/fir/AbstractFirVisualizer.kt

@@ -34,12 +34,13 @@ abstract class AbstractFirVisualizer : AbstractVisualizer() {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(environment.project))
         val session = createSession(environment, scope)
 
-        val builder = RawFirBuilder(session, stubMode = false)
+        val firProvider = (session.firProvider as FirProviderImpl)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
         val transformer = FirTotalResolveTransformer()
         val firFiles = ktFiles.map {
             val firFile = builder.buildFirFile(it)
-            (session.firProvider as FirProviderImpl).recordFile(firFile)
+            firProvider.recordFile(firFile)
             firFile
         }.also {
             try {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeJavaModuleBasedSession.kt

@@ -17,6 +17,8 @@ import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.calls.jvm.JvmCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
 
 
@@ -31,7 +33,7 @@ class FirIdeJavaModuleBasedSession(
     init {
         registerComponent(
             FirProvider::class,
-            FirIdeProvider(project, scope, this)
+            FirIdeProvider(project, scope, this, KotlinScopeProvider(::wrapScopeWithJvmMapped))
         )
         registerComponent(
             FirSymbolProvider::class,

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeProvider.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.idea.stubindex.*
@@ -29,9 +30,10 @@ import org.jetbrains.kotlin.psi.KtFile
 class FirIdeProvider(
     val project: Project,
     val scope: GlobalSearchScope,
-    val session: FirSession
+    val session: FirSession,
+    kotlinScopeProvider: KotlinScopeProvider
 ) : FirProvider() {
-    private val cacheProvider = FirProviderImpl(session)
+    private val cacheProvider = FirProviderImpl(session, kotlinScopeProvider)
 
     data class FirFileWithStamp(val file: FirFile, val stamp: Long)
 
@@ -67,7 +69,7 @@ class FirIdeProvider(
             if (fileWithStamp != null && fileWithStamp.stamp == modificationStamp) {
                 fileWithStamp.file
             } else {
-                val file = RawFirBuilder(session, stubMode = false).buildFirFile(ktFile)
+                val file = RawFirBuilder(session, cacheProvider.kotlinScopeProvider, stubMode = false).buildFirFile(ktFile)
                 cacheProvider.recordFile(file)
                 fileWithStamp = FirFileWithStamp(file, modificationStamp)
                 files[ktFile] = fileWithStamp
@@ -145,9 +147,4 @@ class FirIdeProvider(
         getFirClassifierByFqName(classId)
         return cacheProvider.getNestedClassifierScope(classId)
     }
-
-    override fun getClassUseSiteMemberScope(classId: ClassId, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
-        getFirClassifierByFqName(classId)
-        return cacheProvider.getClassUseSiteMemberScope(classId, useSiteSession, scopeSession)
-    }
 }

idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.classId
 import org.jetbrains.kotlin.fir.dependenciesWithoutSelf
 import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
 import org.jetbrains.kotlin.fir.java.FirLibrarySession
@@ -26,6 +25,7 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
@@ -86,7 +86,8 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
             val session = createSession(module, provider)
             sessions += session
 
-            val builder = RawFirBuilder(session, stubMode = false)
+            val firProvider = (session.firProvider as FirProviderImpl)
+            val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
             val psiManager = PsiManager.getInstance(project)
 
             val ideaModuleInfo = session.moduleInfo.cast<IdeaModuleInfo>()
@@ -106,7 +107,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
             files.forEach {
                 val file = psiManager.findFile(it) as? KtFile ?: return@forEach
                 val firFile = builder.buildFirFile(file)
-                (session.firProvider as FirProviderImpl).recordFile(firFile)
+                firProvider.recordFile(firFile)
                 firFiles += firFile
             }
             firFilesPerSession[session] = firFiles
@@ -151,7 +152,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
                 val javaProvider = symbolProvider.providers.filterIsInstance<JavaSymbolProvider>().first()
                 for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
                     if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
-                    val enhancementScope = javaProvider.getClassUseSiteMemberScope(javaClass.classId, session, ScopeSession()).let {
+                    val enhancementScope = javaClass.buildUseSiteMemberScope(session, ScopeSession()).let {
                         when (it) {
                             is FirCompositeScope -> it.scopes.filterIsInstance<JavaClassEnhancementScope>().first()
                             is JavaClassEnhancementScope -> it