get rid of JetPseudocodeTrace

and JetControlFlowDataTraceFactory

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

@@ -33,7 +33,6 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Severity;
@@ -170,8 +169,8 @@ public class JetTestUtils {
     private JetTestUtils() {
     }
 
-    public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
-        return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, flowDataTraceFactory,
+    public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace) {
+        return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace,
                 CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true));
     }
 

compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java

@@ -28,10 +28,16 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.lang.cfg.LoopInfo;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.lang.cfg.JetControlFlowProcessor;
 import org.jetbrains.jet.lang.cfg.pseudocode.*;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -72,37 +78,46 @@ public class JetControlFlowTest extends JetLiteFixture {
         JetFile file = loadPsiFile(myName + ".jet");
 
         final Map<JetElement, Pseudocode> data = new LinkedHashMap<JetElement, Pseudocode>();
-        final JetPseudocodeTrace pseudocodeTrace = new JetPseudocodeTrace() {
+        AnalyzeExhaust analyzeExhaust = JetTestUtils.analyzeFile(file);
+        List<JetDeclaration> declarations = file.getDeclarations();
+        final BindingContext bindingContext = analyzeExhaust.getBindingContext();
 
+        BindingTrace mockTrace = new BindingTrace() {
             @Override
-            public void recordControlFlowData(@NotNull JetElement element, @NotNull Pseudocode pseudocode) {
-                data.put(element, pseudocode);
+            public BindingContext getBindingContext() {
+                return bindingContext;
             }
 
             @Override
-            public void close() {
-                for (Pseudocode pseudocode : data.values()) {
-                    pseudocode.postProcess();
-                }
+            public <K, V> void record(WritableSlice<K, V> slice, K key, V value) {
             }
 
             @Override
-            public void recordLoopInfo(JetExpression expression, LoopInfo blockInfo) {
+            public <K> void record(WritableSlice<K, Boolean> slice, K key) {
             }
 
             @Override
-            public void recordRepresentativeInstruction(@NotNull JetElement element, @NotNull Instruction instruction) {
+            public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
+                return bindingContext.get(slice, key);
             }
 
-        };
-
-        JetTestUtils.analyzeFile(file, new JetControlFlowDataTraceFactory() {
             @NotNull
             @Override
-            public JetPseudocodeTrace createTrace(JetElement element) {
-                return pseudocodeTrace;
+            public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+                return bindingContext.getKeys(slice);
             }
-        });
+
+            @Override
+            public void report(@NotNull Diagnostic diagnostic) {
+            }
+        };
+        for (JetDeclaration declaration : declarations) {
+            Pseudocode pseudocode = new JetControlFlowProcessor(mockTrace).generatePseudocode(declaration);
+            data.put(declaration, pseudocode);
+            for (Pseudocode localPseudocode : pseudocode.getLocalDeclarations()) {
+                data.put(localPseudocode.getCorrespondingElement(), localPseudocode);
+            }
+        }
 
         try {
             processCFData(myName, data);
@@ -123,6 +138,7 @@ public class JetControlFlowTest extends JetLiteFixture {
         StringBuilder instructionDump = new StringBuilder();
         int i = 0;
         for (Pseudocode pseudocode : pseudocodes) {
+
             JetElement correspondingElement = pseudocode.getCorrespondingElement();
             String label = "";
             assert (correspondingElement instanceof JetNamedDeclaration || correspondingElement instanceof JetSecondaryConstructor || correspondingElement instanceof JetPropertyAccessor) :
@@ -146,11 +162,11 @@ public class JetControlFlowTest extends JetLiteFixture {
 
             instructionDump.append(correspondingElement.getText());
             instructionDump.append("\n---------------------\n");
-            dumpInstructions(pseudocode, instructionDump);
+            dumpInstructions((PseudocodeImpl) pseudocode, instructionDump);
             instructionDump.append("=====================\n");
             
             //check edges directions
-            Collection<Instruction> instructions = pseudocode.getMutableInstructionList();
+            Collection<Instruction> instructions = ((PseudocodeImpl)pseudocode).getMutableInstructionList();
             for (Instruction instruction : instructions) {
                 if (!((InstructionImpl)instruction).isDead()) {
                     for (Instruction nextInstruction : instruction.getNextInstructions()) {
@@ -181,7 +197,7 @@ public class JetControlFlowTest extends JetLiteFixture {
 //                        }
     }
 
-    public void dfsDump(Pseudocode pseudocode, StringBuilder nodes, StringBuilder edges, Map<Instruction, String> nodeNames) {
+    public void dfsDump(PseudocodeImpl pseudocode, StringBuilder nodes, StringBuilder edges, Map<Instruction, String> nodeNames) {
         dfsDump(nodes, edges, pseudocode.getMutableInstructionList().get(0), nodeNames);
     }
 
@@ -243,11 +259,11 @@ public class JetControlFlowTest extends JetLiteFixture {
         return sb.toString();
     }
 
-    public void dumpInstructions(Pseudocode pseudocode, @NotNull StringBuilder out) {
+    public void dumpInstructions(PseudocodeImpl pseudocode, @NotNull StringBuilder out) {
         List<Instruction> instructions = pseudocode.getMutableInstructionList();
         Set<Instruction> remainedAfterPostProcessInstructions = Sets.newHashSet(pseudocode.getInstructions());
-        List<Pseudocode.PseudocodeLabel> labels = pseudocode.getLabels();
-        List<Pseudocode> locals = new ArrayList<Pseudocode>();
+        List<PseudocodeImpl.PseudocodeLabel> labels = pseudocode.getLabels();
+        List<PseudocodeImpl> locals = new ArrayList<PseudocodeImpl>();
         int maxLength = 0;
         int maxNextLength = 0;
         for (Instruction instruction : instructions) {
@@ -276,9 +292,9 @@ public class JetControlFlowTest extends JetLiteFixture {
             Instruction instruction = instructions.get(i);
             if (instruction instanceof LocalDeclarationInstruction) {
                 LocalDeclarationInstruction localDeclarationInstruction = (LocalDeclarationInstruction) instruction;
-                locals.add(localDeclarationInstruction.getBody());
+                locals.add((PseudocodeImpl) localDeclarationInstruction.getBody());
             }
-            for (Pseudocode.PseudocodeLabel label: labels) {
+            for (PseudocodeImpl.PseudocodeLabel label: labels) {
                 if (label.getTargetInstructionIndex() == i) {
                     out.append(label.getName()).append(":\n");
                 }
@@ -288,7 +304,7 @@ public class JetControlFlowTest extends JetLiteFixture {
                     append("    NEXT:").append(String.format("%1$-" + maxNextLength + "s", formatInstructionList(instruction.getNextInstructions()))).
                     append("    PREV:").append(formatInstructionList(instruction.getPreviousInstructions())).append("\n");
         }
-        for (Pseudocode local : locals) {
+        for (PseudocodeImpl local : locals) {
             dumpInstructions(local, out);
         }
     }
@@ -300,7 +316,7 @@ public class JetControlFlowTest extends JetLiteFixture {
                 public void visitLocalDeclarationInstruction(LocalDeclarationInstruction instruction) {
                     int index = count[0];
 //                    instruction.getBody().dumpSubgraph(out, "subgraph cluster_" + index, count, "color=blue;\nlabel = \"f" + index + "\";", nodeToName);
-                    printEdge(out, nodeToName.get(instruction), nodeToName.get(instruction.getBody().getMutableInstructionList().get(0)), null);
+                    printEdge(out, nodeToName.get(instruction), nodeToName.get(((PseudocodeImpl)instruction.getBody()).getMutableInstructionList().get(0)), null);
                     visitInstructionWithNext(instruction);
                 }
 
@@ -415,7 +431,7 @@ public class JetControlFlowTest extends JetLiteFixture {
         int[] count = new int[1];
         Map<Instruction, String> nodeToName = new HashMap<Instruction, String>();
         for (Pseudocode pseudocode : pseudocodes) {
-            dumpNodes(pseudocode.getMutableInstructionList(), out, count, nodeToName, Sets.newHashSet(pseudocode.getInstructions()));
+            dumpNodes(((PseudocodeImpl)pseudocode).getMutableInstructionList(), out, count, nodeToName, Sets.newHashSet(pseudocode.getInstructions()));
         }
         int i = 0;
         for (Pseudocode pseudocode : pseudocodes) {
@@ -431,7 +447,7 @@ public class JetControlFlowTest extends JetLiteFixture {
             out.println("subgraph cluster_" + i + " {\n" +
                         "label=\"" + label + "\";\n" +
                         "color=blue;\n");
-            dumpEdges(pseudocode.getMutableInstructionList(), out, count, nodeToName);
+            dumpEdges(((PseudocodeImpl)pseudocode).getMutableInstructionList(), out, count, nodeToName);
             out.println("}");
             i++;
         }

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

@@ -21,7 +21,6 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.JetLiteFixture;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -107,8 +106,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
 
         public void test(final @NotNull PsiFile psiFile) {
             BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
-                    (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY,
-                    CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true))
+                    (JetFile) psiFile, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true))
                         .getBindingContext();
 
             String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile)).toString();

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

@@ -29,7 +29,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
@@ -172,9 +171,7 @@ public class JetDiagnosticsTest extends JetLiteFixture {
         }
 
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                getProject(), jetFiles, Predicates.<PsiFile>alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY,
-                myEnvironment.getCompilerDependencies())
-                    .getBindingContext();
+                getProject(), jetFiles, Predicates.<PsiFile>alwaysTrue(), myEnvironment.getCompilerDependencies()).getBindingContext();
 
         boolean ok = true;
 

compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java

@@ -26,7 +26,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -87,8 +86,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-                psiFile, JetControlFlowDataTraceFactory.EMPTY,
-                jetCoreEnvironment.getCompilerDependencies())
+                psiFile, jetCoreEnvironment.getCompilerDependencies())
                     .getBindingContext();
         return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel(Name.identifier("test")));
     }

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

@@ -24,7 +24,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-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;
@@ -186,8 +185,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) {
         final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-                myFile, JetControlFlowDataTraceFactory.EMPTY,
-                myEnvironment.getCompilerDependencies());
+                myFile, myEnvironment.getCompilerDependencies());
         analyzeExhaust.throwIfError();
         AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
         GenerationState state = new GenerationState(myEnvironment.getProject(), classBuilderFactory, analyzeExhaust, Collections.singletonList(myFile));

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

@@ -19,7 +19,6 @@ 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.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
@@ -37,8 +36,7 @@ public class GenerationUtils {
 
     public static GenerationState compileFileGetGenerationStateForTest(JetFile psiFile, @NotNull CompilerSpecialMode compilerSpecialMode) {
         final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-                psiFile, JetControlFlowDataTraceFactory.EMPTY,
-                CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true));
+                psiFile, CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true));
         analyzeExhaust.throwIfError();
         GenerationState state = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
         state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);

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

@@ -22,7 +22,6 @@ import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -78,8 +77,7 @@ public class DescriptorRendererTest extends JetLiteFixture {
         JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
         AnalyzeExhaust analyzeExhaust =
                 AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
-                        (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY,
-                        myEnvironment.getCompilerDependencies());
+                        (JetFile) psiFile, myEnvironment.getCompilerDependencies());
         final BindingContext bindingContext = analyzeExhaust.getBindingContext();
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
         psiFile.acceptChildren(new JetVisitorVoid() {

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

@@ -27,7 +27,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
@@ -154,8 +153,7 @@ public abstract class ExpectedResolveData {
         JetStandardLibrary lib = JetStandardLibrary.getInstance();
 
         AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files,
-                Predicates.<PsiFile>alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY,
-                jetCoreEnvironment.getCompilerDependencies());
+                Predicates.<PsiFile>alwaysTrue(), jetCoreEnvironment.getCompilerDependencies());
         BindingContext bindingContext = analyzeExhaust.getBindingContext();
         for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
             if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) {

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

@@ -20,7 +20,6 @@ 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;
@@ -66,7 +65,6 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             JetDeclaration aClass = declarations.get(0);
             assert aClass instanceof JetClass;
             AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file,
-                                                JetControlFlowDataTraceFactory.EMPTY,
                                                 myEnvironment.getCompilerDependencies());
             DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
             WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING);