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.

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -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) {

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

@@ -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)

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.kt

@@ -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(

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

@@ -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)

compiler/cli/src/org/jetbrains/kotlin/resolve/CompilerEnvironment.kt

@@ -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)
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractAnalyzerWithCompilerReport.kt

@@ -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)

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -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

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -197,7 +197,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
 
     useInstance(NoTopLevelDescriptorProvider)
 
-    CompilerEnvironment.configure(this)
+    TargetEnvironment.configureCompilerEnvironment(this)
 
     useInstance(FileScopeProvider.ThrowException)
     useImpl<AnnotationResolverImpl>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerEnvironment.kt

@@ -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>()
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetEnvironment.kt

@@ -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>()
+        }
+    }
+}

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -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
             )

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt

@@ -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
         }

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -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
                 )

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJsStdLib.kt

@@ -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 {

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt

@@ -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) }

compiler/tests-common/tests/org/jetbrains/kotlin/test/KlibTestUtil.kt

@@ -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

compiler/tests/org/jetbrains/kotlin/checkers/InteropFunctionsWithNonStableParameterNamesDiagnosticsTest.kt

@@ -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)
         }

compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt

@@ -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

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -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,