FIR: remove extra layers of caching above JavaSymbolProvider

There needs to be exactly one postcompute-aware cache in order to avoid
breaking recursive calls to getClassLikeSymbolByFqName.

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.session
 
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
@@ -147,16 +146,19 @@ object FirSessionFactory {
             register(FirProvider::class, firProvider)
 
             val symbolProviderForBinariesFromIncrementalCompilation = providerAndScopeForIncrementalCompilation?.let {
-                val javaSymbolProvider = projectEnvironment.getJavaSymbolProvider(this, moduleData, it.scope)
+                FirCompositeSymbolProvider(
-
-                KotlinDeserializedJvmSymbolsProvider(
                     this@session,
-                    SingleModuleDataProvider(moduleData),
+                    listOfNotNull(
-                    kotlinScopeProvider,
+                        KotlinDeserializedJvmSymbolsProvider(
-                    it.packagePartProvider,
+                            this@session,
-                    projectEnvironment.getKotlinClassFinder(it.scope),
+                            SingleModuleDataProvider(moduleData),
-                    javaSymbolProvider,
+                            kotlinScopeProvider,
-                    projectEnvironment.getJavaClassFinder(it.scope)
+                            it.packagePartProvider,
+                            projectEnvironment.getKotlinClassFinder(it.scope),
+                            projectEnvironment.getJavaClassFinder(it.scope)
+                        ),
+                        projectEnvironment.getJavaSymbolProvider(this, moduleData, it.scope)
+                    )
                 )
             }
 
@@ -208,8 +210,6 @@ object FirSessionFactory {
             registerCommonComponents(languageVersionSettings)
             registerCommonJavaComponents()
 
-            val javaSymbolProvider = projectEnvironment.getJavaSymbolProvider(this, moduleDataProvider.allModuleData.last(), scope)
-
             val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
 
             val deserializedProviderForIncrementalCompilation = KotlinDeserializedJvmSymbolsProvider(
@@ -218,7 +218,6 @@ object FirSessionFactory {
                 kotlinScopeProvider = kotlinScopeProvider,
                 packagePartProvider = packagePartProvider,
                 kotlinClassFinder = projectEnvironment.getKotlinClassFinder(scope),
-                javaSymbolProvider = javaSymbolProvider,
                 javaClassFinder = projectEnvironment.getJavaClassFinder(scope)
             )
 
@@ -234,7 +233,7 @@ object FirSessionFactory {
                     deserializedProviderForIncrementalCompilation,
                     FirBuiltinSymbolProvider(this, builtinsModuleData, kotlinScopeProvider),
                     FirCloneableSymbolProvider(this, builtinsModuleData, kotlinScopeProvider),
-                    javaSymbolProvider, // TODO: looks like it can be removed
+                    projectEnvironment.getJavaSymbolProvider(this, moduleDataProvider.allModuleData.last(), scope),
                     FirDependenciesSymbolProviderImpl(this)
                 )
             )

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractFirDeserializedSymbolsProvider.kt

@@ -100,8 +100,6 @@ abstract class AbstractFirDeserializedSymbolsProvider(
             val classPostProcessor: DeserializedClassPostProcessor
         ) : ClassMetadataFindResult()
 
-        class ClassWithoutMetadata(val symbol: FirRegularClassSymbol?) : ClassMetadataFindResult()
-
         object ShouldDeserializeViaParent : ClassMetadataFindResult()
     }
 
@@ -146,7 +144,6 @@ abstract class AbstractFirDeserializedSymbolsProvider(
                 )
                 symbol to postProcessor
             }
-            is ClassMetadataFindResult.ClassWithoutMetadata -> result.symbol to null
             ClassMetadataFindResult.ShouldDeserializeViaParent -> findAndDeserializeClassViaParent(classId) to null
             null -> null to null
         }

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

@@ -42,7 +42,6 @@ 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.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -63,14 +62,22 @@ class JavaSymbolProvider(
     }
 
     private val classCache =
-        session.firCachesFactory.createCacheWithPostCompute(
+        session.firCachesFactory.createCacheWithPostCompute<ClassId, FirRegularClassSymbol?, Nothing?, JavaClass?>(
-            createValue = ::findAndConvertJavaClass,
+            createValue = { classId, _ ->
+                val foundClass = findClass(classId)
+                if (foundClass == null) {
+                    null to null
+                } else {
+                    FirRegularClassSymbol(classId) to foundClass
+                }
+            },
             postCompute = { _, classSymbol, javaClass ->
                 if (classSymbol != null && javaClass != null) {
                     convertJavaClassToFir(classSymbol, javaClass)
                 }
             }
         )
+
     private val packageCache = session.firCachesFactory.createCache(::findPackage)
     private val knownClassNamesInPackage = session.firCachesFactory.createCache<FqName, Set<String>?>(::getKnownClassNames)
 
@@ -80,10 +87,9 @@ class JavaSymbolProvider(
     private val parentClassTypeParameterStackCache = mutableMapOf<FirRegularClassSymbol, JavaTypeParameterStack>()
     private val parentClassEffectiveVisibilityCache = mutableMapOf<FirRegularClassSymbol, EffectiveVisibility>()
 
-    private fun findClass(
+    private fun findClass(classId: ClassId): JavaClass? =
-        classId: ClassId,
+        facade.findClass(JavaClassFinder.Request(classId), searchScope)
-        content: KotlinClassFinder.Result.ClassFileContent?,
+            ?.takeIf { !it.hasDifferentClassId(classId) && !it.hasMetadataAnnotation() }
-    ): JavaClass? = facade.findClass(JavaClassFinder.Request(classId, previouslyFoundClassFileContent = content?.content), searchScope)
 
     @FirSymbolProviderInternals
     override fun getTopLevelCallableSymbolsTo(destination: MutableList<FirCallableSymbol<*>>, packageFqName: FqName, name: Name) {
@@ -133,27 +139,10 @@ class JavaSymbolProvider(
         }
     }
 
-    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirRegularClassSymbol? {
+    private fun getFirJavaClass(classId: ClassId): FirRegularClassSymbol? {
         // Enforce loading of outer class first
         classId.outerClassId?.let { getFirJavaClass(it) }
-
+        return classCache.getValue(classId, null)
-        return classCache.getValue(classId, content)
-    }
-
-    private fun findAndConvertJavaClass(
-        classId: ClassId,
-        content: KotlinClassFinder.Result.ClassFileContent?
-    ): Pair<FirRegularClassSymbol?, JavaClass?> {
-        val foundClass = findClass(classId, content)
-        return if (foundClass == null ||
-            foundClass.hasDifferentClassId(classId) ||
-            foundClass.hasMetadataAnnotation()
-        ) {
-            null to null
-        } else {
-            val symbol = FirRegularClassSymbol(classId)
-            symbol to foundClass
-        }
     }
 
     private fun JavaClass.hasDifferentClassId(lookupClassId: ClassId): Boolean =

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

@@ -42,7 +42,6 @@ open class KotlinDeserializedJvmSymbolsProvider(
     kotlinScopeProvider: FirKotlinScopeProvider,
     private val packagePartProvider: PackagePartProvider,
     private val kotlinClassFinder: KotlinClassFinder,
-    private val javaSymbolProvider: JavaSymbolProvider,
     javaClassFinder: JavaClassFinder,
 ) : AbstractFirDeserializedSymbolsProvider(session, moduleDataProvider, kotlinScopeProvider) {
     private val knownNameInPackageCache = KnownNameInPackageCache(session, javaClassFinder)
@@ -102,9 +101,7 @@ open class KotlinDeserializedJvmSymbolsProvider(
         }
         val kotlinClass = when (result) {
             is KotlinClassFinder.Result.KotlinClass -> result
-            is KotlinClassFinder.Result.ClassFileContent -> {
+            is KotlinClassFinder.Result.ClassFileContent -> return null
-                return ClassMetadataFindResult.ClassWithoutMetadata(readClassFromClassFile(classId, result))
-            }
             null -> return ClassMetadataFindResult.ShouldDeserializeViaParent
         }
         if (kotlinClass.kotlinJvmBinaryClass.classHeader.kind != KotlinClassHeader.Kind.CLASS) return null
@@ -144,10 +141,6 @@ open class KotlinDeserializedJvmSymbolsProvider(
         symbol.fir.replaceDeprecation(symbol.fir.getDeprecationInfos(session.languageVersionSettings.apiVersion))
     }
 
-    private fun readClassFromClassFile(classId: ClassId, classFile: KotlinClassFinder.Result.ClassFileContent): FirRegularClassSymbol? {
-        return javaSymbolProvider.getFirJavaClass(classId, classFile)
-    }
-
     private fun KotlinClassFinder.Result.KotlinClass.extractMetadata(): Pair<NameResolver, ProtoBuf.Class>? {
         val data = kotlinJvmBinaryClass.classHeader.data ?: return null
         val strings = kotlinJvmBinaryClass.classHeader.strings ?: return null

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/providers/FirThreadSafeSymbolProviderWrapper.kt

@@ -1,89 +0,0 @@
-/*
- * Copyright 2010-2020 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.idea.fir.low.level.api.providers
-
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
-import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
-import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import java.util.concurrent.locks.ReadWriteLock
-import java.util.concurrent.locks.ReentrantReadWriteLock
-import kotlin.concurrent.withLock
-
-internal class FirThreadSafeSymbolProviderWrapper(private val provider: FirSymbolProvider) : FirSymbolProvider(provider.session) {
-    private val lock = ReentrantReadWriteLock()
-    private val classesCache = ThreadSafeCache<ClassId, FirClassLikeSymbol<*>>(lock)
-    private val topLevelCache = ThreadSafeCache<CallableId, List<FirCallableSymbol<*>>>(lock)
-    private val packages = ThreadSafeCache<FqName, FqName>(lock)
-
-    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? =
-        classesCache.getOrCompute(classId) {
-            provider.getClassLikeSymbolByFqName(classId)
-        }
-
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> =
-        topLevelCache.getOrCompute(CallableId(packageFqName, name)) {
-            provider.getTopLevelCallableSymbols(packageFqName, name)
-        } ?: emptyList()
-
-    override fun getTopLevelFunctionSymbols(packageFqName: FqName, name: Name): List<FirNamedFunctionSymbol> {
-        return getTopLevelCallableSymbols(packageFqName, name).filterIsInstance<FirNamedFunctionSymbol>()
-    }
-
-    override fun getTopLevelPropertySymbols(packageFqName: FqName, name: Name): List<FirPropertySymbol> {
-        return getTopLevelCallableSymbols(packageFqName, name).filterIsInstance<FirPropertySymbol>()
-    }
-
-    @FirSymbolProviderInternals
-    override fun getTopLevelCallableSymbolsTo(destination: MutableList<FirCallableSymbol<*>>, packageFqName: FqName, name: Name) {
-        error("Should not be called for wrapper")
-    }
-
-    @FirSymbolProviderInternals
-    override fun getTopLevelFunctionSymbolsTo(destination: MutableList<FirNamedFunctionSymbol>, packageFqName: FqName, name: Name) {
-        destination += getTopLevelFunctionSymbols(packageFqName, name)
-    }
-
-    @FirSymbolProviderInternals
-    override fun getTopLevelPropertySymbolsTo(destination: MutableList<FirPropertySymbol>, packageFqName: FqName, name: Name) {
-        destination += getTopLevelPropertySymbols(packageFqName, name)
-    }
-
-    override fun getPackage(fqName: FqName): FqName? =
-        packages.getOrCompute(fqName) { provider.getPackage(fqName) }
-}
-
-private class ThreadSafeCache<KEY, VALUE : Any>(private val lock: ReadWriteLock) {
-    private val map = HashMap<KEY, Any>()
-
-    @OptIn(PrivateForInline::class)
-    inline fun getOrCompute(key: KEY, compute: () -> VALUE?): VALUE? {
-        var value = lock.readLock().withLock { map[key] }
-        if (value == null) {
-            lock.writeLock().withLock {
-                value = compute() ?: NULLABLE_VALUE
-                map[key] = value!!
-            }
-        }
-        @Suppress("UNCHECKED_CAST")
-        return when (value) {
-            NULLABLE_VALUE -> null
-            null -> error("We should not read null from map here")
-            else -> value as VALUE
-        }
-    }
-}
-
-@Suppress("ClassName")
-@PrivateForInline
-internal object NULLABLE_VALUE

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

@@ -46,7 +46,6 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.providers.FirIdeBuiltinsAndCl
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.FirIdeLibrariesSessionProvider
 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.providers.FirThreadSafeSymbolProviderWrapper
 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
@@ -197,8 +196,6 @@ internal object FirIdeSessionFactory {
             registerCommonJavaComponents()
             registerJavaSpecificResolveComponents()
 
-            val javaSymbolProvider = JavaSymbolProvider(this, mainModuleData, project, searchScope)
-
             val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
 
             val moduleDataProvider = project.stateConfigurator.createModuleDataProvider(mainModuleInfo)
@@ -210,19 +207,16 @@ internal object FirIdeSessionFactory {
                 @OptIn(ExperimentalStdlibApi::class)
                 buildList {
                     add(
-                        FirThreadSafeSymbolProviderWrapper(
+                        KotlinDeserializedJvmSymbolsProviderForIde(
-                            KotlinDeserializedJvmSymbolsProviderForIde(
+                            this@session,
-                                this@session,
+                            moduleDataProvider,
-                                moduleDataProvider,
+                            kotlinScopeProvider,
-                                kotlinScopeProvider,
+                            packagePartProvider,
-                                packagePartProvider,
+                            kotlinClassFinder,
-                                kotlinClassFinder,
+                            javaClassFinder
-                                javaSymbolProvider,
-                                javaClassFinder
-                            )
                         )
                     )
-                    add(javaSymbolProvider)
+                    add(JavaSymbolProvider(this@session, mainModuleData, project, searchScope))
                     addAll((builtinsAndCloneableSession.symbolProvider as FirCompositeSymbolProvider).providers)
                 }
             )
@@ -244,11 +238,10 @@ internal object FirIdeSessionFactory {
         kotlinScopeProvider: FirKotlinScopeProvider,
         packagePartProvider: PackagePartProvider,
         kotlinClassFinder: KotlinClassFinder,
-        javaSymbolProvider: JavaSymbolProvider,
         javaClassFinder: JavaClassFinder
     ) : KotlinDeserializedJvmSymbolsProvider(
         session, moduleDataProvider, kotlinScopeProvider, packagePartProvider, kotlinClassFinder,
-        javaSymbolProvider, javaClassFinder
+        javaClassFinder
     ) {
         override fun getClass(
             classId: ClassId,