Merge from brahch analyzeJS.

Conflicts: compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java compiler/cli/src/org/jetbrains/jet/compiler/CompileSession.java compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java idea/src/org/jetbrains/jet/plugin/project/WholeProjectAnalyzerFacade.java idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java
2012-04-09 17:06:56 +04:00
parent ff1cd1c4f7 652be4ed95
commit a030576052
34 changed files with 982 additions and 568 deletions
@@ -25,6 +25,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.di.InjectorForJvmCodegen;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
@@ -34,8 +35,6 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
 import org.jetbrains.jet.lang.psi.JetObjectLiteralExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
-import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.utils.Progress;

 import java.util.List;
@@ -52,18 +51,15 @@ public class GenerationState {


    public GenerationState(Project project, ClassBuilderFactory builderFactory, AnalyzeExhaust analyzeExhaust, List<JetFile> files) {
-        this(project, builderFactory, Progress.DEAF, analyzeExhaust, files, CompilerSpecialMode.REGULAR);
+        this(project, builderFactory, Progress.DEAF, analyzeExhaust, files);
    }

-    public GenerationState(Project project, ClassBuilderFactory builderFactory, Progress progress,
-            @NotNull AnalyzeExhaust exhaust, @NotNull List<JetFile> files, @NotNull CompilerSpecialMode compilerSpecialMode) {
+    public GenerationState(Project project, ClassBuilderFactory builderFactory, Progress progress, @NotNull AnalyzeExhaust exhaust, @NotNull List<JetFile> files) {
        this.project = project;
        this.progress = progress;
        this.analyzeExhaust = exhaust;
        this.files = files;
-        this.injector = new InjectorForJvmCodegen(
-                analyzeExhaust.getStandardLibrary(), analyzeExhaust.getBindingContext(),
-                this.files, project, compilerSpecialMode, this, builderFactory);
+        this.injector = new InjectorForJvmCodegen(analyzeExhaust.getStandardLibrary(), analyzeExhaust.getBindingContext(), this.files, project, this, builderFactory);
    }

    @NotNull
@@ -88,11 +84,11 @@ public class GenerationState {
    }

    public ClassBuilder forClassImplementation(ClassDescriptor aClass) {
-        return getFactory().newVisitor(getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.IMPL).getInternalName() + ".class");
+        return getFactory().newVisitor(getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName() + ".class");
    }

    public ClassBuilder forTraitImplementation(ClassDescriptor aClass) {
-        return getFactory().newVisitor(getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.TRAIT_IMPL).getInternalName() + ".class");
+        return getFactory().newVisitor(getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), OwnerKind.TRAIT_IMPL).getInternalName() + ".class");
    }

    public Pair<String, ClassBuilder> forAnonymousSubclass(JetExpression expression) {
@@ -26,6 +26,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.PsiRecursiveElementWalkingVisitor;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.codegen.ClassBuilderFactories;
 import org.jetbrains.jet.codegen.CompilationErrorHandler;
 import org.jetbrains.jet.codegen.GenerationState;
@@ -41,7 +42,6 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.Severity;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -71,8 +71,11 @@ public class CompileSession {
    private final CompilerDependencies compilerDependencies;
    private AnalyzeExhaust bindingContext;

-    public CompileSession(JetCoreEnvironment environment, MessageRenderer messageRenderer, PrintStream errorStream, boolean verbose,
-            @NotNull CompilerDependencies compilerDependencies) {
+    public CompileSession(JetCoreEnvironment environment,
+                          MessageRenderer messageRenderer,
+                          PrintStream errorStream,
+                          boolean verbose,
+                          CompilerSpecialMode mode) {
        this.environment = environment;
        this.messageRenderer = messageRenderer;
        this.errorStream = errorStream;
@@ -177,8 +180,7 @@ public class CompileSession {
        Predicate<PsiFile> filesToAnalyzeCompletely =
                stubs ? Predicates.<PsiFile>alwaysFalse() : Predicates.<PsiFile>alwaysTrue();
        bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                environment.getProject(), sourceFiles, filesToAnalyzeCompletely, JetControlFlowDataTraceFactory.EMPTY,
-                compilerDependencies);
+            environment.getProject(), sourceFiles, filesToAnalyzeCompletely, JetControlFlowDataTraceFactory.EMPTY, compilerSpecialMode);

        for (Diagnostic diagnostic : bindingContext.getBindingContext().getDiagnostics()) {
            reportDiagnostic(messageCollector, diagnostic);
@@ -18,22 +18,14 @@ package org.jetbrains.jet.lang.resolve.java;

 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Key;
 import com.intellij.psi.PsiFile;
-import com.intellij.psi.util.CachedValue;
-import com.intellij.psi.util.CachedValueProvider;
-import com.intellij.psi.util.CachedValuesManager;
-import com.intellij.psi.util.PsiModificationTracker;
-import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.analyzer.AnalyzerFacade;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
-import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -47,158 +39,66 @@ import java.util.Collections;
 /**
 * @author abreslav
 */
-public class AnalyzerFacadeForJVM {
+public enum AnalyzerFacadeForJVM implements AnalyzerFacade {

-    private static final Logger LOG = Logger.getInstance("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM");
-
-    public static final Function<JetFile, Collection<JetFile>> SINGLE_DECLARATION_PROVIDER = new Function<JetFile, Collection<JetFile>>() {
-        @Override
-        public Collection<JetFile> fun(JetFile file) {
-            return Collections.singleton(file);
-        }
-    };
-
-    private final static Key<CachedValue<AnalyzeExhaust>> BINDING_CONTEXT = Key.create("BINDING_CONTEXT");
-    private static final Object lock = new Object();
+    INSTANCE;

    private AnalyzerFacadeForJVM() {
    }

-    /**
-     * Analyze project with string cache for given file. Given file will be fully analyzed.
-     *
-     * @param file
-     * @param declarationProvider
-     * @return
-     */
-    public static AnalyzeExhaust analyzeFileWithCache(@NotNull final JetFile file,
-            @NotNull final Function<JetFile, Collection<JetFile>> declarationProvider,
-            @NotNull final CompilerSpecialMode compilerSpecialMode, @NotNull final CompilerDependencies compilerDependencies) {
-        // Need lock for getValue(), because parallel threads can start evaluation of compute() simultaneously
-        synchronized (lock) {
-            CachedValue<AnalyzeExhaust> bindingContextCachedValue = file.getUserData(BINDING_CONTEXT);
-            if (bindingContextCachedValue == null) {
-                bindingContextCachedValue = CachedValuesManager.getManager(file.getProject()).createCachedValue(new CachedValueProvider<AnalyzeExhaust>() {
-                    @Override
-                    public Result<AnalyzeExhaust> compute() {
-                        try {
-                            AnalyzeExhaust bindingContext;
-                            bindingContext = analyzeFilesWithJavaIntegration(
-                                    file.getProject(),
-                                    declarationProvider.fun(file),
-                                    Predicates.<PsiFile>equalTo(file),
-                                    JetControlFlowDataTraceFactory.EMPTY,
-                                    compilerDependencies);
-                            return new Result<AnalyzeExhaust>(bindingContext, PsiModificationTracker.MODIFICATION_COUNT);
-                        }
-                        catch (ProcessCanceledException e) {
-                            throw e;
-                        }
-                        catch (Throwable e) {
-                            DiagnosticUtils.throwIfRunningOnServer(e);
-                            LOG.error(e);
-                            BindingTraceContext bindingTraceContext = new BindingTraceContext();
-                            bindingTraceContext.report(Errors.EXCEPTION_WHILE_ANALYZING.on(file, e));
-                            AnalyzeExhaust analyzeExhaust = new AnalyzeExhaust(bindingTraceContext.getBindingContext(), null);
-                            return new Result<AnalyzeExhaust>(analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT);
-                        }
-                    }
-                }, false);
-                file.putUserData(BINDING_CONTEXT, bindingContextCachedValue);
-            }
-            return bindingContextCachedValue.getValue();
-        }
-    }
-
-    /**
-     * Analyze project with string cache for the whole project. All given files will be analyzed only for descriptors.
-     */
-    public static AnalyzeExhaust analyzeProjectWithCache(@NotNull final Project project,
-            @NotNull final Collection<JetFile> files,
-            @NotNull final CompilerSpecialMode compilerSpecialMode,
-            @NotNull final CompilerDependencies compilerDependencies) {
-        // Need lock for getValue(), because parallel threads can start evaluation of compute() simultaneously
-        synchronized (lock) {
-            CachedValue<AnalyzeExhaust> bindingContextCachedValue = project.getUserData(BINDING_CONTEXT);
-            if (bindingContextCachedValue == null) {
-                bindingContextCachedValue = CachedValuesManager.getManager(project).createCachedValue(new CachedValueProvider<AnalyzeExhaust>() {
-                    @Override
-                    public Result<AnalyzeExhaust> compute() {
-                        try {
-                            AnalyzeExhaust analyzeExhaust = analyzeFilesWithJavaIntegration(
-                                    project,
-                                    files,
-                                    Predicates.<PsiFile>alwaysFalse(),
-                                    JetControlFlowDataTraceFactory.EMPTY,
-                                    compilerDependencies);
-                            return new Result<AnalyzeExhaust>(analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT);
-                        }
-                        catch (ProcessCanceledException e) {
-                            throw e;
-                        }
-                        catch (Throwable e) {
-                            DiagnosticUtils.throwIfRunningOnServer(e);
-                            LOG.error(e);
-                            BindingTraceContext bindingTraceContext = new BindingTraceContext();
-                            AnalyzeExhaust analyzeExhaust = new AnalyzeExhaust(bindingTraceContext.getBindingContext(), null);
-                            return new Result<AnalyzeExhaust>(analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT);
-                        }
-                    }
-                }, false);
-                project.putUserData(BINDING_CONTEXT, bindingContextCachedValue);
-            }
-            return bindingContextCachedValue.getValue();
-        }
+    @Override
+    @NotNull
+    public AnalyzeExhaust analyzeFiles(@NotNull Project project,
+                                       @NotNull Collection<JetFile> files,
+                                       @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
+                                       @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
+        return analyzeFilesWithJavaIntegration(project, files, filesToAnalyzeCompletely, flowDataTraceFactory, CompilerSpecialMode.REGULAR);
    }

    public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-            JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory,
-            @NotNull CompilerSpecialMode compilerSpecialMode, @NotNull CompilerDependencies compilerDependencies) {
+        JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory) {
        AnalyzingUtils.checkForSyntacticErrors(file);

-        AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, flowDataTraceFactory, compilerDependencies);
+        AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, flowDataTraceFactory);

        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());

        return analyzeExhaust;
    }

-    public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(
-            JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory,
-            @NotNull CompilerDependencies compilerDependencies) {
+    public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory) {
        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file),
-                Predicates.<PsiFile>alwaysTrue(), flowDataTraceFactory, compilerDependencies);
+                                               Predicates.<PsiFile>alwaysTrue(), flowDataTraceFactory, CompilerSpecialMode.REGULAR);
    }

    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely,
-            JetControlFlowDataTraceFactory flowDataTraceFactory,
-            @NotNull CompilerDependencies compilerDependencies) {
+        Project project, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely,
+        JetControlFlowDataTraceFactory flowDataTraceFactory,
+        CompilerSpecialMode compilerSpecialMode) {
        BindingTraceContext bindingTraceContext = new BindingTraceContext();

        final ModuleDescriptor owner = new ModuleDescriptor("<module>");

        TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                filesToAnalyzeCompletely, false, false);
+            filesToAnalyzeCompletely, false, false);


        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
-                project, topDownAnalysisParameters,
-                new ObservableBindingTrace(bindingTraceContext), owner, flowDataTraceFactory,
-                compilerDependencies);
+            project, topDownAnalysisParameters,
+            new ObservableBindingTrace(bindingTraceContext), owner, flowDataTraceFactory,
+            compilerSpecialMode);


        injector.getTopDownAnalyzer().analyzeFiles(files);
        return new AnalyzeExhaust(bindingTraceContext.getBindingContext(), JetStandardLibrary.getInstance());
    }

-    public static AnalyzeExhaust shallowAnalyzeFiles(Collection<JetFile> files,
-            @NotNull CompilerSpecialMode compilerSpecialMode, @NotNull CompilerDependencies compilerDependencies) {
+    public static AnalyzeExhaust shallowAnalyzeFiles(Collection<JetFile> files) {
        assert files.size() > 0;

        Project project = files.iterator().next().getProject();

        return analyzeFilesWithJavaIntegration(project, files, Predicates.<PsiFile>alwaysFalse(),
-                JetControlFlowDataTraceFactory.EMPTY, compilerDependencies);
+                                               JetControlFlowDataTraceFactory.EMPTY, CompilerSpecialMode.REGULAR);
    }
 }
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package org.jetbrains.jet.lang.resolve.java;
+package org.jetbrains.jet.analyzer;

 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -35,7 +35,8 @@ public class AnalyzeExhaust {
        this.standardLibrary = standardLibrary;
    }

-    @NotNull public BindingContext getBindingContext() {
+    @NotNull
+    public BindingContext getBindingContext() {
        return bindingContext;
    }

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2012 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.analyzer;
+
+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.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.psi.JetFile;
+
+import java.util.Collection;
+
+/**
+ * @author Pavel Talanov
+ */
+public interface AnalyzerFacade {
+
+    @NotNull
+    AnalyzeExhaust analyzeFiles(@NotNull Project project,
+                                @NotNull Collection<JetFile> files,
+                                @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
+                                @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory);
+}
@@ -41,6 +41,7 @@ import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.codegen.ClassBuilder;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import org.jetbrains.jet.codegen.CompilationErrorHandler;
@@ -48,7 +49,6 @@ import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.FqName;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
@@ -102,8 +102,8 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
    }

    private static PsiClass findClass(FqName fqn, StubElement<?> stub) {
-        if (stub instanceof PsiClassStub && Comparing.equal(fqn.getFqName(), ((PsiClassStub) stub).getQualifiedName())) {
-            return (PsiClass) stub.getPsi();
+        if (stub instanceof PsiClassStub && Comparing.equal(fqn.getFqName(), ((PsiClassStub)stub).getQualifiedName())) {
+            return (PsiClass)stub.getPsi();
        }

        for (StubElement child : stub.getChildrenStubs()) {
@@ -130,14 +130,14 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
            }, false);
            file.putUserData(JAVA_API_STUB, answer);
        }
-        
+
        return answer.getValue();
    }
-    
+
    private PsiJavaFileStub calcStub() {
        final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(JetPsiUtil.getFQName(file).getFqName(), true);
        final Project project = getProject();
-        
+
        final Stack<StubElement> stubStack = new Stack<StubElement>();

        final ClassBuilderFactory builderFactory = new ClassBuilderFactory() {
@@ -172,13 +172,14 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
                stubStack.push(answer);

                answer.setPsiFactory(new ClsWrapperStubPsiFactory());
-                final ClsFileImpl fakeFile = new ClsFileImpl((PsiManagerImpl) manager, new ClassFileViewProvider(manager, file.getVirtualFile())) {
-                    @NotNull
-                    @Override
-                    public PsiClassHolderFileStub getStub() {
-                        return answer;
-                    }
-                };
+                final ClsFileImpl fakeFile =
+                    new ClsFileImpl((PsiManagerImpl)manager, new ClassFileViewProvider(manager, file.getVirtualFile())) {
+                        @NotNull
+                        @Override
+                        public PsiClassHolderFileStub getStub() {
+                            return answer;
+                        }
+                    };

                fakeFile.setPhysical(false);
                answer.setPsi(fakeFile);
@@ -209,7 +210,7 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa

    @Override
    public boolean isEquivalentTo(PsiElement another) {
-        return another instanceof PsiClass && Comparing.equal(((PsiClass) another).getQualifiedName(), getQualifiedName());
+        return another instanceof PsiClass && Comparing.equal(((PsiClass)another).getQualifiedName(), getQualifiedName());
    }

    @Override
@@ -221,7 +222,8 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
    public String toString() {
        try {
            return JetLightClass.class.getSimpleName() + ":" + getQualifiedName();
-        } catch (Throwable e) {
+        }
+        catch (Throwable e) {
            return JetLightClass.class.getSimpleName() + ":" + e.toString();
        }
    }
@@ -23,6 +23,7 @@ import com.intellij.openapi.util.ShutDownTracker;
 import com.intellij.openapi.util.io.FileUtil;
 import junit.framework.TestCase;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
@@ -31,7 +32,6 @@ import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
@@ -88,7 +88,7 @@ public class JetTestUtils {

        @Override
        public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
-            if (slice == BindingContext.PROCESSED) return (V) Boolean.FALSE;
+            if (slice == BindingContext.PROCESSED) return (V)Boolean.FALSE;
            return SlicedMap.DO_NOTHING.get(slice, key);
        }

@@ -102,61 +102,61 @@ public class JetTestUtils {
        @Override
        public void report(@NotNull Diagnostic diagnostic) {
            if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
-                UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic) diagnostic;
+                UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic)diagnostic;
                throw new IllegalStateException("Unresolved: " + unresolvedReferenceDiagnostic.getPsiElement().getText());
            }
        }
    };

    public static BindingTrace DUMMY_EXCEPTION_ON_ERROR_TRACE = new BindingTrace() {
-            @Override
-            public BindingContext getBindingContext() {
-                return new BindingContext() {
-                    @Override
-                    public Collection<Diagnostic> getDiagnostics() {
-                        throw new UnsupportedOperationException();
-                    }
+        @Override
+        public BindingContext getBindingContext() {
+            return new BindingContext() {
+                @Override
+                public Collection<Diagnostic> getDiagnostics() {
+                    throw new UnsupportedOperationException();
+                }

-                    @Override
-                    public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
-                        return DUMMY_EXCEPTION_ON_ERROR_TRACE.get(slice, key);
-                    }
+                @Override
+                public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
+                    return DUMMY_EXCEPTION_ON_ERROR_TRACE.get(slice, key);
+                }

-                    @NotNull
-                    @Override
-                    public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
-                        return DUMMY_EXCEPTION_ON_ERROR_TRACE.getKeys(slice);
-                    }
-                };
-            }
-
-            @Override
-            public <K, V> void record(WritableSlice<K, V> slice, K key, V value) {
-            }
-
-            @Override
-            public <K> void record(WritableSlice<K, Boolean> slice, K key) {
-            }
-
-            @Override
-            public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
-                return null;
-            }
-
-            @NotNull
-            @Override
-            public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
-                assert slice.isCollective();
-                return Collections.emptySet();
-            }
-
-            @Override
-                public void report(@NotNull Diagnostic diagnostic) {
-                    if (diagnostic.getSeverity() == Severity.ERROR) {
-                        throw new IllegalStateException(diagnostic.getMessage());
-                    }
+                @NotNull
+                @Override
+                public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+                    return DUMMY_EXCEPTION_ON_ERROR_TRACE.getKeys(slice);
                }
            };
+        }
+
+        @Override
+        public <K, V> void record(WritableSlice<K, V> slice, K key, V value) {
+        }
+
+        @Override
+        public <K> void record(WritableSlice<K, Boolean> slice, K key) {
+        }
+
+        @Override
+        public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
+            return null;
+        }
+
+        @NotNull
+        @Override
+        public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+            assert slice.isCollective();
+            return Collections.emptySet();
+        }
+
+        @Override
+        public void report(@NotNull Diagnostic diagnostic) {
+            if (diagnostic.getSeverity() == Severity.ERROR) {
+                throw new IllegalStateException(diagnostic.getMessage());
+            }
+        }
+    };

    public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
        return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, flowDataTraceFactory,
@@ -205,24 +205,25 @@ public class JetTestUtils {
    public static void deleteOnShutdown(File file) {
        if (filesToDelete.isEmpty()) {
            ShutDownTracker.getInstance().registerShutdownTask(new Runnable() {
-                  @Override
-                  public void run() {
+                @Override
+                public void run() {
                    ShutDownTracker.invokeAndWait(true, true, new Runnable() {
-                      @Override
-                      public void run() {
-                          for (File victim : filesToDelete) {
-                              FileUtil.delete(victim);
-                          }
-                      }
+                        @Override
+                        public void run() {
+                            for (File victim : filesToDelete) {
+                                FileUtil.delete(victim);
+                            }
+                        }
                    });
-                  }
-                });
+                }
+            });
        }

        filesToDelete.add(file);
    }

    public static final Pattern FILE_PATTERN = Pattern.compile("//\\s*FILE:\\s*(.*)$", Pattern.MULTILINE);
+
    public interface TestFileFactory<F> {
        F create(String fileName, String text);
    }
@@ -257,7 +258,10 @@ public class JetTestUtils {

                if (!nextFileExists) break;
            }
-            assert processedChars == expectedText.length() : "Characters skipped from " + processedChars + " to " + (expectedText.length() - 1);
+            assert processedChars == expectedText.length() : "Characters skipped from " +
+                                                             processedChars +
+                                                             " to " +
+                                                             (expectedText.length() - 1);
        }
        return testFileFiles;
    }
@@ -20,11 +20,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.JetLiteFixture;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.parsing.JetParsingTest;
@@ -17,10 +17,9 @@
 package org.jetbrains.jet.codegen;

 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;

@@ -23,7 +23,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.util.PsiTreeUtil;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
@@ -32,7 +32,6 @@ import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic;
 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.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.types.ErrorUtils;
@@ -246,9 +245,6 @@ public abstract class ExpectedResolveData {
            assert expected != null : "No declaration for " + name;

            PsiElement actual = BindingContextUtils.resolveToDeclarationPsiElement(bindingContext, reference);
-            if (actual instanceof JetSimpleNameExpression) {
-                actual = ((JetSimpleNameExpression)actual).getIdentifier();
-            }

            String actualName = null;
            if (actual != null) {
@@ -16,17 +16,16 @@

 package org.jetbrains.jet.types;

-import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.di.InjectorForTests;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
-import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -64,10 +63,9 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
            List<JetDeclaration> declarations = file.getDeclarations();
            JetDeclaration aClass = declarations.get(0);
            assert aClass instanceof JetClass;
-            AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeFileWithCache(
-                    file, AnalyzerFacadeForJVM.SINGLE_DECLARATION_PROVIDER,
-                    CompilerSpecialMode.REGULAR, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR));
-            DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
+            AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file, JetControlFlowDataTraceFactory.EMPTY);
+            DeclarationDescriptor classDescriptor =
+                bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
            WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING);
            assert classDescriptor instanceof ClassifierDescriptor;
            scope.addClassifierDescriptor((ClassifierDescriptor) classDescriptor);