[FIR] Cleanup session creation utils

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
-import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
@@ -150,7 +150,7 @@ abstract class AbstractSimpleFileBenchmark {
     private fun analyzeGreenFileIr(bh: Blackhole) {
         val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
-        val session = createSession(env, scope)
+        val session = createSessionForTests(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
 

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

@@ -57,9 +57,7 @@ import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
 import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers
-import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.createSessionWithDependencies
-import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo
-import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
@@ -318,25 +316,26 @@ object KotlinToJVMBytecodeCompiler {
             if (!checkKotlinPackageUsage(environment, ktFiles)) return false
             val moduleConfiguration = projectConfiguration.applyModuleProperties(module, buildFile)
 
-            val scope = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile })
+            val sourceScope = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile })
                 .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
-            val provider = FirProjectSessionProvider()
 
-            val librariesModuleInfo = FirJvmModuleInfo.createForLibraries()
             val librariesScope = ProjectScope.getLibrariesScope(project)
-            FirSessionFactory.createLibrarySession(
-                librariesModuleInfo, provider, librariesScope,
-                project, environment.createPackagePartProvider(librariesScope)
-            )
 
-            val moduleInfo = FirJvmModuleInfo(module, listOf(librariesModuleInfo))
+            val languageVersionSettings = moduleConfiguration.languageVersionSettings
-            val session = FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, scope, project) {
+            val session = createSessionWithDependencies(
+                module,
+                project,
+                languageVersionSettings,
+                sourceScope,
+                librariesScope,
+                environment::createPackagePartProvider
+            ) {
                 if (extendedAnalysisMode) {
                     registerExtendedCommonCheckers()
                 }
             }
 
-            val firAnalyzerFacade = FirAnalyzerFacade(session, moduleConfiguration.languageVersionSettings, ktFiles)
+            val firAnalyzerFacade = FirAnalyzerFacade(session, languageVersionSettings, ktFiles)
 
             firAnalyzerFacade.runResolution()
             val firDiagnostics = firAnalyzerFacade.runCheckers().values.flatten()

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt

@@ -38,7 +38,7 @@ abstract class AbstractFirLoadCompiledKotlin : AbstractFirLoadBinariesTest() {
         val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
         prepareProjectExtensions(environment.project)
-        val sessionWithDependency = createSession(environment, GlobalSearchScope.EMPTY_SCOPE)
+        val sessionWithDependency = createSessionForTests(environment, GlobalSearchScope.EMPTY_SCOPE)
 
         val testDataDirectoryPath =
             "compiler/fir/analysis-tests/testData/loadCompiledKotlin/" +

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt

@@ -18,7 +18,7 @@ class BuiltInsDeserializationForFirTestCase : AbstractFirLoadBinariesTest() {
 
     fun testBuiltInPackagesContent() {
         val moduleDescriptor = BuiltinsTestUtils.compileBuiltinsModule(environment)
-        val session = createSession(environment, GlobalSearchScope.allScope(project))
+        val session = createSessionForTests(environment, GlobalSearchScope.allScope(project))
         for (packageFqName in BuiltinsTestUtils.BUILTIN_PACKAGE_NAMES) {
             val path = "compiler/fir/analysis-tests/testData/builtIns/" + packageFqName.asString().replace('.', '-') + ".txt"
             checkPackageContent(session, packageFqName, moduleDescriptor, path)

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
@@ -131,7 +131,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
 
         val scope = GlobalSearchScope.filesScope(project, virtualFiles)
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
-        val session = createSession(environment, scope)
+        val session = createSessionForTests(environment, scope)
 
         val topPsiClasses = psiFiles.flatMap { it.getChildrenOfType<PsiClass>().toList() }
 

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/sessionCreationUtils.kt

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2010-2021 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
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
+import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
+import org.jetbrains.kotlin.modules.Module
+import org.jetbrains.kotlin.name.Name
+
+fun createSessionWithDependencies(
+    name: Name,
+    friendPaths: List<String>,
+    outputDirectory: String?,
+    project: Project,
+    languageVersionSettings: LanguageVersionSettings,
+    sourceScope: GlobalSearchScope,
+    librariesScope: GlobalSearchScope,
+    packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
+    sessionConfigurator: FirSessionFactory.FirSessionConfigurator.() -> Unit = {}
+): FirSession {
+    return createSessionWithDependencies(
+        name.identifier,
+        project,
+        languageVersionSettings,
+        sourceScope,
+        librariesScope,
+        packagePartProvider,
+        sessionConfigurator
+    ) {
+        FirJvmModuleInfo(name, it, friendPaths, outputDirectory)
+    }
+}
+
+fun createSessionWithDependencies(
+    module: Module,
+    project: Project,
+    languageVersionSettings: LanguageVersionSettings,
+    sourceScope: GlobalSearchScope,
+    librariesScope: GlobalSearchScope,
+    packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
+    sessionConfigurator: FirSessionFactory.FirSessionConfigurator.() -> Unit = {}
+): FirSession {
+    return createSessionWithDependencies(
+        module.getModuleName(),
+        project,
+        languageVersionSettings,
+        sourceScope,
+        librariesScope,
+        packagePartProvider,
+        sessionConfigurator
+    ) {
+        FirJvmModuleInfo(module, it)
+    }
+}
+
+private inline fun createSessionWithDependencies(
+    moduleName: String,
+    project: Project,
+    languageVersionSettings: LanguageVersionSettings,
+    sourceScope: GlobalSearchScope,
+    librariesScope: GlobalSearchScope,
+    packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
+    noinline sessionConfigurator: FirSessionFactory.FirSessionConfigurator.() -> Unit,
+    moduleInfoProvider: (dependencies: List<ModuleInfo>) -> ModuleInfo,
+): FirSession {
+    val provider = FirProjectSessionProvider()
+    val librariesModuleInfo = FirJvmModuleInfo.createForLibraries(moduleName)
+    FirSessionFactory.createLibrarySession(
+        librariesModuleInfo, provider, librariesScope,
+        project, packagePartProvider(librariesScope)
+    )
+    return FirSessionFactory.createJavaModuleBasedSession(
+        moduleInfoProvider(listOf(librariesModuleInfo)),
+        provider,
+        sourceScope,
+        project,
+        languageVersionSettings = languageVersionSettings,
+        init = sessionConfigurator
+    )
+}

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

@@ -156,7 +156,7 @@ class FirResolveModularizedTotalKotlinTest : AbstractModularizedTest() {
         val scope = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile })
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
         val librariesScope = ProjectScope.getLibrariesScope(project)
-        val session = createSession(environment, scope, librariesScope, moduleData.qualifiedName)
+        val session = createSessionForTests(environment, scope, librariesScope, moduleData.qualifiedName)
         val scopeSession = ScopeSession()
         val processors = createAllCompilerResolveProcessors(session, scopeSession).let {
             if (RUN_CHECKERS) {

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

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
-import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
@@ -104,7 +104,7 @@ object GenerationUtils {
         val scope = GlobalSearchScope.filesScope(project, files.map { it.virtualFile })
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
         val librariesScope = ProjectScope.getLibrariesScope(project)
-        val session = createSession(project, scope, librariesScope, "main", packagePartProvider)
+        val session = createSessionForTests(project, scope, librariesScope, "main", packagePartProvider = packagePartProvider)
 
         // TODO: add running checkers and check that it's safe to compile
         val firAnalyzerFacade = FirAnalyzerFacade(session, configuration.languageVersionSettings, files)

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirTestModuleInfo.kt

@@ -1,22 +0,0 @@
-/*
- * Copyright 2010-2018 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
-
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
-import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
-
-class FirTestModuleInfo(
-    override val name: Name = Name.identifier("TestModule"),
-    val dependencies: MutableList<ModuleInfo> = mutableListOf(),
-    override val platform: TargetPlatform = JvmPlatforms.unspecifiedJvmPlatform,
-    override val analyzerServices: PlatformDependentAnalyzerServices = JvmPlatformAnalyzerServices
-) : ModuleInfo {
-    override fun dependencies(): List<ModuleInfo> = dependencies
-}

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/SessionTestUtils.kt

@@ -8,42 +8,42 @@ package org.jetbrains.kotlin.fir
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.name.Name
 
-fun createSession(
+fun createSessionForTests(
     environment: KotlinCoreEnvironment,
     sourceScope: GlobalSearchScope,
     librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope),
-    moduleName: String = "TestModule"
+    moduleName: String = "TestModule",
-): FirSession = createSession(environment.project, sourceScope, librariesScope, moduleName, environment::createPackagePartProvider)
+    friendPaths: List<String> = emptyList()
+): FirSession = createSessionForTests(
+    environment.project,
+    sourceScope,
+    librariesScope,
+    moduleName,
+    friendPaths,
+    environment::createPackagePartProvider
+)
 
-fun createSession(
+fun createSessionForTests(
     project: Project,
     sourceScope: GlobalSearchScope,
     librariesScope: GlobalSearchScope,
     moduleName: String = "TestModule",
+    friendPaths: List<String> = emptyList(),
     packagePartProvider: (GlobalSearchScope) -> PackagePartProvider
 ): FirSession {
-    val moduleInfo = FirTestModuleInfo(name = Name.identifier(moduleName))
+    return createSessionWithDependencies(
-    val provider = FirProjectSessionProvider()
+        Name.identifier(moduleName),
-    return FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, sourceScope, project).also {
+        friendPaths,
-        createSessionForDependencies(project, provider, moduleInfo, librariesScope, packagePartProvider)
+        outputDirectory = null,
-    }
+        project,
-}
+        languageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-
+        sourceScope,
-private fun createSessionForDependencies(
+        librariesScope,
-    project: Project,
+        packagePartProvider
-    provider: FirProjectSessionProvider,
-    moduleInfo: FirTestModuleInfo,
-    librariesScope: GlobalSearchScope,
-    packagePartProvider: (GlobalSearchScope) -> PackagePartProvider
-) {
-    val dependenciesInfo = FirTestModuleInfo(name = Name.identifier(moduleInfo.name.identifier + ".dependencies"))
-    moduleInfo.dependencies.add(dependenciesInfo)
-    FirSessionFactory.createLibrarySession(
-        dependenciesInfo, provider, librariesScope, project, packagePartProvider(librariesScope)
     )
 }
+

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.compiler.visualizer.FirVisualizer
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
-import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
@@ -30,7 +30,7 @@ abstract class AbstractFirVisualizer : AbstractVisualizer() {
         val ktFiles = environment.getSourceFiles()
         val scope = GlobalSearchScope.filesScope(environment.project, ktFiles.mapNotNull { it.virtualFile })
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(environment.project))
-        val session = createSession(environment, scope)
+        val session = createSessionForTests(environment, scope)
 
         val firProvider = (session.firProvider as FirProviderImpl)
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)