JvmResolveUtil extracted for methods that are used only for tests

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

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.base.Predicate;
-import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableList;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
@@ -42,7 +41,6 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 
 public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
@@ -117,76 +115,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         return new JvmSetup(resolveWithJava.getResolveSession(), resolveWithJava.getJavaDescriptorResolver());
     }
 
-    @NotNull
-    public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(JetFile file) {
-        AnalyzingUtils.checkForSyntacticErrors(file);
-
-        AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file);
-
-        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
-
-        return analyzeExhaust;
-    }
-
-    @NotNull
-    public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(JetFile file) {
-        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file),
-                                               Predicates.<PsiFile>alwaysTrue());
-    }
-
-    @NotNull
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegrationAndCheckForErrors(
-            Project project,
-            Collection<JetFile> files,
-            Predicate<PsiFile> filesToAnalyzeCompletely
-    ) {
-        for (JetFile file : files) {
-            AnalyzingUtils.checkForSyntacticErrors(file);
-        }
-
-        AnalyzeExhaust analyzeExhaust = analyzeFilesWithJavaIntegration(
-                project, files, filesToAnalyzeCompletely, false);
-
-        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
-
-        return analyzeExhaust;
-    }
-
-    @NotNull
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project,
-            Collection<JetFile> files,
-            Predicate<PsiFile> filesToAnalyzeCompletely
-    ) {
-        return analyzeFilesWithJavaIntegration(
-                project, files, filesToAnalyzeCompletely, false);
-    }
-
-    @NotNull
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project,
-            Collection<JetFile> files,
-            Predicate<PsiFile> filesToAnalyzeCompletely,
-            boolean storeContextForBodiesResolve
-    ) {
-        BindingTraceContext bindingTraceContext = new BindingTraceContext();
-
-        return analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, filesToAnalyzeCompletely,
-                                               storeContextForBodiesResolve);
-    }
-
-    @NotNull
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project,
-            Collection<JetFile> files,
-            BindingTrace trace,
-            Predicate<PsiFile> filesToAnalyzeCompletely,
-            boolean storeContextForBodiesResolve
-    ) {
-        return analyzeFilesWithJavaIntegration(project, files, trace, filesToAnalyzeCompletely,
-                                               storeContextForBodiesResolve, createJavaModule("<module>"), MemberFilter.ALWAYS_TRUE);
-    }
-
     @NotNull
     public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
             Project project,
@@ -198,21 +126,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             MemberFilter memberFilter
     ) {
         GlobalContext globalContext = ContextPackage.GlobalContext();
-        return analyzeFilesWithJavaIntegrationInGlobalContext(project, files, trace, filesToAnalyzeCompletely,
-                                                              storeContextForBodiesResolve, module, globalContext, memberFilter);
-    }
-
-    @NotNull
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegrationInGlobalContext(
-            Project project,
-            Collection<JetFile> files,
-            BindingTrace trace,
-            Predicate<PsiFile> filesToAnalyzeCompletely,
-            boolean storeContextForBodiesResolve,
-            ModuleDescriptorImpl module,
-            GlobalContext globalContext,
-            MemberFilter memberFilter
-    ) {
         TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(
                 globalContext.getStorageManager(),
                 globalContext.getExceptionTracker(),

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

@@ -61,6 +61,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -226,14 +227,14 @@ public class JetTestUtils {
 
     @NotNull
     public static AnalyzeExhaust analyzeFile(@NotNull JetFile file) {
-        return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file);
+        return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file);
     }
 
     @NotNull
     public static AnalyzeExhaust analyzeFileWithoutBody(@NotNull JetFile file) {
-        return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(file.getProject(),
-                                                                    Collections.singleton(file),
-                                                                    Predicates.<PsiFile>alwaysFalse());
+        return JvmResolveUtil.analyzeFilesWithJavaIntegration(file.getProject(),
+                                                              Collections.singleton(file),
+                                                              Predicates.<PsiFile>alwaysFalse());
     }
 
     @NotNull

compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java

@@ -25,7 +25,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 
 import java.util.Collections;
 import java.util.List;
@@ -107,7 +107,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
         }
 
         public void test(@NotNull PsiFile psiFile) {
-            BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
+            BindingContext bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(
                     (JetFile) psiFile)
                     .getBindingContext();
 

compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java

@@ -31,7 +31,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.Progress;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.utils.UtilsPackage;
 
 import java.io.File;
@@ -49,7 +49,7 @@ public class CodegenTestUtil {
 
     @NotNull
     public static ClassFileFactory generateFiles(@NotNull JetCoreEnvironment environment, @NotNull CodegenTestFiles files) {
-        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationAndCheckForErrors(
+        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
                 environment.getProject(),
                 files.getPsiFiles(),
                 Predicates.<PsiFile>alwaysTrue());

compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java

@@ -24,7 +24,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 
 import java.util.Collections;
 import java.util.List;
@@ -41,14 +41,14 @@ public class GenerationUtils {
 
     @NotNull
     public static GenerationState compileFileGetGenerationStateForTest(@NotNull JetFile psiFile) {
-        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
+        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
                 psiFile);
         return compileFilesGetGenerationState(psiFile.getProject(), analyzeExhaust, Collections.singletonList(psiFile));
     }
 
     @NotNull
     public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files) {
-        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationAndCheckForErrors(
+        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
                 project, files, Predicates.<PsiFile>alwaysTrue());
         return compileFilesGetGenerationState(project,analyzeExhaust, files);
     }

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

@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.jetbrains.jet.test.util.DescriptorValidator;
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
@@ -82,7 +82,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
     private PackageViewDescriptor analyzeFileToPackageView(@NotNull File... extraClassPath) throws IOException {
         Project project = createEnvironment(Arrays.asList(extraClassPath)).getProject();
 
-        AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
+        AnalyzeExhaust exhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration(
                 JetTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt"))
         );
 
@@ -174,7 +174,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
 
         Project project = createEnvironment(Collections.singletonList(tmpdir)).getProject();
 
-        AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
+        AnalyzeExhaust exhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration(
                 JetTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt"))
         );
         exhaust.throwIfError();

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

@@ -41,7 +41,7 @@ import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -154,7 +154,7 @@ public final class LoadDescriptorUtil {
                     }
                 }
             });
-            AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
+            AnalyzeExhaust exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(
                     jetCoreEnvironment.getProject(), jetFiles, Predicates.<PsiFile>alwaysTrue());
             return new JetFilesAndExhaust(jetFiles, exhaust);
         }

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

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.lazy;
+
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class JvmResolveUtil {
+    @NotNull
+    public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(JetFile file) {
+        AnalyzingUtils.checkForSyntacticErrors(file);
+
+        AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file);
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+
+        return analyzeExhaust;
+    }
+
+    @NotNull
+    public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(JetFile file) {
+        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file),
+                                               Predicates.<PsiFile>alwaysTrue());
+    }
+
+    @NotNull
+    public static AnalyzeExhaust analyzeFilesWithJavaIntegrationAndCheckForErrors(
+            Project project,
+            Collection<JetFile> files,
+            Predicate<PsiFile> filesToAnalyzeCompletely
+    ) {
+        for (JetFile file : files) {
+            AnalyzingUtils.checkForSyntacticErrors(file);
+        }
+
+        AnalyzeExhaust analyzeExhaust = analyzeFilesWithJavaIntegration(
+                project, files, filesToAnalyzeCompletely, false);
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+
+        return analyzeExhaust;
+    }
+
+    @NotNull
+    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
+            Project project,
+            Collection<JetFile> files,
+            Predicate<PsiFile> filesToAnalyzeCompletely
+    ) {
+        return analyzeFilesWithJavaIntegration(
+                project, files, filesToAnalyzeCompletely, false);
+    }
+
+    @NotNull
+    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
+            Project project,
+            Collection<JetFile> files,
+            Predicate<PsiFile> filesToAnalyzeCompletely,
+            boolean storeContextForBodiesResolve
+    ) {
+        BindingTraceContext bindingTraceContext = new BindingTraceContext();
+
+        return analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, filesToAnalyzeCompletely,
+                                               storeContextForBodiesResolve);
+    }
+
+    @NotNull
+    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
+            Project project,
+            Collection<JetFile> files,
+            BindingTrace trace,
+            Predicate<PsiFile> filesToAnalyzeCompletely,
+            boolean storeContextForBodiesResolve
+    ) {
+        return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, trace, filesToAnalyzeCompletely,
+                                                                    storeContextForBodiesResolve,
+                                                                    AnalyzerFacadeForJVM.createJavaModule("<module>"),
+                                                                    MemberFilter.ALWAYS_TRUE);
+    }
+}

compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java

@@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.io.IOException;
@@ -91,7 +91,7 @@ public class DescriptorRendererTest extends JetLiteFixture {
         String fileName = getTestName(false) + ".kt";
         JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
         AnalyzeExhaust analyzeExhaust =
-                AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile);
+                JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile);
         final BindingContext bindingContext = analyzeExhaust.getBindingContext();
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
 

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

@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.ErrorUtils;
@@ -145,7 +145,7 @@ public abstract class ExpectedResolveData {
         }
 
         Project project = files.iterator().next().getProject();
-        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
+        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(
                 project, files, Predicates.<PsiFile>alwaysTrue());
         return analyzeExhaust.getBindingContext();
     }

compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt

@@ -25,16 +25,15 @@ import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall
 import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM
 import org.jetbrains.jet.lang.resolve.scopes.receivers.AbstractReceiverValue
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue
 
 import java.io.File
-import java.util.Collections
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil
 
 public abstract class AbstractResolvedCallsTest() : JetLiteFixture() {
     override fun createEnvironment(): JetCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY)
@@ -51,7 +50,7 @@ public abstract class AbstractResolvedCallsTest() : JetLiteFixture() {
 
         fun analyzeFileAndGetResolvedCallEntries(): Map<JetElement, ResolvedCall<*>> {
             val psiFile = JetTestUtils.loadJetFile(getProject(), file)
-            val analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile)
+            val analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile)
             val bindingContext = analyzeExhaust.getBindingContext()
             return bindingContext.getSliceContents(BindingContext.RESOLVED_CALL)
         }

compiler/tests/org/jetbrains/jet/resolve/constraintSystem/AbstractConstraintSystemTest.kt

@@ -16,43 +16,25 @@
 
 package org.jetbrains.jet.resolve.constraintSystem
 
-import com.google.common.collect.ImmutableMap
-import com.google.common.collect.Maps
-import com.intellij.psi.PsiElement
 import org.jetbrains.jet.ConfigurationKind
 import org.jetbrains.jet.JetLiteFixture
 import org.jetbrains.jet.JetTestUtils
-import org.jetbrains.jet.analyzer.AnalyzeExhaust
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment
 import org.jetbrains.jet.di.InjectorForTests
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
-import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
-import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory
 import org.jetbrains.jet.lang.diagnostics.rendering.Renderers
-import org.jetbrains.jet.lang.psi.*
 import org.jetbrains.jet.lang.resolve.*
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystemImpl
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.types.Variance
-import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import java.io.File
-import java.io.IOException
-import java.util.Collections
-import com.intellij.openapi.project.Project
-import java.util.HashMap
 import java.util.regex.Pattern
 import org.jetbrains.jet.resolve.constraintSystem.AbstractConstraintSystemTest.MyConstraintKind
 import org.jetbrains.jet.resolve.constraintSystem.AbstractConstraintSystemTest.MyConstraint
 import java.util.ArrayList
-import kotlin.test.assertEquals
-import org.junit.Assert
 import java.util.LinkedHashMap
 import kotlin.properties.Delegates
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil
 
 abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     private val typePattern = """([\w|<|>|\(|\)]+)"""
@@ -82,7 +64,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
         val fileName = "declarations/declarations.kt"
 
         val psiFile = createPsiFile(null, fileName, loadFile(fileName))
-        val analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile)
+        val analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile)
         val bindingContext = analyzeExhaust.getBindingContext()
         return MyDeclarations(bindingContext, getProject(), typeResolver)
     }

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

@@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
@@ -84,7 +84,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             List<JetDeclaration> declarations = file.getDeclarations();
             JetDeclaration aClass = declarations.get(0);
             assert aClass instanceof JetClass;
-            AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file
+            AnalyzeExhaust bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(file
             );
             DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
             WritableScopeImpl scope = new WritableScopeImpl(

idea/tests/org/jetbrains/jet/plugin/highlighter/AbstractDiagnosticMessageTest.java

@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
 import java.io.File;
@@ -80,7 +80,7 @@ public abstract class AbstractDiagnosticMessageTest extends JetLiteFixture {
         MessageType messageType = getMessageTypeDirective(directives);
 
         JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
-        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile);
+        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile);
         BindingContext bindingContext = analyzeExhaust.getBindingContext();
 
         List<Diagnostic> diagnostics = ContainerUtil.filter(bindingContext.getDiagnostics().all(), new Condition<Diagnostic>() {