FIR: hide construction of JavaSymbolProvider

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

@@ -14,14 +14,13 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
-import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
-import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
+import org.jetbrains.kotlin.load.java.createJavaClassFinder
 import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
@@ -48,22 +47,11 @@ class PsiBasedProjectEnvironment(
     val localFileSystem: VirtualFileSystem,
     val getPackagePartProviderFn: (GlobalSearchScope) -> PackagePartProvider
 ) : AbstractProjectEnvironment {
-
     override fun getKotlinClassFinder(fileSearchScope: AbstractProjectFileSearchScope): KotlinClassFinder =
         VirtualFileFinderFactory.getInstance(project).create(fileSearchScope.asPsiSearchScope())
 
     override fun getJavaClassFinder(fileSearchScope: AbstractProjectFileSearchScope): JavaClassFinder =
-        JavaClassFinderImpl().apply {
+        project.createJavaClassFinder(fileSearchScope.asPsiSearchScope())
-            this.setProjectInstance(project)
-            this.setScope(fileSearchScope.asPsiSearchScope())
-        }
-
-    override fun getJavaSymbolProvider(
-        firSession: FirSession,
-        baseModuleData: FirModuleData,
-        fileSearchScope: AbstractProjectFileSearchScope
-    ): JavaSymbolProvider =
-        JavaSymbolProvider(firSession, baseModuleData, project, fileSearchScope.asPsiSearchScope())
 
     override fun getJavaModuleResolver(): JavaModuleResolver =
         JavaModuleResolver.getInstance(project)

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirSessionFactory.kt

@@ -153,8 +153,7 @@ object FirSessionFactory {
                     kotlinScopeProvider,
                     it.packagePartProvider,
                     projectEnvironment.getKotlinClassFinder(it.scope),
-                    projectEnvironment.getJavaClassFinder(it.scope),
+                    projectEnvironment.getJavaClassFinder(it.scope)
-                    projectEnvironment.getJavaSymbolProvider(this, moduleData, it.scope)
                 )
             }
 
@@ -166,7 +165,7 @@ object FirSessionFactory {
                     listOfNotNull(
                         firProvider.symbolProvider,
                         symbolProviderForBinariesFromIncrementalCompilation,
-                        JavaSymbolProviderWrapper(this, projectEnvironment.getJavaSymbolProvider(this, moduleData, scope)),
+                        JavaSymbolProviderWrapper(this, moduleData, projectEnvironment.getJavaClassFinder(scope)),
                         dependenciesSymbolProvider,
                     )
                 )
@@ -214,8 +213,7 @@ object FirSessionFactory {
                 kotlinScopeProvider,
                 packagePartProvider,
                 projectEnvironment.getKotlinClassFinder(scope),
-                projectEnvironment.getJavaClassFinder(scope),
+                projectEnvironment.getJavaClassFinder(scope)
-                projectEnvironment.getJavaSymbolProvider(this, moduleDataProvider.allModuleData.last(), scope)
             )
 
             val builtinsModuleData = createModuleDataForBuiltins(

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/environment/AbstractProjectEnvironment.kt

@@ -5,9 +5,7 @@
 
 package org.jetbrains.kotlin.fir.session.environment
 
-import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
@@ -40,17 +38,10 @@ interface AbstractProjectFileSearchScope {
 }
 
 interface AbstractProjectEnvironment {
-
     fun getKotlinClassFinder(fileSearchScope: AbstractProjectFileSearchScope): KotlinClassFinder
 
     fun getJavaClassFinder(fileSearchScope: AbstractProjectFileSearchScope): JavaClassFinder
 
-    fun getJavaSymbolProvider(
-        firSession: FirSession,
-        baseModuleData: FirModuleData,
-        fileSearchScope: AbstractProjectFileSearchScope
-    ): JavaSymbolProvider
-
     fun getJavaModuleResolver(): JavaModuleResolver
 
     fun getPackagePartProvider(fileSearchScope: AbstractProjectFileSearchScope): PackagePartProvider

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

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.fir.java
 
 import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.EffectiveVisibility
@@ -42,16 +40,16 @@ import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.JavaElementImpl
-import org.jetbrains.kotlin.load.java.structure.impl.JavaPackageImpl
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.types.Variance.INVARIANT
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-class JavaSymbolProviderWrapper(session: FirSession, private val javaSymbolProvider: JavaSymbolProvider) : FirSymbolProvider(session) {
+class JavaSymbolProviderWrapper(session: FirSession, baseModuleData: FirModuleData, facade: JavaClassFinder) : FirSymbolProvider(session) {
+    private val javaSymbolProvider = JavaSymbolProvider(session, baseModuleData, facade)
+
     private val classCache =
         session.firCachesFactory.createCacheWithPostCompute(
             createValue = { classId: ClassId, parentClassSymbol: FirRegularClassSymbol? ->
@@ -68,14 +66,12 @@ class JavaSymbolProviderWrapper(session: FirSession, private val javaSymbolProvi
     override fun getPackage(fqName: FqName): FqName? =
         javaSymbolProvider.getPackage(fqName)
 
-    override fun getClassLikeSymbolByClassId(classId: ClassId): FirRegularClassSymbol? {
+    override fun getClassLikeSymbolByClassId(classId: ClassId): FirRegularClassSymbol? =
-        return try {
+        try {
-            if (!javaSymbolProvider.hasTopLevelClassOf(classId)) return null
+            if (javaSymbolProvider.hasTopLevelClassOf(classId)) getFirJavaClass(classId) else null
-            getFirJavaClass(classId)
         } catch (e: ProcessCanceledException) {
             null
         }
-    }
 
     private fun getFirJavaClass(classId: ClassId): FirRegularClassSymbol? =
         classCache.getValue(classId, classId.outerClassId?.let { getFirJavaClass(it) })
@@ -93,25 +89,35 @@ class JavaSymbolProviderWrapper(session: FirSession, private val javaSymbolProvi
 @ThreadSafeMutableState
 class JavaSymbolProvider(
     private val session: FirSession,
-    val baseModuleData: FirModuleData,
+    private val baseModuleData: FirModuleData,
-    val project: Project,
+    private val facade: JavaClassFinder
-    private val searchScope: GlobalSearchScope,
 ) {
     companion object {
         val VALUE_METHOD_NAME = Name.identifier("value")
     }
 
-    private val packageCache = session.firCachesFactory.createCache(::findPackage)
+    private val packageCache = session.firCachesFactory.createCache(facade::findPackage)
-    private val knownClassNamesInPackage = session.firCachesFactory.createCache<FqName, Set<String>?>(::getKnownClassNames)
+    private val knownClassNamesInPackage = session.firCachesFactory.createCache(facade::knownClassNamesInPackage)
 
-    private val facade: KotlinJavaPsiFacade get() = KotlinJavaPsiFacade.getInstance(project)
     private val parentClassTypeParameterStackCache = mutableMapOf<FirRegularClassSymbol, JavaTypeParameterStack>()
     private val parentClassEffectiveVisibilityCache = mutableMapOf<FirRegularClassSymbol, EffectiveVisibility>()
 
     fun findClass(classId: ClassId, knownContent: ByteArray? = null): JavaClass? =
-        facade.findClass(JavaClassFinder.Request(classId, knownContent), searchScope)
+        facade.findClass(JavaClassFinder.Request(classId, knownContent))
             ?.takeIf { !it.hasDifferentClassId(classId) && !it.hasMetadataAnnotation() }
 
+    fun getPackage(fqName: FqName): FqName? =
+        try {
+            packageCache.getValue(fqName)?.fqName
+        } catch (e: ProcessCanceledException) {
+            null
+        }
+
+    fun hasTopLevelClassOf(classId: ClassId): Boolean {
+        val knownNames = knownClassNamesInPackage.getValue(classId.packageFqName) ?: return true
+        return classId.relativeClassName.topLevelName() in knownNames
+    }
+
     private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameter {
         return buildTypeParameter {
             moduleData = this@JavaSymbolProvider.baseModuleData
@@ -139,10 +145,6 @@ class JavaSymbolProvider(
     private fun List<JavaTypeParameter>.convertTypeParameters(stack: JavaTypeParameterStack): List<FirTypeParameter> =
         map { it.toFirTypeParameter(stack) }
 
-    fun getPackage(fqName: FqName): FqName? {
-        return packageCache.getValue(fqName)?.fqName
-    }
-
     private fun JavaClass.hasDifferentClassId(lookupClassId: ClassId): Boolean =
         classId != lookupClassId
 
@@ -550,24 +552,6 @@ class JavaSymbolProvider(
         isNullable = false,
     )
 
-    private fun findPackage(fqName: FqName): JavaPackage? {
+    private fun FqName.topLevelName() =
-        return try {
+        asString().substringBefore(".")
-            val facade = KotlinJavaPsiFacade.getInstance(project)
-            val javaPackage = facade.findPackage(fqName.asString(), searchScope) ?: return null
-            JavaPackageImpl(javaPackage, searchScope)
-        } catch (e: ProcessCanceledException) {
-            return null
-        }
-    }
-
-    fun hasTopLevelClassOf(classId: ClassId): Boolean {
-        val knownNames = knownClassNamesInPackage.getValue(classId.packageFqName) ?: return true
-        return classId.relativeClassName.topLevelName() in knownNames
-    }
-
-    private fun getKnownClassNames(packageFqName: FqName): MutableSet<String>? =
-        facade.knownClassNamesInPackage(packageFqName, searchScope)
 }
-
-fun FqName.topLevelName() =
-    asString().substringBefore(".")

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

@@ -9,14 +9,10 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
-import org.jetbrains.kotlin.fir.caches.createCache
-import org.jetbrains.kotlin.fir.caches.firCachesFactory
-import org.jetbrains.kotlin.fir.caches.getValue
 import org.jetbrains.kotlin.fir.declarations.getDeprecationInfos
 import org.jetbrains.kotlin.fir.deserialization.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
-import org.jetbrains.kotlin.fir.java.topLevelName
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -42,16 +38,15 @@ open class KotlinDeserializedJvmSymbolsProvider(
     kotlinScopeProvider: FirKotlinScopeProvider,
     private val packagePartProvider: PackagePartProvider,
     private val kotlinClassFinder: KotlinClassFinder,
-    javaClassFinder: JavaClassFinder,
+    javaClassFinder: JavaClassFinder
-    private val javaSymbolProvider: JavaSymbolProvider
 ) : AbstractFirDeserializedSymbolsProvider(session, moduleDataProvider, kotlinScopeProvider) {
-    private val knownNameInPackageCache = KnownNameInPackageCache(session, javaClassFinder)
+    private val javaSymbolProvider = JavaSymbolProvider(session, moduleDataProvider.allModuleData.last(), javaClassFinder)
     private val annotationsLoader = AnnotationsLoader(session, kotlinClassFinder)
 
     override fun computePackagePartsInfos(packageFqName: FqName): List<PackagePartsCacheData> {
         return packagePartProvider.findPackageParts(packageFqName.asString()).mapNotNull { partName ->
             val classId = ClassId.topLevel(JvmClassName.byInternalName(partName).fqNameForTopLevelClassMaybeWithDollars)
-            if (knownNameInPackageCache.hasNoTopLevelClassOf(classId)) return@mapNotNull null
+            if (!javaSymbolProvider.hasTopLevelClassOf(classId)) return@mapNotNull null
             val (kotlinJvmBinaryClass, byteContent) =
                 kotlinClassFinder.findKotlinClassOrContent(classId) as? KotlinClassFinder.Result.KotlinClass ?: return@mapNotNull null
 
@@ -97,7 +92,7 @@ open class KotlinDeserializedJvmSymbolsProvider(
         javaSymbolProvider.hasTopLevelClassOf(classId)
 
     override fun extractClassMetadata(classId: ClassId, parentContext: FirDeserializationContext?): ClassMetadataFindResult? {
-        if (knownNameInPackageCache.hasNoTopLevelClassOf(classId)) return null
+        if (!javaSymbolProvider.hasTopLevelClassOf(classId)) return null
         val result = try {
             kotlinClassFinder.findKotlinClassOrContent(classId)
         } catch (e: ProcessCanceledException) {
@@ -106,7 +101,11 @@ open class KotlinDeserializedJvmSymbolsProvider(
         val kotlinClass = when (result) {
             is KotlinClassFinder.Result.KotlinClass -> result
             is KotlinClassFinder.Result.ClassFileContent -> {
-                val javaClass = javaSymbolProvider.findClass(classId, result.content) ?: return null
+                val javaClass = try {
+                    javaSymbolProvider.findClass(classId, result.content) ?: return null
+                } catch (e: ProcessCanceledException) {
+                    return null
+                }
                 return ClassMetadataFindResult.NoMetadata { symbol ->
                     javaSymbolProvider.convertJavaClassToFir(symbol, classId.outerClassId?.let(::getClass), javaClass)
                 }
@@ -159,22 +158,6 @@ open class KotlinDeserializedJvmSymbolsProvider(
         return JvmProtoBufUtil.readClassDataFrom(data, strings)
     }
 
-    private class KnownNameInPackageCache(
-        session: FirSession,
-        private val javaClassFinder: JavaClassFinder
-    ) {
-        private val knownClassNamesInPackage = session.firCachesFactory.createCache(javaClassFinder::knownClassNamesInPackage)
-
-        /**
-         * This function returns true if we are sure that no top-level class with this id is available
-         * If it returns false, it means we can say nothing about this id
-         */
-        fun hasNoTopLevelClassOf(classId: ClassId): Boolean {
-            val knownNames = knownClassNamesInPackage.getValue(classId.packageFqName) ?: return false
-            return classId.relativeClassName.topLevelName() !in knownNames
-        }
-    }
-
     private fun String?.toPath(): Path? {
         return this?.let { Paths.get(it).normalize() }
     }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.load.java
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.JavaPackage
 import org.jetbrains.kotlin.load.java.structure.impl.JavaPackageImpl
@@ -24,8 +25,13 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import javax.inject.Inject
 
-class JavaClassFinderImpl : AbstractJavaClassFinder() {
+fun Project.createJavaClassFinder(scope: GlobalSearchScope): JavaClassFinder =
+    JavaClassFinderImpl().apply {
+        setProjectInstance(this@createJavaClassFinder)
+        setScope(scope)
+    }
 
+class JavaClassFinderImpl : AbstractJavaClassFinder() {
     private lateinit var javaFacade: KotlinJavaPsiFacade
 
     @Inject

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/FirIdeSessionFactory.kt

@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper
 import org.jetbrains.kotlin.fir.caches.FirCachesFactory
 import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers
 import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProvider
-import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
-import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.java.JavaSymbolProviderWrapper
 import org.jetbrains.kotlin.fir.java.deserialization.KotlinDeserializedJvmSymbolsProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirDependenciesSymbolProvider
@@ -46,12 +44,9 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.providers.FirIdeLibrariesSess
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.FirIdeProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.FirModuleWithDependenciesSymbolProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.checkCanceled
-import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
-import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
+import org.jetbrains.kotlin.load.java.createJavaClassFinder
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
@@ -149,7 +144,7 @@ internal object FirIdeSessionFactory {
                     this,
                     providers = listOf(
                         provider.symbolProvider,
-                        JavaSymbolProviderWrapper(this@session, JavaSymbolProvider(this@session, moduleData, project, searchScope)),
+                        JavaSymbolProviderWrapper(this, moduleData, project.createJavaClassFinder(searchScope)),
                     ),
                     dependencyProvider
                 )
@@ -180,46 +175,24 @@ internal object FirIdeSessionFactory {
     ): FirIdeLibrariesSession = librariesCache.cached(mainModuleInfo) {
         checkCanceled()
         val searchScope = project.stateConfigurator.createScopeForModuleLibraries(mainModuleInfo)
-        val javaClassFinder = JavaClassFinderImpl().apply {
-            setProjectInstance(project)
-            setScope(searchScope)
-        }
-        val packagePartProvider = project.stateConfigurator.createPackagePartsProvider(mainModuleInfo, searchScope)
-
-        val kotlinClassFinder = VirtualFileFinderFactory.getInstance(project).create(searchScope)
         FirIdeLibrariesSession(project, searchScope, builtinTypes).apply session@{
-            val mainModuleData = FirModuleInfoBasedModuleData(mainModuleInfo).apply { bindSession(this@session) }
-
             registerIdeComponents(project)
             register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
             registerCommonComponents(languageVersionSettings)
             registerCommonJavaComponents(JavaModuleResolver.getInstance(project))
             registerJavaSpecificResolveComponents()
 
-            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
+            val kotlinSymbolProvider = KotlinDeserializedJvmSymbolsProvider(
-
+                this@session,
-            val moduleDataProvider = project.stateConfigurator.createModuleDataProvider(mainModuleInfo)
+                moduleDataProvider = project.stateConfigurator.createModuleDataProvider(mainModuleInfo).apply {
-
+                    allModuleData.forEach { it.bindSession(this@session) }
-            moduleDataProvider.allModuleData.forEach { it.bindSession(this@session) }
+                },
-
+                kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped),
-            val symbolProvider = FirCompositeSymbolProvider(
+                packagePartProvider = project.stateConfigurator.createPackagePartsProvider(mainModuleInfo, searchScope),
-                this,
+                kotlinClassFinder = VirtualFileFinderFactory.getInstance(project).create(searchScope),
-                @OptIn(ExperimentalStdlibApi::class)
+                javaClassFinder = project.createJavaClassFinder(searchScope)
-                buildList {
-                    add(
-                        KotlinDeserializedJvmSymbolsProviderForIde(
-                            this@session,
-                            moduleDataProvider,
-                            kotlinScopeProvider,
-                            packagePartProvider,
-                            kotlinClassFinder,
-                            javaClassFinder,
-                            JavaSymbolProvider(this@session, mainModuleData, project, searchScope)
-                        )
-                    )
-                    addAll((builtinsAndCloneableSession.symbolProvider as FirCompositeSymbolProvider).providers)
-                }
             )
+            val symbolProvider = FirCompositeSymbolProvider(this, listOf(kotlinSymbolProvider, builtinsAndCloneableSession.symbolProvider))
             register(FirProvider::class, FirIdeLibrariesSessionProvider(symbolProvider))
             register(FirSymbolProvider::class, symbolProvider)
             register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
@@ -227,26 +200,6 @@ internal object FirIdeSessionFactory {
         }
     }
 
-    /**
-     * Workaround of SOE for loading classes that loads via parent.
-     * It is not observable in compiler but it is in IDE
-     * TODO: this is probably already unnecessary
-     */
-    private class KotlinDeserializedJvmSymbolsProviderForIde(
-        session: FirSession,
-        moduleDataProvider: ModuleDataProvider,
-        kotlinScopeProvider: FirKotlinScopeProvider,
-        packagePartProvider: PackagePartProvider,
-        kotlinClassFinder: KotlinClassFinder,
-        javaClassFinder: JavaClassFinder,
-        javaSymbolProvider: JavaSymbolProvider
-    ) : KotlinDeserializedJvmSymbolsProvider(
-        session, moduleDataProvider, kotlinScopeProvider, packagePartProvider, kotlinClassFinder,
-        javaClassFinder, javaSymbolProvider
-    ) {
-        override fun shouldLoadParentsFirst(classId: ClassId): Boolean = true
-    }
-
     fun createBuiltinsAndCloneableSession(
         project: Project,
         builtinTypes: BuiltinTypes,