Introduce ModuleContext, ProjectContext and use it some of the APIs

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt

@@ -16,13 +16,11 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.OrderRootType
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForLazyResolve
 import org.jetbrains.kotlin.idea.framework.JsHeaderLibraryDetectionUtil
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
@@ -44,29 +42,29 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
 
     override fun <M : ModuleInfo> createResolverForModule(
             moduleInfo: M,
-            project: Project,
-            globalContext: GlobalContext,
-            moduleDescriptor: ModuleDescriptorImpl,
+            moduleContext: ModuleContext,
             moduleContent: ModuleContent,
             platformParameters: PlatformAnalysisParameters,
             resolverForProject: ResolverForProject<M, JsResolverForModule>
     ): JsResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
+        val project = moduleContext.project
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
-                project, globalContext.storageManager, syntheticFiles, moduleContentScope
+                project, moduleContext.storageManager, syntheticFiles, moduleContentScope
         )
 
-        val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(),
+        val injector = InjectorForLazyResolve(moduleContext, declarationProviderFactory, BindingTraceContext(),
                                               KotlinJsCheckerProvider, DynamicTypesAllowed())
         val resolveSession = injector.getResolveSession()!!
         var packageFragmentProvider = resolveSession.getPackageFragmentProvider()
 
+        val moduleDescriptor = moduleContext.module
         if (moduleInfo is LibraryInfo) {
             val files = moduleInfo.library.getFiles(OrderRootType.CLASSES)
             if (!JsHeaderLibraryDetectionUtil.isJsHeaderLibraryWithSources(files.toList())) {
                 val providers = moduleInfo.library.getFiles(OrderRootType.CLASSES)
                         .flatMap { KotlinJavascriptMetadataUtils.loadMetadata(PathUtil.getLocalPath(it)!!) }
-                        .map { KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, it.body, globalContext.storageManager) }
+                        .map { KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, it.body, moduleContext.storageManager) }
                         .filterNotNull()
 
                 if (providers.isNotEmpty()) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -30,6 +30,9 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.analyzeInContext
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.context.SimpleGlobalContext
+import org.jetbrains.kotlin.context.withModule
+import org.jetbrains.kotlin.context.withProject
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
@@ -223,10 +226,12 @@ private object KotlinResolveDataProvider {
             val trace = DelegatingBindingTrace(resolveSession.getBindingContext(), "Trace for resolution of " + analyzableElement)
 
             val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
+            val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
+            val moduleContext = globalContext.withProject(project).withModule(resolveSession.getModuleDescriptor() as ModuleDescriptorImpl)
             val lazyTopDownAnalyzer = InjectorForLazyBodyResolve(
-                    project,
-                    SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()),
+                    moduleContext,
                     resolveSession,
+                    resolveSession.getScopeProvider(),
                     trace,
                     targetPlatform.getAdditionalCheckerProvider(),
                     targetPlatform.getDynamicTypesSettings()

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt

@@ -16,24 +16,21 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.module.ModuleManager
-import org.jetbrains.kotlin.utils.keysToMap
-import com.intellij.openapi.roots.LibraryOrderEntry
-import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
-import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.JdkOrderEntry
-import org.jetbrains.kotlin.analyzer.AnalyzerFacade
-import org.jetbrains.kotlin.analyzer.ResolverForModule
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.storage.ExceptionTracker
-import org.jetbrains.kotlin.load.java.structure.JavaClass
-import org.jetbrains.kotlin.analyzer.ResolverForProject
-import org.jetbrains.kotlin.analyzer.ModuleContent
-import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
+import com.intellij.openapi.roots.LibraryOrderEntry
+import com.intellij.openapi.roots.ModuleRootManager
+import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.context.GlobalContextImpl
+import org.jetbrains.kotlin.context.withProject
+import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
+import org.jetbrains.kotlin.load.java.structure.JavaClass
+import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.storage.ExceptionTracker
+import org.jetbrains.kotlin.utils.keysToMap
 
 fun createModuleResolverProvider(
         project: Project,
@@ -64,7 +61,8 @@ fun createModuleResolverProvider(
         }
 
         val resolverForProject = analyzerFacade.setupResolverForProject(
-                globalContext, project, modulesToCreateResolversFor, modulesContent, jvmPlatformParameters, delegateProvider.resolverForProject
+                globalContext.withProject(project), modulesToCreateResolversFor, modulesContent,
+                jvmPlatformParameters, delegateProvider.resolverForProject
         )
         return resolverForProject
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java

@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor;
 import org.jetbrains.kotlin.context.ContextPackage;
-import org.jetbrains.kotlin.context.GlobalContextImpl;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -233,24 +233,22 @@ public class JetSourceNavigationHelper {
             @NotNull Collection<JetNamedDeclaration> candidates,
             @NotNull Project project
     ) {
-        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
-                globalContext.getStorageManager(),
-                getContainingFiles(candidates)
-        );
 
         ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
                                                                          TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS,
                                                                          PlatformToKotlinClassMap.EMPTY);
+        ModuleContext moduleContext = ContextPackage.ModuleContext(moduleDescriptor, project);
+        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
+                moduleContext.getStorageManager(),
+                getContainingFiles(candidates)
+        );
 
         moduleDescriptor.addDependencyOnModule(moduleDescriptor);
         moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
         moduleDescriptor.seal();
 
         ResolveSession resolveSession = new InjectorForLazyResolve(
-                project,
-                globalContext,
-                moduleDescriptor,
+                moduleContext,
                 providerFactory,
                 new BindingTraceContext(),
                 AdditionalCheckerProvider.DefaultProvider.INSTANCE$,

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java

@@ -38,7 +38,7 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.context.ContextPackage;
-import org.jetbrains.kotlin.context.GlobalContextImpl;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.di.InjectorForLazyResolve;
@@ -95,19 +95,19 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
         final Runnable initializeRunnable = new Runnable() {
             @Override
             public void run() {
-                GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-
                 ModuleDescriptorImpl module = new ModuleDescriptorImpl(
                         Name.special("<built-ins resolver module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
                 );
                 module.addDependencyOnModule(module);
                 module.seal();
 
+                ModuleContext moduleContext = ContextPackage.ModuleContext(module, myProject);
+
                 FileBasedDeclarationProviderFactory declarationFactory =
-                        new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), jetBuiltInsFiles);
+                        new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), jetBuiltInsFiles);
 
                 InjectorForLazyResolve injectorForLazyResolve =
-                        new InjectorForLazyResolve(myProject, globalContext, module, declarationFactory, new BindingTraceContext(),
+                        new InjectorForLazyResolve(moduleContext, declarationFactory, new BindingTraceContext(),
                                                    AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
                                                    new DynamicTypesSettings());