[analysis api fir] get rid of read only FirDeclaration -> KtSymbol used for completion

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt

@@ -31,11 +31,12 @@ internal class KtFirAnalysisSession
 private constructor(
     private val project: Project,
     val firResolveSession: LLFirResolveSession,
-    internal val firSymbolBuilder: KtSymbolByFirBuilder,
     token: KtLifetimeToken,
     private val mode: AnalysisSessionMode,
 ) : KtAnalysisSession(token) {
 
+    internal val firSymbolBuilder: KtSymbolByFirBuilder = KtSymbolByFirBuilder(firResolveSession, project, token)
+
     @Suppress("AnalysisApiMissingLifetimeCheck")
     override val useSiteModule: KtModule get() = firResolveSession.useSiteKtModule
 
@@ -135,15 +136,10 @@ private constructor(
             token: KtLifetimeToken,
         ): KtFirAnalysisSession {
             val project = firResolveSession.project
-            val firSymbolBuilder = KtSymbolByFirBuilder(
+
-                firResolveSession,
-                project,
-                token
-            )
             return KtFirAnalysisSession(
                 project,
                 firResolveSession,
-                firSymbolBuilder,
                 token,
                 AnalysisSessionMode.REGULAR,
             )

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt

@@ -56,15 +56,15 @@ internal class KtSymbolByFirBuilder private constructor(
     private val project: Project,
     private val firResolveSession: LLFirResolveSession,
     val token: KtLifetimeToken,
-    val withReadOnlyCaching: Boolean,
-    private val symbolsCache: BuilderCache<FirBasedSymbol<*>, KtSymbol>,
-    private val extensionReceiverSymbolsCache: BuilderCache<FirCallableSymbol<*>, KtSymbol>,
-    private val filesCache: BuilderCache<FirFileSymbol, KtFileSymbol>,
-    private val backingFieldCache: BuilderCache<FirBackingFieldSymbol, KtBackingFieldSymbol>,
 ) {
     private val firProvider get() = firResolveSession.useSiteFirSession.symbolProvider
     val rootSession: FirSession = firResolveSession.useSiteFirSession
 
+    private val symbolsCache = BuilderCache<FirBasedSymbol<*>, KtSymbol>()
+    private val extensionReceiverSymbolsCache = BuilderCache<FirCallableSymbol<*>, KtSymbol>()
+    private val filesCache = BuilderCache<FirFileSymbol, KtFileSymbol>()
+    private val backingFieldCache =  BuilderCache<FirBackingFieldSymbol, KtBackingFieldSymbol>()
+
     val classifierBuilder = ClassifierSymbolBuilder()
     val functionLikeBuilder = FunctionLikeSymbolBuilder()
     val variableLikeBuilder = VariableLikeSymbolBuilder()
@@ -72,35 +72,6 @@ internal class KtSymbolByFirBuilder private constructor(
     val anonymousInitializerBuilder = AnonymousInitializerBuilder()
     val typeBuilder = TypeBuilder()
 
-    constructor(
-        firResolveSession: LLFirResolveSession,
-        project: Project,
-        token: KtLifetimeToken
-    ) : this(
-        project = project,
-        token = token,
-        firResolveSession = firResolveSession,
-        withReadOnlyCaching = false,
-        symbolsCache = BuilderCache(),
-        extensionReceiverSymbolsCache = BuilderCache(),
-        backingFieldCache = BuilderCache(),
-        filesCache = BuilderCache(),
-    )
-
-    fun createReadOnlyCopy(newFirResolveSession: LLFirResolveSession): KtSymbolByFirBuilder {
-        check(!withReadOnlyCaching) { "Cannot create readOnly KtSymbolByFirBuilder from a readonly one" }
-        return KtSymbolByFirBuilder(
-            project,
-            token = token,
-            firResolveSession = newFirResolveSession,
-            withReadOnlyCaching = true,
-            symbolsCache = symbolsCache.createReadOnlyCopy(),
-            extensionReceiverSymbolsCache = extensionReceiverSymbolsCache.createReadOnlyCopy(),
-            filesCache = filesCache.createReadOnlyCopy(),
-            backingFieldCache = backingFieldCache.createReadOnlyCopy(),
-        )
-    }
-
     fun buildSymbol(fir: FirDeclaration): KtSymbol =
         buildSymbol(fir.symbol)
 
@@ -618,19 +589,11 @@ internal class KtSymbolByFirBuilder private constructor(
 
 private class BuilderCache<From, To : Any> private constructor(
     private val cache: ConcurrentMap<From, To>,
-    private val isReadOnly: Boolean
 ) {
-    constructor() : this(ContainerUtil.createConcurrentSoftMap(), isReadOnly = false)
+    constructor() : this(ContainerUtil.createConcurrentSoftMap())
-
-    fun createReadOnlyCopy(): BuilderCache<From, To> {
-        check(!isReadOnly) { "Cannot create readOnly BuilderCache from a readonly one" }
-        return BuilderCache(cache, isReadOnly = true)
-    }
 
     inline fun <reified S : To> cache(key: From, calculation: () -> S): S {
-        val value = if (isReadOnly) {
+        val value = cache.getOrPut(key, calculation)
-            cache[key] ?: calculation()
-        } else cache.getOrPut(key, calculation)
         return value as? S
             ?: error("Cannot cast ${value::class} to ${S::class}\n${DebugSymbolRenderer.render(value as KtSymbol)}")
     }