[FIR] KT-58065: Support LT in K2JsIrCompiler

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cli.js
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.text.StringUtil
+import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.backend.common.CompilationException
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.wasm.compileToLoweredIr
@@ -31,10 +32,7 @@ import org.jetbrains.kotlin.cli.js.klib.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.Services
-import org.jetbrains.kotlin.config.getModuleNameForSource
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
@@ -494,16 +492,37 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
         val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
 
-        val outputs = compileModuleToAnalyzedFir(
-            moduleStructure = moduleStructure,
-            ktFiles = environmentForJS.getSourceFiles(),
-            libraries = libraries,
-            friendLibraries = friendLibraries,
-            messageCollector = messageCollector,
-            diagnosticsReporter = diagnosticsReporter,
-            incrementalDataProvider = configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER],
-            lookupTracker = lookupTracker,
-        ) ?: return null
+        val outputs = if (
+            configuration.getBoolean(CommonConfigurationKeys.USE_FIR) && configuration.getBoolean(CommonConfigurationKeys.USE_LIGHT_TREE)
+        ) {
+            val groupedSources = collectSources(configuration, environmentForJS.project, messageCollector)
+
+            compileModulesToAnalyzedFirWithLightTree(
+                moduleStructure = moduleStructure,
+                groupedSources = groupedSources,
+                // TODO: Only pass groupedSources, because
+                //  we will need to have them separated again
+                //  in createSessionsForLegacyMppProject anyway
+                ktSourceFiles = groupedSources.commonSources + groupedSources.platformSources,
+                libraries = libraries,
+                friendLibraries = friendLibraries,
+                messageCollector = messageCollector,
+                diagnosticsReporter = diagnosticsReporter,
+                incrementalDataProvider = configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER],
+                lookupTracker = lookupTracker,
+            ) ?: return null
+        } else {
+            compileModuleToAnalyzedFirWithPsi(
+                moduleStructure = moduleStructure,
+                ktFiles = environmentForJS.getSourceFiles(),
+                libraries = libraries,
+                friendLibraries = friendLibraries,
+                messageCollector = messageCollector,
+                diagnosticsReporter = diagnosticsReporter,
+                incrementalDataProvider = configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER],
+                lookupTracker = lookupTracker,
+            ) ?: return null
+        }
 
         // FIR2IR
         val fir2IrActualizedResult = transformFirToIr(moduleStructure, outputs, diagnosticsReporter)

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt

@@ -9,13 +9,10 @@ import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.fileBelongsToModuleForPsi
+import org.jetbrains.kotlin.cli.common.*
 import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
-import org.jetbrains.kotlin.cli.common.isCommonSourceForPsi
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.common.prepareJsSessions
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
@@ -54,15 +51,19 @@ import org.jetbrains.kotlin.utils.metadataVersion
 import java.io.File
 import java.nio.file.Paths
 
-fun compileModuleToAnalyzedFir(
+inline fun <F> compileModuleToAnalyzedFir(
     moduleStructure: ModulesStructure,
-    ktFiles: List<KtFile>,
+    files: List<F>,
     libraries: List<String>,
     friendLibraries: List<String>,
     messageCollector: MessageCollector,
     diagnosticsReporter: BaseDiagnosticsCollector,
     incrementalDataProvider: IncrementalDataProvider?,
     lookupTracker: LookupTracker?,
+    fileHasSyntaxErrors: (F) -> Boolean,
+    noinline isCommonSource: (F) -> Boolean,
+    noinline fileBelongsToModule: (F, String) -> Boolean,
+    buildResolveAndCheckFir: (FirSession, List<F>) -> ModuleCompilerAnalyzedOutput,
 ): List<ModuleCompilerAnalyzedOutput>? {
     val renderDiagnosticNames = moduleStructure.compilerConfiguration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
 
@@ -72,8 +73,8 @@ fun compileModuleToAnalyzedFir(
     val mainModuleName = moduleStructure.compilerConfiguration.get(CommonConfigurationKeys.MODULE_NAME)!!
     val escapedMainModuleName = Name.special("<$mainModuleName>")
 
-    val syntaxErrors = ktFiles.fold(false) { errorsFound, ktFile ->
-        AnalyzerWithCompilerReport.reportSyntaxErrors(ktFile, messageCollector).isHasErrors or errorsFound
+    val syntaxErrors = files.fold(false) { errorsFound, file ->
+        fileHasSyntaxErrors(file) or errorsFound
     }
 
     val binaryModuleData = BinaryModuleData.initialize(escapedMainModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices)
@@ -84,15 +85,17 @@ fun compileModuleToAnalyzedFir(
     }
 
     val resolvedLibraries = moduleStructure.allDependencies
-
     val sessionsWithSources = prepareJsSessions(
-        ktFiles, moduleStructure.compilerConfiguration, escapedMainModuleName,
-        resolvedLibraries, dependencyList, extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi,
-        lookupTracker, icData = incrementalDataProvider?.let { KlibIcData(it) }
+        files, moduleStructure.compilerConfiguration, escapedMainModuleName,
+        resolvedLibraries, dependencyList, extensionRegistrars,
+        isCommonSource = isCommonSource,
+        fileBelongsToModule = fileBelongsToModule,
+        lookupTracker,
+        icData = incrementalDataProvider?.let(::KlibIcData),
     )
 
     val outputs = sessionsWithSources.map {
-        buildResolveAndCheckFir(it.session, it.files, diagnosticsReporter)
+        buildResolveAndCheckFir(it.session, it.files)
     }
 
     if (syntaxErrors || diagnosticsReporter.hasErrors) {
@@ -103,6 +106,63 @@ fun compileModuleToAnalyzedFir(
     return outputs
 }
 
+fun compileModuleToAnalyzedFirWithPsi(
+    moduleStructure: ModulesStructure,
+    ktFiles: List<KtFile>,
+    libraries: List<String>,
+    friendLibraries: List<String>,
+    messageCollector: MessageCollector,
+    diagnosticsReporter: BaseDiagnosticsCollector,
+    incrementalDataProvider: IncrementalDataProvider?,
+    lookupTracker: LookupTracker?,
+): List<ModuleCompilerAnalyzedOutput>? {
+    return compileModuleToAnalyzedFir(
+        moduleStructure,
+        ktFiles,
+        libraries,
+        friendLibraries,
+        messageCollector,
+        diagnosticsReporter,
+        incrementalDataProvider,
+        lookupTracker,
+        fileHasSyntaxErrors = { AnalyzerWithCompilerReport.reportSyntaxErrors(it, messageCollector).isHasErrors },
+        isCommonSource = isCommonSourceForPsi,
+        fileBelongsToModule = fileBelongsToModuleForPsi,
+        buildResolveAndCheckFir = { session, files ->
+            buildResolveAndCheckFir(session, files, diagnosticsReporter)
+        },
+    )
+}
+
+fun compileModulesToAnalyzedFirWithLightTree(
+    moduleStructure: ModulesStructure,
+    groupedSources: GroupedKtSources,
+    ktSourceFiles: List<KtSourceFile>,
+    libraries: List<String>,
+    friendLibraries: List<String>,
+    messageCollector: MessageCollector,
+    diagnosticsReporter: BaseDiagnosticsCollector,
+    incrementalDataProvider: IncrementalDataProvider?,
+    lookupTracker: LookupTracker?,
+): List<ModuleCompilerAnalyzedOutput>? {
+    return compileModuleToAnalyzedFir(
+        moduleStructure,
+        ktSourceFiles,
+        libraries,
+        friendLibraries,
+        messageCollector,
+        diagnosticsReporter,
+        incrementalDataProvider,
+        lookupTracker,
+        fileHasSyntaxErrors = { false },
+        isCommonSource = { groupedSources.isCommonSourceForLt(it) },
+        fileBelongsToModule = { file, it -> groupedSources.fileBelongsToModuleForLt(file, it) },
+        buildResolveAndCheckFir = { session, files ->
+            buildResolveAndCheckFir(session, files, diagnosticsReporter, null)
+        },
+    )
+}
+
 fun transformFirToIr(
     moduleStructure: ModulesStructure,
     firOutputs: List<ModuleCompilerAnalyzedOutput>,

compiler/cli/src/org/jetbrains/kotlin/cli/common/FirSessionConstructionUtils.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.cli.common
 
 import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
-import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.GroupedKtSources
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers

compiler/cli/src/org/jetbrains/kotlin/cli/common/GroupedKtSources.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2010-2023 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.cli.common
+
+import com.intellij.ide.highlighter.JavaFileType
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.KtSourceFile
+import org.jetbrains.kotlin.KtVirtualFileSourceFile
+import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.jvm.compiler.VfsBasedProjectEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.forAllFiles
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.idea.KotlinFileType
+
+private const val kotlinFileExtensionWithDot = ".${KotlinFileType.EXTENSION}"
+private const val javaFileExtensionWithDot = ".${JavaFileType.DEFAULT_EXTENSION}"
+
+data class GroupedKtSources(
+    val platformSources: Collection<KtSourceFile>,
+    val commonSources: Collection<KtSourceFile>,
+    val sourcesByModuleName: Map<String, Set<KtSourceFile>>,
+)
+
+fun collectSources(
+    compilerConfiguration: CompilerConfiguration,
+    projectEnvironment: VfsBasedProjectEnvironment,
+    messageCollector: MessageCollector
+): GroupedKtSources {
+    return collectSources(compilerConfiguration, projectEnvironment.project, messageCollector)
+}
+
+fun collectSources(
+    compilerConfiguration: CompilerConfiguration,
+    project: Project,
+    messageCollector: MessageCollector
+): GroupedKtSources {
+    val platformSources = linkedSetOf<KtSourceFile>()
+    val commonSources = linkedSetOf<KtSourceFile>()
+    val sourcesByModuleName = mutableMapOf<String, MutableSet<KtSourceFile>>()
+
+    // TODO: the scripts checking should be part of the scripting plugin functionality, as it is implemented now in ScriptingProcessSourcesBeforeCompilingExtension
+    // TODO: implement in the next round of K2 scripting support (https://youtrack.jetbrains.com/issue/KT-55728)
+    val skipScriptsInLtMode = compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_FIR) &&
+            compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_LIGHT_TREE)
+    var skipScriptsInLtModeWarning = false
+
+    compilerConfiguration.kotlinSourceRoots.forAllFiles(
+        compilerConfiguration,
+        project
+    ) { virtualFile, isCommon, moduleName ->
+        val file = KtVirtualFileSourceFile(virtualFile)
+        when {
+            file.path.endsWith(javaFileExtensionWithDot) -> {}
+            file.path.endsWith(kotlinFileExtensionWithDot) || !skipScriptsInLtMode -> {
+                if (isCommon) commonSources.add(file)
+                else platformSources.add(file)
+
+                if (moduleName != null) {
+                    sourcesByModuleName.getOrPut(moduleName) { mutableSetOf() }.add(file)
+                }
+            }
+            else -> {
+                // temporarily assume it is a script, see the TODO above
+                skipScriptsInLtModeWarning = true
+            }
+        }
+    }
+
+    if (skipScriptsInLtModeWarning) {
+        // TODO: remove then Scripts are supported in LT (probably different K2 extension should be written for handling the case properly)
+        messageCollector.report(
+            CompilerMessageSeverity.STRONG_WARNING,
+            "Scripts are not yet supported with K2 in LightTree mode, consider using K1 or disable LightTree mode with -Xuse-fir-lt=false"
+        )
+    }
+    return GroupedKtSources(platformSources, commonSources, sourcesByModuleName)
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt

@@ -45,7 +45,6 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.Fir2IrConfiguration
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
@@ -56,7 +55,6 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.session.IncrementalCompilationContext
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
-import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
@@ -73,10 +71,6 @@ import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStat
 import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import java.io.File
-import kotlin.reflect.KFunction2
-
-private const val kotlinFileExtensionWithDot = ".${KotlinFileType.EXTENSION}"
-private const val javaFileExtensionWithDot = ".${JavaFileType.DEFAULT_EXTENSION}"
 
 fun compileModulesUsingFrontendIrAndLightTree(
     projectEnvironment: AbstractProjectEnvironment,
@@ -166,59 +160,6 @@ fun compileModulesUsingFrontendIrAndLightTree(
     )
 }
 
-data class GroupedKtSources(
-    val platformSources: Collection<KtSourceFile>,
-    val commonSources: Collection<KtSourceFile>,
-    val sourcesByModuleName: Map<String, Set<KtSourceFile>>,
-)
-
-fun collectSources(
-    compilerConfiguration: CompilerConfiguration,
-    projectEnvironment: VfsBasedProjectEnvironment,
-    messageCollector: MessageCollector
-): GroupedKtSources {
-    val platformSources = linkedSetOf<KtSourceFile>()
-    val commonSources = linkedSetOf<KtSourceFile>()
-    val sourcesByModuleName = mutableMapOf<String, MutableSet<KtSourceFile>>()
-
-    // TODO: the scripts checking should be part of the scripting plugin functionality, as it is implemented now in ScriptingProcessSourcesBeforeCompilingExtension
-    // TODO: implement in the next round of K2 scripting support (https://youtrack.jetbrains.com/issue/KT-55728)
-    val skipScriptsInLtMode = compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_FIR) &&
-            compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_LIGHT_TREE)
-    var skipScriptsInLtModeWarning = false
-
-    compilerConfiguration.kotlinSourceRoots.forAllFiles(
-        compilerConfiguration,
-        projectEnvironment.project
-    ) { virtualFile, isCommon, moduleName ->
-        val file = KtVirtualFileSourceFile(virtualFile)
-        when {
-            file.path.endsWith(javaFileExtensionWithDot) -> {}
-            file.path.endsWith(kotlinFileExtensionWithDot) || !skipScriptsInLtMode -> {
-                if (isCommon) commonSources.add(file)
-                else platformSources.add(file)
-
-                if (moduleName != null) {
-                    sourcesByModuleName.getOrPut(moduleName) { mutableSetOf() }.add(file)
-                }
-            }
-            else -> {
-                // temporarily assume it is a script, see the TODO above
-                skipScriptsInLtModeWarning = true
-            }
-        }
-    }
-
-    if (skipScriptsInLtModeWarning) {
-        // TODO: remove then Scripts are supported in LT (probably different K2 extension should be written for handling the case properly)
-        messageCollector.report(
-            CompilerMessageSeverity.STRONG_WARNING,
-            "Scripts are not yet supported with K2 in LightTree mode, consider using K1 or disable LightTree mode with -Xuse-fir-lt=false"
-        )
-    }
-    return GroupedKtSources(platformSources, commonSources, sourcesByModuleName)
-}
-
 fun convertAnalyzedFirToIr(
     input: ModuleCompilerInput,
     analysisResults: FirResult,
@@ -361,16 +302,6 @@ fun compileModuleToAnalyzedFir(
     return FirResult(outputs)
 }
 
-private fun buildResolveAndCheckFir(
-    session: FirSession,
-    ktFiles: Collection<KtSourceFile>,
-    diagnosticsReporter: DiagnosticReporter,
-    countFilesAndLines: KFunction2<Int, Int, Unit>?
-): ModuleCompilerAnalyzedOutput {
-    val firFiles = session.buildFirViaLightTree(ktFiles, diagnosticsReporter, countFilesAndLines)
-    return resolveAndCheckFir(session, firFiles, diagnosticsReporter)
-}
-
 fun writeOutputs(
     projectEnvironment: AbstractProjectEnvironment,
     configuration: CompilerConfiguration,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipelineData.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.cli.jvm.compiler.pipeline
 
 import org.jetbrains.kotlin.backend.common.actualizer.IrActualizedResult
+import org.jetbrains.kotlin.cli.common.GroupedKtSources
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/FirMetadataSerializer.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.VfsBasedProjectEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.createContextForIncrementalCompilation
-import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.collectSources
 import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.createContextForIncrementalCompilation
 import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.createIncrementalCompilationScope
 import org.jetbrains.kotlin.cli.jvm.compiler.toAbstractProjectEnvironment

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/firUtils.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.session.sourcesToPathsMapper
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.readSourceFileWithMapping
+import kotlin.reflect.KFunction2
 
 fun FirSession.buildFirViaLightTree(
     files: Collection<KtSourceFile>,
@@ -70,4 +71,14 @@ fun resolveAndCheckFir(
     val (scopeSession, fir) = session.runResolution(firFiles)
     session.runCheckers(scopeSession, fir, diagnosticsReporter)
     return ModuleCompilerAnalyzedOutput(session, scopeSession, fir)
-}
+}
+
+fun buildResolveAndCheckFir(
+    session: FirSession,
+    ktFiles: Collection<KtSourceFile>,
+    diagnosticsReporter: DiagnosticReporter,
+    countFilesAndLines: KFunction2<Int, Int, Unit>?
+): ModuleCompilerAnalyzedOutput {
+    val firFiles = session.buildFirViaLightTree(ktFiles, diagnosticsReporter, countFilesAndLines)
+    return resolveAndCheckFir(session, firFiles, diagnosticsReporter)
+}

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

@@ -16,9 +16,9 @@ import org.jetbrains.kotlin.KtPsiSourceFile
 import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.ObsoleteTestInfrastructure
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
+import org.jetbrains.kotlin.cli.common.collectSources
 import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.cli.jvm.compiler.*
-import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.collectSources
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -15,10 +15,8 @@ import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.jvm.JvmIrDeserializerImpl
 import org.jetbrains.kotlin.build.DEFAULT_KOTLIN_SOURCE_FILES_EXTENSIONS
 import org.jetbrains.kotlin.build.report.BuildReporter
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.ExitCode
+import org.jetbrains.kotlin.cli.common.*
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.computeKotlinPaths
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
 import org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback
@@ -28,7 +26,6 @@ import org.jetbrains.kotlin.cli.common.messages.GroupingMessageCollector
 import org.jetbrains.kotlin.cli.common.messages.IrMessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.modules.ModuleBuilder
-import org.jetbrains.kotlin.cli.common.setupCommonArguments
 import org.jetbrains.kotlin.cli.jvm.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.VfsBasedProjectEnvironment

compiler/testData/cli/js/firLightTree.kt

@@ -0,0 +1,3 @@
+fun MutableList<String>.test() {
+    this += "Alpha"
+}

compiler/testData/cli/js/firLightTreeOn.args

@@ -0,0 +1,10 @@
+$TESTDATA_DIR$/firLightTree.kt
+-language-version
+2.0
+-Xuse-fir-lt=true
+-ir-output-dir
+$TEMP_DIR$
+-ir-output-name
+fir
+-libraries
+libraries/stdlib/js-ir/build/classes/kotlin/js/main

compiler/testData/cli/js/firLightTreeOn.out

@@ -0,0 +1,2 @@
+warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features
+OK

compiler/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java

@@ -1323,6 +1323,11 @@ public class CliTestGenerated extends AbstractCliTest {
             runTest("compiler/testData/cli/js/fir.args");
         }
 
+        @TestMetadata("firLightTreeOn.args")
+        public void testFirLightTreeOn() throws Exception {
+            runTest("compiler/testData/cli/js/firLightTreeOn.args");
+        }
+
         @TestMetadata("firMpp.args")
         public void testFirMpp() throws Exception {
             runTest("compiler/testData/cli/js/firMpp.args");

js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
-import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir
+import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFirWithPsi
 import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib
 import org.jetbrains.kotlin.cli.js.klib.transformFirToIr
 import org.jetbrains.kotlin.codegen.ProjectInfo
@@ -64,7 +64,7 @@ abstract class FirAbstractInvalidationTest(
             friendDependenciesPaths = friendLibraries
         )
 
-        val outputs = compileModuleToAnalyzedFir(
+        val outputs = compileModuleToAnalyzedFirWithPsi(
             moduleStructure = moduleStructure,
             ktFiles = sourceFiles,
             libraries = libraries,

js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsPartialLinkageTestCase.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
-import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir
+import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFirWithPsi
 import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization
 import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib
 import org.jetbrains.kotlin.cli.js.klib.transformFirToIr
@@ -205,7 +205,7 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)
         val outputStream = ByteArrayOutputStream()
         val messageCollector = PrintingMessageCollector(PrintStream(outputStream), MessageRenderer.PLAIN_FULL_PATHS, true)
 
-        val outputs = compileModuleToAnalyzedFir(
+        val outputs = compileModuleToAnalyzedFirWithPsi(
             moduleStructure = moduleStructure,
             ktFiles = ktFiles,
             libraries = regularDependencies,