Refactor creation of ModuleDescriptor

Add storageManager to ModuleDescriptorImpl (to be used later)
Extract ModuleParameters to hold default imports and platform class map
Introduce MutableModuleContext to simplify module creation code

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java

@@ -20,11 +20,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.ReflectionTypes;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 
@@ -34,7 +37,6 @@ import java.util.Collection;
 import java.util.List;
 
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getBuiltIns;
-import static org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM.createJavaModule;
 
 public class JvmRuntimeTypes {
     private final ReflectionTypes reflectionTypes;
@@ -46,10 +48,10 @@ public class JvmRuntimeTypes {
     public JvmRuntimeTypes(@NotNull ReflectionTypes reflectionTypes) {
         this.reflectionTypes = reflectionTypes;
 
-        PackageFragmentDescriptor kotlinJvmInternal = new MutablePackageFragmentDescriptor(
+        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<jvm functions impl>"),
-                createJavaModule("<jvm functions impl>"),
+                                                               LockBasedStorageManager.NO_LOCKS,
-                new FqName("kotlin.jvm.internal")
+                                                               TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS);
-        );
+        PackageFragmentDescriptor kotlinJvmInternal = new MutablePackageFragmentDescriptor(module, new FqName("kotlin.jvm.internal"));
 
         this.functionImpl = createClass(kotlinJvmInternal, "FunctionImpl", "out R");
         this.memberFunctionImpl = createClass(kotlinJvmInternal, "MemberFunctionImpl", "in T", "out R");

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

@@ -40,8 +40,7 @@ import org.jetbrains.kotlin.codegen.*;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.Progress;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
-import org.jetbrains.kotlin.context.ContextPackage;
+import org.jetbrains.kotlin.context.ModuleContext;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCache;
@@ -317,10 +316,10 @@ public class KotlinToJVMBytecodeCompiler {
                     @Override
                     public AnalysisResult invoke() {
                         BindingTrace sharedTrace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-                        ModuleDescriptorImpl analyzeModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+                        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.getProject());
 
                         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-                                ContextPackage.ModuleContext(analyzeModule, environment.getProject()),
+                                moduleContext,
                                 environment.getSourceFiles(),
                                 sharedTrace,
                                 environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS),

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

@@ -43,8 +43,7 @@ import org.jetbrains.kotlin.codegen.CompilationErrorHandler;
 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.MutableModuleContext;
-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;
@@ -108,9 +107,8 @@ public class ReplInterpreter {
         Project project = environment.getProject();
         this.psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project);
         this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-        this.module = TopDownAnalyzerFacadeForJVM.createJavaModule("<repl>");
+        MutableModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project);
-
+        this.module = moduleContext.getModule();
-        ModuleContext context = ContextPackage.ModuleContext(module, project);
 
         scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory();
 
@@ -123,7 +121,7 @@ public class ReplInterpreter {
         };
 
         InjectorForReplWithJava injector = new InjectorForReplWithJava(
-                context,
+                moduleContext,
                 trace,
                 scriptDeclarationFactory,
                 ProjectScope.getAllScope(project),
@@ -134,15 +132,12 @@ public class ReplInterpreter {
         this.topDownAnalyzer = injector.getLazyTopDownAnalyzerForTopLevel();
         this.resolveSession = injector.getResolveSession();
 
-        module.initialize(new CompositePackageFragmentProvider(
+        moduleContext.initializeModuleContents(new CompositePackageFragmentProvider(
                 Arrays.asList(
                         injector.getResolveSession().getPackageFragmentProvider(),
                         injector.getJavaDescriptorResolver().getPackageFragmentProvider()
                 )
         ));
-        module.addDependencyOnModule(module);
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        module.seal();
 
         List<URL> classpath = Lists.newArrayList();
         for (File file : getJvmClasspathRoots(configuration)) {

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

@@ -20,13 +20,13 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 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
@@ -79,8 +79,8 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
         return JvmResolverForModule(resolveSession, javaDescriptorResolver)
     }
 
-    override val defaultImports = TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS
+    override val moduleParameters: ModuleParameters
-    override val platformToKotlinClassMap = JavaToKotlinClassMap.INSTANCE
+        get() = TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS
 
     public platformStatic fun getAllFilesToAnalyze(project: Project, moduleInfo: ModuleInfo?, baseFiles: Collection<JetFile>): List<JetFile> {
         val allFiles = ArrayList(baseFiles)

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

@@ -23,9 +23,10 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
+import org.jetbrains.kotlin.descriptors.ModuleParameters;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider;
 import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCache;
@@ -33,6 +34,7 @@ import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCacheProvid
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
+import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -44,6 +46,8 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import static org.jetbrains.kotlin.context.ContextPackage.ContextForNewModule;
+
 public enum TopDownAnalyzerFacadeForJVM {
 
     INSTANCE;
@@ -66,6 +70,20 @@ public enum TopDownAnalyzerFacadeForJVM {
         return list;
     }
 
+    public static ModuleParameters JVM_MODULE_PARAMETERS = new ModuleParameters() {
+        @NotNull
+        @Override
+        public List<ImportPath> getDefaultImports() {
+            return DEFAULT_IMPORTS;
+        }
+
+        @NotNull
+        @Override
+        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
+            return JavaToKotlinClassMap.INSTANCE;
+        }
+    };
+
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationNoIncremental(
             @NotNull ModuleContext moduleContext,
@@ -138,18 +156,11 @@ public enum TopDownAnalyzerFacadeForJVM {
     }
 
     @NotNull
-    public static ModuleDescriptorImpl createJavaModule(@NotNull String name) {
+    public static MutableModuleContext createContextWithSealedModule(@NotNull Project project) {
-        return new ModuleDescriptorImpl(Name.special(name),
+        MutableModuleContext context = ContextForNewModule(
-                                        DEFAULT_IMPORTS,
+                project, Name.special("<shared-module>"), JVM_MODULE_PARAMETERS
-                                        JavaToKotlinClassMap.INSTANCE);
+        );
-    }
+        context.setDependencies(context.getModule(), KotlinBuiltIns.getInstance().getBuiltInsModule());
-
+        return context;
-    @NotNull
-    public static ModuleDescriptorImpl createSealedJavaModule() {
-        ModuleDescriptorImpl module = createJavaModule("<shared-module>");
-        module.addDependencyOnModule(module);
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        module.seal();
-        return module;
     }
 }

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

@@ -22,11 +22,10 @@ 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.ModuleParameters
 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
@@ -116,7 +115,6 @@ public trait ModuleInfo {
     }
 }
 
-//TODO: (module refactoring) extract project context
 public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParameters> {
     public fun <M : ModuleInfo> setupResolverForProject(
             projectContext: ProjectContext,
@@ -130,7 +128,7 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
             val descriptorByModule = HashMap<M, ModuleDescriptorImpl>()
             modules.forEach {
                 module ->
-                descriptorByModule[module] = ModuleDescriptorImpl(module.name, defaultImports, platformToKotlinClassMap)
+                descriptorByModule[module] = ModuleDescriptorImpl(module.name, projectContext.storageManager, moduleParameters)
             }
             return ResolverForProjectImpl(descriptorByModule, delegateResolver)
         }
@@ -193,7 +191,6 @@ public trait AnalyzerFacade<A : ResolverForModule, in P : PlatformAnalysisParame
             platformParameters: P, resolverForProject: ResolverForProject<M, A>
     ): A
 
-    public val defaultImports: List<ImportPath>
+    public val moduleParameters: ModuleParameters
-    public val platformToKotlinClassMap: PlatformToKotlinClassMap
 }
 

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

@@ -19,6 +19,10 @@ package org.jetbrains.kotlin.context
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleParameters
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -43,6 +47,25 @@ public trait ModuleContext : ProjectContext {
         get() = module.builtIns
 }
 
+public trait MutableModuleContext: ModuleContext {
+    override val module: ModuleDescriptorImpl
+
+    public fun setDependencies(vararg dependencies: ModuleDescriptorImpl) {
+        setDependencies(dependencies.toList())
+    }
+
+    public fun setDependencies(dependencies: List<ModuleDescriptorImpl>) {
+        for (dependency in dependencies) {
+            module.addDependencyOnModule(dependency)
+        }
+        module.seal()
+    }
+
+    public fun initializeModuleContents(packageFragmentProvider: PackageFragmentProvider) {
+        module.initialize(packageFragmentProvider)
+    }
+}
+
 public open class SimpleGlobalContext(
         override val storageManager: StorageManager,
         override val exceptionTracker: ExceptionTracker
@@ -65,6 +88,11 @@ public class ModuleContextImpl(
         projectContext: ProjectContext
 ) : ModuleContext, ProjectContext by projectContext
 
+public class MutableModuleContextImpl(
+        override val module: ModuleDescriptorImpl,
+        projectContext: ProjectContext
+) : MutableModuleContext, ProjectContext by projectContext
+
 public fun GlobalContext(): GlobalContextImpl {
     val tracker = ExceptionTracker()
     return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker)
@@ -77,6 +105,16 @@ public fun ModuleContext(module: ModuleDescriptor, project: Project): ModuleCont
 public fun GlobalContext.withProject(project: Project): ProjectContext = ProjectContextImpl(project, this)
 public fun ProjectContext.withModule(module: ModuleDescriptor): ModuleContext = ModuleContextImpl(module, this)
 
+public fun ContextForNewModule(
+        project: Project,
+        moduleName: Name,
+        parameters: ModuleParameters
+): MutableModuleContext {
+    val projectContext = ProjectContext(project)
+    val module = ModuleDescriptorImpl(moduleName, projectContext.storageManager, parameters)
+    return MutableModuleContextImpl(module, projectContext)
+}
+
 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/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java

@@ -51,6 +51,7 @@ import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.storage.ExceptionTracker;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
+import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.util.DescriptorValidator;
@@ -88,10 +89,18 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                 }
         );
 
-        Map<TestModule, ModuleDescriptorImpl> modules = createModules(groupedByModule);
-        Map<TestModule, BindingContext> moduleBindings = new HashMap<TestModule, BindingContext>();
-
         LazyOperationsLog lazyOperationsLog = new LazyOperationsLog(HASH_SANITIZER);
+        ExceptionTracker tracker = new ExceptionTracker();
+        GlobalContext context = new SimpleGlobalContext(
+                new LoggingStorageManager(
+                        LockBasedStorageManager.createWithExceptionHandling(tracker),
+                        lazyOperationsLog.getAddRecordFunction()
+                ),
+                tracker
+        );
+
+        Map<TestModule, ModuleDescriptorImpl> modules = createModules(groupedByModule, context.getStorageManager());
+        Map<TestModule, BindingContext> moduleBindings = new HashMap<TestModule, BindingContext>();
 
         for (Map.Entry<TestModule, List<TestFile>> entry : groupedByModule.entrySet()) {
             TestModule testModule = entry.getKey();
@@ -104,15 +113,9 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
 
             moduleBindings.put(testModule, moduleTrace.getBindingContext());
 
-            ExceptionTracker tracker = new ExceptionTracker();
+
-            GlobalContext context = new SimpleGlobalContext(
+            ModuleContext moduleContext = withModule(withProject(context, getProject()), module);
-                    new LoggingStorageManager(
+            analyzeModuleContents(moduleContext, jetFiles, moduleTrace);
-                            LockBasedStorageManager.createWithExceptionHandling(tracker),
-                            lazyOperationsLog.getAddRecordFunction()
-                    ),
-                    tracker
-            );
-            analyzeModuleContents(context, jetFiles, module, moduleTrace);
 
             checkAllResolvedCallsAreCompleted(jetFiles, moduleTrace.getBindingContext());
         }
@@ -222,13 +225,10 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
     }
 
     protected void analyzeModuleContents(
-            GlobalContext context,
+            @NotNull ModuleContext moduleContext,
-            List<JetFile> jetFiles,
+            @NotNull List<JetFile> jetFiles,
-            ModuleDescriptorImpl module,
+            @NotNull BindingTrace moduleTrace
-            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(
@@ -308,14 +308,17 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
         return RECURSIVE.filterRecursion(stepIntoFilter).withValidationStrategy(DescriptorValidator.ValidationVisitor.errorTypesAllowed());
     }
 
-    private Map<TestModule, ModuleDescriptorImpl> createModules(Map<TestModule, List<TestFile>> groupedByModule) {
+    private Map<TestModule, ModuleDescriptorImpl> createModules(
+            @NotNull Map<TestModule, List<TestFile>> groupedByModule,
+            @NotNull StorageManager storageManager
+    ) {
         Map<TestModule, ModuleDescriptorImpl> modules = new HashMap<TestModule, ModuleDescriptorImpl>();
 
         for (TestModule testModule : groupedByModule.keySet()) {
             ModuleDescriptorImpl module =
                     testModule == null ?
-                    createSealedModule() :
+                    createSealedModule(storageManager) :
-                    createModule("<" + testModule.getName() + ">");
+                    createModule("<" + testModule.getName() + ">", storageManager);
 
             modules.put(testModule, module);
         }
@@ -336,13 +339,20 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
         return modules;
     }
 
-    protected ModuleDescriptorImpl createModule(String moduleName) {
+    @NotNull
-        return TopDownAnalyzerFacadeForJVM.createJavaModule(moduleName);
+    protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) {
+        return new ModuleDescriptorImpl(Name.special(moduleName),
+                                        storageManager,
+                                        TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS);
     }
 
     @NotNull
-    protected ModuleDescriptorImpl createSealedModule() {
+    protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) {
-        return TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+        ModuleDescriptorImpl moduleDescriptor = createModule("<test-module>", storageManager);
+        moduleDescriptor.addDependencyOnModule(moduleDescriptor);
+        moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        moduleDescriptor.seal();
+        return moduleDescriptor;
     }
 
     private static void checkAllResolvedCallsAreCompleted(@NotNull List<JetFile> jetFiles, @NotNull BindingContext bindingContext) {

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

@@ -22,14 +22,15 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
-import org.jetbrains.kotlin.context.GlobalContext;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
 import org.jetbrains.kotlin.js.config.Config;
-import org.jetbrains.kotlin.js.config.EcmaVersion;
 import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
+import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
+import org.jetbrains.kotlin.storage.StorageManager;
 
 import java.util.List;
 import java.util.Map;
@@ -57,12 +58,11 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet
 
     @Override
     protected void analyzeModuleContents(
-            GlobalContext context,
+            @NotNull ModuleContext moduleContext,
-            List<JetFile> jetFiles,
+            @NotNull List<JetFile> jetFiles,
-            ModuleDescriptorImpl module,
+            @NotNull BindingTrace moduleTrace
-            BindingTrace moduleTrace
     ) {
-        TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, config);
+        TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, moduleContext, config);
     }
 
     @Override
@@ -70,25 +70,25 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet
         return true;
     }
 
+    @NotNull
     @Override
-    protected ModuleDescriptorImpl createModule(String moduleName) {
+    protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) {
-        return TopDownAnalyzerFacadeForJS.createJsModule(moduleName);
+        return new ModuleDescriptorImpl(Name.special(moduleName), storageManager, TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS);
     }
 
     @NotNull
     @Override
-    protected ModuleDescriptorImpl createSealedModule() {
+    protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) {
-        //It's JVM specific thing, so for JS we just create and setup module.
+        ModuleDescriptorImpl module = createModule("<kotlin-js-test-module>", storageManager);
-
-        ModuleDescriptorImpl module = createModule("<kotlin-js-test-module>");
 
         module.addDependencyOnModule(module);
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
 
         for(ModuleDescriptorImpl moduleDescriptor : config.getModuleDescriptors()) {
             module.addDependencyOnModule(moduleDescriptor);
         }
 
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+
         module.seal();
 
         return module;

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

@@ -16,27 +16,21 @@
 
 package org.jetbrains.kotlin.checkers
 
-import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.hasError
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
-import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.js.facade.K2JSTranslator
 import org.jetbrains.kotlin.js.facade.MainCallParameters
-import org.jetbrains.kotlin.js.facade.exceptions.TranslationException
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-
-import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.hasError
 
 public abstract class AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation : AbstractJetDiagnosticsTestWithJsStdLib() {
     override fun analyzeModuleContents(
-            context: GlobalContext,
+            moduleContext: ModuleContext,
-            jetFiles: List<JetFile>,
+            jetFiles: MutableList<JetFile>,
-            module: ModuleDescriptorImpl,
             moduleTrace: BindingTrace
     ) {
-        val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, getConfig())
+        val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, moduleContext, getConfig())
         val diagnostics = analysisResult.bindingTrace.getBindingContext().getDiagnostics()
 
         if (!hasError(diagnostics)) {

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

@@ -25,11 +25,10 @@ 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.config.CompilerConfiguration;
-import org.jetbrains.kotlin.context.ContextPackage;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -148,16 +147,16 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-        ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.getProject());
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
-                ContextPackage.ModuleContext(module, environment.getProject()),
+                moduleContext,
                 environment.getSourceFiles(),
                 trace,
                 TopDownAnalysisMode.TopLevelDeclarations
         );
 
-        PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
+        PackageViewDescriptor packageView = moduleContext.getModule().getPackage(TEST_PACKAGE_FQNAME);
         assert packageView != null : "Test package not found";
 
         checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);

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

@@ -21,7 +21,6 @@ import com.intellij.openapi.util.io.FileUtil
 import com.intellij.testFramework.UsefulTestCase
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 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
@@ -48,16 +47,15 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
         val fileText = FileUtil.loadFile(File(path), true)
         val psiFile = JetPsiFactory(getProject()).createFile(fileText)
 
-        val lazyModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
+        val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject())
-        val moduleContext = ModuleContext(lazyModule, getProject())
 
         val resolveSession = InjectorForLazyResolve(
-                moduleContext,
+                context,
-                FileBasedDeclarationProviderFactory(moduleContext.storageManager, listOf(psiFile)),
+                FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
 
-        lazyModule.initialize(resolveSession.getPackageFragmentProvider())
+        context.initializeModuleContents(resolveSession.getPackageFragmentProvider())
 
         val descriptors = ArrayList<DeclarationDescriptor>()
 
@@ -65,7 +63,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
             override fun visitJetFile(file: JetFile) {
                 val fqName = file.getPackageFqName()
                 if (!fqName.isRoot()) {
-                    val packageDescriptor = lazyModule.getPackage(fqName)
+                    val packageDescriptor = context.module.getPackage(fqName)
                     descriptors.add(packageDescriptor)
                 }
                 file.acceptChildren(this)

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

@@ -19,10 +19,8 @@ package org.jetbrains.kotlin.resolve.lazy;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
-import org.jetbrains.kotlin.context.ContextPackage;
+import org.jetbrains.kotlin.context.ModuleContext;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -45,8 +43,7 @@ public class JvmResolveUtil {
 
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) {
-        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file)
+        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file));
-        );
     }
 
     @NotNull
@@ -70,14 +67,10 @@ public class JvmResolveUtil {
             @NotNull Project project,
             @NotNull Collection<JetFile> files
     ) {
-        ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule("<module>");
+        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project);
-        module.addDependencyOnModule(module);
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        module.seal();
 
         BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
 
-        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
+        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(moduleContext, files, trace, null, null);
-                ContextPackage.ModuleContext(module, project), files, trace, null, null);
     }
 }

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

@@ -21,9 +21,8 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.context.ContextPackage;
+import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.JetFile;
@@ -53,13 +52,13 @@ public class LazyResolveTestUtil {
 
     @NotNull
     public static ModuleDescriptor resolve(@NotNull Project project, @NotNull BindingTrace trace, @NotNull List<JetFile> sourceFiles) {
-        ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project);
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
-                ContextPackage.ModuleContext(module, project), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations
+                moduleContext, sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations
         );
 
-        return module;
+        return moduleContext.getModule();
     }
 
     @NotNull

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

@@ -21,7 +21,6 @@ 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.ModuleContext
 import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -53,15 +52,14 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
                 JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
-        val module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
+        val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project)
-        val moduleContext = ModuleContext(module, environment.project)
         val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
 
         val injector = InjectorForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 providerFactory, GlobalSearchScope.allScope(environment.project)
         )
-        module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
+        moduleContext.initializeModuleContents(injector.getJavaDescriptorResolver().packageFragmentProvider)
 
         val components = injector.getDeserializationComponentsForJava().components
 

compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java

@@ -52,6 +52,7 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.ContentRoot;
 import org.jetbrains.kotlin.config.KotlinSourceRoot;
+import org.jetbrains.kotlin.descriptors.ModuleParameters;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.Errors;
@@ -60,15 +61,14 @@ import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.idea.JetLanguage;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetExpression;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.ImportPath;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
+import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.test.util.UtilPackage;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
@@ -911,7 +911,9 @@ public class JetTestUtils {
 
     @NotNull
     public static ModuleDescriptorImpl createEmptyModule(@NotNull String name) {
-        return new ModuleDescriptorImpl(Name.special(name), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);
+        return new ModuleDescriptorImpl(
+                Name.special(name), LockBasedStorageManager.NO_LOCKS, ModuleParameters.Empty.INSTANCE$
+        );
     }
 
     @NotNull

core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.di;
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
+import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
 import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
 import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver;
@@ -28,7 +29,6 @@ import org.jetbrains.kotlin.load.java.components.SamConversionResolver;
 import org.jetbrains.kotlin.load.java.components.RuntimeErrorReporter;
 import org.jetbrains.kotlin.load.java.components.RuntimeSourceElementFactory;
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
-import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder;
 import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClassFinder;
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
@@ -46,6 +46,7 @@ public class InjectorForRuntimeDescriptorLoader {
 
     private final ClassLoader classLoader;
     private final ModuleDescriptor moduleDescriptor;
+    private final StorageManager storageManager;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final DeserializationComponentsForJava deserializationComponentsForJava;
     private final ExternalSignatureResolver externalSignatureResolver;
@@ -57,7 +58,6 @@ public class InjectorForRuntimeDescriptorLoader {
     private final RuntimeErrorReporter runtimeErrorReporter;
     private final RuntimeSourceElementFactory runtimeSourceElementFactory;
     private final SingleModuleClassResolver singleModuleClassResolver;
-    private final LockBasedStorageManager lockBasedStorageManager;
     private final ReflectJavaClassFinder reflectJavaClassFinder;
     private final ReflectKotlinClassFinder reflectKotlinClassFinder;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
@@ -69,11 +69,12 @@ public class InjectorForRuntimeDescriptorLoader {
 
     public InjectorForRuntimeDescriptorLoader(
         @NotNull ClassLoader classLoader,
-        @NotNull ModuleDescriptor moduleDescriptor
+        @NotNull ModuleDescriptor moduleDescriptor,
+        @NotNull StorageManager storageManager
     ) {
         this.classLoader = classLoader;
         this.moduleDescriptor = moduleDescriptor;
-        this.lockBasedStorageManager = new LockBasedStorageManager();
+        this.storageManager = storageManager;
         this.reflectJavaClassFinder = new ReflectJavaClassFinder(classLoader);
         this.reflectKotlinClassFinder = new ReflectKotlinClassFinder(classLoader);
         this.runtimeErrorReporter = RuntimeErrorReporter.INSTANCE$;
@@ -86,13 +87,13 @@ public class InjectorForRuntimeDescriptorLoader {
         this.samConversionResolver = SamConversionResolver.EMPTY;
         this.runtimeSourceElementFactory = RuntimeSourceElementFactory.INSTANCE$;
         this.singleModuleClassResolver = new SingleModuleClassResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver);
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver);
         this.reflectionTypes = new ReflectionTypes(getModuleDescriptor());
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor(), reflectionTypes);
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor());
         this.javaClassDataFinder = new JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), lockBasedStorageManager, reflectKotlinClassFinder, runtimeErrorReporter);
+        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), storageManager, reflectKotlinClassFinder, runtimeErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(lockBasedStorageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
 
         singleModuleClassResolver.setResolver(javaDescriptorResolver);
 

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -17,12 +17,14 @@
 package org.jetbrains.kotlin.load.kotlin.reflect
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForRuntimeDescriptorLoader
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.serialization.deserialization.LocalClassResolver
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
 public class RuntimeModuleData private(private val injector: InjectorForRuntimeDescriptorLoader) {
     public val module: ModuleDescriptor get() = injector.getModuleDescriptor()
@@ -31,10 +33,13 @@ public class RuntimeModuleData private(private val injector: InjectorForRuntimeD
 
     companion object {
         public fun create(classLoader: ClassLoader): RuntimeModuleData {
-            val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), listOf(), JavaToKotlinClassMap.INSTANCE)
+            val storageManager = LockBasedStorageManager()
+            val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), storageManager,
+                                              ModuleParameters(listOf(), JavaToKotlinClassMap.INSTANCE))
             module.addDependencyOnModule(module)
             module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
-            val injector = InjectorForRuntimeDescriptorLoader(classLoader, module)
+            module.seal()
+            val injector = InjectorForRuntimeDescriptorLoader(classLoader, module, storageManager)
             module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
             return RuntimeModuleData(injector)
         }

core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java

@@ -28,9 +28,7 @@ import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.ImportPath;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.serialization.deserialization.FlexibleTypeCapabilitiesDeserializer;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
@@ -109,12 +107,13 @@ public class KotlinBuiltIns {
     public static final FqNames FQ_NAMES = new FqNames();
 
     private KotlinBuiltIns() {
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
         builtInsModule = new ModuleDescriptorImpl(
-                Name.special("<built-ins module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
+                Name.special("<built-ins module>"), storageManager, ModuleParameters.Empty.INSTANCE$
         );
 
         PackageFragmentProvider packageFragmentProvider = BuiltinsPackage.createBuiltInPackageFragmentProvider(
-                new LockBasedStorageManager(), builtInsModule, Collections.singleton(BUILT_INS_PACKAGE_FQ_NAME),
+                storageManager, builtInsModule, Collections.singleton(BUILT_INS_PACKAGE_FQ_NAME),
                 FlexibleTypeCapabilitiesDeserializer.ThrowException.INSTANCE$, new Function1<String, InputStream>() {
                     @Override
                     public InputStream invoke(String path) {

core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt

@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.descriptors
 
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.impl.PackageViewDescriptorImpl
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.descriptors.impl.PackageViewDescriptorImpl
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 
-public trait ModuleDescriptor : DeclarationDescriptor {
+public trait ModuleDescriptor : DeclarationDescriptor, ModuleParameters {
     override fun getContainingDeclaration(): DeclarationDescriptor? = null
 
     public fun getPackageFragmentProvider(): PackageFragmentProvider
@@ -33,10 +33,6 @@ public trait ModuleDescriptor : DeclarationDescriptor {
         return if (!fragments.isEmpty()) PackageViewDescriptorImpl(this, fqName, fragments) else null
     }
 
-    public val defaultImports: List<ImportPath>
-
-    public val platformToKotlinClassMap: PlatformToKotlinClassMap
-
     public val builtIns: KotlinBuiltIns
 
     public fun isFriend(other: ModuleDescriptor): Boolean
@@ -49,3 +45,19 @@ public trait ModuleDescriptor : DeclarationDescriptor {
         return visitor.visitModuleDeclaration(this, data)
     }
 }
+
+trait ModuleParameters {
+    public val defaultImports: List<ImportPath>
+    public val platformToKotlinClassMap: PlatformToKotlinClassMap
+
+    object Empty: ModuleParameters {
+        override val defaultImports: List<ImportPath> = emptyList()
+        override val platformToKotlinClassMap: PlatformToKotlinClassMap = PlatformToKotlinClassMap.EMPTY
+    }
+}
+
+public fun ModuleParameters(defaultImports: List<ImportPath>, platformToKotlinClassMap: PlatformToKotlinClassMap): ModuleParameters =
+        object : ModuleParameters {
+            override val defaultImports: List<ImportPath> = defaultImports
+            override val platformToKotlinClassMap: PlatformToKotlinClassMap = platformToKotlinClassMap
+        }

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt

@@ -18,20 +18,20 @@ package org.jetbrains.kotlin.descriptors.impl
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
+import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.resolve.ImportPath
 import java.util.ArrayList
 import java.util.LinkedHashSet
 import kotlin.properties.Delegates
 
 public class ModuleDescriptorImpl(
         moduleName: Name,
-        override val defaultImports: List<ImportPath>,
+        private val storageManager: StorageManager,
-        override val platformToKotlinClassMap: PlatformToKotlinClassMap
+        private val moduleParameters: ModuleParameters
-) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor {
+) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor, ModuleParameters by moduleParameters {
     init {
         if (!moduleName.isSpecial()) {
             throw IllegalArgumentException("Module name must be special: $moduleName")

core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java

@@ -24,10 +24,9 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.*;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.ImportPath;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.error.ErrorSimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.utils.Printer;
 
@@ -44,8 +43,8 @@ public class ErrorUtils {
     static {
         ERROR_MODULE = new ModuleDescriptorImpl(
                 Name.special("<ERROR MODULE>"),
-                Collections.<ImportPath>emptyList(),
+                LockBasedStorageManager.NO_LOCKS,
-                PlatformToKotlinClassMap.EMPTY
+                ModuleParameters.Empty.INSTANCE$
         );
     }
 

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

@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
 import org.jetbrains.kotlin.resolve.lazy.*
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesAllowed
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 import org.jetbrains.kotlin.types.expressions.*
@@ -127,6 +127,7 @@ private fun generatorForRuntimeDescriptorLoader() =
         generator("core/descriptors.runtime/src", DI_DEFAULT_PACKAGE, "InjectorForRuntimeDescriptorLoader") {
             parameter<ClassLoader>()
             publicParameter<ModuleDescriptor>()
+            parameter<StorageManager>()
 
             publicField<JavaDescriptorResolver>()
             publicField<DeserializationComponentsForJava>()
@@ -142,7 +143,6 @@ private fun generatorForRuntimeDescriptorLoader() =
             field<RuntimeSourceElementFactory>()
             field<SingleModuleClassResolver>()
 
-            field<LockBasedStorageManager>()
             field<ReflectJavaClassFinder>()
             field<ReflectKotlinClassFinder>()
         }

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

@@ -20,13 +20,13 @@ import com.intellij.openapi.roots.OrderRootType
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.ModuleParameters
 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
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
@@ -77,7 +77,6 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
         return JsResolverForModule(resolveSession)
     }
 
-    override val defaultImports = TopDownAnalyzerFacadeForJS.DEFAULT_IMPORTS
+    override val moduleParameters: ModuleParameters
-    override val platformToKotlinClassMap = PlatformToKotlinClassMap.EMPTY
+        get() = TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS
-
 }

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

@@ -40,10 +40,9 @@ 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.ModuleContext;
+import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.di.InjectorForLazyResolve;
 import org.jetbrains.kotlin.idea.caches.resolve.JsProjectDetector;
 import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
@@ -71,6 +70,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
+import static org.jetbrains.kotlin.descriptors.DescriptorsPackage.ModuleParameters;
 import static org.jetbrains.kotlin.idea.decompiler.navigation.MemberMatching.*;
 
 public class JetSourceNavigationHelper {
@@ -234,27 +234,29 @@ public class JetSourceNavigationHelper {
             @NotNull Project project
     ) {
 
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
+        MutableModuleContext newModuleContext = ContextPackage.ContextForNewModule(
-                                                                         TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS,
+                project, Name.special("<library module>"),
-                                                                         PlatformToKotlinClassMap.EMPTY);
+                ModuleParameters(
-        ModuleContext moduleContext = ContextPackage.ModuleContext(moduleDescriptor, project);
+                        TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS,
+                        PlatformToKotlinClassMap.EMPTY
+                )
+        );
+
+        newModuleContext.setDependencies(newModuleContext.getModule(), KotlinBuiltIns.getInstance().getBuiltInsModule());
+
         FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
-                moduleContext.getStorageManager(),
+                newModuleContext.getStorageManager(),
                 getContainingFiles(candidates)
         );
 
-        moduleDescriptor.addDependencyOnModule(moduleDescriptor);
-        moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        moduleDescriptor.seal();
-
         ResolveSession resolveSession = new InjectorForLazyResolve(
-                moduleContext,
+                newModuleContext,
                 providerFactory,
                 new BindingTraceContext(),
                 AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
                 new DynamicTypesSettings()).getResolveSession();
 
-        moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider());
+        newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());
         return resolveSession;
     }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt

@@ -20,6 +20,7 @@ import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
@@ -31,7 +32,6 @@ import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
@@ -46,10 +46,10 @@ public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDec
 
 public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val directoryPackageFqName: FqName) : ResolverForDecompiler {
 
-    private val moduleDescriptor =
+    private val storageManager = LockBasedStorageManager.NO_LOCKS
-            ModuleDescriptorImpl(Name.special("<module for building decompiled sources>"), listOf(), PlatformToKotlinClassMap.EMPTY)
+    private val moduleDescriptor = createDummyModule("module for building decompiled sources")
 
-    private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), listOf(), PlatformToKotlinClassMap.EMPTY)
+    private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), storageManager, ModuleParameters.Empty)
 
     override fun resolveTopLevelClass(classId: ClassId) = deserializationComponents.deserializeClass(classId)
 
@@ -74,8 +74,6 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
     private val classFinder = DirectoryBasedClassFinder(packageDirectory, directoryPackageFqName)
     private val classDataFinder = DirectoryBasedDataFinder(classFinder, LOG)
 
-    private val storageManager = LockBasedStorageManager.NO_LOCKS
-
     private val annotationAndConstantLoader =
             BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, storageManager, classFinder, LoggingErrorReporter(LOG))
 

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

@@ -38,15 +38,18 @@ 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.ModuleContext;
+import org.jetbrains.kotlin.context.MutableModuleContext;
+import org.jetbrains.kotlin.context.ProjectContext;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.di.InjectorForLazyResolve;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
+import org.jetbrains.kotlin.resolve.BindingTraceContext;
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
+import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
@@ -55,7 +58,10 @@ import org.jetbrains.kotlin.utils.UtilsPackage;
 import java.io.File;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.util.*;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getClassId;
 import static org.jetbrains.kotlin.serialization.deserialization.DeserializationPackage.findClassAcrossModuleDependencies;
@@ -95,23 +101,22 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
         final Runnable initializeRunnable = new Runnable() {
             @Override
             public void run() {
-                ModuleDescriptorImpl module = new ModuleDescriptorImpl(
+                MutableModuleContext newModuleContext = ContextPackage
-                        Name.special("<built-ins resolver module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
+                        .ContextForNewModule(myProject, Name.special("<built-ins resolver module>"), ModuleParameters.Empty.INSTANCE$);
-                );
+                newModuleContext.setDependencies(newModuleContext.getModule());
-                module.addDependencyOnModule(module);
-                module.seal();
-
-                ModuleContext moduleContext = ContextPackage.ModuleContext(module, myProject);
 
                 FileBasedDeclarationProviderFactory declarationFactory =
-                        new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), jetBuiltInsFiles);
+                        new FileBasedDeclarationProviderFactory(newModuleContext.getStorageManager(), jetBuiltInsFiles);
 
                 InjectorForLazyResolve injectorForLazyResolve =
-                        new InjectorForLazyResolve(moduleContext, declarationFactory, new BindingTraceContext(),
+                        new InjectorForLazyResolve(
-                                                   AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
+                                newModuleContext,
-                                                   new DynamicTypesSettings());
+                                declarationFactory, new BindingTraceContext(),
+                                AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
+                                new DynamicTypesSettings()
+                        );
 
-                module.initialize(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider());
+                newModuleContext.initializeModuleContents(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider());
 
                 if (!ApplicationManager.getApplication().isUnitTestMode()) {
                     // Use lazy initialization in tests
@@ -119,9 +124,9 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                 }
 
                 List<PackageFragmentDescriptor> fragments =
-                        module.getPackageFragmentProvider().getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);
+                        newModuleContext.getModule().getPackageFragmentProvider().getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);
 
-                moduleDescriptor = module;
+                BuiltInsReferenceResolver.this.moduleDescriptor = newModuleContext.getModule();
                 builtinsPackageFragment = KotlinPackage.single(fragments);
                 builtInsSources = Sets.newHashSet(jetBuiltInsFiles);
             }
@@ -138,7 +143,6 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                 }
             });
         }
-
     }
 
     @NotNull

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

@@ -19,7 +19,6 @@ 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.ModuleContext
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -61,11 +60,10 @@ public class DecompiledTextConsistencyTest : JetLightCodeInsightFixtureTestCase(
 
 class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompiler {
     val module: ModuleDescriptor = run {
-        val module = TopDownAnalyzerFacadeForJVM.createJavaModule("<module for resolving stdlib with java top down analysis>")
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-        module.addDependencyOnModule(module)
+                TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project),
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
+                listOf(), BindingTraceContext(), null, null
-        module.seal()
+        ).moduleDescriptor
-        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(ModuleContext(module, project), listOf(), BindingTraceContext(), null, null).moduleDescriptor
     }
 
     override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? {

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

@@ -21,6 +21,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.ModuleContext;
+import org.jetbrains.kotlin.context.MutableModuleContext;
+import org.jetbrains.kotlin.descriptors.ModuleParameters;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs;
@@ -32,6 +34,7 @@ import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -43,10 +46,23 @@ public final class TopDownAnalyzerFacadeForJS {
             new ImportPath("kotlin.js.*")
     );
 
+    public static ModuleParameters JS_MODULE_PARAMETERS = new ModuleParameters() {
+        @NotNull
+        @Override
+        public List<ImportPath> getDefaultImports() {
+            return DEFAULT_IMPORTS;
+        }
+
+        @NotNull
+        @Override
+        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
+            return PlatformToKotlinClassMap.EMPTY;
+        }
+    };
+
     private TopDownAnalyzerFacadeForJS() {
     }
 
-    //TODO: refactor
     @NotNull
     public static JsAnalysisResult analyzeFiles(
             @NotNull Collection<JetFile> files,
@@ -54,36 +70,38 @@ public final class TopDownAnalyzerFacadeForJS {
     ) {
         BindingTrace trace = new BindingTraceContext();
 
-        ModuleDescriptorImpl module = createJsModule("<" + config.getModuleId() + ">");
+        MutableModuleContext newModuleContext = ContextPackage.ContextForNewModule(
-        module.addDependencyOnModule(module);
+                config.getProject(), Name.special("<" + config.getModuleId() + ">"), JS_MODULE_PARAMETERS
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        );
+        newModuleContext.setDependencies(computeDependencies(newModuleContext.getModule(), config));
+        return analyzeFilesWithGivenTrace(files, trace, newModuleContext, config);
+    }
 
-        for(ModuleDescriptorImpl moduleDescriptor : config.getModuleDescriptors()) {
+    @NotNull
-            module.addDependencyOnModule(moduleDescriptor);
+    private static List<ModuleDescriptorImpl> computeDependencies(ModuleDescriptorImpl module, @NotNull Config config) {
-        }
+        List<ModuleDescriptorImpl> allDependencies = new ArrayList<ModuleDescriptorImpl>();
-
+        allDependencies.add(module);
-        module.seal();
+        allDependencies.addAll(config.getModuleDescriptors());
-
+        allDependencies.add(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        return analyzeFilesWithGivenTrace(files, trace, module, config);
+        return allDependencies;
     }
 
     @NotNull
     public static JsAnalysisResult analyzeFilesWithGivenTrace(
             @NotNull Collection<JetFile> files,
             @NotNull BindingTrace trace,
-            @NotNull ModuleDescriptorImpl module,
+            @NotNull ModuleContext moduleContext,
             @NotNull Config config
     ) {
-        ModuleContext context = ContextPackage.ModuleContext(module, config.getProject());
         Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
 
         InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
-                context, trace, new FileBasedDeclarationProviderFactory(context.getStorageManager(), allFiles)
+                moduleContext, trace, new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles)
         );
         try {
             injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files,
-                                                           Collections.<PackageFragmentProvider>emptyList());
+                                                                      Collections.<PackageFragmentProvider>emptyList());
-            return JsAnalysisResult.success(trace, module);
+            return JsAnalysisResult.success(trace, moduleContext.getModule());
         }
         finally {
             injector.destroy();
@@ -96,9 +114,4 @@ public final class TopDownAnalyzerFacadeForJS {
             AnalyzingUtils.checkForSyntacticErrors(file);
         }
     }
-
-    @NotNull
-    public static ModuleDescriptorImpl createJsModule(@NotNull String name) {
-        return new ModuleDescriptorImpl(Name.special(name), DEFAULT_IMPORTS, PlatformToKotlinClassMap.EMPTY);
-    }
 }

js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
+import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
@@ -40,10 +41,11 @@ import java.util.List;
  */
 public abstract class Config {
     private final boolean inlineEnabled;
-
     @NotNull
     private final Project project;
     @NotNull
+    private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
+    @NotNull
     private final List<JetFile> sourceFilesFromLibraries = new SmartList<JetFile>();
     @NotNull
     private final EcmaVersion target;
@@ -122,7 +124,6 @@ public abstract class Config {
         }
         for (ModuleDescriptorImpl module : moduleDescriptors) {
             setDependencies(module, moduleDescriptors);
-            module.seal();
         }
 
         return moduleDescriptors;
@@ -146,14 +147,16 @@ public abstract class Config {
         initialized = true;
     }
 
-    private static ModuleDescriptorImpl createModuleDescriptor(KotlinJavascriptMetadata metadata) {
+    private ModuleDescriptorImpl createModuleDescriptor(KotlinJavascriptMetadata metadata) {
-        ModuleDescriptorImpl moduleDescriptor = TopDownAnalyzerFacadeForJS.createJsModule("<" + metadata.getModuleName() + ">");
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(
+                Name.special("<" + metadata.getModuleName() + ">"), storageManager,
+                TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS
+        );
 
         PackageFragmentProvider provider =
-                KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, metadata.getBody(), new LockBasedStorageManager());
+                KotlinJavascriptSerializationUtil.createPackageFragmentProvider(moduleDescriptor, metadata.getBody(), storageManager);
 
         moduleDescriptor.initialize(provider != null ? provider : PackageFragmentProvider.Empty.INSTANCE$);
-        moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
 
         return moduleDescriptor;
     }
@@ -162,6 +165,8 @@ public abstract class Config {
         for (ModuleDescriptorImpl moduleItem : modules) {
             module.addDependencyOnModule(moduleItem);
         }
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
+        module.seal();
     }
 
     @NotNull