Rid of most of the usage of JsConfig in TopDownAnalyzerFacadeForJS

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

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- *
+ * that can be found in the license/LICENSE.txt file.
- * 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.checkers
@@ -65,7 +54,7 @@ abstract class AbstractDiagnosticsTestWithJsStdLib : AbstractDiagnosticsTest() {
     ): JsAnalysisResult {
         // TODO: support LANGUAGE directive in JS diagnostic tests
         moduleTrace.record<ModuleDescriptor, ModuleKind>(MODULE_KIND, moduleContext.module, getModuleKind(files))
-        return TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(files, moduleTrace, moduleContext, config)
+        return TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(files, moduleTrace, moduleContext, config.configuration)
     }
 
     private fun getModuleKind(ktFiles: List<KtFile>): ModuleKind {

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -1,26 +1,18 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- *
+ * that can be found in the license/LICENSE.txt file.
- * 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.js.analyze
 
+import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.js.di.createTopDownAnalyzerForJs
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -33,43 +25,60 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
+import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
+import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.serialization.js.PackagesWithHeaderMetadata
 
 object TopDownAnalyzerFacadeForJS {
     @JvmStatic
-    fun analyzeFiles(files: Collection<KtFile>, config: JsConfig): JsAnalysisResult {
+    fun analyzeFiles(
-        val context = ContextForNewModule(
+        files: Collection<KtFile>,
-                ProjectContext(config.project), Name.special("<${config.moduleId}>"), JsPlatform.builtIns, null
+        config: JsConfig
-        )
+    ): JsAnalysisResult {
-
+        return analyzeFiles(files, config.project, config.configuration, config.moduleDescriptors, config.friendModuleDescriptors)
-        // a hack to avoid adding lookups for builtins
-        val lookupTracker = config.configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER)
-        config.configuration.put(CommonConfigurationKeys.LOOKUP_TRACKER, LookupTracker.DO_NOTHING)
-        context.module.setDependencies(
-                listOf(context.module) +
-                config.moduleDescriptors.map { it.data } +
-                listOf(JsPlatform.builtIns.builtInsModule),
-                config.friendModuleDescriptors.map { it.data }.toSet()
-        )
-        lookupTracker?.let { config.configuration.put(CommonConfigurationKeys.LOOKUP_TRACKER, it) }
-
-        val trace = BindingTraceContext()
-        trace.record(MODULE_KIND, context.module, config.moduleKind)
-        return analyzeFilesWithGivenTrace(files, trace, context, config)
     }
 
-    @JvmStatic
+    fun analyzeFiles(
-    fun analyzeFilesWithGivenTrace(
+        files: Collection<KtFile>,
-            files: Collection<KtFile>,
+        project: Project,
-            trace: BindingTrace,
+        configuration: CompilerConfiguration,
-            moduleContext: ModuleContext,
+        moduleDescriptors: List<JsModuleDescriptor<ModuleDescriptorImpl>>,
-            config: JsConfig
+        friendModuleDescriptors: List<JsModuleDescriptor<ModuleDescriptorImpl>>
     ): JsAnalysisResult {
-        val lookupTracker = config.configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
+
-        val expectActualTracker = config.configuration.get(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER) ?: ExpectActualTracker.DoNothing
+        val moduleName = configuration[CommonConfigurationKeys.MODULE_NAME]!!
-        val languageVersionSettings = config.configuration.languageVersionSettings
+        val context = ContextForNewModule(ProjectContext(project), Name.special("<$moduleName>"), JsPlatform.builtIns, null)
-        val packageFragment = config.configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER]?.let {
+
+        // a hack to avoid adding lookups for builtins
+        val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER)
+        configuration.put(CommonConfigurationKeys.LOOKUP_TRACKER, LookupTracker.DO_NOTHING)
+
+        context.module.setDependencies(
+            listOf(context.module) +
+                    moduleDescriptors.map { it.data } +
+                    listOf(JsPlatform.builtIns.builtInsModule),
+            friendModuleDescriptors.map { it.data }.toSet()
+        )
+        lookupTracker?.let { configuration.put(CommonConfigurationKeys.LOOKUP_TRACKER, it) }
+
+        val moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
+
+        val trace = BindingTraceContext()
+        trace.record(MODULE_KIND, context.module, moduleKind)
+        return analyzeFilesWithGivenTrace(files, trace, context, configuration)
+    }
+
+    fun analyzeFilesWithGivenTrace(
+        files: Collection<KtFile>,
+        trace: BindingTrace,
+        moduleContext: ModuleContext,
+        configuration: CompilerConfiguration
+    ): JsAnalysisResult {
+        val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
+        val expectActualTracker = configuration.get(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER) ?: ExpectActualTracker.DoNothing
+        val languageVersionSettings = configuration.languageVersionSettings
+        val packageFragment = configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER]?.let {
             val metadata = PackagesWithHeaderMetadata(it.headerMetadata, it.compiledPackageParts.values.map { it.metadata })
             KotlinJavascriptSerializationUtil.readDescriptors(
                     metadata, moduleContext.storageManager, moduleContext.module,