Move CompilerEnvironment from 'frontend' to 'cli'

This is needed in order to have a single convenient place where to register frontend services implemented _outside_ of the 'frontend' module, such as the control flow analysis, extracted to a separate module in a subsequent commit.
2020-03-16 00:50:16 +01:00
parent 3efbca85ea
commit ca5a35b4b3
31 changed files with 147 additions and 96 deletions
@@ -57,6 +57,7 @@ import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.resolve.CompilerEnvironment;
 import org.jetbrains.kotlin.serialization.js.ModuleKind;
 import org.jetbrains.kotlin.utils.*;

@@ -235,7 +236,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {

        configuration.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile));

-        JsConfig config = new JsConfig(project, configuration);
+        JsConfig config = new JsConfig(project, configuration, CompilerEnvironment.INSTANCE);
        JsConfig.Reporter reporter = new JsConfig.Reporter() {
            @Override
            public void error(@NotNull String message) {
@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.util.Logger
 import org.jetbrains.kotlin.utils.KotlinPaths
@@ -165,7 +166,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {

        // TODO: in this method at least 3 different compiler configurations are used (original, env.configuration, jsConfig.configuration)
        // Such situation seems a bit buggy...
-        val config = JsConfig(projectJs, configurationJs)
+        val config = JsConfig(projectJs, configurationJs, CompilerEnvironment)
        val outputDir: File = outputFile.parentFile ?: outputFile.absoluteFile.parentFile!!
        try {
            config.configuration.put(JSConfigurationKeys.OUTPUT_DIR, outputDir.canonicalFile)
@@ -32,9 +32,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.sortedDiagnostics
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.AnalyzingUtils
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.checkers.ExperimentalUsageChecker
 import org.jetbrains.kotlin.resolve.jvm.JvmBindingContextSlices

@@ -42,6 +40,9 @@ class AnalyzerWithCompilerReport(
    private val messageCollector: MessageCollector,
    private val languageVersionSettings: LanguageVersionSettings
 ) : AbstractAnalyzerWithCompilerReport {
+    override val targetEnvironment: TargetEnvironment
+        get() = CompilerEnvironment
+
    override lateinit var analysisResult: AnalysisResult

    constructor(configuration: CompilerConfiguration) : this(
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.CommonPlatforms
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import java.io.File

 internal val KotlinCoreEnvironment.destDir: File?
@@ -50,7 +51,7 @@ private fun runCommonAnalysis(
    analyzer.analyzeAndReport(files) {
        CommonResolverForModuleFactory.analyzeFiles(
            files, moduleName, dependOnBuiltins, configuration.languageVersionSettings,
-            CommonPlatforms.defaultCommonPlatform,
+            CommonPlatforms.defaultCommonPlatform, CompilerEnvironment,
            dependenciesContainer = dependencyContainer
        ) { content ->
            environment.createPackagePartProvider(content.moduleContentScope)
@@ -0,0 +1,14 @@
+/*
+ * 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.resolve
+
+import org.jetbrains.kotlin.container.StorageComponentContainer
+
+object CompilerEnvironment : TargetEnvironment("Compiler") {
+    override fun configure(container: StorageComponentContainer) {
+        configureCompilerEnvironment(container)
+    }
+}
@@ -6,8 +6,11 @@
 package org.jetbrains.kotlin.analyzer

 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.TargetEnvironment

 interface AbstractAnalyzerWithCompilerReport {
+    val targetEnvironment: TargetEnvironment
+
    val analysisResult: AnalysisResult

    fun analyzeAndReport(files: Collection<KtFile>, analyze: () -> AnalysisResult)
@@ -118,6 +118,7 @@ class CommonResolverForModuleFactory(
        fun analyzeFiles(
            files: Collection<KtFile>, moduleName: Name, dependOnBuiltIns: Boolean, languageVersionSettings: LanguageVersionSettings,
            targetPlatform: TargetPlatform,
+            targetEnvironment: TargetEnvironment,
            capabilities: Map<ModuleCapability<*>, Any?> = emptyMap(),
            dependenciesContainer: CommonDependenciesContainer? = null,
            metadataPartProviderFactory: (ModuleContent<ModuleInfo>) -> MetadataPartProvider
@@ -141,7 +142,7 @@ class CommonResolverForModuleFactory(

            val resolverForModuleFactory = CommonResolverForModuleFactory(
                CommonAnalysisParameters(metadataPartProviderFactory),
-                CompilerEnvironment,
+                targetEnvironment,
                targetPlatform,
                shouldCheckExpectActual = false,
                dependenciesContainer
@@ -197,7 +197,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(

    useInstance(NoTopLevelDescriptorProvider)

-    CompilerEnvironment.configure(this)
+    TargetEnvironment.configureCompilerEnvironment(this)

    useInstance(FileScopeProvider.ThrowException)
    useImpl<AnnotationResolverImpl>()
@@ -1,34 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.resolve
-
-import org.jetbrains.kotlin.container.StorageComponentContainer
-import org.jetbrains.kotlin.container.useImpl
-import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.idea.MainFunctionDetector
-import org.jetbrains.kotlin.resolve.lazy.CompilerLocalDescriptorResolver
-import org.jetbrains.kotlin.resolve.lazy.BasicAbsentDescriptorHandler
-
-object CompilerEnvironment : TargetEnvironment("Compiler") {
-    override fun configure(container: StorageComponentContainer) {
-        container.useInstance(BodyResolveCache.ThrowException)
-        container.useImpl<CompilerLocalDescriptorResolver>()
-        container.useImpl<BasicAbsentDescriptorHandler>()
-        container.useInstance(ModuleStructureOracle.SingleModule)
-        container.useImpl<MainFunctionDetector.Factory.Ordinary>()
-    }
-}
@@ -17,9 +17,24 @@
 package org.jetbrains.kotlin.resolve

 import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.useImpl
+import org.jetbrains.kotlin.container.useInstance
+import org.jetbrains.kotlin.idea.MainFunctionDetector
+import org.jetbrains.kotlin.resolve.lazy.BasicAbsentDescriptorHandler
+import org.jetbrains.kotlin.resolve.lazy.CompilerLocalDescriptorResolver

 abstract class TargetEnvironment(private val name: String) {
    abstract fun configure(container: StorageComponentContainer)

    override fun toString() = name
-}
+
+    companion object {
+        fun configureCompilerEnvironment(container: StorageComponentContainer) {
+            container.useInstance(BodyResolveCache.ThrowException)
+            container.useImpl<CompilerLocalDescriptorResolver>()
+            container.useImpl<BasicAbsentDescriptorHandler>()
+            container.useInstance(ModuleStructureOracle.SingleModule)
+            container.useImpl<MainFunctionDetector.Factory.Ordinary>()
+        }
+    }
+}
@@ -395,7 +395,8 @@ private class ModulesStructure(
                project,
                compilerConfiguration,
                allDependencies.getFullList().map { getModuleDescriptor(it) },
-                friendModuleDescriptors = friendDependencies.map { getModuleDescriptor(it) },
+                friendDependencies.map { getModuleDescriptor(it) },
+                analyzer.targetEnvironment,
                thisIsBuiltInsModule = builtInModuleDescriptor == null,
                customBuiltInsModule = builtInModuleDescriptor
            )
@@ -235,7 +235,7 @@ class ClassicFrontendFacade(
        files: List<KtFile>,
        dependentDescriptors: List<ModuleDescriptorImpl>
    ): AnalysisResult {
-        val jsConfig = JsConfig(project, configuration)
+        val jsConfig = JsConfig(project, configuration, CompilerEnvironment)
        val dependentDescriptorsIncludingLibraries = buildList {
            addAll(dependentDescriptors)
            addAll(jsConfig.moduleDescriptors)
@@ -245,7 +245,8 @@ class ClassicFrontendFacade(
            project,
            configuration,
            moduleDescriptors = dependentDescriptorsIncludingLibraries,
-            friendModuleDescriptors = emptyList()
+            friendModuleDescriptors = emptyList(),
+            CompilerEnvironment,
        )
    }

@@ -276,8 +277,9 @@ class ClassicFrontendFacade(
            dependOnBuiltIns = true,
            module.languageVersionSettings,
            module.targetPlatform,
+            CompilerEnvironment,
            // TODO: add dependency manager
-        ) { _ ->
+        ) {
            // TODO
            MetadataPartProvider.Empty
        }
@@ -404,7 +404,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
        if (platform.isCommon()) {
            return CommonResolverForModuleFactory.analyzeFiles(
                files, moduleDescriptor.name, true, languageVersionSettings,
-                CommonPlatforms.defaultCommonPlatform,
+                CommonPlatforms.defaultCommonPlatform, CompilerEnvironment,
                mapOf(
                    MODULE_FILES to files
                )
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.js.resolve.MODULE_KIND
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.test.KotlinTestUtils
@@ -35,7 +36,7 @@ abstract class AbstractDiagnosticsTestWithJsStdLib : AbstractDiagnosticsTest() {
        JsConfig(project, environment.configuration.copy().apply {
            put(CommonConfigurationKeys.MODULE_NAME, KotlinTestUtils.TEST_MODULE_NAME)
            put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB)
-        })
+        }, CompilerEnvironment)
    }

    protected val config: JsConfig get() = lazyConfig!!.value
@@ -58,7 +59,9 @@ abstract class AbstractDiagnosticsTestWithJsStdLib : AbstractDiagnosticsTest() {
        // TODO: support LANGUAGE directive in JS diagnostic tests
        moduleTrace.record<ModuleDescriptor, ModuleKind>(MODULE_KIND, moduleContext.module, getModuleKind(files))
        config.configuration.languageVersionSettings = languageVersionSettings
-        return TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(files, moduleTrace, moduleContext, config.configuration)
+        return TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(
+            files, moduleTrace, moduleContext, config.configuration, CompilerEnvironment,
+        )
    }

    private fun getModuleKind(ktFiles: List<KtFile>): ModuleKind {
@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
@@ -126,7 +127,8 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
                TopDownAnalyzerFacadeForJS.analyzeFiles(
                    ktFilesToAnalyze, environment.project, environment.configuration,
                    moduleDescriptors = emptyList(),
-                    friendModuleDescriptors = emptyList()
+                    friendModuleDescriptors = emptyList(),
+                    CompilerEnvironment,
                ),
                psi2ir, ktFilesToAnalyze, GeneratorExtensions(),
                createIdSignatureComposer = { IdSignatureDescriptor(JsManglerDesc) }
@@ -21,14 +21,18 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
-import org.jetbrains.kotlin.library.*
+import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
+import org.jetbrains.kotlin.library.KotlinLibraryVersioning
+import org.jetbrains.kotlin.library.ToolingSingleFileKlibResolveStrategy
 import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
 import org.jetbrains.kotlin.library.impl.KotlinLibraryLayoutForWriter
 import org.jetbrains.kotlin.library.impl.KotlinLibraryWriterImpl
 import org.jetbrains.kotlin.library.metadata.NativeTypeTransformer
 import org.jetbrains.kotlin.library.metadata.NullFlexibleTypeDeserializer
+import org.jetbrains.kotlin.library.resolveSingleFileKlib
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.CommonPlatforms
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.util.DummyLogger
 import java.io.File
@@ -52,11 +56,12 @@ object KlibTestUtil {
            )

            CommonResolverForModuleFactory.analyzeFiles(
-                files = environment.getSourceFiles(),
+                environment.getSourceFiles(),
                moduleName = Name.special("<$libraryName>"),
                dependOnBuiltIns = true,
-                languageVersionSettings = environment.configuration.languageVersionSettings,
-                targetPlatform = CommonPlatforms.defaultCommonPlatform
+                environment.configuration.languageVersionSettings,
+                CommonPlatforms.defaultCommonPlatform,
+                CompilerEnvironment,
            ) { content ->
                environment.createPackagePartProvider(content.moduleContentScope)
            }.moduleDescriptor
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.platform.CommonPlatforms
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.serialization.NonStableParameterNamesSerializationTest
 import org.jetbrains.kotlin.storage.StorageManager
@@ -61,15 +62,16 @@ class InteropFunctionsWithNonStableParameterNamesDiagnosticsTest : AbstractDiagn
        jvmTarget: JvmTarget
    ): AnalysisResult {
        return CommonResolverForModuleFactory.analyzeFiles(
-            files = files,
-            moduleName = moduleContext.module.name,
+            files,
+            moduleContext.module.name,
            dependOnBuiltIns = true,
-            languageVersionSettings = languageVersionSettings,
-            targetPlatform = CommonPlatforms.defaultCommonPlatform,
+            languageVersionSettings,
+            CommonPlatforms.defaultCommonPlatform,
+            CompilerEnvironment,
            capabilities = mapOf(
 //                MODULE_FILES to files
            ),
-            dependenciesContainer = CommonDependenciesContainerImpl(moduleContext.module.allDependencyModules)
+            CommonDependenciesContainerImpl(moduleContext.module.allDependencyModules)
        ) { content ->
            environment.createPackagePartProvider(content.moduleContentScope)
        }
@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.js.JsPlatforms
 import org.jetbrains.kotlin.resolve.BindingTraceContext
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.serialization.AbstractVersionRequirementTest
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
@@ -47,13 +48,13 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() {
        }
        val trace = BindingTraceContext()
        val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(
-            ktFiles, trace, createModule(environment), environment.configuration
+            ktFiles, trace, createModule(environment), environment.configuration, CompilerEnvironment,
        )

        // There are INVISIBLE_REFERENCE errors on RequireKotlin and K2JSTranslator refuses to translate the code otherwise
        trace.clearDiagnostics()

-        val result = K2JSTranslator(JsConfig(environment.project, environment.configuration)).translate(
+        val result = K2JSTranslator(JsConfig(environment.project, environment.configuration, CompilerEnvironment)).translate(
            object : JsConfig.Reporter() {}, ktFiles, MainCallParameters.noCall(), analysisResult
        ) as TranslationResult.Success
        result.getOutputFiles(File(outputDirectory, "lib.js"), null, null).writeAllTo(outputDirectory)
@@ -62,7 +63,7 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() {
    override fun loadModule(directory: File): ModuleDescriptor {
        val environment = createEnvironment(extraDependencies = listOf(File(directory, "lib.meta.js")))
        return TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(
-            emptyList(), BindingTraceContext(), createModule(environment), environment.configuration
+            emptyList(), BindingTraceContext(), createModule(environment), environment.configuration, CompilerEnvironment,
        ).moduleDescriptor
    }

@@ -85,7 +86,7 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() {
        )

    private fun createModule(environment: KotlinCoreEnvironment): MutableModuleContext {
-        val config = JsConfig(environment.project, environment.configuration)
+        val config = JsConfig(environment.project, environment.configuration, CompilerEnvironment)
        return ContextForNewModule(
            ProjectContext(environment.project, "ProjectContext"),
            Name.special("<test>"), JsPlatformAnalyzerServices.builtIns, JsPlatforms.defaultJsPlatform
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil.readModuleAsProto
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -75,7 +76,7 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
        try {
            val environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
            val files = environment.getSourceFiles()
-            val config = JsConfig(environment.project, environment.configuration)
+            val config = JsConfig(environment.project, environment.configuration, CompilerEnvironment)
            val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, config)
            val description = JsModuleDescriptor(
                    name = KotlinTestUtils.TEST_MODULE_NAME,
@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.js.config.JSConfigurationKeys;
 import org.jetbrains.kotlin.js.config.JsConfig;
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs;
 import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.resolve.CompilerEnvironment;
 import org.jetbrains.kotlin.test.KotlinTestUtils;

 import java.lang.reflect.Field;
@@ -66,6 +67,6 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic
                LanguageVersionSettingsImpl.DEFAULT.getApiVersion(),
                Collections.emptyMap(),
                specificFeatures));
-        return new JsConfig(getProject(), configuration);
+        return new JsConfig(getProject(), configuration, CompilerEnvironment.INSTANCE);
    }
 }
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.frontend.js.di

 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.get
-import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
@@ -31,18 +30,22 @@ import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.platform.js.JsPlatforms
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
+import org.jetbrains.kotlin.resolve.TargetEnvironment
+import org.jetbrains.kotlin.resolve.createContainer
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory

 fun createTopDownAnalyzerForJs(
-        moduleContext: ModuleContext,
-        bindingTrace: BindingTrace,
-        declarationProviderFactory: DeclarationProviderFactory,
-        languageVersionSettings: LanguageVersionSettings,
-        lookupTracker: LookupTracker,
-        expectActualTracker: ExpectActualTracker,
-        additionalPackages: List<PackageFragmentProvider>
+    moduleContext: ModuleContext,
+    bindingTrace: BindingTrace,
+    declarationProviderFactory: DeclarationProviderFactory,
+    languageVersionSettings: LanguageVersionSettings,
+    lookupTracker: LookupTracker,
+    expectActualTracker: ExpectActualTracker,
+    additionalPackages: List<PackageFragmentProvider>,
+    targetEnvironment: TargetEnvironment,
 ): LazyTopDownAnalyzer {
    val storageComponentContainer = createContainer("TopDownAnalyzerForJs", JsPlatformAnalyzerServices) {
        configureModule(
@@ -57,8 +60,7 @@ fun createTopDownAnalyzerForJs(
        configureStandardResolveComponents()

        useInstance(declarationProviderFactory)
-        CompilerEnvironment.configure(this)
-
+        targetEnvironment.configure(this)
    }.apply {
        val packagePartProviders = mutableListOf(get<KotlinCodeAnalyzer>().packageFragmentProvider)
        val moduleDescriptor = get<ModuleDescriptorImpl>()
@@ -46,6 +46,7 @@ abstract class AbstractTopDownAnalyzerFacadeForJS {
        configuration: CompilerConfiguration,
        moduleDescriptors: List<ModuleDescriptorImpl>,
        friendModuleDescriptors: List<ModuleDescriptorImpl>,
+        targetEnvironment: TargetEnvironment,
        thisIsBuiltInsModule: Boolean = false,
        customBuiltInsModule: ModuleDescriptorImpl? = null
    ): JsAnalysisResult {
@@ -81,7 +82,7 @@ abstract class AbstractTopDownAnalyzerFacadeForJS {

        val trace = BindingTraceContext()
        trace.record(MODULE_KIND, context.module, moduleKind)
-        return analyzeFilesWithGivenTrace(files, trace, context, configuration, additionalPackages)
+        return analyzeFilesWithGivenTrace(files, trace, context, configuration, targetEnvironment, additionalPackages)
    }

    protected abstract fun loadIncrementalCacheMetadata(
@@ -96,6 +97,7 @@ abstract class AbstractTopDownAnalyzerFacadeForJS {
        trace: BindingTrace,
        moduleContext: ModuleContext,
        configuration: CompilerConfiguration,
+        targetEnvironment: TargetEnvironment,
        additionalPackages: List<PackageFragmentProvider> = emptyList()
    ): JsAnalysisResult {
        val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
@@ -110,7 +112,8 @@ abstract class AbstractTopDownAnalyzerFacadeForJS {
            languageVersionSettings,
            lookupTracker,
            expectActualTracker,
-            additionalPackages + listOfNotNull(packageFragment)
+            additionalPackages + listOfNotNull(packageFragment),
+            targetEnvironment,
        )
        analyzerForJs.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
        return JsAnalysisResult.success(trace, moduleContext.module)
@@ -169,6 +172,8 @@ object TopDownAnalyzerFacadeForJS : AbstractTopDownAnalyzerFacadeForJS() {
        config: JsConfig
    ): JsAnalysisResult {
        config.init()
-        return analyzeFiles(files, config.project, config.configuration, config.moduleDescriptors, config.friendModuleDescriptors)
+        return analyzeFiles(
+            files, config.project, config.configuration, config.moduleDescriptors, config.friendModuleDescriptors, config.targetEnvironment,
+        )
    }
 }
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker;
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration;
+import org.jetbrains.kotlin.resolve.TargetEnvironment;
 import org.jetbrains.kotlin.serialization.js.*;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.utils.JsMetadataVersion;
@@ -71,15 +72,22 @@ public class JsConfig {
    @Nullable
    private final Set<String> librariesToSkip;

-    public JsConfig(@NotNull Project project, @NotNull CompilerConfiguration configuration) {
-        this(project, configuration, null, null);
+    public final TargetEnvironment targetEnvironment;
+
+    public JsConfig(@NotNull Project project, @NotNull CompilerConfiguration configuration, @NotNull TargetEnvironment targetEnvironment) {
+        this(project, configuration, targetEnvironment, null, null);
    }

-    public JsConfig(@NotNull Project project, @NotNull CompilerConfiguration configuration,
+    public JsConfig(
+            @NotNull Project project,
+            @NotNull CompilerConfiguration configuration,
+            @NotNull TargetEnvironment targetEnvironment,
            @Nullable List<JsModuleDescriptor<KotlinJavaScriptLibraryParts>> metadataCache,
-            @Nullable Set<String> librariesToSkip) {
+            @Nullable Set<String> librariesToSkip
+    ) {
        this.project = project;
        this.configuration = configuration.copy();
+        this.targetEnvironment = targetEnvironment;
        this.metadataCache = metadataCache;
        this.librariesToSkip = librariesToSkip;
    }
@@ -56,6 +56,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.multiplatform.isCommonSource
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.junit.After
@@ -435,6 +436,7 @@ class GenerateIrRuntime {
                configuration,
                emptyList(),
                friendModuleDescriptors = emptyList(),
+                CompilerEnvironment,
                thisIsBuiltInsModule = true,
                customBuiltInsModule = null
            )
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.js.test.utils.LineCollector
 import org.jetbrains.kotlin.js.test.utils.LineOutputToStringVisitor
 import org.jetbrains.kotlin.js.util.TextOutputImpl
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinBaseTest
@@ -127,7 +128,7 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() {
        configuration.put(JSConfigurationKeys.SOURCE_MAP, true)
        configuration.put(JSConfigurationKeys.META_INFO, true)

-        return JsConfig(project, configuration)
+        return JsConfig(project, configuration, CompilerEnvironment)
    }

    private fun createPsiFile(fileName: String): KtFile {
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.jvm.compiler.ExpectedLoadErrorsUtil
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.renderer.*
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.MemberComparator
 import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPublicApi
@@ -62,7 +63,7 @@ class ApiTest : KotlinTestWithEnvironment() {
            configuration.put(CommonConfigurationKeys.MODULE_NAME, "test")
            configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB)

-            val config = JsConfig(project, configuration)
+            val config = JsConfig(project, configuration, CompilerEnvironment)

            return config.moduleDescriptors.single().packagesSerialized()
        }
@@ -47,6 +47,7 @@ import org.jetbrains.kotlin.metadata.DebugProtoBuf
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
@@ -908,7 +909,7 @@ abstract class BasicBoxTest(

        configuration.put(CommonConfigurationKeys.EXPECT_ACTUAL_LINKER, expectActualLinker)

-        return JsConfig(project, configuration, METADATA_CACHE, (JsConfig.JS_STDLIB + JsConfig.JS_KOTLIN_TEST).toSet())
+        return JsConfig(project, configuration, CompilerEnvironment, METADATA_CACHE, (JsConfig.JS_STDLIB + JsConfig.JS_KOTLIN_TEST).toSet())
    }

    private fun minifyAndRun(
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.library.resolver.impl.KotlinResolvedLibraryImpl
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.test.Directives
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.TestFiles
@@ -162,8 +163,9 @@ abstract class BasicWasmBoxTest(
    private fun createConfig(languageVersionSettings: LanguageVersionSettings?): JsConfig {
        val configuration = environment.configuration.copy()
        configuration.put(CommonConfigurationKeys.MODULE_NAME, TEST_MODULE)
-        configuration.languageVersionSettings = languageVersionSettings ?: LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE)
-        return JsConfig(project, configuration, null, null)
+        configuration.languageVersionSettings = languageVersionSettings
+            ?: LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE)
+        return JsConfig(project, configuration, CompilerEnvironment, null, null)
    }

    private inner class TestFileFactoryImpl : TestFiles.TestFileFactoryNoModules<TestFile>(), Closeable {
@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.naming.encodeSignature
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull
 import org.junit.Assert
@@ -212,7 +213,10 @@ class EncodeSignatureTest {
            configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB)
            configuration.put(CommonConfigurationKeys.MODULE_NAME, "sample")

-            val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(listOf(psiFile), JsConfig(project, configuration))
+            val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(
+                listOf(psiFile),
+                JsConfig(project, configuration, CompilerEnvironment),
+            )
            val module = analysisResult.moduleDescriptor
            val rootPackage = module.getPackage(FqName.ROOT)

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.CommonPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
@@ -320,12 +321,13 @@ private class AnalyzedModules(
                .toList()

            val module = CommonResolverForModuleFactory.analyzeFiles(
-                files = psiFiles,
-                moduleName = Name.special("<$moduleName>"),
+                psiFiles,
+                Name.special("<$moduleName>"),
                dependOnBuiltIns = true,
-                languageVersionSettings = environment.configuration.languageVersionSettings,
-                targetPlatform = CommonPlatforms.defaultCommonPlatform,
-                dependenciesContainer = DependenciesContainerImpl(sharedTarget, currentTarget, dependencies)
+                environment.configuration.languageVersionSettings,
+                CommonPlatforms.defaultCommonPlatform,
+                CompilerEnvironment,
+                dependenciesContainer = DependenciesContainerImpl(sharedTarget, currentTarget, dependencies),
            ) { content ->
                environment.createPackagePartProvider(content.moduleContentScope)
            }.moduleDescriptor
@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTraceContext
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory

@@ -64,7 +65,8 @@ abstract class AbstractJsScriptlikeCodeAnalyser(
            languageVersionSettings,
            lookupTracker,
            expectActualTracker,
-            additionalPackages
+            additionalPackages,
+            CompilerEnvironment,
        )
        val analyzerContext = analyzer.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, listOf(psi))