Use ModuleDescriptor instead of ModuleConfiguration

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

@@ -95,7 +95,7 @@ public class ReplInterpreter {
                 true,
                 Collections.<AnalyzerScriptParameter>emptyList());
         injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
-        module.setModuleConfiguration(injector.getModuleConfiguration());
+        module.setModuleConfiguration(injector.getModuleDescriptor().getModuleConfiguration());
 
         List<URL> classpath = Lists.newArrayList();
 
@@ -225,7 +225,7 @@ public class ReplInterpreter {
             earierScripts.add(Pair.create(earlierLine.getScriptDescriptor(), earlierLine.getClassName()));
         }
 
-        BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), injector.getModuleConfiguration()).getBindingContext();
+        BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), module).getBindingContext();
         GenerationState generationState = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false),
                                                               bindingContext, Collections.singletonList(psiFile));
         generationState.getScriptCodegen().compileScript(psiFile.getScript(), scriptClassName, earierScripts,

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

@@ -61,7 +61,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -78,7 +77,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
-    private JavaBridgeConfiguration moduleConfiguration;
+    private JavaBridgeConfiguration javaBridgeConfiguration;
     private JavaDescriptorResolver javaDescriptorResolver;
     private PsiClassFinderImpl psiClassFinder;
     private NamespaceFactoryImpl namespaceFactory;
@@ -130,7 +129,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
-        this.moduleConfiguration = new JavaBridgeConfiguration();
+        this.javaBridgeConfiguration = new JavaBridgeConfiguration();
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.psiClassFinder = new PsiClassFinderImpl();
         this.namespaceFactory = new NamespaceFactoryImpl();
@@ -198,7 +197,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        this.moduleConfiguration.setJavaSemanticServices(javaSemanticServices);
+        this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
 
         javaDescriptorResolver.setClassResolver(javaClassResolver);
         javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
@@ -209,7 +208,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         psiClassFinder.setProject(project);
 
-        this.namespaceFactory.setConfiguration(moduleConfiguration);
         this.namespaceFactory.setModuleDescriptor(moduleDescriptor);
         this.namespaceFactory.setTrace(bindingTrace);
 
@@ -241,14 +239,14 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleDescriptor(moduleDescriptor);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
 
-        importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleDescriptor(moduleDescriptor);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         importsResolver.setTrace(bindingTrace);
 
@@ -336,7 +334,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaPropertyResolver.setSemanticServices(javaSemanticServices);
         javaPropertyResolver.setTrace(bindingTrace);
 
-        moduleConfiguration.init();
+        javaBridgeConfiguration.init();
 
         psiClassFinder.initialize();
 
@@ -382,8 +380,12 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         return this.bindingTrace;
     }
     
-    public ModuleConfiguration getModuleConfiguration() {
+    public ModuleDescriptorImpl getModuleDescriptor() {
-        return this.moduleConfiguration;
+        return this.moduleDescriptor;
+    }
+    
+    public JavaBridgeConfiguration getJavaBridgeConfiguration() {
+        return this.javaBridgeConfiguration;
     }
     
     public NamespaceFactoryImpl getNamespaceFactory() {

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

@@ -31,6 +31,7 @@ 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;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -72,11 +73,11 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                                                @NotNull Predicate<PsiFile> filesForBodiesResolve,
                                                @NotNull BindingTrace headersTraceContext,
                                                @NotNull BodiesResolveContext bodiesResolveContext,
-                                               @NotNull ModuleConfiguration configuration
+                                               @NotNull ModuleDescriptor module
     ) {
         return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration(
                 project, scriptParameters, filesForBodiesResolve,
-                headersTraceContext, bodiesResolveContext, configuration);
+                headersTraceContext, bodiesResolveContext, module);
     }
 
     @NotNull
@@ -136,7 +137,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
         lazyModule.setModuleConfiguration(moduleConfiguration);
 
-        return new ResolveSession(fileProject, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, javaResolverTrace);
+        return new ResolveSession(fileProject, storageManager, lazyModule, declarationProviderFactory, javaResolverTrace);
     }
 
     public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(
@@ -209,13 +210,13 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
                 project, topDownAnalysisParameters,
                 new ObservableBindingTrace(trace), owner);
-        owner.setModuleConfiguration(injector.getModuleConfiguration());
+        owner.setModuleConfiguration(injector.getJavaBridgeConfiguration());
         try {
             injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters);
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
                                                         null;
-            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration());
+            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, owner);
         } finally {
             injector.destroy();
         }

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java

@@ -18,70 +18,43 @@ package org.jetbrains.jet.analyzer;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.types.ErrorUtils;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-
-import java.util.Collections;
-import java.util.List;
 
 public class AnalyzeExhaust {
-    private static final ModuleConfiguration ERROR_CONFIGURATION = new ModuleConfiguration() {
-        @Override
-        public List<ImportPath> getDefaultImports() {
-            return Collections.emptyList();
-        }
 
-        @Override
+    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleDescriptor module) {
-        public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
+        return new AnalyzeExhaust(bindingContext, module, null, null);
-        }
-
-        @NotNull
-        @Override
-        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-            return PlatformToKotlinClassMap.EMPTY;
-        }
-
-        @Override
-        public String toString() {
-            return "ERROR_CONFIGURATION";
-        }
-    };
-
-    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleConfiguration configuration) {
-        return new AnalyzeExhaust(bindingContext, configuration, null, null);
     }
+
     public static AnalyzeExhaust success(@NotNull BindingContext bindingContext,
             @Nullable BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration
+            @NotNull ModuleDescriptor module
     ) {
-        return new AnalyzeExhaust(bindingContext, configuration, bodiesResolveContext, null);
+        return new AnalyzeExhaust(bindingContext, module, bodiesResolveContext, null);
     }
 
     public static AnalyzeExhaust error(@NotNull BindingContext bindingContext, @NotNull Throwable error) {
-        return new AnalyzeExhaust(bindingContext, ERROR_CONFIGURATION, null, error);
+        return new AnalyzeExhaust(bindingContext, ErrorUtils.getErrorModule(), null, error);
     }
 
     private final BindingContext bindingContext;
     private final Throwable error;
     private final BodiesResolveContext bodiesResolveContext;
-    private final ModuleConfiguration configuration;
+    private final ModuleDescriptor moduleDescriptor;
 
     private AnalyzeExhaust(
             @NotNull BindingContext bindingContext,
-            @NotNull ModuleConfiguration configuration,
+            @NotNull ModuleDescriptor moduleDescriptor,
             @Nullable BodiesResolveContext bodiesResolveContext,
             @Nullable Throwable error
     ) {
         this.bindingContext = bindingContext;
         this.error = error;
         this.bodiesResolveContext = bodiesResolveContext;
-        this.configuration = configuration;
+        this.moduleDescriptor = moduleDescriptor;
     }
 
     @Nullable
@@ -110,7 +83,7 @@ public class AnalyzeExhaust {
     }
 
     @NotNull
-    public ModuleConfiguration getModuleConfiguration() {
+    public ModuleDescriptor getModuleDescriptor() {
-        return configuration;
+        return moduleDescriptor;
     }
 }

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java

@@ -20,7 +20,7 @@ import com.google.common.base.Predicate;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -47,7 +47,7 @@ public interface AnalyzerFacade {
             @NotNull Predicate<PsiFile> filesForBodiesResolve,
             @NotNull BindingTrace traceContext,
             @NotNull BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration
+            @NotNull ModuleDescriptor module
     );
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java

@@ -21,12 +21,8 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.di.InjectorForBodyResolve;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
+import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.resolve.ObservableBindingTrace;
-import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 
 import java.util.List;
 
@@ -39,7 +35,7 @@ public class AnalyzerFacadeForEverything {
             Project project, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
             @NotNull BindingTrace traceContext,
             @NotNull BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration) {
+            @NotNull ModuleDescriptor module) {
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, scriptParameters);
@@ -49,11 +45,11 @@ public class AnalyzerFacadeForEverything {
         InjectorForBodyResolve injector = new InjectorForBodyResolve(
                 project, topDownAnalysisParameters,
                 new ObservableBindingTrace(traceContext),
-                bodiesResolveContext, configuration);
+                bodiesResolveContext, module);
 
         try {
             injector.getBodyResolver().resolveBodies();
-            return AnalyzeExhaust.success(traceContext.getBindingContext(), configuration);
+            return AnalyzeExhaust.success(traceContext.getBindingContext(), module);
         } finally {
             injector.destroy();
         }

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

@@ -21,7 +21,7 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -46,7 +46,7 @@ public class InjectorForBodyResolve {
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
     private final BodiesResolveContext bodiesResolveContext;
-    private final ModuleConfiguration moduleConfiguration;
+    private final ModuleDescriptor moduleDescriptor;
     private CallResolver callResolver;
     private ArgumentTypeResolver argumentTypeResolver;
     private ExpressionTypingServices expressionTypingServices;
@@ -66,14 +66,14 @@ public class InjectorForBodyResolve {
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
         @NotNull BodiesResolveContext bodiesResolveContext,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleDescriptor moduleDescriptor
     ) {
         this.bodyResolver = new BodyResolver();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.bodiesResolveContext = bodiesResolveContext;
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleDescriptor = moduleDescriptor;
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
@@ -123,7 +123,7 @@ public class InjectorForBodyResolve {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleDescriptor(moduleDescriptor);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
@@ -38,7 +38,7 @@ public class InjectorForLazyResolve {
     
     private final Project project;
     private final ResolveSession resolveSession;
-    private final ModuleConfiguration moduleConfiguration;
+    private final ModuleDescriptor moduleDescriptor;
     private DescriptorResolver descriptorResolver;
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
@@ -54,11 +54,11 @@ public class InjectorForLazyResolve {
     public InjectorForLazyResolve(
         @NotNull Project project,
         @NotNull ResolveSession resolveSession,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleDescriptor moduleDescriptor
     ) {
         this.project = project;
         this.resolveSession = resolveSession;
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleDescriptor = moduleDescriptor;
         this.descriptorResolver = new DescriptorResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
@@ -83,7 +83,7 @@ public class InjectorForLazyResolve {
 
         this.typeResolver.setAnnotationResolver(annotationResolver);
         this.typeResolver.setDescriptorResolver(descriptorResolver);
-        this.typeResolver.setModuleConfiguration(moduleConfiguration);
+        this.typeResolver.setModuleDescriptor(moduleDescriptor);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         this.annotationResolver.setCallResolver(callResolver);

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.di;
 
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -35,7 +35,7 @@ public class InjectorForMacros {
     
     private ExpressionTypingServices expressionTypingServices;
     private final Project project;
-    private final ModuleConfiguration moduleConfiguration;
+    private final ModuleDescriptor moduleDescriptor;
     private CallExpressionResolver callExpressionResolver;
     private CallResolver callResolver;
     private ArgumentTypeResolver argumentTypeResolver;
@@ -47,11 +47,11 @@ public class InjectorForMacros {
     
     public InjectorForMacros(
         @NotNull Project project,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleDescriptor moduleDescriptor
     ) {
         this.expressionTypingServices = new ExpressionTypingServices();
         this.project = project;
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleDescriptor = moduleDescriptor;
         this.callExpressionResolver = new CallExpressionResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -79,7 +79,7 @@ public class InjectorForMacros {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleDescriptor(moduleDescriptor);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         annotationResolver.setCallResolver(callResolver);

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

@@ -16,11 +16,11 @@
 
 package org.jetbrains.jet.di;
 
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 
 public interface InjectorForTopDownAnalyzer {
-    ModuleConfiguration getModuleConfiguration();
+    ModuleDescriptor getModuleDescriptor();
 
     TopDownAnalyzer getTopDownAnalyzer();
 }

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

@@ -26,7 +26,6 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
@@ -61,7 +60,6 @@ public class InjectorForTopDownAnalyzerBasic {
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
-    private final ModuleConfiguration moduleConfiguration;
     private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
     private NamespaceFactoryImpl namespaceFactory;
     private DeclarationResolver declarationResolver;
@@ -85,8 +83,7 @@ public class InjectorForTopDownAnalyzerBasic {
         @NotNull Project project,
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl moduleDescriptor,
+        @NotNull ModuleDescriptorImpl moduleDescriptor
-        @NotNull ModuleConfiguration moduleConfiguration
     ) {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
@@ -98,7 +95,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
-        this.moduleConfiguration = moduleConfiguration;
         this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
         this.namespaceFactory = new NamespaceFactoryImpl();
         this.declarationResolver = new DeclarationResolver();
@@ -150,7 +146,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        namespaceFactory.setConfiguration(moduleConfiguration);
         namespaceFactory.setModuleDescriptor(moduleDescriptor);
         namespaceFactory.setTrace(bindingTrace);
 
@@ -182,14 +177,14 @@ public class InjectorForTopDownAnalyzerBasic {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleDescriptor(moduleDescriptor);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
 
-        importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleDescriptor(moduleDescriptor);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         importsResolver.setTrace(bindingTrace);
 
@@ -261,4 +256,8 @@ public class InjectorForTopDownAnalyzerBasic {
         return this.bindingTrace;
     }
     
+    public ModuleDescriptorImpl getModuleDescriptor() {
+        return this.moduleDescriptor;
+    }
+    
 }

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

@@ -19,9 +19,13 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
+import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
+import java.util.List;
+
 public interface ModuleDescriptor extends DeclarationDescriptor, NamespaceDescriptorParent {
     @Override
     @Nullable
@@ -32,6 +36,12 @@ public interface ModuleDescriptor extends DeclarationDescriptor, NamespaceDescri
     @NotNull
     ModuleConfiguration getModuleConfiguration();
 
+    @NotNull
+    List<ImportPath> getDefaultImports();
+
+    @NotNull
+    PlatformToKotlinClassMap getPlatformToKotlinClassMap();
+
     @NotNull
     @Override
     ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor);

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

@@ -19,14 +19,17 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
+import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import javax.inject.Inject;
 import java.util.Collections;
+import java.util.List;
 
 public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ClassOrNamespaceDescriptor, ModuleDescriptor {
     private NamespaceDescriptor rootNamepsace;
@@ -63,6 +66,18 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements C
         return moduleConfiguration;
     }
 
+    @NotNull
+    @Override
+    public List<ImportPath> getDefaultImports() {
+        return getModuleConfiguration().getDefaultImports();
+    }
+
+    @NotNull
+    @Override
+    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
+        return getModuleConfiguration().getPlatformToKotlinClassMap();
+    }
+
     @Inject
     public ModuleDescriptorImpl setModuleConfiguration(@NotNull ModuleConfiguration moduleConfiguration) {
         this.moduleConfiguration = moduleConfiguration;

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

@@ -19,12 +19,8 @@ package org.jetbrains.jet.lang.resolve;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -42,7 +38,7 @@ public class ImportsResolver {
     @NotNull
     private TopDownAnalysisContext context;
     @NotNull
-    private ModuleConfiguration configuration;
+    private ModuleDescriptor moduleDescriptor;
     @NotNull
     private QualifiedExpressionResolver qualifiedExpressionResolver;
     @NotNull
@@ -56,8 +52,8 @@ public class ImportsResolver {
     }
 
     @Inject
-    public void setConfiguration(@NotNull ModuleConfiguration configuration) {
+    public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) {
-        this.configuration = configuration;
+        this.moduleDescriptor = moduleDescriptor;
     }
 
     @Inject
@@ -95,7 +91,7 @@ public class ImportsResolver {
     }
 
     private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List<JetImportDirective> directives, JetScope rootScope) {
-        processImportsInFile(lookupMode, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, importsFactory);
+        processImportsInFile(lookupMode, scope, directives, rootScope, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory);
     }
 
     public static void processImportsInFile(
@@ -103,7 +99,7 @@ public class ImportsResolver {
             @NotNull WritableScope namespaceScope,
             @NotNull List<JetImportDirective> importDirectives,
             @NotNull JetScope rootScope,
-            @NotNull ModuleConfiguration configuration,
+            @NotNull ModuleDescriptor module,
             @NotNull BindingTrace trace,
             @NotNull QualifiedExpressionResolver qualifiedExpressionResolver,
             @NotNull JetImportsFactory importsFactory
@@ -114,13 +110,13 @@ public class ImportsResolver {
             namespaceScope.clearImports();
         }
 
-        for (ImportPath defaultImportPath : configuration.getDefaultImports()) {
+        for (ImportPath defaultImportPath : module.getDefaultImports()) {
             TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
                     trace, "transient trace to resolve default imports"); //not to trace errors of default imports
 
             JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath);
             qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter,
-                                                               temporaryTrace, configuration, lookupMode);
+                                                               temporaryTrace, module, lookupMode);
         }
 
         Map<JetImportDirective, Collection<? extends DeclarationDescriptor>> resolvedDirectives = Maps.newHashMap();
@@ -128,7 +124,7 @@ public class ImportsResolver {
         for (JetImportDirective importDirective : importDirectives) {
             Collection<? extends DeclarationDescriptor> descriptors =
                 qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter,
-                                                                   trace, configuration, lookupMode);
+                                                                   trace, module, lookupMode);
             if (!descriptors.isEmpty()) {
                 resolvedDirectives.put(importDirective, descriptors);
             }
@@ -136,7 +132,7 @@ public class ImportsResolver {
             JetExpression importedReference = importDirective.getImportedReference();
             if (lookupMode != LookupMode.ONLY_CLASSES && importedReference != null) {
                 for (DeclarationDescriptor descriptor : descriptors) {
-                    reportPlatformClassMappedToKotlin(configuration, trace, importedReference, descriptor);
+                    reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor);
                 }
             }
         }
@@ -150,14 +146,14 @@ public class ImportsResolver {
     }
 
     public static void reportPlatformClassMappedToKotlin(
-            @NotNull ModuleConfiguration configuration,
+            @NotNull ModuleDescriptor module,
             @NotNull BindingTrace trace,
             @NotNull JetElement element,
             @NotNull DeclarationDescriptor descriptor
     ) {
         if (!(descriptor instanceof ClassDescriptor)) return;
 
-        PlatformToKotlinClassMap platformToKotlinMap = configuration.getPlatformToKotlinClassMap();
+        PlatformToKotlinClassMap platformToKotlinMap = module.getPlatformToKotlinClassMap();
         Collection<ClassDescriptor> kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor);
         if (!kotlinAnalogsForClass.isEmpty()) {
             trace.report(PLATFORM_CLASS_MAPPED_TO_KOTLIN.on(element, kotlinAnalogsForClass));

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

@@ -20,13 +20,15 @@ import com.google.common.collect.Sets;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
+import org.jetbrains.jet.lang.psi.JetReferenceExpression;
+import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -45,7 +47,6 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
 
     private ModuleDescriptorImpl moduleDescriptor;
     private BindingTrace trace;
-    private ModuleConfiguration configuration;
 
     @Inject
     public void setModuleDescriptor(ModuleDescriptorImpl moduleDescriptor) {
@@ -57,11 +58,6 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         this.trace = trace;
     }
 
-    @Inject
-    public void setConfiguration(ModuleConfiguration configuration) {
-        this.configuration = configuration;
-    }
-
     @NotNull
     public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull JetFile file,
                                                                          @NotNull JetScope outerScope,
@@ -190,7 +186,7 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         namespaceDescriptor.initialize(scope);
         scope.changeLockLevel(WritableScope.LockLevel.BOTH);
         //
-        configuration.extendNamespaceScope(trace, namespaceDescriptor, scope);
+        moduleDescriptor.getModuleConfiguration().extendNamespaceScope(trace, namespaceDescriptor, scope);
         owner.addNamespace(namespaceDescriptor);
         if (expression != null) {
             trace.record(BindingContext.NAMESPACE, expression, namespaceDescriptor);

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

@@ -22,7 +22,6 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
@@ -49,9 +48,9 @@ public class QualifiedExpressionResolver {
             @NotNull JetImportDirective importDirective,
             @NotNull JetScope scope,
             @NotNull BindingTrace trace,
-            @NotNull ModuleConfiguration moduleConfiguration
+            @NotNull ModuleDescriptor module
     ) {
-        return processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace, moduleConfiguration, LookupMode.EVERYTHING);
+        return processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace, module, LookupMode.EVERYTHING);
     }
 
     @NotNull
@@ -61,7 +60,7 @@ public class QualifiedExpressionResolver {
             @NotNull JetScope scopeToCheckVisibility,
             @NotNull Importer importer,
             @NotNull BindingTrace trace,
-            @NotNull ModuleConfiguration moduleConfiguration,
+            @NotNull ModuleDescriptor module,
             @NotNull LookupMode lookupMode
     ) {
         if (importDirective.isAbsoluteInRootNamespace()) {
@@ -94,7 +93,7 @@ public class QualifiedExpressionResolver {
             }
 
             for (DeclarationDescriptor descriptor : descriptors) {
-                importer.addAllUnderImport(descriptor, moduleConfiguration.getPlatformToKotlinClassMap());
+                importer.addAllUnderImport(descriptor, module.getPlatformToKotlinClassMap());
             }
             return Collections.emptyList();
         }

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

@@ -161,7 +161,7 @@ public class TopDownAnalyzer {
                 Predicates.<PsiFile>alwaysFalse(), true, false, Collections.<AnalyzerScriptParameter>emptyList());
         InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
                 project, topDownAnalysisParameters, new ObservableBindingTrace(trace),       
-                KotlinBuiltIns.getInstance().getBuiltInsModule(), ModuleConfiguration.EMPTY);
+                KotlinBuiltIns.getInstance().getBuiltInsModule());
 
         injector.getTopDownAnalyzer().doProcessStandardLibraryNamespace(outerScope, standardLibraryNamespace, files);
     }
@@ -194,8 +194,7 @@ public class TopDownAnalyzer {
                 false, true, Collections.<AnalyzerScriptParameter>emptyList());
 
         InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
-                project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor,
+                project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor);
-                ModuleConfiguration.EMPTY);
 
         injector.getTopDownAnalyzer().doProcess(outerScope, new NamespaceLikeBuilder() {
 

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

@@ -19,11 +19,7 @@ package org.jetbrains.jet.lang.resolve;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -46,7 +42,7 @@ public class TypeResolver {
     private AnnotationResolver annotationResolver;
     private DescriptorResolver descriptorResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
-    private ModuleConfiguration moduleConfiguration;
+    private ModuleDescriptor moduleDescriptor;
 
     @Inject
     public void setDescriptorResolver(DescriptorResolver descriptorResolver) {
@@ -64,8 +60,8 @@ public class TypeResolver {
     }
 
     @Inject
-    public void setModuleConfiguration(@NotNull ModuleConfiguration moduleConfiguration) {
+    public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) {
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleDescriptor = moduleDescriptor;
     }
 
     @NotNull
@@ -333,7 +329,7 @@ public class TypeResolver {
         Collection<? extends DeclarationDescriptor> descriptors = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace);
         for (DeclarationDescriptor descriptor : descriptors) {
             if (descriptor instanceof ClassifierDescriptor) {
-                ImportsResolver.reportPlatformClassMappedToKotlin(moduleConfiguration, trace, userType, descriptor);
+                ImportsResolver.reportPlatformClassMappedToKotlin(moduleDescriptor, trace, userType, descriptor);
                 return (ClassifierDescriptor) descriptor;
             }
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java

@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve.lazy;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -32,9 +31,6 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 public interface KotlinCodeAnalyzer {
     ModuleDescriptor getRootModuleDescriptor();
 
-    @NotNull
-    ModuleConfiguration getModuleConfiguration();
-
     @Nullable
     NamespaceDescriptor getPackageDescriptor(@NotNull Name shortName);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java

@@ -171,7 +171,7 @@ public class LazyImportScope implements JetScope {
                     packageDescriptor.getMemberScope(),
                     importer,
                     traceForImportResolve,
-                    resolveSession.getModuleConfiguration(),
+                    resolveSession.getRootModuleDescriptor(),
                     lookupMode);
         }
         finally {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java

@@ -25,11 +25,12 @@ import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForLazyResolve;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor;
@@ -65,18 +66,16 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
 
     private final InjectorForLazyResolve injector;
-    private final ModuleConfiguration moduleConfiguration;
 
     private final Function<FqName, Name> classifierAliases;
 
     public ResolveSession(
-        @NotNull Project project,
+            @NotNull Project project,
-        @NotNull StorageManager storageManager,
+            @NotNull StorageManager storageManager,
-        @NotNull ModuleDescriptorImpl rootDescriptor,
+            @NotNull ModuleDescriptorImpl rootDescriptor,
-        @NotNull ModuleConfiguration moduleConfiguration,
+            @NotNull DeclarationProviderFactory declarationProviderFactory
-        @NotNull DeclarationProviderFactory declarationProviderFactory
     ) {
-        this(project, storageManager, rootDescriptor, moduleConfiguration, declarationProviderFactory, NO_ALIASES,
+        this(project, storageManager, rootDescriptor, declarationProviderFactory, NO_ALIASES,
              Predicates.<FqNameUnsafe>alwaysFalse(),
              new BindingTraceContext());
     }
@@ -85,14 +84,12 @@ public class ResolveSession implements KotlinCodeAnalyzer {
             @NotNull Project project,
             @NotNull StorageManager storageManager,
             @NotNull ModuleDescriptorImpl rootDescriptor,
-            @NotNull ModuleConfiguration moduleConfiguration,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
             @NotNull BindingTrace delegationTrace
     ) {
         this(project,
              storageManager,
              rootDescriptor,
-             moduleConfiguration,
              declarationProviderFactory,
              NO_ALIASES,
              Predicates.<FqNameUnsafe>alwaysFalse(),
@@ -104,7 +101,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
             @NotNull Project project,
             @NotNull StorageManager storageManager,
             @NotNull ModuleDescriptorImpl rootDescriptor,
-            @NotNull ModuleConfiguration moduleConfiguration,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
             @NotNull Function<FqName, Name> classifierAliases,
             @NotNull Predicate<FqNameUnsafe> specialClasses,
@@ -114,9 +110,8 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         this.classifierAliases = classifierAliases;
         this.specialClasses = specialClasses;
         this.trace = storageManager.createSafeTrace(delegationTrace);
-        this.injector = new InjectorForLazyResolve(project, this, moduleConfiguration);
+        this.injector = new InjectorForLazyResolve(project, this, rootDescriptor);
         this.module = rootDescriptor;
-        this.moduleConfiguration = moduleConfiguration;
         PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT);
         assert provider != null : "No declaration provider for root package in " + rootDescriptor;
         this.rootPackage = new LazyPackageDescriptor(rootDescriptor, FqNameUnsafe.ROOT_NAME, this, provider);
@@ -144,12 +139,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         return storageManager;
     }
 
-    @Override
-    @NotNull
-    public ModuleConfiguration getModuleConfiguration() {
-        return moduleConfiguration;
-    }
-
     @Override
     @Nullable
     public NamespaceDescriptor getPackageDescriptor(@NotNull Name shortName) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java

@@ -26,7 +26,6 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForBodyResolve;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
@@ -161,7 +160,7 @@ public class ResolveSessionUtils {
     private static void delegationSpecifierAdditionalResolve(
             KotlinCodeAnalyzer analyzer,
             JetDelegationSpecifierList specifier, DelegatingBindingTrace trace, JetFile file) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleConfiguration());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getRootModuleDescriptor());
 
         JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent();
         LazyClassDescriptor descriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject);
@@ -186,7 +185,7 @@ public class ResolveSessionUtils {
                 return propertyResolutionScope;
             }
         });
-        BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getModuleConfiguration());
+        BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getRootModuleDescriptor());
         PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty);
 
         JetExpression propertyInitializer = jetProperty.getInitializer();
@@ -204,7 +203,7 @@ public class ResolveSessionUtils {
             DelegatingBindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleConfiguration());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getRootModuleDescriptor());
         JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(namedFunction);
         FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction);
         bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope);
@@ -216,7 +215,7 @@ public class ResolveSessionUtils {
             DelegatingBindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleConfiguration());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getRootModuleDescriptor());
         JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class);
         LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject);
         bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(),
@@ -226,19 +225,19 @@ public class ResolveSessionUtils {
     }
 
     private static BodyResolver createBodyResolver(DelegatingBindingTrace trace, JetFile file, BodyResolveContextForLazy bodyResolveContext,
-            ModuleConfiguration moduleConfiguration) {
+            ModuleDescriptor module) {
         TopDownAnalysisParameters parameters = new TopDownAnalysisParameters(
                 Predicates.<PsiFile>alwaysTrue(), false, true, Collections.<AnalyzerScriptParameter>emptyList());
-        InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, moduleConfiguration);
+        InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, module);
         return bodyResolve.getBodyResolver();
     }
 
     private static BodyResolver createBodyResolverWithEmptyContext(
             DelegatingBindingTrace trace,
             JetFile file,
-            ModuleConfiguration moduleConfiguration
+            ModuleDescriptor module
     ) {
-        return createBodyResolver(trace, file, EMPTY_CONTEXT, moduleConfiguration);
+        return createBodyResolver(trace, file, EMPTY_CONTEXT, module);
     }
 
     private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java

@@ -99,7 +99,7 @@ public class ScopeProvider {
         }
 
         JetImportsFactory importsFactory = resolveSession.getInjector().getJetImportsFactory();
-        List<ImportPath> defaultImports = resolveSession.getModuleConfiguration().getDefaultImports();
+        List<ImportPath> defaultImports = resolveSession.getRootModuleDescriptor().getDefaultImports();
 
         Collection<JetImportDirective> defaultImportDirectives = importsFactory.createImportDirectives(defaultImports);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java

@@ -45,7 +45,7 @@ public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl imple
         super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), name);
 
         WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Package scope");
-        resolveSession.getModuleConfiguration().extendNamespaceScope(resolveSession.getTrace(), this, scope);
+        resolveSession.getRootModuleDescriptor().getModuleConfiguration().extendNamespaceScope(resolveSession.getTrace(), this, scope);
         scope.changeLockLevel(WritableScope.LockLevel.READING);
 
         this.lazyScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this);

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

@@ -309,5 +309,9 @@ public class ErrorUtils {
         }
     }
 
+    public static ModuleDescriptor getErrorModule() {
+        return ERROR_MODULE;
+    }
+
     private ErrorUtils() {}
 }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java

@@ -244,12 +244,12 @@ public class ExpressionTypingUtils {
             @NotNull JetExpression receiverExpression,
             @NotNull JetType receiverType,
             @NotNull JetScope scope,
-            @NotNull ModuleConfiguration moduleConfiguration
+            @NotNull ModuleDescriptor module
     ) {
         JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, callableFQN.getFqName());
 
         Collection<? extends DeclarationDescriptor> declarationDescriptors = new QualifiedExpressionResolver()
-                .analyseImportReference(importDirective, scope, new BindingTraceContext(), moduleConfiguration);
+                .analyseImportReference(importDirective, scope, new BindingTraceContext(), module);
 
         List<CallableDescriptor> callableExtensionDescriptors = new ArrayList<CallableDescriptor>();
         ReceiverValue receiverValue = new ExpressionReceiver(receiverExpression, receiverType);

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

@@ -229,7 +229,6 @@ public class KotlinBuiltIns {
                 project,
                 storageManager,
                 builtInsModule,
-                SpecialModuleConfiguration.INSTANCE,
                 new FileBasedDeclarationProviderFactory(storageManager, files),
                 ResolveSession.NO_ALIASES,
                 Predicates.in(Sets.newHashSet(new FqNameUnsafe("jet.Any"), new FqNameUnsafe("jet.Nothing"))),

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

@@ -39,6 +39,9 @@ import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestPackJdkAnnotations;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
+import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.diagnostics.Severity;
@@ -50,6 +53,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
+import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.jetbrains.jet.test.InnerTestClasses;
 import org.jetbrains.jet.test.TestMetadata;
@@ -553,4 +557,10 @@ public class JetTestUtils {
         String text = FileUtil.loadFile(ioFile);
         return JetPsiFactory.createPhysicalFile(project, ioFile.getName(), text);
     }
+
+    public static ModuleDescriptor createEmptyModule() {
+        ModuleDescriptorImpl descriptor = new ModuleDescriptorImpl(Name.special("<empty-for-test>"));
+        descriptor.setModuleConfiguration(ModuleConfiguration.EMPTY);
+        return descriptor;
+    }
 }

compiler/tests/org/jetbrains/jet/di/InjectorForTests.java

@@ -21,8 +21,8 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
@@ -39,8 +39,8 @@ public class InjectorForTests {
     private TypeResolver typeResolver;
     private CallResolver callResolver;
     private KotlinBuiltIns kotlinBuiltIns;
-    private ModuleConfiguration moduleConfiguration;
     private final Project project;
+    private final ModuleDescriptor moduleDescriptor;
     private AnnotationResolver annotationResolver;
     private CallExpressionResolver callExpressionResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
@@ -48,15 +48,16 @@ public class InjectorForTests {
     private CandidateResolver candidateResolver;
     
     public InjectorForTests(
-        @NotNull Project project
+        @NotNull Project project,
+        @NotNull ModuleDescriptor moduleDescriptor
     ) {
         this.descriptorResolver = new DescriptorResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.callResolver = new CallResolver();
         this.kotlinBuiltIns = KotlinBuiltIns.getInstance();
-        this.moduleConfiguration = ModuleConfiguration.EMPTY;
         this.project = project;
+        this.moduleDescriptor = moduleDescriptor;
         this.annotationResolver = new AnnotationResolver();
         this.callExpressionResolver = new CallExpressionResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -75,7 +76,7 @@ public class InjectorForTests {
 
         this.typeResolver.setAnnotationResolver(annotationResolver);
         this.typeResolver.setDescriptorResolver(descriptorResolver);
-        this.typeResolver.setModuleConfiguration(moduleConfiguration);
+        this.typeResolver.setModuleDescriptor(moduleDescriptor);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         this.callResolver.setArgumentTypeResolver(argumentTypeResolver);

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

@@ -153,7 +153,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                         Predicates.<PsiFile>alwaysFalse(), false, false, Collections.<AnalyzerScriptParameter>emptyList()),
                 trace,
                 moduleDescriptor);
-        moduleDescriptor.setModuleConfiguration(injectorForAnalyzer.getModuleConfiguration());
+        moduleDescriptor.setModuleConfiguration(injectorForAnalyzer.getJavaBridgeConfiguration());
 
         injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList());
 

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

@@ -55,10 +55,10 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         Collection<JetFile> files = Lists.newArrayList(psiFile);
 
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
-        lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleConfiguration());
+        lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration());
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
-        final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
+        final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule,
-                                                    new FileBasedDeclarationProviderFactory(storageManager, files));
+                                                                 new FileBasedDeclarationProviderFactory(storageManager, files));
 
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
         psiFile.accept(new JetVisitorVoid() {

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

@@ -63,7 +63,6 @@ public class LazyResolveTestUtil {
         ModuleDescriptorImpl eagerModuleForLazy = new ModuleDescriptorImpl(Name.special("<eager module for lazy>"));
 
         InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment);
-        eagerModuleForLazy.setModuleConfiguration(tdaInjectorForLazy.getModuleConfiguration());
         // This line is required fro the 'jet' namespace to be filled in with functions
         tdaInjectorForLazy.getTopDownAnalyzer().analyzeFiles(
                 Collections.singletonList(JetPsiFactory.createFile(environment.getProject(), "")), Collections.<AnalyzerScriptParameter>emptyList());
@@ -76,13 +75,14 @@ public class LazyResolveTestUtil {
         TopDownAnalysisParameters params = new TopDownAnalysisParameters(
                 Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
         BindingTrace sharedTrace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace();
-        return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, module);
+        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, module);
+        module.setModuleConfiguration(injector.getJavaBridgeConfiguration());
+        return injector;
     }
 
     public static ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
         ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<test module>"));
         InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
-        module.setModuleConfiguration(injector.getModuleConfiguration());
         injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
         return module;
     }
@@ -143,7 +143,7 @@ public class LazyResolveTestUtil {
 
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
         lazyModule.setModuleConfiguration(moduleConfiguration);
-        return new ResolveSession(project, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, sharedTrace);
+        return new ResolveSession(project, storageManager, lazyModule, declarationProviderFactory, sharedTrace);
     }
 
     public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {

compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java

@@ -20,12 +20,10 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import junit.framework.Assert;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.di.InjectorForTests;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
@@ -129,7 +127,8 @@ public class JetExpectedResolveDataUtil {
             Project project,
             JetType... parameterTypes
     ) {
-        ExpressionTypingServices expressionTypingServices = new InjectorForTests(project).getExpressionTypingServices();
+        ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
+        ExpressionTypingServices expressionTypingServices = new InjectorForTests(project, emptyModule).getExpressionTypingServices();
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
                 expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),

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

@@ -65,7 +65,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         private JetScope scope;
 
         public void setUp() throws Exception {
-            InjectorForTests injector = new InjectorForTests(getProject());
+            InjectorForTests injector = new InjectorForTests(getProject(), root);
             KotlinBuiltIns builtIns = injector.getKotlinBuiltIns();
             descriptorResolver = injector.getDescriptorResolver();
             scope = createScope(builtIns.getBuiltInsScope());

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

@@ -46,7 +46,7 @@ public class JetOverloadTest extends JetLiteFixture {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject());
+        InjectorForTests injector = new InjectorForTests(getProject(), root);
         builtIns = injector.getKotlinBuiltIns();
         descriptorResolver = injector.getDescriptorResolver();
     }

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

@@ -46,7 +46,7 @@ public class JetOverridingTest extends JetLiteFixture {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject());
+        InjectorForTests injector = new InjectorForTests(getProject(), root);
         builtIns = injector.getKotlinBuiltIns();
         descriptorResolver = injector.getDescriptorResolver();
     }

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

@@ -79,7 +79,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
         builtIns = KotlinBuiltIns.getInstance();
 
-        InjectorForTests injector = new InjectorForTests(getProject());
+        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
         descriptorResolver = injector.getDescriptorResolver();
         typeResolver = injector.getTypeResolver();
         expressionTypingServices = injector.getExpressionTypingServices();

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

@@ -24,6 +24,7 @@ import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -65,7 +66,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
     protected void setUp() throws Exception {
         super.setUp();
 
-        injector = new InjectorForTests(getProject());
+        injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
         scope = getContextScope();
     }
 

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

@@ -27,8 +27,6 @@ import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.di.DependencyInjectorGenerator;
 import org.jetbrains.jet.di.GivenExpression;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
-import org.jetbrains.jet.di.InstantiateType;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
@@ -70,7 +68,7 @@ public class GenerateInjectors {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
         generator.addParameter(Project.class);
         generator.addParameter(ResolveSession.class);
-        generator.addParameter(ModuleConfiguration.class);
+        generator.addParameter(ModuleDescriptor.class);
         generator.addPublicField(DescriptorResolver.class);
         generator.addPublicField(ExpressionTypingServices.class);
         generator.addPublicField(TypeResolver.class);
@@ -84,7 +82,6 @@ public class GenerateInjectors {
     private static void generateInjectorForTopDownAnalyzerBasic() throws IOException {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
         generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addParameter(ModuleConfiguration.class);
         generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class);
         generator.addField(NamespaceFactoryImpl.class);
         generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic", GenerateInjectors.class);
@@ -93,7 +90,6 @@ public class GenerateInjectors {
     private static void generateInjectorForTopDownAnalyzerForJs() throws IOException {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
         generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addPublicParameter(ModuleConfiguration.class);
         generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class);
         generator.addField(NamespaceFactoryImpl.class);
         generator.generate("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs", GenerateInjectors.class);
@@ -103,7 +99,7 @@ public class GenerateInjectors {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
         generator.implementInterface(InjectorForTopDownAnalyzer.class);
         generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addField(true, ModuleConfiguration.class, null, new InstantiateType(JavaBridgeConfiguration.class));
+        generator.addPublicField(JavaBridgeConfiguration.class);
         generator.addField(JavaDescriptorResolver.class);
         generator.addField(PsiClassFinderImpl.class);
         generator.addPublicField(NamespaceFactoryImpl.class);
@@ -142,7 +138,7 @@ public class GenerateInjectors {
         generator.addPublicParameter(Project.class);
         generator.addPublicParameter(TopDownAnalysisParameters.class);
         generator.addPublicParameter(BindingTrace.class);
-        generator.addParameter(ModuleDescriptorImpl.class);
+        generator.addPublicParameter(ModuleDescriptorImpl.class);
     }
 
     private static void generateMacroInjector() throws IOException {
@@ -153,7 +149,7 @@ public class GenerateInjectors {
 
         // Parameters
         generator.addPublicParameter(Project.class);
-        generator.addParameter(ModuleConfiguration.class);
+        generator.addParameter(ModuleDescriptor.class);
 
         generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros", GenerateInjectors.class);
     }
@@ -167,10 +163,10 @@ public class GenerateInjectors {
         generator.addPublicField(TypeResolver.class);
         generator.addPublicField(CallResolver.class);
         generator.addField(true, KotlinBuiltIns.class, null, new GivenExpression("KotlinBuiltIns.getInstance()"));
-        generator.addField(false, ModuleConfiguration.class, null, new GivenExpression("ModuleConfiguration.EMPTY"));
 
         // Parameters
         generator.addPublicParameter(Project.class);
+        generator.addParameter(ModuleDescriptor.class);
 
         generator.generate("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests", GenerateInjectors.class);
     }
@@ -229,7 +225,7 @@ public class GenerateInjectors {
         generator.addPublicParameter(TopDownAnalysisParameters.class);
         generator.addPublicParameter(BindingTrace.class);
         generator.addPublicParameter(BodiesResolveContext.class);
-        generator.addParameter(ModuleConfiguration.class);
+        generator.addParameter(ModuleDescriptor.class);
         generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve", GenerateInjectors.class);
     }
 }

idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java

@@ -236,7 +236,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
             if (functionFQN != null) {
                 JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, new ImportPath(functionFQN, false));
                 Collection<? extends DeclarationDescriptor> declarationDescriptors = new QualifiedExpressionResolver().analyseImportReference(
-                        importDirective, jetScope, new BindingTraceContext(), resolveSession.getModuleConfiguration());
+                        importDirective, jetScope, new BindingTraceContext(), resolveSession.getRootModuleDescriptor());
                 for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
                     if (declarationDescriptor instanceof FunctionDescriptor) {
                         result.add((FunctionDescriptor) declarationDescriptor);
@@ -335,7 +335,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
                 // Iterate through the function with attempt to resolve found functions
                 for (FqName functionFQN : functionFQNs) {
                     for (CallableDescriptor functionDescriptor : ExpressionTypingUtils.canFindSuitableCall(
-                            functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getModuleConfiguration())) {
+                            functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getRootModuleDescriptor())) {
 
                         resultDescriptors.add(functionDescriptor);
                     }

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

@@ -227,7 +227,6 @@ public class JetSourceNavigationHelper {
                 project,
                 storageManager,
                 moduleDescriptor,
-                DefaultModuleConfiguration.createStandardConfiguration(),
                 providerFactory);
 
         for (JetNamedDeclaration candidate : candidates) {

idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java

@@ -67,7 +67,7 @@ public abstract class BaseJetVariableMacro extends Macro {
             return null;
         }
 
-        ExpressionTypingServices callResolverContext = new InjectorForMacros(project, analyzeExhaust.getModuleConfiguration()).getExpressionTypingServices();
+        ExpressionTypingServices callResolverContext = new InjectorForMacros(project, analyzeExhaust.getModuleDescriptor()).getExpressionTypingServices();
 
         List<VariableDescriptor> filteredDescriptors = new ArrayList<VariableDescriptor>();
         for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {

idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java

@@ -38,7 +38,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.asJava.LightClassUtil;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -46,6 +45,7 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCacheImpl;
@@ -121,7 +121,7 @@ public final class AnalyzerFacadeWithCache {
     }
 
     private static AnalyzeExhaust emptyExhaust() {
-        return AnalyzeExhaust.success(BindingContext.EMPTY, ModuleConfiguration.EMPTY);
+        return AnalyzeExhaust.success(BindingContext.EMPTY, ErrorUtils.getErrorModule());
     }
 
     private static AnalyzeExhaust analyzeHeadersWithCacheOnFile(@NotNull JetFile fileToCache) {
@@ -143,7 +143,6 @@ public final class AnalyzerFacadeWithCache {
 
     private static AnalyzeExhaust analyzeBodies(AnalyzeExhaust analyzeExhaustHeaders, JetFile file) {
         BodiesResolveContext context = analyzeExhaustHeaders.getBodiesResolveContext();
-        ModuleConfiguration moduleConfiguration = analyzeExhaustHeaders.getModuleConfiguration();
         assert context != null : "Headers resolver should prepare and stored information for bodies resolve";
 
         // Need to resolve bodies in given file and all in the same package
@@ -154,7 +153,7 @@ public final class AnalyzerFacadeWithCache {
                 new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(),
                                            "trace to resolve bodies in file", file.getName()),
                 context,
-                moduleConfiguration);
+                analyzeExhaustHeaders.getModuleDescriptor());
     }
 
     @NotNull

idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java

@@ -22,7 +22,7 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.analyzer.AnalyzerFacade;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -59,9 +59,9 @@ public enum JSAnalyzerFacadeForIDEA implements AnalyzerFacade {
             @NotNull Predicate<PsiFile> filesForBodiesResolve,
             @NotNull BindingTrace traceContext,
             @NotNull BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration
+            @NotNull ModuleDescriptor module
     ) {
-        return AnalyzerFacadeForJS.analyzeBodiesInFiles(filesForBodiesResolve, new IDEAConfig(project), traceContext, bodiesResolveContext, configuration);
+        return AnalyzerFacadeForJS.analyzeBodiesInFiles(filesForBodiesResolve, new IDEAConfig(project), traceContext, bodiesResolveContext, module);
     }
 
     @NotNull

idea/src/org/jetbrains/jet/plugin/quickfix/MigrateSureInProjectFix.java

@@ -25,7 +25,6 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
@@ -155,7 +154,6 @@ public class MigrateSureInProjectFix extends JetIntentionAction<PsiElement> {
                 Predicates.<PsiFile>alwaysFalse());
 
         BodiesResolveContext context = analyzeExhaustHeaders.getBodiesResolveContext();
-        ModuleConfiguration moduleConfiguration = analyzeExhaustHeaders.getModuleConfiguration();
         assert context != null : "Headers resolver should prepare and stored information for bodies resolve";
 
         // Need to resolve bodies in given file and all in the same package
@@ -165,6 +163,6 @@ public class MigrateSureInProjectFix extends JetIntentionAction<PsiElement> {
                 Predicates.<PsiFile>alwaysTrue(),
                 new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace in migrate sure fix"),
                 context,
-                moduleConfiguration);
+                analyzeExhaustHeaders.getModuleDescriptor());
     }
 }

idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java

@@ -31,7 +31,6 @@ import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.HelpID;
 import com.intellij.refactoring.introduce.inplace.OccurrencesChooser;
-import com.intellij.refactoring.util.CommonRefactoringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
@@ -128,7 +127,7 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase {
             }
 
             ObservableBindingTrace bindingTrace = new ObservableBindingTrace(new BindingTraceContext());
-            InjectorForMacros injector = new InjectorForMacros(project, analyzeExhaust.getModuleConfiguration());
+            InjectorForMacros injector = new InjectorForMacros(project, analyzeExhaust.getModuleDescriptor());
             JetType typeNoExpectedType = injector.getExpressionTypingServices().getType(scope, expression,
                                                                                 TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
                                                                                 bindingTrace);

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -26,7 +26,6 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
@@ -61,7 +60,6 @@ public class InjectorForTopDownAnalyzerForJs {
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
-    private final ModuleConfiguration moduleConfiguration;
     private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
     private NamespaceFactoryImpl namespaceFactory;
     private DeclarationResolver declarationResolver;
@@ -85,8 +83,7 @@ public class InjectorForTopDownAnalyzerForJs {
         @NotNull Project project,
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl moduleDescriptor,
+        @NotNull ModuleDescriptorImpl moduleDescriptor
-        @NotNull ModuleConfiguration moduleConfiguration
     ) {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
@@ -98,7 +95,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
-        this.moduleConfiguration = moduleConfiguration;
         this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
         this.namespaceFactory = new NamespaceFactoryImpl();
         this.declarationResolver = new DeclarationResolver();
@@ -150,7 +146,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        namespaceFactory.setConfiguration(moduleConfiguration);
         namespaceFactory.setModuleDescriptor(moduleDescriptor);
         namespaceFactory.setTrace(bindingTrace);
 
@@ -182,14 +177,14 @@ public class InjectorForTopDownAnalyzerForJs {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleDescriptor(moduleDescriptor);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
 
-        importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleDescriptor(moduleDescriptor);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         importsResolver.setTrace(bindingTrace);
 
@@ -261,8 +256,8 @@ public class InjectorForTopDownAnalyzerForJs {
         return this.bindingTrace;
     }
     
-    public ModuleConfiguration getModuleConfiguration() {
+    public ModuleDescriptorImpl getModuleDescriptor() {
-        return this.moduleConfiguration;
+        return this.moduleDescriptor;
     }
     
 }

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

@@ -25,13 +25,13 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.k2js.config.Config;
@@ -87,10 +87,8 @@ public final class AnalyzerFacadeForJS {
         BindingTrace trace = libraryBindingContext == null ?
                              new ObservableBindingTrace(new BindingTraceContext()) :
                              new DelegatingBindingTrace(libraryBindingContext, "trace for analyzing library in js");
-        InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
+        owner.setModuleConfiguration(new JsConfiguration(libraryBindingContext));
-                project, topDownAnalysisParameters, trace, owner,
+        InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(project, topDownAnalysisParameters, trace, owner);
-                new JsConfiguration(libraryBindingContext));
-        owner.setModuleConfiguration(injector.getModuleConfiguration());
         try {
             Collection<JetFile> allFiles = libraryBindingContext != null ?
                                            files :
@@ -99,7 +97,7 @@ public final class AnalyzerFacadeForJS {
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
                                                         null;
-            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration());
+            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, owner);
         }
         finally {
             injector.destroy();
@@ -112,12 +110,12 @@ public final class AnalyzerFacadeForJS {
             @NotNull Config config,
             @NotNull BindingTrace traceContext,
             @NotNull BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration) {
+            @NotNull ModuleDescriptor module) {
         Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
 
         return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration(
                 config.getProject(), Collections.<AnalyzerScriptParameter>emptyList(), completely, traceContext, bodiesResolveContext,
-                configuration);
+                module);
     }
 
     public static void checkForErrors(@NotNull Collection<JetFile> allFiles, @NotNull BindingContext bindingContext) {
@@ -146,6 +144,6 @@ public final class AnalyzerFacadeForJS {
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
         ModuleDescriptorImpl lazyModule = new ModuleDescriptorImpl(Name.special("<lazy module>"));
         lazyModule.setModuleConfiguration(new JsConfiguration(null));
-        return new ResolveSession(config.getProject(), storageManager, lazyModule, lazyModule.getModuleConfiguration(), declarationProviderFactory);
+        return new ResolveSession(config.getProject(), storageManager, lazyModule, declarationProviderFactory);
     }
 }