ModuleDescriptor stores default imports

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

@@ -41,14 +41,14 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilderDummy;
-import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
@@ -88,14 +88,14 @@ public class ReplInterpreter {
         jetCoreEnvironment = new JetCoreEnvironment(disposable, configuration);
         Project project = jetCoreEnvironment.getProject();
         trace = new BindingTraceContext();
-        module = new ModuleDescriptorImpl(Name.special("<repl>"));
+        module = AnalyzerFacadeForJVM.createJavaModule("<repl>");
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 Predicates.<PsiFile>alwaysTrue(),
                 false,
                 true,
                 Collections.<AnalyzerScriptParameter>emptyList());
         injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
-        module.setModuleConfiguration(injector.getModuleDescriptor().getModuleConfiguration());
+        module.setModuleConfiguration(injector.getJavaBridgeConfiguration());
 
         List<URL> classpath = Lists.newArrayList();
 

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -161,8 +161,6 @@ public class InjectorForJavaDescriptorResolver {
         javaPropertyResolver.setSemanticServices(javaSemanticServices);
         javaPropertyResolver.setTrace(bindingTrace);
 
-        javaBridgeConfiguration.init();
-
         psiClassFinder.initialize();
 
     }

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java

@@ -73,7 +73,7 @@ public class InjectorForJavaSemanticServices {
         this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext();
         this.javaBridgeConfiguration = new JavaBridgeConfiguration();
         this.psiClassFinder = new PsiClassFinderImpl();
-        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"));
+        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"), JavaBridgeConfiguration.ALL_JAVA_IMPORTS);
         this.project = project;
         this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
         this.javaTypeTransformer = new JavaTypeTransformer();
@@ -161,8 +161,6 @@ public class InjectorForJavaSemanticServices {
         javaPropertyResolver.setSemanticServices(javaSemanticServices);
         javaPropertyResolver.setTrace(bindingTrace);
 
-        javaBridgeConfiguration.init();
-
         psiClassFinder.initialize();
 
     }

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

@@ -334,8 +334,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaPropertyResolver.setSemanticServices(javaSemanticServices);
         javaPropertyResolver.setTrace(bindingTrace);
 
-        javaBridgeConfiguration.init();
-
         psiClassFinder.initialize();
 
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java

@@ -18,8 +18,6 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
@@ -28,7 +26,6 @@ import org.jetbrains.jet.analyzer.AnalyzerFacade;
 import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
-import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -47,7 +44,6 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collection;
 import java.util.Collections;
-import java.util.LinkedHashSet;
 import java.util.List;
 
 public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
@@ -83,7 +79,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
     @NotNull
     @Override
     public ResolveSession getLazyResolveSession(@NotNull Project fileProject, @NotNull Collection<JetFile> files) {
-        ModuleDescriptorImpl javaModule = new ModuleDescriptorImpl(Name.special("<java module>"));
+        ModuleDescriptorImpl javaModule = createJavaModule("<java module>");
 
         BindingTraceContext javaResolverTrace = new BindingTraceContext();
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(fileProject, javaResolverTrace, javaModule);
@@ -104,9 +100,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         ModuleConfiguration moduleConfiguration = new ModuleConfiguration() {
             @Override
             public List<ImportPath> getDefaultImports() {
-                LinkedHashSet<ImportPath> imports = Sets.newLinkedHashSet(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS);
+                return JavaBridgeConfiguration.ALL_JAVA_IMPORTS;
-                imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
-                return Lists.newArrayList(imports);
             }
 
             @Override
@@ -134,7 +128,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         };
         javaModule.setModuleConfiguration(moduleConfiguration);
 
-        ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        ModuleDescriptorImpl lazyModule = createJavaModule("<lazy module>");
         lazyModule.setModuleConfiguration(moduleConfiguration);
 
         return new ResolveSession(fileProject, storageManager, lazyModule, declarationProviderFactory, javaResolverTrace);
@@ -202,7 +196,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             Predicate<PsiFile> filesToAnalyzeCompletely,
             boolean storeContextForBodiesResolve
     ) {
-        ModuleDescriptorImpl owner = new ModuleDescriptorImpl(Name.special("<module>"));
+        ModuleDescriptorImpl owner = createJavaModule("<module>");
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, scriptParameters);
@@ -230,4 +224,9 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         return analyzeFilesWithJavaIntegration(project,
                 files, Collections.<AnalyzerScriptParameter>emptyList(), Predicates.<PsiFile>alwaysFalse());
     }
+
+    @NotNull
+    public static ModuleDescriptorImpl createJavaModule(@NotNull String name) {
+        return new ModuleDescriptorImpl(Name.special(name), JavaBridgeConfiguration.ALL_JAVA_IMPORTS);
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -51,7 +51,8 @@ import java.util.Set;
 public final class JavaNamespaceResolver {
 
     @NotNull
-    public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptorImpl(JavaDescriptorResolver.JAVA_ROOT);
+    public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptorImpl(JavaDescriptorResolver.JAVA_ROOT,
+                                                                                     JavaBridgeConfiguration.ALL_JAVA_IMPORTS);
     @NotNull
     private final Map<FqName, JavaBaseScope> resolvedNamespaceCache = Maps.newHashMap();
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java

@@ -34,12 +34,14 @@ import java.util.List;
 public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ClassOrNamespaceDescriptor, ModuleDescriptor {
     private NamespaceDescriptor rootNamepsace;
     private ModuleConfiguration moduleConfiguration;
+    private final List<ImportPath> defaultImports;
 
-    public ModuleDescriptorImpl(@NotNull Name name) {
+    public ModuleDescriptorImpl(@NotNull Name name, @NotNull List<ImportPath> defaultImports) {
         super(Collections.<AnnotationDescriptor>emptyList(), name);
         if (!name.isSpecial()) {
             throw new IllegalArgumentException("module name must be special: " + name);
         }
+        this.defaultImports = defaultImports;
     }
 
     public void setRootNamespace(@NotNull NamespaceDescriptor rootNs) {
@@ -69,7 +71,7 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements C
     @NotNull
     @Override
     public List<ImportPath> getDefaultImports() {
-        return getModuleConfiguration().getDefaultImports();
+        return defaultImports;
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -186,7 +186,8 @@ public class TopDownAnalyzer {
             @NotNull final DeclarationDescriptor containingDeclaration,
             @NotNull JetClassOrObject object
     ) {
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<dummy for object>"));
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<dummy for object>"),
+                                                                         Collections.<ImportPath>emptyList());
         moduleDescriptor.setModuleConfiguration(ModuleConfiguration.EMPTY);
 
         TopDownAnalysisParameters topDownAnalysisParameters =

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
+import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -34,7 +35,7 @@ public class ErrorUtils {
 
     private static final ModuleDescriptor ERROR_MODULE;
     static {
-        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<ERROR MODULE>"));
+        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<ERROR MODULE>"), Collections.<ImportPath>emptyList());
         module.setModuleConfiguration(ModuleConfiguration.EMPTY);
         ERROR_MODULE = module;
     }

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java

@@ -170,7 +170,7 @@ public class KotlinBuiltIns {
 
     private KotlinBuiltIns(@NotNull Project project) {
         try {
-            this.builtInsModule = new ModuleDescriptorImpl(Name.special("<built-ins lazy module>"));
+            this.builtInsModule = new ModuleDescriptorImpl(Name.special("<built-ins lazy module>"), DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
             builtInsModule.setModuleConfiguration(SpecialModuleConfiguration.INSTANCE);
             this.analyzer = createLazyResolveSession(project);
 

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -51,6 +51,7 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -558,8 +559,12 @@ public class JetTestUtils {
         return JetPsiFactory.createPhysicalFile(project, ioFile.getName(), text);
     }
 
-    public static ModuleDescriptor createEmptyModule() {
+    public static ModuleDescriptorImpl createEmptyModule() {
-        ModuleDescriptorImpl descriptor = new ModuleDescriptorImpl(Name.special("<empty-for-test>"));
+        return createEmptyModule("<empty-for-test>");
+    }
+
+    public static ModuleDescriptorImpl createEmptyModule(@NotNull String name) {
+        ModuleDescriptorImpl descriptor = new ModuleDescriptorImpl(Name.special(name), Collections.<ImportPath>emptyList());
         descriptor.setModuleConfiguration(ModuleConfiguration.EMPTY);
         return descriptor;
     }

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

@@ -37,9 +37,9 @@ import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.junit.Assert;
 
@@ -138,7 +138,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, Arrays.asList(sourcesDir.getAbsolutePath()));
         JetCoreEnvironment environment = new JetCoreEnvironment(getTestRootDisposable(), configuration);
 
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<test module>"));
+        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<test module>");
 
         // we need the same binding trace for resolve from Java and Kotlin
         BindingTrace trace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace();

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -28,10 +28,10 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 import java.io.File;
@@ -54,7 +54,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
         Collection<JetFile> files = Lists.newArrayList(psiFile);
 
-        ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
         lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration());
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule,

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
@@ -60,7 +61,7 @@ public class LazyResolveTestUtil {
     }
 
     public static InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) {
-        ModuleDescriptorImpl eagerModuleForLazy = new ModuleDescriptorImpl(Name.special("<eager module for lazy>"));
+        ModuleDescriptorImpl eagerModuleForLazy = AnalyzerFacadeForJVM.createJavaModule("<eager module for lazy>");
 
         InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment);
         // This line is required fro the 'jet' namespace to be filled in with functions
@@ -81,7 +82,7 @@ public class LazyResolveTestUtil {
     }
 
     public static ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
-        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<test module>"));
+        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<test module>");
         InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
         injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
         return module;
@@ -90,7 +91,7 @@ public class LazyResolveTestUtil {
     public static KotlinCodeAnalyzer resolveLazilyWithSession(List<JetFile> files, JetCoreEnvironment environment) {
         JetTestUtils.newTrace(environment);
 
-        ModuleDescriptorImpl javaModule = new ModuleDescriptorImpl(Name.special("<java module>"));
+        ModuleDescriptorImpl javaModule = AnalyzerFacadeForJVM.createJavaModule("<java module>");
 
         Project project = environment.getProject();
         BindingTrace sharedTrace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace();
@@ -141,7 +142,7 @@ public class LazyResolveTestUtil {
         };
         javaModule.setModuleConfiguration(moduleConfiguration);
 
-        ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
         lazyModule.setModuleConfiguration(moduleConfiguration);
         return new ResolveSession(project, storageManager, lazyModule, declarationProviderFactory, sharedTrace);
     }

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

@@ -60,7 +60,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
     }
 
     public class JetDefaultModalityModifiersTestCase  {
-        private ModuleDescriptorImpl root = new ModuleDescriptorImpl(Name.special("<test_root>"));
+        private ModuleDescriptorImpl root = JetTestUtils.createEmptyModule("<test_root>");
         private DescriptorResolver descriptorResolver;
         private JetScope scope;
 

compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java

@@ -24,17 +24,15 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.OverloadUtil;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 public class JetOverloadTest extends JetLiteFixture {
 
-    private ModuleDescriptor root = new ModuleDescriptorImpl(Name.special("<test_root>"));
+    private ModuleDescriptor root = JetTestUtils.createEmptyModule("<test_root>");
     private KotlinBuiltIns builtIns;
     private DescriptorResolver descriptorResolver;
 

compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java

@@ -24,17 +24,15 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 public class JetOverridingTest extends JetLiteFixture {
 
-    private ModuleDescriptor root = new ModuleDescriptorImpl(Name.special("<test_root>"));
+    private ModuleDescriptor root = JetTestUtils.createEmptyModule("<test_root>");
     private KotlinBuiltIns builtIns;
     private DescriptorResolver descriptorResolver;
 

generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -183,7 +183,8 @@ public class GenerateInjectors {
         generator.addPublicField(PsiClassFinderImpl.class);
         generator.addField(false, ModuleDescriptorImpl.class, null,
                            new GivenExpression("new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(" +
-                                               "org.jetbrains.jet.lang.resolve.name.Name.special(\"<dummy>\"))"));
+                                               "org.jetbrains.jet.lang.resolve.name.Name.special(\"<dummy>\"), " +
+                                               "JavaBridgeConfiguration.ALL_JAVA_IMPORTS)"));
 
         // Parameters
         generator.addPublicParameter(Project.class);

idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -116,7 +117,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         BindingContext bindingContext = declarationsCache.getBindingContext();
         DelegatingBindingTrace delegatingTrace = new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
 
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<fake>"));
+        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<fake>");
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, delegatingTrace, moduleDescriptor);
         moduleDescriptor.setModuleConfiguration(injector.getJavaBridgeConfiguration());
         return injector;

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -221,7 +221,7 @@ public class JetSourceNavigationHelper {
                         return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName);
                     }
                 });
-        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"));
+        ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"), DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
         moduleDescriptor.setModuleConfiguration(DefaultModuleConfiguration.createStandardConfiguration());
         KotlinCodeAnalyzer analyzer = new ResolveSession(
                 project,

idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java

@@ -226,7 +226,8 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
 
         private FakeJetNamespaceDescriptor() {
             super(new NamespaceDescriptorImpl(
-                    new ModuleDescriptorImpl(Name.special("<fake_module>")).setModuleConfiguration(ModuleConfiguration.EMPTY),
+                    new ModuleDescriptorImpl(Name.special("<fake_module>"), Collections.<ImportPath>emptyList())
+                            .setModuleConfiguration(ModuleConfiguration.EMPTY),
                   Collections.<AnnotationDescriptor>emptyList(), Name.special("<root>")), Collections.<AnnotationDescriptor>emptyList(),
                   KotlinBuiltIns.getInstance().getBuiltInsPackage().getName());
         }

js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java

@@ -76,7 +76,7 @@ public final class AnalyzerFacadeForJS {
             boolean storeContextForBodiesResolve) {
         Project project = config.getProject();
 
-        ModuleDescriptorImpl owner = new ModuleDescriptorImpl(Name.special("<module>"));
+        ModuleDescriptorImpl owner = new ModuleDescriptorImpl(Name.special("<module>"), JsConfiguration.DEFAULT_IMPORT_PATHS);
 
         Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
 
@@ -142,7 +142,7 @@ public final class AnalyzerFacadeForJS {
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
-        ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
+        ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"), JsConfiguration.DEFAULT_IMPORT_PATHS);
         lazyModule.setModuleConfiguration(new JsConfiguration(null));
         return new ResolveSession(config.getProject(), storageManager, lazyModule, declarationProviderFactory);
     }