Do not inject TopDownAnalysisParameters into TopDownAnalyzer

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

@@ -178,7 +178,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 

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

@@ -229,7 +229,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
         try {
             module.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
-            TopDownAnalysisContext topDownAnalysisContext = injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters);
+            TopDownAnalysisContext topDownAnalysisContext = injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, scriptParameters);
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(topDownAnalysisContext) :
                                                         null;

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

@@ -145,7 +145,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 

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

@@ -53,8 +53,6 @@ public class TopDownAnalyzer {
     @NotNull
     private OverloadResolver overloadResolver;
     @NotNull
-    private TopDownAnalysisParameters topDownAnalysisParameters;
-    @NotNull
     private BindingTrace trace;
     @NotNull
     private ModuleDescriptor moduleDescriptor;
@@ -83,11 +81,6 @@ public class TopDownAnalyzer {
         this.overloadResolver = overloadResolver;
     }
 
-    @Inject
-    public void setTopDownAnalysisParameters(@NotNull TopDownAnalysisParameters topDownAnalysisParameters) {
-        this.topDownAnalysisParameters = topDownAnalysisParameters;
-    }
-
     @Inject
     public void setTrace(@NotNull BindingTrace trace) {
         this.trace = trace;
@@ -125,7 +118,7 @@ public class TopDownAnalyzer {
 
         overloadResolver.process(c);
 
-        if (!topDownAnalysisParameters.isAnalyzingBootstrapLibrary()) {
+        if (!c.getTopDownAnalysisParameters().isAnalyzingBootstrapLibrary()) {
             bodyResolver.resolveBodies(c);
         }
 
@@ -218,6 +211,7 @@ public class TopDownAnalyzer {
 
     @NotNull
     public TopDownAnalysisContext analyzeFiles(
+            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
             @NotNull Collection<JetFile> files,
             @NotNull List<AnalyzerScriptParameter> scriptParameters) {
         ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider);

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

@@ -140,22 +140,23 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         BindingTrace trace = support.getTrace();
         ModuleDescriptorImpl module = support.getModule();
 
+        TopDownAnalysisParameters parameters = new TopDownAnalysisParameters(
+                new LockBasedStorageManager(),
+                new ExceptionTracker(), // dummy
+                Predicates.<PsiFile>alwaysFalse(),
+                false,
+                false,
+                Collections.<AnalyzerScriptParameter>emptyList()
+        );
         InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
                 environment.getProject(),
-                new TopDownAnalysisParameters(
+                parameters,
-                        new LockBasedStorageManager(),
-                        new ExceptionTracker(), // dummy
-                        Predicates.<PsiFile>alwaysFalse(),
-                        false,
-                        false,
-                        Collections.<AnalyzerScriptParameter>emptyList()
-                ),
                 trace,
                 module);
 
         module.addFragmentProvider(DependencyKind.BINARIES, injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider());
 
-        injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList());
+        injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(parameters, environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList());
 
         PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
         assert packageView != null : "Test package not found";

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

@@ -26,7 +26,6 @@ import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContextImpl;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -49,7 +48,7 @@ public class LazyResolveTestUtil {
     private LazyResolveTestUtil() {
     }
 
-    public static InjectorForTopDownAnalyzer createInjectorForTDA(JetCoreEnvironment environment) {
+    public static ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
         JetTestUtils.newTrace(environment);
 
         GlobalContextImpl globalContext = ContextPackage.GlobalContext();
@@ -62,12 +61,7 @@ public class LazyResolveTestUtil {
         InjectorForTopDownAnalyzerForJvm injector =
                 new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule);
         sharedModule.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
-        return injector;
+        injector.getTopDownAnalyzer().analyzeFiles(params, files, Collections.<AnalyzerScriptParameter>emptyList());
-    }
-
-    public static ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
-        InjectorForTopDownAnalyzer injector = createInjectorForTDA(environment);
-        injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
         return injector.getModuleDescriptor();
     }
 

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

@@ -97,7 +97,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                         myProject, topDownAnalysisParameters, trace, module);
 
                 TopDownAnalyzer analyzer = injector.getTopDownAnalyzer();
-                analyzer.analyzeFiles(jetBuiltInsFiles, Collections.<AnalyzerScriptParameter>emptyList());
+                analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles, Collections.<AnalyzerScriptParameter>emptyList());
 
                 builtinsPackageFragment = analyzer.getPackageFragmentProvider().getOrCreateFragment(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);
                 builtInsSources = Sets.newHashSet(jetBuiltInsFiles);

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

@@ -145,7 +145,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
-        this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 

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

@@ -109,7 +109,7 @@ public final class AnalyzerFacadeForJS {
                                            files :
                                            Config.withJsLibAdded(files, config);
             TopDownAnalysisContext topDownAnalysisContext =
-                    injector.getTopDownAnalyzer().analyzeFiles(allFiles, Collections.<AnalyzerScriptParameter>emptyList());
+                    injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, allFiles, Collections.<AnalyzerScriptParameter>emptyList());
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(topDownAnalysisContext) :
                                                         null;