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/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(
-                    new LoggingStorageManager(
-                            LockBasedStorageManager.createWithExceptionHandling(tracker),
-                            lazyOperationsLog.getAddRecordFunction()
-                    ),
-                    tracker
-            );
-            analyzeModuleContents(context, jetFiles, module, moduleTrace);
+
+            ModuleContext moduleContext = withModule(withProject(context, getProject()), module);
+            analyzeModuleContents(moduleContext, jetFiles, moduleTrace);
 
             checkAllResolvedCallsAreCompleted(jetFiles, moduleTrace.getBindingContext());
         }
@@ -222,13 +225,10 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
     }
 
     protected void analyzeModuleContents(
-            GlobalContext context,
-            List<JetFile> jetFiles,
-            ModuleDescriptorImpl module,
-            BindingTrace moduleTrace
+            @NotNull ModuleContext moduleContext,
+            @NotNull List<JetFile> jetFiles,
+            @NotNull 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() :
-                    createModule("<" + testModule.getName() + ">");
+                    createSealedModule(storageManager) :
+                    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) {
-        return TopDownAnalyzerFacadeForJVM.createJavaModule(moduleName);
+    @NotNull
+    protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) {
+        return new ModuleDescriptorImpl(Name.special(moduleName),
+                                        storageManager,
+                                        TopDownAnalyzerFacadeForJVM.JVM_MODULE_PARAMETERS);
     }
 
     @NotNull
-    protected ModuleDescriptorImpl createSealedModule() {
-        return TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+    protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) {
+        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,
-            List<JetFile> jetFiles,
-            ModuleDescriptorImpl module,
-            BindingTrace moduleTrace
+            @NotNull ModuleContext moduleContext,
+            @NotNull List<JetFile> jetFiles,
+            @NotNull 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) {
-        return TopDownAnalyzerFacadeForJS.createJsModule(moduleName);
+    protected ModuleDescriptorImpl createModule(@NotNull String moduleName, @NotNull StorageManager storageManager) {
+        return new ModuleDescriptorImpl(Name.special(moduleName), storageManager, TopDownAnalyzerFacadeForJS.JS_MODULE_PARAMETERS);
     }
 
     @NotNull
     @Override
-    protected ModuleDescriptorImpl createSealedModule() {
-        //It's JVM specific thing, so for JS we just create and setup module.
-
-        ModuleDescriptorImpl module = createModule("<kotlin-js-test-module>");
+    protected ModuleDescriptorImpl createSealedModule(@NotNull StorageManager storageManager) {
+        ModuleDescriptorImpl module = createModule("<kotlin-js-test-module>", storageManager);
 
         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.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.context.ModuleContext
+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,
-            jetFiles: List<JetFile>,
-            module: ModuleDescriptorImpl,
+            moduleContext: ModuleContext,
+            jetFiles: MutableList<JetFile>,
             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 moduleContext = ModuleContext(lazyModule, getProject())
+        val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject())
 
         val resolveSession = InjectorForLazyResolve(
-                moduleContext,
-                FileBasedDeclarationProviderFactory(moduleContext.storageManager, listOf(psiFile)),
+                context,
+                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.descriptors.impl.ModuleDescriptorImpl;
+import org.jetbrains.kotlin.context.ModuleContext;
 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>");
-        module.addDependencyOnModule(module);
-        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        module.seal();
+        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project);
 
         BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
 
-        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
-                ContextPackage.ModuleContext(module, project), files, trace, null, null);
+        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(moduleContext, 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 = ModuleContext(module, environment.project)
+        val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(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