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

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 platformToKotlinClassMap = PlatformToKotlinClassMap.EMPTY
-
+    override val moduleParameters: ModuleParameters
+        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>"),
-                                                                         TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS,
-                                                                         PlatformToKotlinClassMap.EMPTY);
-        ModuleContext moduleContext = ContextPackage.ModuleContext(moduleDescriptor, project);
+        MutableModuleContext newModuleContext = ContextPackage.ContextForNewModule(
+                project, Name.special("<library module>"),
+                ModuleParameters(
+                        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 =
-            ModuleDescriptorImpl(Name.special("<module for building decompiled sources>"), listOf(), PlatformToKotlinClassMap.EMPTY)
+    private val storageManager = LockBasedStorageManager.NO_LOCKS
+    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(
-                        Name.special("<built-ins resolver module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
-                );
-                module.addDependencyOnModule(module);
-                module.seal();
-
-                ModuleContext moduleContext = ContextPackage.ModuleContext(module, myProject);
+                MutableModuleContext newModuleContext = ContextPackage
+                        .ContextForNewModule(myProject, Name.special("<built-ins resolver module>"), ModuleParameters.Empty.INSTANCE$);
+                newModuleContext.setDependencies(newModuleContext.getModule());
 
                 FileBasedDeclarationProviderFactory declarationFactory =
-                        new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), jetBuiltInsFiles);
+                        new FileBasedDeclarationProviderFactory(newModuleContext.getStorageManager(), jetBuiltInsFiles);
 
                 InjectorForLazyResolve injectorForLazyResolve =
-                        new InjectorForLazyResolve(moduleContext, declarationFactory, new BindingTraceContext(),
-                                                   AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
-                                                   new DynamicTypesSettings());
+                        new InjectorForLazyResolve(
+                                newModuleContext,
+                                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>")
-        module.addDependencyOnModule(module)
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
-        module.seal()
-        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(ModuleContext(module, project), listOf(), BindingTraceContext(), null, null).moduleDescriptor
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
+                TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project),
+                listOf(), BindingTraceContext(), null, null
+        ).moduleDescriptor
     }
 
     override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? {