[FIR] Refactor symbol providers setup for source sessions

- Create only source providers instead of the full list of providers
  at the call-sites of `FirAbstractSessionFactory.createSourceSession`
- Store providers of a session grouped by kind (source/dependency/shared).
  It makes creating the resulting provider for session more convenient.
  Also, it would be helpful during creation of deduplicating provider
  in the scope of KT-75268

Author: demiurg906

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

@@ -123,20 +123,21 @@ abstract class AbstractFirKlibSessionFactory<LIBRARY_CONTEXT, SOURCE_CONTEXT> :
             extensionRegistrars,
             configuration,
             init,
-            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, dependencies ->
-                listOfNotNull(
-                    symbolProvider,
-                    generatedSymbolsProvider,
-                    icData?.let {
-                        KlibIcCacheBasedSymbolProvider(
-                            session,
-                            SingleModuleDataProvider(moduleData),
-                            kotlinScopeProvider,
-                            it,
-                            flexibleTypeFactory = createFlexibleTypeFactory(session),
-                        )
-                    },
-                    *dependencies.toTypedArray(),
+            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider ->
+                SourceProviders(
+                    listOfNotNull(
+                        symbolProvider,
+                        generatedSymbolsProvider,
+                        icData?.let {
+                            KlibIcCacheBasedSymbolProvider(
+                                session,
+                                SingleModuleDataProvider(moduleData),
+                                kotlinScopeProvider,
+                                it,
+                                flexibleTypeFactory = createFlexibleTypeFactory(session),
+                            )
+                        },
+                    )
                 )
             }
         )

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.impl.*
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.utils.addToStdlib.plusIfNotNull
 
 /**
  * This is the base class for factories, which create various sessions for compilation.
@@ -160,7 +161,16 @@ abstract class FirAbstractSessionFactory<LIBRARY_CONTEXT, SOURCE_CONTEXT> {
             registerCommonComponentsAfterExtensionsAreConfigured()
 
             val providers = createProviders(this, kotlinScopeProvider)
-            val providersWithShared = providers + sharedLibrarySession.symbolProvider
+            register(
+                StructuredProviders::class,
+                StructuredProviders(
+                    sourceProviders = emptyList(),
+                    librariesProviders = providers,
+                    sharedProvider = sharedLibrarySession.symbolProvider,
+                )
+            )
+
+            val providersWithShared = providers + sharedLibrarySession.symbolProvider.flatten()
 
             val symbolProvider = FirCachingCompositeSymbolProvider(this, providersWithShared)
             register(FirSymbolProvider::class, symbolProvider)
@@ -188,8 +198,7 @@ abstract class FirAbstractSessionFactory<LIBRARY_CONTEXT, SOURCE_CONTEXT> {
         createProviders: (
             FirSession, FirKotlinScopeProvider, FirSymbolProvider,
             FirSwitchableExtensionDeclarationsSymbolProvider?,
-            dependencies: List<FirSymbolProvider>,
-        ) -> List<FirSymbolProvider>
+        ) -> SourceProviders
     ): FirSession {
         val languageVersionSettings = configuration.languageVersionSettings
         return FirCliSession(sessionProvider, FirSession.Kind.Source).apply session@{
@@ -225,30 +234,52 @@ abstract class FirAbstractSessionFactory<LIBRARY_CONTEXT, SOURCE_CONTEXT> {
             }.configure()
             registerCommonComponentsAfterExtensionsAreConfigured()
 
-            val dependencyProviders = computeDependencyProviderList(moduleData)
+            val structuredDependencyProvidersWithoutSource = computeDependencyProviderList(moduleData)
             val generatedSymbolsProvider = FirSwitchableExtensionDeclarationsSymbolProvider.createIfNeeded(this)
 
-            val providers = createProviders(
+            val (sourceProviders, additionalOptionalAnnotationsProvider) = createProviders(
                 this,
                 kotlinScopeProvider,
                 firProvider.symbolProvider,
                 generatedSymbolsProvider,
-                dependencyProviders,
             )
 
+            val structuredProvidersForModule = StructuredProviders(
+                sourceProviders = sourceProviders,
+                librariesProviders = structuredDependencyProvidersWithoutSource.librariesProviders.plusIfNotNull(additionalOptionalAnnotationsProvider),
+                sharedProvider = structuredDependencyProvidersWithoutSource.sharedProvider,
+            ).also {
+                register(StructuredProviders::class, it)
+            }
+
+            val providersListWithoutSources = buildList {
+                structuredProvidersForModule.librariesProviders.flatMapTo(this) { it.flatten() }
+                addAll(structuredProvidersForModule.sharedProvider.flatten())
+            }.distinct()
+
+            val providersList = structuredProvidersForModule.sourceProviders + providersListWithoutSources
+
             register(
                 FirSymbolProvider::class,
                 FirCachingCompositeSymbolProvider(
-                    this, providers,
+                    this, providersList,
                     expectedCachesToBeCleanedOnce = generatedSymbolsProvider != null
                 )
             )
 
             generatedSymbolsProvider?.let { register(FirSwitchableExtensionDeclarationsSymbolProvider::class, it) }
-            register(DEPENDENCIES_SYMBOL_PROVIDER_QUALIFIED_KEY, FirCachingCompositeSymbolProvider(this, dependencyProviders))
+            register(
+                DEPENDENCIES_SYMBOL_PROVIDER_QUALIFIED_KEY,
+                FirCachingCompositeSymbolProvider(this, providersListWithoutSources)
+            )
         }
     }
 
+    protected data class SourceProviders(
+        val sourceProviders: List<FirSymbolProvider>,
+        val additionalOptionalAnnotationsProvider: FirSymbolProvider? = null,
+    )
+
     protected abstract fun createKotlinScopeProviderForSourceSession(
         moduleData: FirModuleData, languageVersionSettings: LanguageVersionSettings
     ): FirKotlinScopeProvider
@@ -261,21 +292,42 @@ abstract class FirAbstractSessionFactory<LIBRARY_CONTEXT, SOURCE_CONTEXT> {
 
     // ==================================== Utilities ====================================
 
-    private fun FirSession.computeDependencyProviderList(moduleData: FirModuleData): List<FirSymbolProvider> {
+    private fun computeDependencyProviderList(moduleData: FirModuleData): StructuredProviders {
         // dependsOnDependencies can actualize declarations from their dependencies. Because actual declarations can be more specific
         // (e.g. have additional supertypes), the modules must be ordered from most specific (i.e. actual) to most generic (i.e. expect)
         // to prevent false positive resolution errors (see KT-57369 for an example).
-        return (moduleData.dependencies + moduleData.friendDependencies + moduleData.allDependsOnDependencies)
-            .mapNotNull { sessionProvider?.getSession(it) }
-            .flatMap { it.symbolProvider.flatten() }
-            .distinct()
+
+        val providersFromDependencies = (moduleData.dependencies + moduleData.friendDependencies + moduleData.allDependsOnDependencies)
             .sortedBy { it.session.kind }
+            .map { it to it.session.structuredProviders }
+
+        val dependencyProviders = providersFromDependencies.flatMap { (dependencyModuleData, providers) ->
+            when (dependencyModuleData.session.kind) {
+                FirSession.Kind.Library -> providers.librariesProviders.also { check(providers.sourceProviders.isEmpty()) }
+
+                // Dependency providers for common and platform modules are basically the same, so there is no need in duplicating them.
+                FirSession.Kind.Source -> providers.sourceProviders
+            }
+        }
+
+        // Here we are looking for the first binary dependency to support source-source dependency between
+        // regular modules.
+        // TODO(KT-75896): Such dependencies might occur only in old tests, which are not migrated to CLI facades yet.
+        val sharedProvider = providersFromDependencies
+            .first { (moduleData, _) -> moduleData.session.kind == FirSession.Kind.Library }
+            .second.sharedProvider
+
+        return StructuredProviders(
+            sourceProviders = emptyList(),
+            dependencyProviders,
+            sharedProvider
+        )
     }
 
     /* It eliminates dependency and composite providers since the current dependency provider is composite in fact.
     *  To prevent duplications and resolving errors, library or source providers from other modules should be filtered out during flattening.
     *  It depends on the session's kind of the top-level provider */
-    private fun FirSymbolProvider.flatten(): List<FirSymbolProvider> {
+    protected fun FirSymbolProvider.flatten(): List<FirSymbolProvider> {
         val originalSession = session.takeIf { it.kind == FirSession.Kind.Source }
         val result = mutableListOf<FirSymbolProvider>()
 

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

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesPr
 import org.jetbrains.kotlin.fir.resolve.FirJvmActualizingBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.*
+import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
@@ -159,22 +160,24 @@ object FirJvmSessionFactory : FirAbstractSessionFactory<FirJvmSessionFactory.Lib
             extensionRegistrars,
             configuration,
             init,
-            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, dependencies ->
+            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider ->
                 val javaSymbolProvider =
                     JavaSymbolProvider(session, projectEnvironment.getFirJavaFacade(session, moduleData, javaSourcesScope))
                 session.register(JavaSymbolProvider::class, javaSymbolProvider)
 
                 val incrementalCompilationSymbolProviders = createIncrementalCompilationSymbolProviders(session)
 
-                listOfNotNull(
+                val providers = listOfNotNull(
                     symbolProvider,
                     generatedSymbolsProvider,
                     *(incrementalCompilationSymbolProviders?.previousFirSessionsSymbolProviders?.toTypedArray() ?: emptyArray()),
                     incrementalCompilationSymbolProviders?.symbolProviderForBinariesFromIncrementalCompilation,
                     javaSymbolProvider,
-                    initializeForStdlibIfNeeded(projectEnvironment, session, kotlinScopeProvider, dependencies),
-                    *dependencies.toTypedArray(),
-                    incrementalCompilationSymbolProviders?.optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation,
+                    initializeForStdlibIfNeeded(projectEnvironment, session, kotlinScopeProvider),
+                )
+                SourceProviders(
+                    providers,
+                    incrementalCompilationSymbolProviders?.optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation
                 )
             }
         ).also {
@@ -236,14 +239,17 @@ object FirJvmSessionFactory : FirAbstractSessionFactory<FirJvmSessionFactory.Lib
         projectEnvironment: AbstractProjectEnvironment,
         session: FirSession,
         kotlinScopeProvider: FirKotlinScopeProvider,
-        dependencies: List<FirSymbolProvider>,
     ): FirSymbolProvider? {
         return runIf(session.languageVersionSettings.getFlag(AnalysisFlags.stdlibCompilation) && !session.moduleData.isCommon) {
             val kotlinClassFinder = projectEnvironment.getKotlinClassFinder(projectEnvironment.getSearchScopeForProjectLibraries())
             val builtinsSymbolProvider = initializeBuiltinsProvider(session, session.moduleData, kotlinScopeProvider, kotlinClassFinder)
             if (session.moduleData.dependsOnDependencies.isNotEmpty()) {
                 runIf(!session.languageVersionSettings.getFlag(JvmAnalysisFlags.expectBuiltinsAsPartOfStdlib)) {
-                    val refinedSourceSymbolProviders = dependencies.filter { it.session.kind == FirSession.Kind.Source }
+                    val refinedSourceSymbolProviders = session.moduleData.dependsOnDependencies
+                        .map { it.session }
+                        .flatMap { it.symbolProvider.flatten() }
+                        .filter { it.session.kind == FirSession.Kind.Source }
+                        .distinct()
                     FirJvmActualizingBuiltinSymbolProvider(builtinsSymbolProvider, refinedSourceSymbolProviders)
                 }
             } else {

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

@@ -135,7 +135,7 @@ object FirMetadataSessionFactory : FirAbstractSessionFactory<Nothing?, Nothing?>
             extensionRegistrars,
             configuration,
             init,
-            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, dependencies ->
+            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider ->
                 var symbolProviderForBinariesFromIncrementalCompilation: MetadataSymbolProvider? = null
                 incrementalCompilationContext?.let {
                     val precompiledBinariesPackagePartProvider = it.precompiledBinariesPackagePartProvider
@@ -153,12 +153,13 @@ object FirMetadataSessionFactory : FirAbstractSessionFactory<Nothing?, Nothing?>
                     }
                 }
 
-                listOfNotNull(
-                    symbolProvider,
-                    *(incrementalCompilationContext?.previousFirSessionsSymbolProviders?.toTypedArray() ?: emptyArray()),
-                    symbolProviderForBinariesFromIncrementalCompilation,
-                    generatedSymbolsProvider,
-                    *dependencies.toTypedArray(),
+                SourceProviders(
+                    listOfNotNull(
+                        symbolProvider,
+                        *(incrementalCompilationContext?.previousFirSessionsSymbolProviders?.toTypedArray() ?: emptyArray()),
+                        symbolProviderForBinariesFromIncrementalCompilation,
+                        generatedSymbolsProvider,
+                    )
                 )
             }
         )

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2025 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.session
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+
+class StructuredProviders(
+    // source, generated, IC
+    val sourceProviders: List<FirSymbolProvider>,
+    // klib/jar deserialized providers
+    val librariesProviders: List<FirSymbolProvider>,
+    // buitlins, etc
+    val sharedProvider: FirSymbolProvider
+) : FirSessionComponent {
+    fun withSourceProviders(sourceProviders: List<FirSymbolProvider>): StructuredProviders = StructuredProviders(
+        this.sourceProviders + sourceProviders,
+        librariesProviders,
+        sharedProvider,
+    )
+
+    operator fun plus(other: StructuredProviders): StructuredProviders = StructuredProviders(
+        sourceProviders + other.sourceProviders,
+        librariesProviders + other.librariesProviders,
+        sharedProvider,
+    ).also {
+        check(sharedProvider == other.sharedProvider) {
+            "Shared providers should be the same"
+        }
+    }
+}
+
+val FirSession.structuredProviders: StructuredProviders by FirSession.sessionComponentAccessor()

core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt

@@ -408,3 +408,8 @@ inline fun <T, S> MutableList<T>.assignFrom(other: Iterable<S>, transform: (S) -
 fun <T> MutableList<T>.assignFrom(other: Iterable<T>) {
     assignFrom(other) { it }
 }
+
+fun <T : Any> List<T>.plusIfNotNull(element: T?): List<T> = when (element) {
+    null -> this
+    else -> this + element
+}