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,
-            @Nullable BodiesResolveContext bodiesResolveContext, @Nullable Throwable error) {
+    private AnalyzeExhaust(
+            @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) {
-        return new AnalyzeExhaust(bindingContext, null, null);
+    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleConfiguration configuration) {
+        return new AnalyzeExhaust(bindingContext, configuration, null, null);
     }
 
     public static AnalyzeExhaust success(@NotNull BindingContext bindingContext,
-            BodiesResolveContext bodiesResolveContext) {
-        return new AnalyzeExhaust(bindingContext, bodiesResolveContext, null);
+            @Nullable BodiesResolveContext bodiesResolveContext,
+            @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,
-                                @NotNull Collection<JetFile> files,
-                                @NotNull List<AnalyzerScriptParameter> scriptParameters,
-                                @NotNull Predicate<PsiFile> filesToAnalyzeCompletely);
+    AnalyzeExhaust analyzeFiles(
+            @NotNull Project project,
+            @NotNull Collection<JetFile> files,
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely
+    );
 
     @NotNull
-    AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project,
-                                        @NotNull List<AnalyzerScriptParameter> scriptParameters,
-                                        @NotNull Predicate<PsiFile> filesForBodiesResolve,
-                                        @NotNull BindingTrace traceContext,
-                                        @NotNull BodiesResolveContext bodiesResolveContext);
+    AnalyzeExhaust analyzeBodiesInFiles(
+            @NotNull Project project,
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Predicate<PsiFile> filesForBodiesResolve,
+            @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);