add ModuleConfiguration to injectors

(to be able to use it in TypeResolver)

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

@@ -235,7 +235,7 @@ public class ReplInterpreter {
         }
 
         GenerationState generationState = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), backendProgress,
-                AnalyzeExhaust.success(trace.getBindingContext()), Collections.singletonList(psiFile),
+                AnalyzeExhaust.success(trace.getBindingContext(), injector.getModuleConfiguration()), Collections.singletonList(psiFile),
                 BuiltinToJavaTypesMapping.ENABLED);
         generationState.getScriptCodegen().compileScript(psiFile.getScript(), scriptClassName, earierScripts,
                                                          CompilationErrorHandler.THROW_EXCEPTION);

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

@@ -197,6 +197,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
+        typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         importsResolver.setConfiguration(moduleConfiguration);

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

@@ -26,6 +26,7 @@ import org.jetbrains.jet.analyzer.AnalyzerFacade;
 import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
+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.*;
@@ -61,11 +62,12 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                                                @NotNull List<AnalyzerScriptParameter> scriptParameters,
                                                @NotNull Predicate<PsiFile> filesForBodiesResolve,
                                                @NotNull BindingTrace headersTraceContext,
-                                               @NotNull BodiesResolveContext bodiesResolveContext
+                                               @NotNull BodiesResolveContext bodiesResolveContext,
+                                               @NotNull ModuleConfiguration configuration
     ) {
         return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration(
                 project, scriptParameters, filesForBodiesResolve,
-                headersTraceContext, bodiesResolveContext);
+                headersTraceContext, bodiesResolveContext, configuration);
     }
 
     public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(
@@ -126,7 +128,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
                                                         null;
-            return AnalyzeExhaust.success(bindingTraceContext.getBindingContext(), bodiesResolveContext);
+            return AnalyzeExhaust.success(bindingTraceContext.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration());
         } finally {
             injector.destroy();
         }

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

@@ -18,39 +18,50 @@ 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.NamespaceDescriptor;
+import org.jetbrains.jet.lang.psi.JetImportDirective;
 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.types.lang.JetStandardLibrary;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+import java.util.Collection;
 
 /**
  * @author Stepan Koltsov
  */
 public class AnalyzeExhaust {
-    @NotNull
     private final BindingContext bindingContext;
     private final Throwable error;
-
-    @Nullable
     private final BodiesResolveContext bodiesResolveContext;
+    private final ModuleConfiguration configuration;
 
-    private AnalyzeExhaust(@NotNull BindingContext bindingContext,
+    private AnalyzeExhaust(
-            @Nullable BodiesResolveContext bodiesResolveContext, @Nullable Throwable error) {
+            @NotNull BindingContext bindingContext,
+            @NotNull ModuleConfiguration configuration,
+            @Nullable BodiesResolveContext bodiesResolveContext,
+            @Nullable Throwable error
+    ) {
         this.bindingContext = bindingContext;
         this.error = error;
         this.bodiesResolveContext = bodiesResolveContext;
+        this.configuration = configuration;
     }
 
-    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext) {
+    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleConfiguration configuration) {
-        return new AnalyzeExhaust(bindingContext, null, null);
+        return new AnalyzeExhaust(bindingContext, configuration, null, null);
     }
 
     public static AnalyzeExhaust success(@NotNull BindingContext bindingContext,
-            BodiesResolveContext bodiesResolveContext) {
+            @Nullable BodiesResolveContext bodiesResolveContext,
-        return new AnalyzeExhaust(bindingContext, bodiesResolveContext, null);
+            @NotNull ModuleConfiguration configuration
+    ) {
+        return new AnalyzeExhaust(bindingContext, configuration, bodiesResolveContext, null);
     }
 
     public static AnalyzeExhaust error(@NotNull BindingContext bindingContext, @NotNull Throwable error) {
-        return new AnalyzeExhaust(bindingContext, null, error);
+        return new AnalyzeExhaust(bindingContext, ModuleConfiguration.EMPTY, null, error);
     }
 
     @Nullable
@@ -77,4 +88,9 @@ public class AnalyzeExhaust {
             throw new IllegalStateException("failed to analyze: " + error, error);
         }
     }
+
+    @NotNull
+    public ModuleConfiguration getModuleConfiguration() {
+        return configuration;
+    }
 }

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

@@ -20,6 +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.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -34,15 +35,20 @@ import java.util.List;
 public interface AnalyzerFacade {
 
     @NotNull
-    AnalyzeExhaust analyzeFiles(@NotNull Project project,
+    AnalyzeExhaust analyzeFiles(
-                                @NotNull Collection<JetFile> files,
+            @NotNull Project project,
-                                @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Collection<JetFile> files,
-                                @NotNull Predicate<PsiFile> filesToAnalyzeCompletely);
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely
+    );
 
     @NotNull
-    AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project,
+    AnalyzeExhaust analyzeBodiesInFiles(
-                                        @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Project project,
-                                        @NotNull Predicate<PsiFile> filesForBodiesResolve,
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
-                                        @NotNull BindingTrace traceContext,
+            @NotNull Predicate<PsiFile> filesForBodiesResolve,
-                                        @NotNull BodiesResolveContext bodiesResolveContext);
+            @NotNull BindingTrace traceContext,
+            @NotNull BodiesResolveContext bodiesResolveContext,
+            @NotNull ModuleConfiguration configuration
+    );
 }

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

@@ -21,6 +21,7 @@ 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.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
@@ -40,7 +41,8 @@ public class AnalyzerFacadeForEverything {
     public static AnalyzeExhaust analyzeBodiesInFilesWithJavaIntegration(
             Project project, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
             @NotNull BindingTrace traceContext,
-            @NotNull BodiesResolveContext bodiesResolveContext) {
+            @NotNull BodiesResolveContext bodiesResolveContext,
+            @NotNull ModuleConfiguration configuration) {
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, scriptParameters);
@@ -50,11 +52,11 @@ public class AnalyzerFacadeForEverything {
         InjectorForBodyResolve injector = new InjectorForBodyResolve(
                 project, topDownAnalysisParameters,
                 new ObservableBindingTrace(traceContext),
-                bodiesResolveContext);
+                bodiesResolveContext, configuration);
 
         try {
             injector.getBodyResolver().resolveBodies();
-            return AnalyzeExhaust.success(traceContext.getBindingContext());
+            return AnalyzeExhaust.success(traceContext.getBindingContext(), configuration);
         } finally {
             injector.destroy();
         }

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

@@ -22,6 +22,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.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -44,6 +45,7 @@ public class InjectorForBodyResolve {
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
     private final BodiesResolveContext bodiesResolveContext;
+    private final ModuleConfiguration moduleConfiguration;
     private CallResolver callResolver;
     private DescriptorResolver descriptorResolver;
     private AnnotationResolver annotationResolver;
@@ -60,13 +62,15 @@ public class InjectorForBodyResolve {
         @NotNull Project project,
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
-        @NotNull BodiesResolveContext bodiesResolveContext
+        @NotNull BodiesResolveContext bodiesResolveContext,
+        @NotNull ModuleConfiguration moduleConfiguration
     ) {
         this.bodyResolver = new BodyResolver();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.bodiesResolveContext = bodiesResolveContext;
+        this.moduleConfiguration = moduleConfiguration;
         this.callResolver = new CallResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.annotationResolver = new AnnotationResolver();
@@ -108,6 +112,7 @@ public class InjectorForBodyResolve {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
+        typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);

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

@@ -20,6 +20,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.resolve.BindingTrace;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
@@ -37,6 +38,7 @@ public class InjectorForLazyResolve {
     private final Project project;
     private final ResolveSession resolveSession;
     private final BindingTrace bindingTrace;
+    private final ModuleConfiguration moduleConfiguration;
     private DescriptorResolver descriptorResolver;
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
@@ -49,11 +51,13 @@ public class InjectorForLazyResolve {
     public InjectorForLazyResolve(
         @NotNull Project project,
         @NotNull ResolveSession resolveSession,
-        @NotNull BindingTrace bindingTrace
+        @NotNull BindingTrace bindingTrace,
+        @NotNull ModuleConfiguration moduleConfiguration
     ) {
         this.project = project;
         this.resolveSession = resolveSession;
         this.bindingTrace = bindingTrace;
+        this.moduleConfiguration = moduleConfiguration;
         this.descriptorResolver = new DescriptorResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
@@ -74,6 +78,7 @@ public class InjectorForLazyResolve {
 
         this.typeResolver.setAnnotationResolver(annotationResolver);
         this.typeResolver.setDescriptorResolver(descriptorResolver);
+        this.typeResolver.setModuleConfiguration(moduleConfiguration);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         this.annotationResolver.setCallResolver(callResolver);

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

@@ -19,6 +19,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.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -33,6 +34,7 @@ public class InjectorForMacros {
 
     private ExpressionTypingServices expressionTypingServices;
     private final Project project;
+    private final ModuleConfiguration moduleConfiguration;
     private CallResolver callResolver;
     private DescriptorResolver descriptorResolver;
     private AnnotationResolver annotationResolver;
@@ -41,10 +43,12 @@ public class InjectorForMacros {
     private OverloadingConflictResolver overloadingConflictResolver;
 
     public InjectorForMacros(
-        @NotNull Project project
+        @NotNull Project project,
+        @NotNull ModuleConfiguration moduleConfiguration
     ) {
         this.expressionTypingServices = new ExpressionTypingServices();
         this.project = project;
+        this.moduleConfiguration = moduleConfiguration;
         this.callResolver = new CallResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.annotationResolver = new AnnotationResolver();
@@ -71,6 +75,7 @@ public class InjectorForMacros {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
+        typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
     }

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

@@ -168,6 +168,7 @@ public class InjectorForTopDownAnalyzerBasic {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
+        typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         importsResolver.setConfiguration(moduleConfiguration);

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

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve;
 
 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.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
@@ -47,6 +48,7 @@ public class TypeResolver {
     private AnnotationResolver annotationResolver;
     private DescriptorResolver descriptorResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private ModuleConfiguration moduleConfiguration;
 
     @Inject
     public void setDescriptorResolver(DescriptorResolver descriptorResolver) {
@@ -63,6 +65,11 @@ public class TypeResolver {
         this.qualifiedExpressionResolver = qualifiedExpressionResolver;
     }
 
+    @Inject
+    public void setModuleConfiguration(@NotNull ModuleConfiguration moduleConfiguration) {
+        this.moduleConfiguration = moduleConfiguration;
+    }
+
     @NotNull
     public JetType resolveType(@NotNull final JetScope scope, @NotNull final JetTypeReference typeReference, BindingTrace trace, boolean checkBounds) {
         JetType cachedType = trace.getBindingContext().get(BindingContext.TYPE, typeReference);

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

@@ -85,7 +85,7 @@ public class ResolveSession {
     ) {
         this.classifierAliases = classifierAliases;
         this.specialClasses = specialClasses;
-        this.injector = new InjectorForLazyResolve(project, this, trace);
+        this.injector = new InjectorForLazyResolve(project, this, trace, moduleConfiguration);
         this.module = rootDescriptor;
         this.moduleConfiguration = moduleConfiguration;
         PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT);

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

@@ -22,6 +22,7 @@ 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.JetStandardLibrary;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
@@ -37,6 +38,7 @@ public class InjectorForTests {
     private TypeResolver typeResolver;
     private CallResolver callResolver;
     private JetStandardLibrary jetStandardLibrary;
+    private ModuleConfiguration moduleConfiguration;
     private final Project project;
     private AnnotationResolver annotationResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
@@ -50,6 +52,7 @@ public class InjectorForTests {
         this.typeResolver = new TypeResolver();
         this.callResolver = new CallResolver();
         this.jetStandardLibrary = JetStandardLibrary.getInstance();
+        this.moduleConfiguration = ModuleConfiguration.EMPTY;
         this.project = project;
         this.annotationResolver = new AnnotationResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -66,6 +69,7 @@ public class InjectorForTests {
 
         this.typeResolver.setAnnotationResolver(annotationResolver);
         this.typeResolver.setDescriptorResolver(descriptorResolver);
+        this.typeResolver.setModuleConfiguration(moduleConfiguration);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         this.callResolver.setDescriptorResolver(descriptorResolver);

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

@@ -29,6 +29,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiNamedElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.TipsManager;
 import org.jetbrains.jet.di.InjectorForMacros;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
@@ -63,13 +64,14 @@ public abstract class BaseJetVariableMacro extends Macro {
         JetExpression contextExpression = findContextExpression(psiFile, context.getStartOffset());
         if (contextExpression == null) return null;
 
-        BindingContext bc = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) psiFile).getBindingContext();
+        AnalyzeExhaust analyzeExhaust = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) psiFile);
+        BindingContext bc = analyzeExhaust.getBindingContext();
         JetScope scope = bc.get(BindingContext.RESOLUTION_SCOPE, contextExpression);
         if (scope == null) {
             return null;
         }
 
-        ExpressionTypingServices callResolverContext = new InjectorForMacros(project).getExpressionTypingServices();
+        ExpressionTypingServices callResolverContext = new InjectorForMacros(project, analyzeExhaust.getModuleConfiguration()).getExpressionTypingServices();
 
         List<VariableDescriptor> filteredDescriptors = new ArrayList<VariableDescriptor>();
         for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {

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

@@ -22,6 +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.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -43,20 +44,25 @@ public enum JSAnalyzerFacadeForIDEA implements AnalyzerFacade {
 
     @NotNull
     @Override
-    public AnalyzeExhaust analyzeFiles(@NotNull Project project,
+    public AnalyzeExhaust analyzeFiles(
-                                       @NotNull Collection<JetFile> files,
+            @NotNull Project project,
-                                       @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Collection<JetFile> files,
-                                       @NotNull Predicate<PsiFile> filesToAnalyzeCompletely) {
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely
+    ) {
         return AnalyzerFacadeForJS.analyzeFiles(files, filesToAnalyzeCompletely, new IDEAConfig(project), true);
     }
 
     @NotNull
     @Override
-    public AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project,
+    public AnalyzeExhaust analyzeBodiesInFiles(
-                                               @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Project project,
-                                               @NotNull Predicate<PsiFile> filesForBodiesResolve,
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
-                                               @NotNull BindingTrace traceContext,
+            @NotNull Predicate<PsiFile> filesForBodiesResolve,
-                                               @NotNull BodiesResolveContext bodiesResolveContext) {
+            @NotNull BindingTrace traceContext,
-        return AnalyzerFacadeForJS.analyzeBodiesInFiles(filesForBodiesResolve, new IDEAConfig(project), traceContext, bodiesResolveContext);
+            @NotNull BodiesResolveContext bodiesResolveContext,
+            @NotNull ModuleConfiguration configuration
+    ) {
+        return AnalyzerFacadeForJS.analyzeBodiesInFiles(filesForBodiesResolve, new IDEAConfig(project), traceContext, bodiesResolveContext, configuration);
     }
 }

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

@@ -34,6 +34,7 @@ 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;
 import org.jetbrains.jet.di.InjectorForMacros;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
@@ -113,7 +114,8 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase {
                 return;
             }
         }
-        BindingContext bindingContext = AnalyzeSingleFileUtil.getContextForSingleFile((JetFile)expression.getContainingFile());
+        AnalyzeExhaust analyzeExhaust = AnalyzeSingleFileUtil.analyzeSingleFileWithCache((JetFile) expression.getContainingFile());
+        BindingContext bindingContext = analyzeExhaust.getBindingContext();
         final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); //can be null or error type
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (scope != null) {
@@ -123,7 +125,7 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase {
             }
 
             ObservableBindingTrace bindingTrace = new ObservableBindingTrace(new BindingTraceContext());
-            InjectorForMacros injector = new InjectorForMacros(project);
+            InjectorForMacros injector = new InjectorForMacros(project, analyzeExhaust.getModuleConfiguration());
             JetType typeNoExpectedType = injector.getExpressionTypingServices().getType(scope, expression,
                                                                                 TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
                                                                                 bindingTrace);

injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java

@@ -67,6 +67,7 @@ public class AllInjectorsGenerator {
         generator.addParameter(Project.class);
         generator.addParameter(ResolveSession.class);
         generator.addParameter(BindingTrace.class);
+        generator.addParameter(ModuleConfiguration.class);
         generator.addPublicField(DescriptorResolver.class);
         generator.addPublicField(ExpressionTypingServices.class);
         generator.addPublicField(TypeResolver.class);
@@ -88,7 +89,7 @@ public class AllInjectorsGenerator {
     private static void generateInjectorForTopDownAnalyzerForJs() throws IOException {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
         generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addParameter(ModuleConfiguration.class);
+        generator.addPublicParameter(ModuleConfiguration.class);
         generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class);
         generator.addField(NamespaceFactoryImpl.class);
         generator.generate("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs");
@@ -148,6 +149,7 @@ public class AllInjectorsGenerator {
 
         // Parameters
         generator.addPublicParameter(Project.class);
+        generator.addParameter(ModuleConfiguration.class);
 
         generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros");
     }
@@ -161,6 +163,7 @@ public class AllInjectorsGenerator {
         generator.addPublicField(TypeResolver.class);
         generator.addPublicField(CallResolver.class);
         generator.addField(true, JetStandardLibrary.class, null, new GivenExpression("JetStandardLibrary.getInstance()"));
+        generator.addField(false, ModuleConfiguration.class, null, new GivenExpression("ModuleConfiguration.EMPTY"));
 
         // Parameters
         generator.addPublicParameter(Project.class);
@@ -226,6 +229,7 @@ public class AllInjectorsGenerator {
         generator.addPublicParameter(TopDownAnalysisParameters.class);
         generator.addPublicParameter(BindingTrace.class);
         generator.addPublicParameter(BodiesResolveContext.class);
+        generator.addParameter(ModuleConfiguration.class);
         generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve");
     }
 }

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

@@ -168,6 +168,7 @@ public class InjectorForTopDownAnalyzerForJs {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
+        typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         importsResolver.setConfiguration(moduleConfiguration);
@@ -241,4 +242,8 @@ public class InjectorForTopDownAnalyzerForJs {
         return this.bindingTrace;
     }
 
+    public ModuleConfiguration getModuleConfiguration() {
+        return this.moduleConfiguration;
+    }
+
 }

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

@@ -25,6 +25,7 @@ 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.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
@@ -96,7 +97,7 @@ public final class AnalyzerFacadeForJS {
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
                                                         null;
-            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext);
+            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration());
         }
         finally {
             injector.destroy();
@@ -108,11 +109,13 @@ public final class AnalyzerFacadeForJS {
             @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
             @NotNull Config config,
             @NotNull BindingTrace traceContext,
-            @NotNull BodiesResolveContext bodiesResolveContext) {
+            @NotNull BodiesResolveContext bodiesResolveContext,
+            @NotNull ModuleConfiguration configuration) {
         Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
 
         return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration(
-                config.getProject(), Collections.<AnalyzerScriptParameter>emptyList(), completely, traceContext, bodiesResolveContext);
+                config.getProject(), Collections.<AnalyzerScriptParameter>emptyList(), completely, traceContext, bodiesResolveContext,
+                configuration);
     }
 
     public static void checkForErrors(@NotNull Collection<JetFile> allFiles, @NotNull BindingContext bindingContext) {