Prettify TopDownAnalyzerFacadeFor{JVM,JS}

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt

@@ -19,36 +19,31 @@ package org.jetbrains.kotlin.resolve.jvm
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.context.*
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
-import org.jetbrains.kotlin.frontend.java.di.ContainerForTopDownAnalyzerForJvm
+import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
-import org.jetbrains.kotlin.frontend.java.di.*
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackagePartProvider
-import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
-import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
-import org.jetbrains.kotlin.modules.Module
 import org.jetbrains.kotlin.modules.TargetId
-import org.jetbrains.kotlin.modules.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
-
+import java.util.*
-import java.util.ArrayList
 
 object TopDownAnalyzerFacadeForJVM {
     @JvmStatic
@@ -59,87 +54,57 @@ object TopDownAnalyzerFacadeForJVM {
             configuration: CompilerConfiguration,
             packagePartProvider: PackagePartProvider
     ): AnalysisResult {
-        var packagePartProvider = packagePartProvider
+        val storageManager = moduleContext.storageManager
         val project = moduleContext.project
+        val module = moduleContext.module
 
-        val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, files)
+        val incrementalComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
-
+        val lookupTracker = incrementalComponents?.getLookupTracker() ?: LookupTracker.DO_NOTHING
-        val incrementalCompilationComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
+        val targetIds = configuration.get(JVMConfigurationKeys.MODULES)?.map(::TargetId)
-        val lookupTracker = if (incrementalCompilationComponents != null)
-            incrementalCompilationComponents.getLookupTracker()
-        else
-            LookupTracker.DO_NOTHING
-
-        var targetIds: MutableList<TargetId>? = null
-        val modules = configuration.get(JVMConfigurationKeys.MODULES)
-        if (modules != null) {
-            targetIds = ArrayList<TargetId>(modules.size)
-
-            for (module in modules) {
-                targetIds.add(TargetId(module))
-            }
-        }
-
-        packagePartProvider = IncrementalPackagePartProvider.create(
-                packagePartProvider, files, targetIds, incrementalCompilationComponents, moduleContext.storageManager
-        )
 
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext,
                 trace,
-                providerFactory,
+                FileBasedDeclarationProviderFactory(storageManager, files),
                 GlobalSearchScope.allScope(project),
                 lookupTracker,
-                packagePartProvider,
+                IncrementalPackagePartProvider.create(packagePartProvider, files, targetIds, incrementalComponents, storageManager),
-                configuration.get<LanguageVersionSettings>(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+                configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
         )
 
         val additionalProviders = ArrayList<PackageFragmentProvider>()
 
-        if (targetIds != null && incrementalCompilationComponents != null) {
+        if (incrementalComponents != null) {
-            for (targetId in targetIds) {
+            targetIds?.mapTo(additionalProviders) { targetId ->
-                val incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId)
+                IncrementalPackageFragmentProvider(
-
+                        files, module, storageManager, container.deserializationComponentsForJava.components,
-                additionalProviders.add(
+                        incrementalComponents.getIncrementalCache(targetId), targetId
-                        IncrementalPackageFragmentProvider(
-                                files, moduleContext.module, moduleContext.storageManager,
-                                container.deserializationComponentsForJava.components,
-                                incrementalCache, targetId
-                        )
                 )
             }
         }
+
         additionalProviders.add(container.javaDescriptorResolver.packageFragmentProvider)
 
-        for (extension in PackageFragmentProviderExtension.getInstances(project)) {
+        PackageFragmentProviderExtension.getInstances(project).mapNotNullTo(additionalProviders) { extension ->
-            val provider = extension.getPackageFragmentProvider(
+            extension.getPackageFragmentProvider(project, module, storageManager, trace, null)
-                    project, moduleContext.module, moduleContext.storageManager, trace, null)
-            if (provider != null) additionalProviders.add(provider)
         }
 
         container.lazyTopDownAnalyzerForTopLevel.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, additionalProviders)
 
-        val bindingContext = trace.bindingContext
+        for (extension in AnalysisCompletedHandlerExtension.getInstances(project)) {
-        val module = moduleContext.module
-
-        val analysisCompletedHandlerExtensions = AnalysisCompletedHandlerExtension.getInstances(moduleContext.project)
-
-        for (extension in analysisCompletedHandlerExtensions) {
             val result = extension.analysisCompleted(project, module, trace, files)
             if (result != null) return result
         }
 
-        return AnalysisResult.success(bindingContext, module)
+        return AnalysisResult.success(trace.bindingContext, module)
     }
 
     @JvmStatic
-    fun createContextWithSealedModule(
+    fun createContextWithSealedModule(project: Project, configuration: CompilerConfiguration): MutableModuleContext {
-            project: Project, configuration: CompilerConfiguration
-    ): MutableModuleContext {
         val projectContext = ProjectContext(project)
         val builtIns = JvmBuiltIns(projectContext.storageManager)
         val context = ContextForNewModule(
-                projectContext, Name.special("<" + configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME) + ">"),
+                projectContext, Name.special("<${configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)}>"),
                 JvmPlatform, builtIns
         )
         context.setDependencies(context.module, builtIns.builtInsModule)

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

@@ -17,14 +17,11 @@
 package org.jetbrains.kotlin.js.analyze
 
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.context.*
+import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.context.MutableModuleContext
+import org.jetbrains.kotlin.context.ProjectContext
-import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.frontend.js.di.createTopDownAnalyzerForJs
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.frontend.js.di.*
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.resolve.JsPlatform
@@ -32,32 +29,18 @@ 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 java.util.ArrayList
-import java.util.Collections
 
 object TopDownAnalyzerFacadeForJS {
     @JvmStatic
     fun analyzeFiles(files: Collection<KtFile>, config: JsConfig): JsAnalysisResult {
-        val trace = BindingTraceContext()
+        val context =
-
+                ContextForNewModule(ProjectContext(config.project), Name.special("<${config.moduleId}>"), JsPlatform, JsPlatform.builtIns)
-        val newModuleContext = ContextForNewModule(
+        context.setDependencies(
-                ProjectContext(config.project), Name.special("<" + config.moduleId + ">"), JsPlatform,
+                listOf(context.module) +
-                JsPlatform.builtIns
+                config.moduleDescriptors.map { it.data } +
+                listOf(JsPlatform.builtIns.builtInsModule)
         )
-        newModuleContext.setDependencies(computeDependencies(newModuleContext.module, config))
+        return analyzeFilesWithGivenTrace(files, BindingTraceContext(), context, config)
-        return analyzeFilesWithGivenTrace(files, trace, newModuleContext, config)
-    }
-
-    private fun computeDependencies(module: ModuleDescriptorImpl, config: JsConfig): List<ModuleDescriptorImpl> {
-        val allDependencies = ArrayList<ModuleDescriptorImpl>()
-        allDependencies.add(module)
-        for (descriptor in config.moduleDescriptors) {
-            allDependencies.add(descriptor.data)
-        }
-        allDependencies.add(JsPlatform.builtIns.builtInsModule)
-        return allDependencies
     }
 
     @JvmStatic
@@ -68,13 +51,12 @@ object TopDownAnalyzerFacadeForJS {
             config: JsConfig
     ): JsAnalysisResult {
         val allFiles = JsConfig.withJsLibAdded(files, config)
-
         val analyzerForJs = createTopDownAnalyzerForJs(
                 moduleContext, trace,
                 FileBasedDeclarationProviderFactory(moduleContext.storageManager, allFiles),
-                config.configuration.get<LanguageVersionSettings>(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+                config.configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
         )
-        analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, emptyList<PackageFragmentProvider>())
+        analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, emptyList())
         return JsAnalysisResult.success(trace, moduleContext.module)
     }