Replace direct usages of TopDownLazyResolveForJava with facade

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

@@ -58,20 +58,32 @@ public enum TopDownAnalyzerFacadeForJVM {
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegration(
-            Project project,
+            @NotNull Project project,
-            Collection<JetFile> files,
+            @NotNull Collection<JetFile> files,
-            BindingTrace trace,
+            @NotNull BindingTrace trace,
-            Predicate<PsiFile> filesToAnalyzeCompletely,
+            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
-            ModuleDescriptorImpl module,
+            @NotNull ModuleDescriptorImpl module
+    ) {
+        return analyzeFilesWithJavaIntegration(project, files, trace, topDownAnalysisParameters, module, null, null);
+    }
+
+    @NotNull
+    public static AnalysisResult analyzeFilesWithJavaIntegration(
+            @NotNull Project project,
+            @NotNull Collection<JetFile> files,
+            @NotNull BindingTrace trace,
+            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
+            @NotNull ModuleDescriptorImpl module,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCacheProvider incrementalCacheProvider
     ) {
-        GlobalContext globalContext = ContextPackage.GlobalContext();
+        return analyzeFilesWithJavaIntegrationWithCustomContext(
-        return analyzeFilesWithJavaIntegrationWithCustomContext(project, globalContext, files, trace, filesToAnalyzeCompletely, module,
+                project, ContextPackage.GlobalContext(), files, trace,
-                                                                moduleIds,
+                filesToAnalyzeCompletely, module, moduleIds,
-                                                                incrementalCacheProvider);
+                incrementalCacheProvider);
     }
 
+    @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationWithCustomContext(
             @NotNull Project project,
             @NotNull GlobalContext globalContext,
@@ -90,6 +102,20 @@ public enum TopDownAnalyzerFacadeForJVM {
                 false
         );
 
+        return analyzeFilesWithJavaIntegration(
+                project, files, trace, topDownAnalysisParameters, module, moduleIds, incrementalCacheProvider);
+    }
+
+    @NotNull
+    private static AnalysisResult analyzeFilesWithJavaIntegration(
+            Project project,
+            Collection<JetFile> files,
+            BindingTrace trace,
+            TopDownAnalysisParameters topDownAnalysisParameters,
+            ModuleDescriptorImpl module,
+            @Nullable List<String> moduleIds,
+            @Nullable IncrementalCacheProvider incrementalCacheProvider
+    ) {
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
         try {
             List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
@@ -100,7 +126,7 @@ public enum TopDownAnalyzerFacadeForJVM {
 
                     additionalProviders.add(
                             new IncrementalPackageFragmentProvider(
-                                    files, module, globalContext.getStorageManager(), injector.getDeserializationGlobalContextForJava(),
+                                    files, module, topDownAnalysisParameters.getStorageManager(), injector.getDeserializationGlobalContextForJava(),
                                     incrementalCache, moduleId, injector.getJavaDescriptorResolver()
                             )
                     );

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

@@ -33,7 +33,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
@@ -43,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.storage.ExceptionTracker;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
@@ -157,15 +157,13 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 false,
                 false
         );
-        InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
-                environment.getProject(),
-                parameters,
-                trace,
-                module);
 
-        injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                parameters, environment.getSourceFiles(),
+                environment.getProject(),
-                injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider()
+                environment.getSourceFiles(),
+                trace,
+                parameters,
+                module
         );
 
         PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);

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

@@ -26,12 +26,12 @@ 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.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
 
@@ -54,10 +54,13 @@ public class LazyResolveTestUtil {
         BindingTrace sharedTrace = support.getTrace();
         ModuleDescriptorImpl sharedModule = support.newModule();
 
-        InjectorForTopDownAnalyzerForJvm injector =
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule);
+                environment.getProject(),
-        injector.getTopDownAnalyzer().analyzeFiles(params, files, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+                files, 
-        return injector.getModuleDescriptor();
+                sharedTrace,
+                params, sharedModule);
+
+        return sharedModule;
     }
 
     @NotNull