Introduce ModuleContext, ProjectContext and use it some of the APIs

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.addKotlinSourceRoots
-import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -86,7 +86,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
 
         val builtInModule = BuiltinsSourcesModule()
         val resolver = JvmAnalyzerFacade.setupResolverForProject(
-                GlobalContext(), environment.project, listOf(builtInModule),
+                ProjectContext(environment.project), listOf(builtInModule),
                 { ModuleContent(files, GlobalSearchScope.EMPTY_SCOPE) },
                 platformParameters = JvmPlatformParameters { throw IllegalStateException() }
         )

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -320,11 +320,9 @@ public class KotlinToJVMBytecodeCompiler {
                         ModuleDescriptorImpl analyzeModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
 
                         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-                                environment.getProject(),
+                                ContextPackage.ModuleContext(analyzeModule, environment.getProject()),
-                                ContextPackage.GlobalContext(),
                                 environment.getSourceFiles(),
                                 sharedTrace,
-                                analyzeModule,
                                 environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS),
                                 environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER)
                         );

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.codegen.KotlinCodegenFacade;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.context.ContextPackage;
-import org.jetbrains.kotlin.context.GlobalContextImpl;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -110,7 +110,7 @@ public class ReplInterpreter {
         this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         this.module = TopDownAnalyzerFacadeForJVM.createJavaModule("<repl>");
 
-        GlobalContextImpl context = ContextPackage.GlobalContext();
+        ModuleContext context = ContextPackage.ModuleContext(module, project);
 
         scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory();
 
@@ -123,10 +123,8 @@ public class ReplInterpreter {
         };
 
         InjectorForReplWithJava injector = new InjectorForReplWithJava(
-                project,
                 context,
                 trace,
-                module,
                 scriptDeclarationFactory,
                 ProjectScope.getAllScope(project),
                 scopeProvider

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.di;
 
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
@@ -85,13 +85,13 @@ import javax.annotation.PreDestroy;
 @SuppressWarnings("all")
 public class InjectorForLazyResolveWithJava {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final ResolveSession resolveSession;
     private final ScopeProvider scopeProvider;
@@ -149,23 +149,21 @@ public class InjectorForLazyResolveWithJava {
     private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
 
     public InjectorForLazyResolveWithJava(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
         @NotNull GlobalSearchScope moduleContentScope,
         @NotNull ModuleClassResolver moduleClassResolver
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
+        this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.moduleContentScope = moduleContentScope;
         this.moduleClassResolver = moduleClassResolver;
@@ -181,9 +179,9 @@ public class InjectorForLazyResolveWithJava {
         this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
         this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModule());
+        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor);
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.lazyResolveToken = new LazyResolveToken();
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
@@ -200,7 +198,7 @@ public class InjectorForLazyResolveWithJava {
         this.delegatedPropertyResolver = new DelegatedPropertyResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.fakeCallResolver = new FakeCallResolver(project, callResolver);
         this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
@@ -212,13 +210,13 @@ public class InjectorForLazyResolveWithJava {
         this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
         this.taskPrioritizer = new TaskPrioritizer(storageManager);
         this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
         this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
+        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, virtualFileFinder, traceBasedErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, moduleDescriptor, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -281,7 +279,7 @@ public class InjectorForLazyResolveWithJava {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -334,8 +332,8 @@ public class InjectorForLazyResolveWithJava {
     public void destroy() {
     }
 
-    public ModuleDescriptorImpl getModule() {
+    public ModuleContext getModuleContext() {
-        return this.module;
+        return this.moduleContext;
     }
 
     public ResolveSession getResolveSession() {

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.di;
 
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
@@ -96,13 +96,13 @@ import javax.annotation.PreDestroy;
 @SuppressWarnings("all")
 public class InjectorForReplWithJava {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final ResolveSession resolveSession;
     private final ScopeProvider scopeProvider;
@@ -171,23 +171,21 @@ public class InjectorForReplWithJava {
     private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
 
     public InjectorForReplWithJava(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
         @NotNull GlobalSearchScope moduleContentScope,
         @NotNull AdditionalFileScopeProvider additionalFileScopeProvider
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
+        this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.moduleContentScope = moduleContentScope;
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
@@ -205,12 +203,12 @@ public class InjectorForReplWithJava {
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
         this.singleModuleClassResolver = new SingleModuleClassResolver();
         this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModule());
+        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor);
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
+        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, virtualFileFinder, traceBasedErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, moduleDescriptor, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
@@ -228,7 +226,7 @@ public class InjectorForReplWithJava {
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.typeLazinessToken = new TypeLazinessToken();
         this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.fakeCallResolver = new FakeCallResolver(project, callResolver);
         this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
@@ -240,7 +238,7 @@ public class InjectorForReplWithJava {
         this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
         this.taskPrioritizer = new TaskPrioritizer(storageManager);
         this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
         this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.bodyResolver = new BodyResolver();
@@ -271,7 +269,7 @@ public class InjectorForReplWithJava {
         this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
         this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
         this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
+        this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
@@ -331,7 +329,7 @@ public class InjectorForReplWithJava {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -411,8 +409,8 @@ public class InjectorForReplWithJava {
     public void destroy() {
     }
 
-    public ModuleDescriptorImpl getModule() {
+    public ModuleContext getModuleContext() {
-        return this.module;
+        return this.moduleContext;
     }
 
     public ResolveSession getResolveSession() {

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.di;
 
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
@@ -96,13 +96,13 @@ import javax.annotation.PreDestroy;
 @SuppressWarnings("all")
 public class InjectorForTopDownAnalyzerForJvm {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final ResolveSession resolveSession;
     private final ScopeProvider scopeProvider;
@@ -171,22 +171,20 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
 
     public InjectorForTopDownAnalyzerForJvm(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
         @NotNull GlobalSearchScope moduleContentScope
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
+        this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.moduleContentScope = moduleContentScope;
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
@@ -204,12 +202,12 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
         this.singleModuleClassResolver = new SingleModuleClassResolver();
         this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModule());
+        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor);
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
+        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, virtualFileFinder, traceBasedErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, moduleDescriptor, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
         this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
         this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
@@ -226,7 +224,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.typeLazinessToken = new TypeLazinessToken();
         this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.fakeCallResolver = new FakeCallResolver(project, callResolver);
         this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
@@ -238,7 +236,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
         this.taskPrioritizer = new TaskPrioritizer(storageManager);
         this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
         this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
@@ -270,7 +268,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
         this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
         this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
+        this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
@@ -330,7 +328,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -410,8 +408,8 @@ public class InjectorForTopDownAnalyzerForJvm {
     public void destroy() {
     }
 
-    public ModuleDescriptorImpl getModule() {
+    public ModuleContext getModuleContext() {
-        return this.module;
+        return this.moduleContext;
     }
 
     public ResolveSession getResolveSession() {

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

@@ -16,29 +16,22 @@
 
 package org.jetbrains.kotlin.resolve.jvm
 
-import org.jetbrains.kotlin.analyzer.AnalyzerFacade
-import org.jetbrains.kotlin.analyzer.ResolverForModule
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
-import org.jetbrains.kotlin.analyzer.ResolverForProject
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
-import org.jetbrains.kotlin.load.java.structure.JavaClass
-import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.analyzer.ModuleContent
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
-import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import com.intellij.psi.search.GlobalSearchScope
-import java.util.ArrayList
+import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
+import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
-import kotlin.platform.platformStatic
+import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
-import com.intellij.openapi.module.Module
+import org.jetbrains.kotlin.load.java.structure.JavaClass
+import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
+import java.util.ArrayList
+import kotlin.platform.platformStatic
 
 public class JvmResolverForModule(
         override val lazyResolveSession: ResolveSession,
@@ -53,17 +46,16 @@ public class JvmPlatformParameters(
 public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatformParameters> {
     override fun <M : ModuleInfo> createResolverForModule(
             moduleInfo: M,
-            project: Project,
+            moduleContext: ModuleContext,
-            globalContext: GlobalContext,
-            moduleDescriptor: ModuleDescriptorImpl,
             moduleContent: ModuleContent,
             platformParameters: JvmPlatformParameters,
             resolverForProject: ResolverForProject<M, JvmResolverForModule>
     ): JvmResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
+        val project = moduleContext.project
         val filesToAnalyze = getAllFilesToAnalyze(project, moduleInfo, syntheticFiles)
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
-                project, globalContext.storageManager, filesToAnalyze,
+                project, moduleContext.storageManager, filesToAnalyze,
                 if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
         )
 
@@ -72,16 +64,17 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
             resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
         }
         val injector = InjectorForLazyResolveWithJava(
-                project, globalContext,
+                moduleContext,
                 CodeAnalyzerInitializer.getInstance(project).createTrace(),
-                moduleDescriptor, declarationProviderFactory,
+                declarationProviderFactory,
-                moduleContentScope, moduleClassResolver
+                moduleContentScope,
+                moduleClassResolver
         )
 
         val resolveSession = injector.getResolveSession()!!
         val javaDescriptorResolver = injector.getJavaDescriptorResolver()!!
         val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
-        moduleDescriptor.initialize(CompositePackageFragmentProvider(providersForModule))
+        moduleContext.module.initialize(CompositePackageFragmentProvider(providersForModule))
         return JvmResolverForModule(resolveSession, javaDescriptorResolver)
     }
 

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

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.context.GlobalContext;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -66,57 +66,47 @@ public enum TopDownAnalyzerFacadeForJVM {
         return list;
     }
 
-    private TopDownAnalyzerFacadeForJVM() {
-    }
-
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationNoIncremental(
-            @NotNull Project project,
+            @NotNull ModuleContext moduleContext,
-            @NotNull GlobalContext globalContext,
             @NotNull Collection<JetFile> files,
             @NotNull BindingTrace trace,
-            @NotNull TopDownAnalysisMode topDownAnalysisMode,
+            @NotNull TopDownAnalysisMode topDownAnalysisMode
-            @NotNull ModuleDescriptorImpl module
     ) {
-        return analyzeFilesWithJavaIntegration(project, globalContext, files, trace, topDownAnalysisMode, module, null, null);
+        return analyzeFilesWithJavaIntegration(moduleContext, files, trace, topDownAnalysisMode, null, null);
     }
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationWithCustomContext(
-            @NotNull Project project,
+            @NotNull ModuleContext moduleContext,
-            @NotNull GlobalContext globalContext,
             @NotNull Collection<JetFile> files,
             @NotNull BindingTrace trace,
-            @NotNull ModuleDescriptorImpl module,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCacheProvider incrementalCacheProvider
     ) {
         return analyzeFilesWithJavaIntegration(
-                project, globalContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, module,
+                moduleContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, moduleIds, incrementalCacheProvider
-                moduleIds, incrementalCacheProvider);
+        );
     }
 
     @NotNull
     private static AnalysisResult analyzeFilesWithJavaIntegration(
-            Project project,
+            @NotNull ModuleContext moduleContext,
-            @NotNull GlobalContext globalContext,
+            @NotNull Collection<JetFile> files,
-            Collection<JetFile> files,
+            @NotNull BindingTrace trace,
-            BindingTrace trace,
+            @NotNull TopDownAnalysisMode topDownAnalysisMode,
-            TopDownAnalysisMode topDownAnalysisMode,
-            ModuleDescriptorImpl module,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCacheProvider incrementalCacheProvider
     ) {
+        Project project = moduleContext.getProject();
         List<JetFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, null, files);
 
         FileBasedDeclarationProviderFactory providerFactory =
-                new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), allFiles);
+                new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles);
 
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
-                project,
+                moduleContext,
-                globalContext,
                 trace,
-                module,
                 providerFactory,
                 GlobalSearchScope.allScope(project)
         );
@@ -130,7 +120,7 @@ public enum TopDownAnalyzerFacadeForJVM {
 
                     additionalProviders.add(
                             new IncrementalPackageFragmentProvider(
-                                    files, module, globalContext.getStorageManager(),
+                                    files, moduleContext.getModule(), moduleContext.getStorageManager(),
                                     injector.getDeserializationComponentsForJava().getComponents(),
                                     incrementalCache, moduleId
                             )
@@ -140,7 +130,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
 
             injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders);
-            return AnalysisResult.success(trace.getBindingContext(), module);
+            return AnalysisResult.success(trace.getBindingContext(), moduleContext.getModule());
         }
         finally {
             injector.destroy();

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

@@ -16,19 +16,20 @@
 
 package org.jetbrains.kotlin.analyzer
 
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import java.util.HashMap
-import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import java.util.ArrayList
-import org.jetbrains.kotlin.psi.JetFile
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.context.withModule
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.ImportPath
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import java.util.ArrayList
+import java.util.HashMap
 import kotlin.properties.Delegates
 
 public trait ResolverForModule {
@@ -118,8 +119,7 @@ public trait ModuleInfo {
 //TODO: (module refactoring) extract project context
 public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParameters> {
     public fun <M : ModuleInfo> setupResolverForProject(
-            globalContext: GlobalContext,
+            projectContext: ProjectContext,
-            project: Project,
             modules: Collection<M>,
             modulesContent: (M) -> ModuleContent,
             platformParameters: P,
@@ -173,7 +173,7 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
                 module ->
                 val descriptor = resolverForProject.descriptorForModule(module)
                 val resolverForModule = createResolverForModule(
-                        module, project, globalContext, descriptor, modulesContent(module), platformParameters, resolverForProject
+                        module, projectContext.withModule(descriptor), modulesContent(module), platformParameters, resolverForProject
                 )
                 assert(descriptor.isInitialized, "ModuleDescriptorImpl#initialize() should be called in createResolverForModule")
                 resolverForProject.resolverByModuleDescriptor[descriptor] = resolverForModule
@@ -186,9 +186,7 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
 
     protected fun <M : ModuleInfo> createResolverForModule(
             moduleInfo: M,
-            project: Project,
+            moduleContext: ModuleContext,
-            globalContext: GlobalContext,
-            moduleDescriptor: ModuleDescriptorImpl,
             moduleContent: ModuleContent,
             platformParameters: P,
             resolverForProject: ResolverForProject<M, A>

compiler/frontend/src/org/jetbrains/kotlin/context/context.kt

@@ -16,15 +16,33 @@
 
 package org.jetbrains.kotlin.context
 
-import org.jetbrains.kotlin.storage.StorageManager
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
 
 public trait GlobalContext {
     public val storageManager: StorageManager
     public val exceptionTracker: ExceptionTracker
 }
 
+public trait ProjectContext : GlobalContext {
+    public val project: Project
+}
+
+public trait ModuleContext : ProjectContext {
+    public val module: ModuleDescriptorImpl
+
+    public val platformToKotlinClassMap: PlatformToKotlinClassMap
+        get() = module.platformToKotlinClassMap
+
+    public val builtIns: KotlinBuiltIns
+        get() = module.builtIns
+}
+
 public open class SimpleGlobalContext(
         override val storageManager: StorageManager,
         override val exceptionTracker: ExceptionTracker
@@ -37,11 +55,28 @@ public open class GlobalContextImpl(
     override val storageManager: LockBasedStorageManager = super.storageManager as LockBasedStorageManager
 }
 
+public class ProjectContextImpl(
+        override val project: Project,
+        private val globalContext: GlobalContext
+) : ProjectContext, GlobalContext by globalContext
+
+public class ModuleContextImpl(
+        override val module: ModuleDescriptorImpl,
+        projectContext: ProjectContext
+) : ModuleContext, ProjectContext by projectContext
+
 public fun GlobalContext(): GlobalContextImpl {
     val tracker = ExceptionTracker()
     return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker)
 }
 
+public fun ProjectContext(project: Project): ProjectContext = ProjectContextImpl(project, GlobalContext())
+public fun ModuleContext(module: ModuleDescriptorImpl, project: Project): ModuleContext =
+        ModuleContextImpl(module, ProjectContext(project))
+
+public fun GlobalContext.withProject(project: Project): ProjectContext = ProjectContextImpl(project, this)
+public fun ProjectContext.withModule(module: ModuleDescriptorImpl): ModuleContext = ModuleContextImpl(module, this)
+
 deprecated("Used temporarily while we are in transition from to lazy resolve")
 public open class TypeLazinessToken {
     deprecated("Used temporarily while we are in transition from to lazy resolve")

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java

@@ -17,59 +17,35 @@
 package org.jetbrains.kotlin.di;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.builtins.ReflectionTypes;
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.context.TypeLazinessToken;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
+import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
+import org.jetbrains.kotlin.resolve.calls.*;
+import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
+import org.jetbrains.kotlin.storage.StorageManager;
+import org.jetbrains.kotlin.types.DynamicTypesSettings;
+import org.jetbrains.kotlin.types.expressions.*;
+
 import javax.annotation.PreDestroy;
 
 /* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
 @SuppressWarnings("all")
 public class InjectorForBodyResolve {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptor moduleDescriptor;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final SymbolUsageValidator symbolUsageValidator;
     private final StatementFilter statementFilter;
@@ -105,20 +81,18 @@ public class InjectorForBodyResolve {
     private final ScriptBodyResolver scriptBodyResolver;
 
     public InjectorForBodyResolve(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor,
         @NotNull AdditionalCheckerProvider additionalCheckerProvider,
         @NotNull StatementFilter statementFilter
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.bindingTrace = bindingTrace;
-        this.moduleDescriptor = moduleDescriptor;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
         this.statementFilter = statementFilter;
@@ -194,7 +168,7 @@ public class InjectorForBodyResolve {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java

@@ -17,79 +17,46 @@
 package org.jetbrains.kotlin.di;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.builtins.ReflectionTypes;
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.context.TypeLazinessToken;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
+import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
+import org.jetbrains.kotlin.resolve.calls.*;
+import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
+import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
+import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
+import org.jetbrains.kotlin.storage.StorageManager;
+import org.jetbrains.kotlin.types.DynamicTypesSettings;
+import org.jetbrains.kotlin.types.expressions.*;
+
 import javax.annotation.PreDestroy;
 
 /* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
 @SuppressWarnings("all")
 public class InjectorForLazyBodyResolve {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final KotlinCodeAnalyzer analyzer;
-    private final ModuleDescriptor moduleDescriptor;
+    private final FileScopeProvider fileScopeProvider;
-    private final ScopeProvider scopeProvider;
     private final BindingTrace bindingTrace;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final SymbolUsageValidator symbolUsageValidator;
     private final DynamicTypesSettings dynamicTypesSettings;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
@@ -122,34 +89,33 @@ public class InjectorForLazyBodyResolve {
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final ScriptBodyResolver scriptBodyResolver;
     private final DeclarationResolver declarationResolver;
+    private final DeclarationScopeProviderImpl declarationScopeProvider;
+    private final LazyDeclarationResolver lazyDeclarationResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
 
     public InjectorForLazyBodyResolve(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull KotlinCodeAnalyzer analyzer,
+        @NotNull FileScopeProvider fileScopeProvider,
         @NotNull BindingTrace bindingTrace,
         @NotNull AdditionalCheckerProvider additionalCheckerProvider,
         @NotNull DynamicTypesSettings dynamicTypesSettings
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.analyzer = analyzer;
-        this.moduleDescriptor = analyzer.getModuleDescriptor();
+        this.fileScopeProvider = fileScopeProvider;
-        this.scopeProvider = analyzer.getScopeProvider();
         this.bindingTrace = bindingTrace;
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
         this.dynamicTypesSettings = dynamicTypesSettings;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
-        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
@@ -182,6 +148,8 @@ public class InjectorForLazyBodyResolve {
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.declarationResolver = new DeclarationResolver();
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(moduleContext, bindingTrace);
+        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -189,15 +157,10 @@ public class InjectorForLazyBodyResolve {
         this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(analyzer);
         this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
 
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
-
         lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
         lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
+        lazyTopDownAnalyzer.setFileScopeProvider(fileScopeProvider);
         lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
         lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
@@ -247,7 +210,7 @@ public class InjectorForLazyBodyResolve {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -292,6 +255,11 @@ public class InjectorForLazyBodyResolve {
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setTrace(bindingTrace);
 
+        declarationScopeProvider.setFileScopeProvider(fileScopeProvider);
+
+        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
+        lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
+
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java

@@ -17,69 +17,38 @@
 package org.jetbrains.kotlin.di;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
-import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
-import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.builtins.ReflectionTypes;
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.context.TypeLazinessToken;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
+import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
+import org.jetbrains.kotlin.resolve.calls.*;
+import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
+import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
+import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
+import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
+import org.jetbrains.kotlin.storage.StorageManager;
+import org.jetbrains.kotlin.types.DynamicTypesSettings;
+import org.jetbrains.kotlin.types.expressions.*;
+
 import javax.annotation.PreDestroy;
 
 /* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
 @SuppressWarnings("all")
 public class InjectorForLazyLocalClassifierAnalyzer {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptor module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final AdditionalCheckerProvider additionalCheckerProvider;
     private final SymbolUsageValidator symbolUsageValidator;
     private final DynamicTypesSettings dynamicTypesSettings;
@@ -125,21 +94,19 @@ public class InjectorForLazyLocalClassifierAnalyzer {
     private final VarianceChecker varianceChecker;
 
     public InjectorForLazyLocalClassifierAnalyzer(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor module,
         @NotNull AdditionalCheckerProvider additionalCheckerProvider,
         @NotNull DynamicTypesSettings dynamicTypesSettings,
         @NotNull LocalClassDescriptorHolder localClassDescriptorHolder
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
         this.dynamicTypesSettings = dynamicTypesSettings;
@@ -147,7 +114,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$;
         this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
-        this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorHolder);
+        this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(moduleContext, bindingTrace, localClassDescriptorHolder);
         this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorHolder);
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
@@ -162,13 +129,13 @@ public class InjectorForLazyLocalClassifierAnalyzer {
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
         this.typeLazinessToken = new TypeLazinessToken();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.fakeCallResolver = new FakeCallResolver(project, callResolver);
         this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
         this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
         this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(module);
+        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
         this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
         this.statementFilter = new StatementFilter();
         this.candidateResolver = new CandidateResolver();
@@ -189,7 +156,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
         this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
         this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider);
         this.lazyTopDownAnalyzer.setLazyDeclarationResolver(localLazyDeclarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
+        this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
@@ -242,7 +209,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java

@@ -17,60 +17,41 @@
 package org.jetbrains.kotlin.di;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
+import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.builtins.ReflectionTypes;
+import org.jetbrains.kotlin.context.LazyResolveToken;
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
+import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.BindingTrace;
+import org.jetbrains.kotlin.resolve.*;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
+import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
+import org.jetbrains.kotlin.resolve.calls.*;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
+import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
+import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import org.jetbrains.kotlin.context.LazyResolveToken;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
+import org.jetbrains.kotlin.storage.StorageManager;
+import org.jetbrains.kotlin.types.DynamicTypesSettings;
+import org.jetbrains.kotlin.types.expressions.*;
+
 import javax.annotation.PreDestroy;
 
 /* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
 @SuppressWarnings("all")
 public class InjectorForLazyResolve {
 
-    private final Project project;
+    private final ModuleContext moduleContext;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final ModuleDescriptorImpl moduleDescriptor;
     private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final Project project;
+    private final StorageManager storageManager;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final BindingTrace bindingTrace;
     private final AdditionalCheckerProvider additionalCheckerProvider;
@@ -109,26 +90,24 @@ public class InjectorForLazyResolve {
     private final AdditionalFileScopeProvider additionalFileScopeProvider;
 
     public InjectorForLazyResolve(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
-        @NotNull ModuleDescriptorImpl moduleDescriptor,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
         @NotNull BindingTrace bindingTrace,
         @NotNull AdditionalCheckerProvider additionalCheckerProvider,
         @NotNull DynamicTypesSettings dynamicTypesSettings
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
-        this.moduleDescriptor = moduleDescriptor;
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
+        this.project = moduleContext.getProject();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.storageManager = moduleContext.getStorageManager();
         this.declarationProviderFactory = declarationProviderFactory;
         this.bindingTrace = bindingTrace;
         this.additionalCheckerProvider = additionalCheckerProvider;
         this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
         this.dynamicTypesSettings = dynamicTypesSettings;
-        this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
+        this.resolveSession = new ResolveSession(project, moduleContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.lazyResolveToken = new LazyResolveToken();
         this.annotationResolver = new AnnotationResolver();
@@ -155,7 +134,7 @@ public class InjectorForLazyResolve {
         this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
         this.taskPrioritizer = new TaskPrioritizer(storageManager);
         this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(moduleContext, bindingTrace);
         this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
@@ -202,7 +181,7 @@ public class InjectorForLazyResolve {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -19,9 +19,12 @@ package org.jetbrains.kotlin.types.expressions
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.withModule
+import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.JetClassOrObject
@@ -59,12 +62,11 @@ public class LocalClassifierAnalyzer(
             additionalCheckerProvider: AdditionalCheckerProvider,
             dynamicTypesSettings: DynamicTypesSettings
     ) {
-        val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration)
+        val module = DescriptorUtils.getContainingModule(containingDeclaration)
+        val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module as ModuleDescriptorImpl)
         val injector = InjectorForLazyLocalClassifierAnalyzer(
-                classOrObject.getProject(),
+                moduleContext,
-                globalContext,
                 context.trace,
-                moduleDescriptor,
                 additionalCheckerProvider,
                 dynamicTypesSettings,
                 LocalClassDescriptorHolder(
@@ -73,7 +75,7 @@ public class LocalClassifierAnalyzer(
                         containingDeclaration,
                         globalContext.storageManager,
                         context,
-                        moduleDescriptor,
+                        module,
                         descriptorResolver,
                         funcionDescriptorResolver,
                         typeResolver,

compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java

@@ -29,6 +29,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.context.GlobalContext;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.context.SimpleGlobalContext;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
@@ -59,6 +60,8 @@ import org.jetbrains.kotlin.utils.UtilsPackage;
 import java.io.File;
 import java.util.*;
 
+import static org.jetbrains.kotlin.context.ContextPackage.withModule;
+import static org.jetbrains.kotlin.context.ContextPackage.withProject;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE;
 import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE_ALL;
@@ -144,7 +147,8 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
 
         StringBuilder actualText = new StringBuilder();
         for (TestFile testFile : testFiles) {
-            ok &= testFile.getActualText(moduleBindings.get(testFile.getModule()), actualText, shouldSkipJvmSignatureDiagnostics(groupedByModule));
+            ok &= testFile.getActualText(moduleBindings.get(testFile.getModule()), actualText,
+                                         shouldSkipJvmSignatureDiagnostics(groupedByModule));
         }
 
         Throwable exceptionFromDynamicCallDescriptorsValidation = null;
@@ -223,14 +227,14 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
             ModuleDescriptorImpl module,
             BindingTrace moduleTrace
     ) {
+        ModuleContext moduleContext = withModule(withProject(context, getProject()), module);
+
         // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
         // albeit with same class names
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-                getProject(),
+                moduleContext,
-                context,
                 jetFiles,
                 moduleTrace,
-                module,
                 null,
                 null
         );
@@ -378,7 +382,6 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
             if (diagnosticsStoringResolvedCalls1.contains(factory)) {
                 assertResolvedCallsAreCompleted(
                         diagnostic, DiagnosticFactory.cast(diagnostic, diagnosticsStoringResolvedCalls1).getA());
-
             }
             //noinspection SuspiciousMethodCalls
             if (diagnosticsStoringResolvedCalls2.contains(factory)) {

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -151,12 +151,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
-                environment.getProject(),
+                ContextPackage.ModuleContext(module, environment.getProject()),
-                ContextPackage.GlobalContext(),
                 environment.getSourceFiles(),
                 trace,
-                TopDownAnalysisMode.TopLevelDeclarations,
+                TopDownAnalysisMode.TopLevelDeclarations
-                module);
+        );
 
         PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
         assert packageView != null : "Test package not found";

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -57,7 +57,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
         val environment = createEnvironment(moduleDirs)
         val modules = setupModules(environment, moduleDirs)
         val resolverForProject = JvmAnalyzerFacade.setupResolverForProject(
-                GlobalContext(), environment.project, modules,
+                ProjectContext(environment.project), modules,
                 { m -> ModuleContent(m.kotlinFiles, m.javaFilesScope) },
                 JvmPlatformParameters {
                     javaClass ->

compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -16,28 +16,28 @@
 
 package org.jetbrains.kotlin.renderer
 
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import com.intellij.openapi.editor.impl.DocumentImpl
-import org.jetbrains.kotlin.test.JetTestUtils
+import com.intellij.openapi.util.io.FileUtil
-import java.util.ArrayList
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.test.ConfigurationKind
 import com.intellij.testFramework.UsefulTestCase
-import java.io.File
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.di.InjectorForLazyResolve
-import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.di.InjectorForLazyResolve
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment
-import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
+import org.jetbrains.kotlin.test.ConfigurationKind
+import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.types.DynamicTypesSettings
+import java.io.File
+import java.util.ArrayList
 
 public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
     protected open fun getDescriptor(declaration: JetDeclaration, resolveSession: ResolveSession): DeclarationDescriptor {
@@ -49,11 +49,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
         val psiFile = JetPsiFactory(getProject()).createFile(fileText)
 
         val lazyModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
-        val globalContext = GlobalContext()
+        val moduleContext = ModuleContext(lazyModule, getProject())
 
         val resolveSession = InjectorForLazyResolve(
-                getProject(), globalContext, lazyModule,
+                moduleContext,
-                FileBasedDeclarationProviderFactory(globalContext.storageManager, listOf(psiFile)),
+                FileBasedDeclarationProviderFactory(moduleContext.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
 

compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java

@@ -78,6 +78,6 @@ public class JvmResolveUtil {
         BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
 
         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-                project, ContextPackage.GlobalContext(), files, trace, module, null, null);
+                ContextPackage.ModuleContext(module, project), files, trace, null, null);
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java

@@ -56,7 +56,7 @@ public class LazyResolveTestUtil {
         ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
-                project, ContextPackage.GlobalContext(), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations, module
+                ContextPackage.ModuleContext(module, project), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations
         );
 
         return module;

compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtil.kt

@@ -17,24 +17,24 @@
 package org.jetbrains.kotlin.resolve.lazy
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.psi.JetFile
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.analyzer.ModuleContent
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
+import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 
 public fun createResolveSessionForFiles(
         project: Project,
         syntheticFiles: Collection<JetFile>,
         addBuiltIns: Boolean
 ): ResolveSession {
-    val globalContext = GlobalContext()
+    val projectContext = ProjectContext(project)
     val testModule = TestModule(addBuiltIns)
     val resolverForProject = JvmAnalyzerFacade.setupResolverForProject(
-            globalContext, project, listOf(testModule),
+            projectContext, listOf(testModule),
             { ModuleContent(syntheticFiles, GlobalSearchScope.allScope(project)) },
             JvmPlatformParameters { testModule }
     )

compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
-import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -54,11 +54,11 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
         val module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
-        val globalContext = GlobalContext()
+        val moduleContext = ModuleContext(module, environment.project)
-        val providerFactory = FileBasedDeclarationProviderFactory(globalContext.storageManager, emptyList())
+        val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
 
         val injector = InjectorForTopDownAnalyzerForJvm(
-                environment.project, globalContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), module,
+                moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 providerFactory, GlobalSearchScope.allScope(environment.project)
         )
         module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)

compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java

@@ -20,17 +20,13 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 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;
 import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
+import org.jetbrains.kotlin.resolve.*;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.BindingTraceContext;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
@@ -102,12 +98,10 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         }
 
         private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
-            GlobalContextImpl globalContext = ContextPackage.GlobalContext();
+            ModuleContext moduleContext = ContextPackage.ModuleContext(root, getProject());
             ResolveSession resolveSession = new InjectorForLazyResolve(
-                    getProject(),
+                    moduleContext,
-                    globalContext,
+                    new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
-                    root,
-                    new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(),
                                                             Collections.singleton(aClass.getContainingJetFile())),
                     new BindingTraceContext(),
                     AdditionalCheckerProvider.DefaultProvider.INSTANCE$,

generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt

@@ -20,8 +20,8 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.LazyResolveToken
+import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.generators.di.*
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
@@ -82,10 +82,8 @@ public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
 
 private fun generatorForLazyLocalClassifierAnalyzer() =
         generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") {
-            parameter<Project>()
+            parameter<ModuleContext>(useAsContext = true)
-            parameter<GlobalContext>(useAsContext = true)
             parameter<BindingTrace>()
-            parameter<ModuleDescriptor>(name = "module", useAsContext = true)
             parameter<AdditionalCheckerProvider>(useAsContext = true)
             parameter<DynamicTypesSettings>()
             parameter<LocalClassDescriptorHolder>()
@@ -100,15 +98,13 @@ private fun generatorForLazyLocalClassifierAnalyzer() =
 
 private fun generatorForLazyBodyResolve() =
         generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyBodyResolve") {
-            parameter<Project>()
+            parameter<ModuleContext>(useAsContext = true)
-            parameter<GlobalContext>(useAsContext = true)
+            parameter<KotlinCodeAnalyzer>(name = "analyzer")
-            parameter<KotlinCodeAnalyzer>(name = "analyzer", useAsContext = true)
+            parameter<FileScopeProvider>()
             parameter<BindingTrace>()
             parameter<AdditionalCheckerProvider>(useAsContext = true)
             parameter<DynamicTypesSettings>()
 
-            field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
-
             publicField<LazyTopDownAnalyzerForTopLevel>()
         }
 
@@ -222,10 +218,8 @@ private fun generatorForTests() =
 
 private fun generatorForBodyResolve() =
         generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForBodyResolve") {
-            parameter<Project>()
+            parameter<ModuleContext>(useAsContext = true)
-            parameter<GlobalContext>(useAsContext = true)
             parameter<BindingTrace>()
-            parameter<ModuleDescriptor>(useAsContext = true)
             parameter<AdditionalCheckerProvider>(useAsContext = true)
             parameter<StatementFilter>()
 
@@ -234,9 +228,7 @@ private fun generatorForBodyResolve() =
 
 private fun generatorForLazyResolve() =
         generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyResolve") {
-            parameter<Project>()
+            parameter<ModuleContext>(useAsContext = true)
-            parameter<GlobalContext>(useAsContext = true)
-            parameter<ModuleDescriptorImpl>(useAsContext = true)
             parameter<DeclarationProviderFactory>()
             parameter<BindingTrace>()
             parameter<AdditionalCheckerProvider>(useAsContext = true)
@@ -249,10 +241,8 @@ private fun generatorForLazyResolve() =
         }
 
 private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
-    parameter<Project>()
+    publicParameter<ModuleContext>(useAsContext = true)
-    parameter<GlobalContext>(useAsContext = true)
     parameter<BindingTrace>()
-    publicParameter<ModuleDescriptorImpl>(name = "module", useAsContext = true)
     parameter<DeclarationProviderFactory>()
 
     publicField<ResolveSession>()

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt

@@ -21,10 +21,12 @@ import com.google.common.base.Functions
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.computeTypeInContext
 import org.jetbrains.kotlin.cfg.JetFlowInformationProvider
-import org.jetbrains.kotlin.context.GlobalContextImpl
 import org.jetbrains.kotlin.context.SimpleGlobalContext
+import org.jetbrains.kotlin.context.withModule
+import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForBodyResolve
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -38,7 +40,6 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
@@ -372,8 +373,8 @@ public abstract class ElementResolver protected(
     private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver {
         val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
         val bodyResolve = InjectorForBodyResolve(
-                file.getProject(), globalContext,
+                globalContext.withProject(file.getProject()).withModule(resolveSession.getModuleDescriptor() as ModuleDescriptorImpl),
-                trace, resolveSession.getModuleDescriptor(), getAdditionalCheckerProvider(file), statementFilter
+                trace, getAdditionalCheckerProvider(file), statementFilter
         )
         return bodyResolve.getBodyResolver()
     }

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,
+            moduleContext: ModuleContext,
-            globalContext: GlobalContext,
-            moduleDescriptor: ModuleDescriptorImpl,
             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,
+                    moduleContext,
-                    SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()),
                     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.project.Project
-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.roots.JdkOrderEntry
-import org.jetbrains.kotlin.analyzer.AnalyzerFacade
+import com.intellij.openapi.roots.LibraryOrderEntry
-import org.jetbrains.kotlin.analyzer.ResolverForModule
+import com.intellij.openapi.roots.ModuleRootManager
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.analyzer.*
-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 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,
+                moduleContext,
-                globalContext,
-                moduleDescriptor,
                 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());
 

idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -65,7 +65,7 @@ class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompile
         module.addDependencyOnModule(module)
         module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
         module.seal()
-        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(project, GlobalContext(), listOf(), BindingTraceContext(), module, null, null).moduleDescriptor
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(ModuleContext(module, project), listOf(), BindingTraceContext(), null, null).moduleDescriptor
     }
 
     override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? {

js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.di;
 
+import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
@@ -76,13 +76,13 @@ import javax.annotation.PreDestroy;
 @SuppressWarnings("all")
 public class InjectorForTopDownAnalyzerForJs {
 
+    private final ModuleContext moduleContext;
+    private final KotlinBuiltIns kotlinBuiltIns;
+    private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
-    private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final ResolveSession resolveSession;
     private final ScopeProvider scopeProvider;
@@ -131,21 +131,19 @@ public class InjectorForTopDownAnalyzerForJs {
     private final VarianceChecker varianceChecker;
 
     public InjectorForTopDownAnalyzerForJs(
-        @NotNull Project project,
+        @NotNull ModuleContext moduleContext,
-        @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
         @NotNull DeclarationProviderFactory declarationProviderFactory
     ) {
-        this.project = project;
+        this.moduleContext = moduleContext;
-        this.globalContext = globalContext;
+        this.kotlinBuiltIns = moduleContext.getBuiltIns();
-        this.storageManager = globalContext.getStorageManager();
+        this.moduleDescriptor = moduleContext.getModule();
+        this.platformToKotlinClassMap = moduleContext.getPlatformToKotlinClassMap();
+        this.project = moduleContext.getProject();
+        this.storageManager = moduleContext.getStorageManager();
         this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
+        this.resolveSession = new ResolveSession(project, getModuleContext(), moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
         this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
@@ -163,20 +161,20 @@ public class InjectorForTopDownAnalyzerForJs {
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
         this.typeLazinessToken = new TypeLazinessToken();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed);
+        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.fakeCallResolver = new FakeCallResolver(project, callResolver);
         this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
         this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
         this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(getModule());
+        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
         this.valueParameterResolver = new ValueParameterResolver(kotlinJsCheckerProvider, expressionTypingServices);
         this.statementFilter = new StatementFilter();
         this.candidateResolver = new CandidateResolver();
         this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
         this.taskPrioritizer = new TaskPrioritizer(storageManager);
         this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
+        this.lazyDeclarationResolver = new LazyDeclarationResolver(getModuleContext(), bindingTrace);
         this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
@@ -236,7 +234,7 @@ public class InjectorForTopDownAnalyzerForJs {
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
         expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
         expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
+        expressionTypingComponents.setGlobalContext(moduleContext);
         expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
         expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
         expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
@@ -282,7 +280,7 @@ public class InjectorForTopDownAnalyzerForJs {
         lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
         lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
         lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        lazyTopDownAnalyzer.setModuleDescriptor(module);
+        lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
         lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
         lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
@@ -322,8 +320,8 @@ public class InjectorForTopDownAnalyzerForJs {
     public void destroy() {
     }
 
-    public ModuleDescriptorImpl getModule() {
+    public ModuleContext getModuleContext() {
-        return this.module;
+        return this.moduleContext;
     }
 
     public ResolveSession getResolveSession() {

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

@@ -17,11 +17,10 @@
 package org.jetbrains.kotlin.js.analyze;
 
 import com.google.common.collect.ImmutableList;
-import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 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.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs;
@@ -75,15 +74,12 @@ public final class TopDownAnalyzerFacadeForJS {
             @NotNull ModuleDescriptorImpl module,
             @NotNull Config config
     ) {
-        Project project = config.getProject();
+        ModuleContext context = ContextPackage.ModuleContext(module, config.getProject());
-
-        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-
         Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
 
         InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
-                project, globalContext, trace, module,
+                context, trace, new FileBasedDeclarationProviderFactory(context.getStorageManager(), allFiles)
-                new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), allFiles));
+        );
         try {
             injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files,
                                                            Collections.<PackageFragmentProvider>emptyList());