removed allow dead collecting

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java

@@ -39,12 +39,6 @@ public interface JetControlFlowBuilder {
 
     void bindLabel(@NotNull Label label);
 
-    @NotNull
-    Label createAllowDeadLabel(@NotNull Collection<Label> allowDeadLabels);
-    @NotNull
-    Label createAllowDeadLabel(@NotNull String name, @NotNull Collection<Label> allowDeadLabels);
-    void stopAllowDead(@NotNull Collection<Label> allowDeadLabels);
-
     // Jumps
     void jump(@NotNull Label label);
     void jumpOnFalse(@NotNull Label label);

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java

@@ -62,26 +62,6 @@ public class JetControlFlowBuilderAdapter implements JetControlFlowBuilder {
         builder.bindLabel(label);
     }
 
-    @NotNull
-    @Override
-    public Label createAllowDeadLabel(@NotNull Collection<Label> allowDeadLabels) {
-        assert builder != null;
-        return builder.createAllowDeadLabel(allowDeadLabels);
-    }
-
-    @NotNull
-    @Override
-    public Label createAllowDeadLabel(@NotNull String name, @NotNull Collection<Label> allowDeadLabels) {
-        assert builder != null;
-        return builder.createAllowDeadLabel(name, allowDeadLabels);
-    }
-
-    @Override
-    public void stopAllowDead(@NotNull Collection<Label> allowDeadLabels) {
-        assert builder != null;
-        builder.stopAllowDead(allowDeadLabels);
-    }
-
     @Override
     public void jump(@NotNull Label label) {
         assert builder != null;

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -408,7 +408,6 @@ public class JetControlFlowProcessor {
 
             Collection<Label> allowDeadLabels = Lists.newArrayList();
             if (hasCatches) {
-                builder.createAllowDeadLabel(allowDeadLabels);
                 Label afterCatches = builder.createUnboundLabel("afterCatches");
                 builder.jump(afterCatches);
 
@@ -438,15 +437,11 @@ public class JetControlFlowProcessor {
                     if (catchBody != null) {
                         value(catchBody, false);
                     }
-                    builder.createAllowDeadLabel(allowDeadLabels);
                     builder.jump(afterCatches);
                 }
 
                 builder.bindLabel(afterCatches);
             }
-            else {
-                builder.createAllowDeadLabel(allowDeadLabels);
-            }
 
             if (finallyBlock != null) {
                 builder.exitTryFinally();
@@ -460,7 +455,6 @@ public class JetControlFlowProcessor {
 
                 finallyBlockGenerator.generate();
             }
-            builder.stopAllowDead(allowDeadLabels);
         }
 
         @Override
@@ -850,7 +844,6 @@ public class JetControlFlowProcessor {
 
                 builder.bindLabel(bodyLabel);
                 value(whenEntry.getExpression(), inCondition);
-                builder.createAllowDeadLabel(allowDeadLabels);
                 builder.jump(doneLabel);
 
                 if (!isIrrefutable) {
@@ -862,7 +855,6 @@ public class JetControlFlowProcessor {
             if (!hasElseOrIrrefutableBranch && !isWhenExhaust) {
                 trace.report(NO_ELSE_IN_WHEN.on(expression));
             }
-            builder.stopAllowDead(allowDeadLabels);
         }
 
         @Override

compiler/frontend/src/org/jetbrains/jet/lang/cfg/Label.java

@@ -21,5 +21,4 @@ package org.jetbrains.jet.lang.cfg;
  */
 public interface Label {
     String getName();
-    boolean allowDead();
 }

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java

@@ -275,28 +275,6 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
             pseudocode.bindLabel(label);
         }
 
-        @NotNull
-        @Override
-        public Label createAllowDeadLabel(@NotNull Collection<Label> allowDeadLabels) {
-            return createAllowDeadLabel("d" + allowDeadLabelCount++, allowDeadLabels);
-        }
-
-        @NotNull
-        @Override
-        public Label createAllowDeadLabel(@NotNull String name, @NotNull Collection<Label> allowDeadLabels) {
-            Label label = pseudocode.createAllowDeadLabel(name);
-            bindLabel(label);
-            allowDeadLabels.add(label);
-            return label;
-        }
-
-        @Override
-        public void stopAllowDead(@NotNull Collection<Label> allowDeadLabels) {
-            Label allowedDeadLabel = createUnboundLabel("stop " + allowDeadLabels);
-            bindLabel(allowedDeadLabel);
-            pseudocode.stopAllowDead(allowedDeadLabel, allowDeadLabels);
-        }
-
         @Override
         public void nondeterministicJump(Label label) {
             handleJumpInsideTryFinally(label);

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/PseudocodeImpl.java

@@ -34,13 +34,11 @@ public class PseudocodeImpl implements Pseudocode {
 
     public class PseudocodeLabel implements Label {
         private final String name;
-        private final boolean allowDead;
         private Integer targetInstructionIndex;
 
 
-        private PseudocodeLabel(String name, boolean allowDead) {
+        private PseudocodeLabel(String name) {
             this.name = name;
-            this.allowDead = allowDead;
         }
 
         @Override
@@ -48,11 +46,6 @@ public class PseudocodeImpl implements Pseudocode {
             return name;
         }
 
-        @Override
-        public boolean allowDead() {
-            return allowDead;
-        }
-
         @Override
         public String toString() {
             return name;
@@ -78,7 +71,7 @@ public class PseudocodeImpl implements Pseudocode {
         }
 
         public Label copy() {
-            return new PseudocodeLabel("copy " + name, allowDead);
+            return new PseudocodeLabel("copy " + name);
         }
     }
 
@@ -93,7 +86,6 @@ public class PseudocodeImpl implements Pseudocode {
     private final Map<JetExpression, LoopInfo> loopInfo = Maps.newHashMap();
     
     private final List<PseudocodeLabel> labels = new ArrayList<PseudocodeLabel>();
-    private final Map<Label, Collection<Label>> stopAllowDeadLabels = Maps.newHashMap();
 
     private final JetElement correspondingElement;
     private SubroutineExitInstruction exitInstruction;
@@ -133,23 +125,11 @@ public class PseudocodeImpl implements Pseudocode {
     }
 
     /*package*/ PseudocodeLabel createLabel(String name) {
-        return createLabel(name, false);
+        PseudocodeLabel label = new PseudocodeLabel(name);
-    }
-
-    private PseudocodeLabel createLabel(String name, boolean allowDead) {
-        PseudocodeLabel label = new PseudocodeLabel(name, allowDead);
         labels.add(label);
         return label;
     }
     
-    /*package*/ Label createAllowDeadLabel(String name) {
-        return createLabel(name, true);
-    }
-    
-    /*package*/ void stopAllowDead(Label label, Collection<Label> allowDeadLabels) {
-        stopAllowDeadLabels.put((PseudocodeLabel) label, allowDeadLabels);
-    }
-
     @Override
     @NotNull
     public List<Instruction> getInstructions() {
@@ -392,71 +372,6 @@ public class PseudocodeImpl implements Pseudocode {
         }
     }
 
-    @NotNull
-    private Map<Instruction, Label> prepareAllowDeadStarters() {
-        Map<Instruction, Label> allowedDeadBeginners = Maps.newHashMap();
-        for (PseudocodeLabel label : labels) {
-            if (!label.allowDead()) continue;
-            Instruction allowDeadPossibleBeginner = getJumpTarget(label);
-            if (((InstructionImpl)allowDeadPossibleBeginner).isDead()) {
-                allowedDeadBeginners.put(allowDeadPossibleBeginner, label);
-            }
-        }
-        return allowedDeadBeginners;
-    }
-    
-    @NotNull
-    private Map<Instruction, Collection<Label>> prepareAllowDeadStoppers() {
-        Map<Instruction, Collection<Label>> stopAllowedDeadInstructions = Maps.newHashMap();
-        for (Map.Entry<Label, Collection<Label>> entry : stopAllowDeadLabels.entrySet()) {
-            Label stopAllowedDeadLabel = entry.getKey();
-            Instruction stopAllowDeadInsruction = getJumpTarget(stopAllowedDeadLabel);
-            if (((InstructionImpl)stopAllowDeadInsruction).isDead()) {
-                stopAllowedDeadInstructions.put(stopAllowDeadInsruction, entry.getValue());
-            }
-        }
-        return stopAllowedDeadInstructions;
-    }
-
-    @NotNull
-    private Collection<Instruction> collectAllowedDeadInstructions() {
-        // Allow dead instruction block can have several starters and
-        // one stopper that knows all corresponding starters by labels
-        Map<Instruction, Label> allowDeadStarters = prepareAllowDeadStarters();
-        Map<Instruction, Collection<Label>> allowDeadStoppers = prepareAllowDeadStoppers();
-        Set<Instruction> allowedDeadInstructions = Sets.newHashSet();
-
-        for (Map.Entry<Instruction, Label> entry : allowDeadStarters.entrySet()) {
-            Instruction starter = entry.getKey();
-
-            Set<Instruction> allowedDeadFromThisInstruction = Sets.newHashSet();
-            Label starterLabel = entry.getValue();
-            collectAllowedDeadInstructions(starter, starterLabel, allowedDeadFromThisInstruction, allowDeadStoppers);
-            allowedDeadInstructions.addAll(allowedDeadFromThisInstruction);
-        }
-        return allowedDeadInstructions;
-    }
-    
-    private static void collectAllowedDeadInstructions(
-            @NotNull Instruction current,
-            @NotNull Label starterLabel,
-            @NotNull Set<Instruction> collectedDeadInstructions,
-            @NotNull Map<Instruction, Collection<Label>> allowDeadStoppers
-    ) {
-
-        if (collectedDeadInstructions.contains(current)) return;
-        Collection<Label> allowDeadLabels = allowDeadStoppers.get(current);
-        boolean isStopper = allowDeadLabels != null && allowDeadLabels.contains(starterLabel);
-        if (isStopper) return;
-
-        if (((InstructionImpl)current).isDead()) {
-            collectedDeadInstructions.add(current);
-            for (Instruction instruction : current.getNextInstructions()) {
-                collectAllowedDeadInstructions(instruction, starterLabel, collectedDeadInstructions, allowDeadStoppers);
-            }
-        }
-    }
-
     @NotNull
     private Instruction getJumpTarget(@NotNull Label targetLabel) {
         return ((PseudocodeLabel)targetLabel).resolveToInstruction();
@@ -493,15 +408,6 @@ public class PseudocodeImpl implements Pseudocode {
             addInstruction(copyInstruction(originalInstruction, originalToCopy));
         }
         repeatLabelsBindingForInstruction(mutableInstructionList.get(finishIndex), originalToCopy, originalLabelsForInstruction);
-
-        for (Map.Entry<Label, Label> entry : originalToCopy.entrySet()) {
-            Label oldLabel = entry.getKey();
-            Label newLabel = entry.getValue();
-            Collection<Label> stopAllowDead = stopAllowDeadLabels.get(oldLabel);
-            if (stopAllowDead != null) {
-                stopAllowDeadLabels.put(newLabel, copyLabels(stopAllowDead, originalToCopy));
-            }
-        }
     }
 
     private void repeatLabelsBindingForInstruction(

compiler/testData/cfg/Finally.instructions

@@ -16,7 +16,6 @@ L0:
       })                                    NEXT:[jmp?(L2 [onExceptionToFinallyBlock])]    PREV:[<START>]
     jmp?(L2 [onExceptionToFinallyBlock])    NEXT:[r(2), r(1)]                              PREV:[r(try { 1 } finally { 2 }) ]
     r(1)                                    NEXT:[jmp(L3 [skipFinallyToErrorBlock])]       PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
-d0:
     jmp(L3 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                    PREV:[r(1)]
 L2 [onExceptionToFinallyBlock]:
 L4 [start finally]:
@@ -26,7 +25,6 @@ L5 [finish finally]:
 L3 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                   PREV:[jmp(L3 [skipFinallyToErrorBlock])]
 L1:
-L6 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[jmp(error)]
@@ -70,7 +68,6 @@ L5 [finish finally]:
 L3:
     read (Unit)                             NEXT:[jmp(L7 [skipFinallyToErrorBlock])]       PREV:[jf(L3)]
 L6:
-d0:
     jmp(L7 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                    PREV:[read (Unit)]
 L2 [onExceptionToFinallyBlock]:
     r(2)                                    NEXT:[jmp(error)]                              PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
@@ -78,7 +75,6 @@ L2 [onExceptionToFinallyBlock]:
 L7 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                   PREV:[jmp(L7 [skipFinallyToErrorBlock])]
 L1:
-L8 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[ret L1, r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[jmp(error)]
@@ -125,7 +121,6 @@ L3:
               return@                   
             }                           
         })                                  NEXT:[jmp(L8 [skipFinallyToErrorBlock])]                                   PREV:[jmp?(L3)]
-d0:
     jmp(L8 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                                                PREV:[r({ () => if (2 > 3) { retur..)]
 L2 [onExceptionToFinallyBlock]:
 L9 [start finally]:
@@ -135,7 +130,6 @@ L10 [finish finally]:
 L8 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                                               PREV:[jmp(L8 [skipFinallyToErrorBlock])]
 L1:
-L11 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                                              PREV:[r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                                              PREV:[jmp(error)]
@@ -258,7 +252,6 @@ L8 [finish finally]:
 L6:
     read (Unit)                             NEXT:[jmp(L10 [skipFinallyToErrorBlock])]      PREV:[jf(L6)]
 L9:
-d0:
     jmp(L10 [skipFinallyToErrorBlock])      NEXT:[r(2)]                                    PREV:[read (Unit)]
 L5 [onExceptionToFinallyBlock]:
     r(2)                                    NEXT:[jmp(error)]                              PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
@@ -266,7 +259,6 @@ L5 [onExceptionToFinallyBlock]:
 L10 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                   PREV:[jmp(L10 [skipFinallyToErrorBlock])]
 L4:
-L11 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[ret L4, r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[jmp(error)]
@@ -311,7 +303,6 @@ L8 [finish finally]:
 L6:
     read (Unit)                             NEXT:[jmp(L10 [skipFinallyToErrorBlock])]      PREV:[jf(L6)]
 L9:
-d0:
     jmp(L10 [skipFinallyToErrorBlock])      NEXT:[r(2)]                                    PREV:[read (Unit)]
 L5 [onExceptionToFinallyBlock]:
     r(2)                                    NEXT:[jmp(error)]                              PREV:[jmp?(L5 [onExceptionToFinallyBlock])]
@@ -319,7 +310,6 @@ L5 [onExceptionToFinallyBlock]:
 L10 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                   PREV:[jmp(L10 [skipFinallyToErrorBlock])]
 L4:
-L11 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[ret L4, r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[jmp(error)]
@@ -379,14 +369,12 @@ L9 [finish finally]:
 L7:
     read (Unit)                             NEXT:[jmp(L11 [skipFinallyToErrorBlock])]      PREV:[jf(L7)]
 L10:
-d0:
     jmp(L11 [skipFinallyToErrorBlock])      NEXT:[r(2)]                                    PREV:[read (Unit)]
 L6 [onExceptionToFinallyBlock]:
     r(2)                                    NEXT:[jmp(error)]                              PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
     jmp(error)                              NEXT:[<ERROR>]                                 PREV:[r(2)]
 L11 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[jmp(L2 [loop entry point])]              PREV:[jmp(L11 [skipFinallyToErrorBlock])]
-L12 [stop [d0]]:
     jmp(L2 [loop entry point])              NEXT:[r(true)]                                 PREV:[r(2)]
 L3 [loop exit point]:
     read (Unit)                             NEXT:[<END>]                                   PREV:[jmp(L3 [loop exit point])]
@@ -451,7 +439,6 @@ L8:
 L4 [loop exit point]:
     read (Unit)                             NEXT:[r(5)]                                      PREV:[jmp(L4 [loop exit point])]
     r(5)                                    NEXT:[jmp(L9 [skipFinallyToErrorBlock])]         PREV:[read (Unit)]
-d0:
     jmp(L9 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                      PREV:[r(5)]
 L2 [onExceptionToFinallyBlock]:
 L10 [start finally]:
@@ -461,7 +448,6 @@ L11 [finish finally]:
 L9 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                     PREV:[jmp(L9 [skipFinallyToErrorBlock])]
 L1:
-L12 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                    PREV:[r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                    PREV:[jmp(error)]
@@ -519,7 +505,6 @@ L8:
     jmp(L3 [loop entry point])              NEXT:[r(true)]                                   PREV:[read (Unit)]
 L4 [loop exit point]:
     read (Unit)                             NEXT:[jmp(L9 [skipFinallyToErrorBlock])]         PREV:[jmp(L4 [loop exit point])]
-d0:
     jmp(L9 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                      PREV:[read (Unit)]
 L2 [onExceptionToFinallyBlock]:
 L10 [start finally]:
@@ -529,7 +514,6 @@ L11 [finish finally]:
 L9 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                     PREV:[jmp(L9 [skipFinallyToErrorBlock])]
 L1:
-L12 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                    PREV:[r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                    PREV:[jmp(error)]
@@ -597,14 +581,12 @@ L9 [finish finally]:
 L7:
     read (Unit)                             NEXT:[jmp(L11 [skipFinallyToErrorBlock])]              PREV:[jf(L7)]
 L10:
-d0:
     jmp(L11 [skipFinallyToErrorBlock])      NEXT:[r(2)]                                            PREV:[read (Unit)]
 L6 [onExceptionToFinallyBlock]:
     r(2)                                    NEXT:[jmp(error)]                                      PREV:[jmp?(L6 [onExceptionToFinallyBlock])]
     jmp(error)                              NEXT:[<ERROR>]                                         PREV:[r(2)]
 L11 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[jmp?(L4 [loop entry point])]                     PREV:[jmp(L11 [skipFinallyToErrorBlock])]
-L12 [stop [d0]]:
     jmp?(L4 [loop entry point])             NEXT:[r(try { 1 if (2 > 3) { conti..), read (Unit)]    PREV:[r(2)]
 L2:
     read (Unit)                             NEXT:[<END>]                                           PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
@@ -677,7 +659,6 @@ L8:
 L3:
     read (Unit)                             NEXT:[r(5)]                                       PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
     r(5)                                    NEXT:[jmp(L9 [skipFinallyToErrorBlock])]          PREV:[read (Unit)]
-d0:
     jmp(L9 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                       PREV:[r(5)]
 L2 [onExceptionToFinallyBlock]:
 L10 [start finally]:
@@ -687,7 +668,6 @@ L11 [finish finally]:
 L9 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                      PREV:[jmp(L9 [skipFinallyToErrorBlock])]
 L1:
-L12 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                     PREV:[r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                     PREV:[jmp(error)]
@@ -753,7 +733,6 @@ L8:
     jmp?(L5 [loop entry point])             NEXT:[r(1), read (Unit)]                          PREV:[read (Unit)]
 L3:
     read (Unit)                             NEXT:[jmp(L9 [skipFinallyToErrorBlock])]          PREV:[jmp?(L3), jmp?(L5 [loop entry point])]
-d0:
     jmp(L9 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                       PREV:[read (Unit)]
 L2 [onExceptionToFinallyBlock]:
 L10 [start finally]:
@@ -763,7 +742,6 @@ L11 [finish finally]:
 L9 [skipFinallyToErrorBlock]:
     r(2)                                    NEXT:[<END>]                                      PREV:[jmp(L9 [skipFinallyToErrorBlock])]
 L1:
-L12 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                     PREV:[r(2)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                     PREV:[jmp(error)]
@@ -795,7 +773,6 @@ L3 [start finally]:
     ret(*) L1                               NEXT:[<END>]                                   PREV:[r(2)]
 L4 [finish finally]:
 -   ret(*) L1                               NEXT:[<END>]                                   PREV:[]
-d0:
 -   jmp(L5 [skipFinallyToErrorBlock])       NEXT:[r(2)]                                    PREV:[]
 L2 [onExceptionToFinallyBlock]:
     r(2)                                    NEXT:[ret(*) L1]                               PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
@@ -805,7 +782,6 @@ L5 [skipFinallyToErrorBlock]:
 -   r(2)                                    NEXT:[ret(*) L1]                               PREV:[]
 -   ret(*) L1                               NEXT:[<END>]                                   PREV:[]
 L1:
-L6 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[ret(*) L1, ret(*) L1]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[]
@@ -838,7 +814,6 @@ L3 [start finally]:
     r(doSmth(3))                            NEXT:[ret(*) L1]                               PREV:[r(doSmth)]
 L4 [finish finally]:
     ret(*) L1                               NEXT:[<END>]                                   PREV:[r(doSmth(3))]
-d0:
 -   jmp(L5 [skipFinallyToErrorBlock])       NEXT:[r(3)]                                    PREV:[]
 L2 [onExceptionToFinallyBlock]:
     r(3)                                    NEXT:[r(doSmth)]                               PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
@@ -850,7 +825,6 @@ L5 [skipFinallyToErrorBlock]:
 -   r(doSmth)                               NEXT:[r(doSmth(3))]                            PREV:[]
 -   r(doSmth(3))                            NEXT:[<END>]                                   PREV:[]
 L1:
-L6 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[ret(*) L1]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[jmp(error)]
@@ -890,7 +864,6 @@ L4 [start finally]:
     r(doSmth(3))                                      NEXT:[ret(*) L1]                                                                    PREV:[r(doSmth)]
 L5 [finish finally]:
     ret(*) L1                                         NEXT:[<END>]                                                                        PREV:[r(doSmth(3))]
-d0:
 -   jmp(L6 [afterCatches])                            NEXT:[jmp(L7 [skipFinallyToErrorBlock])]                                            PREV:[]
 L2 [onException]:
     v(e: UnsupportedOperationException)               NEXT:[w(e)]                                                                         PREV:[jmp?(L2 [onException])]
@@ -898,7 +871,6 @@ L2 [onException]:
     r(2)                                              NEXT:[r(doSmth)]                                                                    PREV:[w(e)]
     r(doSmth)                                         NEXT:[r(doSmth(2))]                                                                 PREV:[r(2)]
     r(doSmth(2))                                      NEXT:[jmp(L6 [afterCatches])]                                                       PREV:[r(doSmth)]
-d1:
     jmp(L6 [afterCatches])                            NEXT:[jmp(L7 [skipFinallyToErrorBlock])]                                            PREV:[r(doSmth(2))]
 L6 [afterCatches]:
     jmp(L7 [skipFinallyToErrorBlock])                 NEXT:[r(3)]                                                                         PREV:[jmp(L6 [afterCatches])]
@@ -912,7 +884,6 @@ L7 [skipFinallyToErrorBlock]:
     r(doSmth)                                         NEXT:[r(doSmth(3))]                                                                 PREV:[r(3)]
     r(doSmth(3))                                      NEXT:[<END>]                                                                        PREV:[r(doSmth)]
 L1:
-L8 [stop [d0, d1]]:
     <END>                                             NEXT:[<SINK>]                                                                       PREV:[ret(*) L1, r(doSmth(3))]
 error:
     <ERROR>                                           NEXT:[<SINK>]                                                                       PREV:[jmp(error)]
@@ -940,7 +911,6 @@ L0:
     jmp?(L2 [onException])                            NEXT:[v(e: UnsupportedOperationException), r(1)]    PREV:[r(try { return 1 } catch (e:..)]
     r(1)                                              NEXT:[ret(*) L1]                                    PREV:[jmp?(L2 [onException])]
     ret(*) L1                                         NEXT:[<END>]                                        PREV:[r(1)]
-d0:
 -   jmp(L3 [afterCatches])                            NEXT:[<END>]                                        PREV:[]
 L2 [onException]:
     v(e: UnsupportedOperationException)               NEXT:[w(e)]                                         PREV:[jmp?(L2 [onException])]
@@ -948,11 +918,9 @@ L2 [onException]:
     r(2)                                              NEXT:[r(doSmth)]                                    PREV:[w(e)]
     r(doSmth)                                         NEXT:[r(doSmth(2))]                                 PREV:[r(2)]
     r(doSmth(2))                                      NEXT:[jmp(L3 [afterCatches])]                       PREV:[r(doSmth)]
-d1:
     jmp(L3 [afterCatches])                            NEXT:[<END>]                                        PREV:[r(doSmth(2))]
 L1:
 L3 [afterCatches]:
-L4 [stop [d0, d1]]:
     <END>                                             NEXT:[<SINK>]                                       PREV:[ret(*) L1, jmp(L3 [afterCatches])]
 error:
     <ERROR>                                           NEXT:[<SINK>]                                       PREV:[]
@@ -992,7 +960,6 @@ L4 [start finally]:
     r(doSmth(3))                                      NEXT:[ret(*) L1]                                                                    PREV:[r(doSmth)]
 L5 [finish finally]:
     ret(*) L1                                         NEXT:[<END>]                                                                        PREV:[r(doSmth(3))]
-d0:
 -   jmp(L6 [afterCatches])                            NEXT:[jmp(L7 [skipFinallyToErrorBlock])]                                            PREV:[]
 L2 [onException]:
     v(e: UnsupportedOperationException)               NEXT:[w(e)]                                                                         PREV:[jmp?(L2 [onException])]
@@ -1002,7 +969,6 @@ L2 [onException]:
     r(doSmth)                                         NEXT:[r(doSmth(3))]                                                                 PREV:[r(3)]
     r(doSmth(3))                                      NEXT:[ret(*) L1]                                                                    PREV:[r(doSmth)]
     ret(*) L1                                         NEXT:[<END>]                                                                        PREV:[r(doSmth(3))]
-d1:
 -   jmp(L6 [afterCatches])                            NEXT:[jmp(L7 [skipFinallyToErrorBlock])]                                            PREV:[]
 L6 [afterCatches]:
 -   jmp(L7 [skipFinallyToErrorBlock])                 NEXT:[r(3)]                                                                         PREV:[]
@@ -1016,7 +982,6 @@ L7 [skipFinallyToErrorBlock]:
 -   r(doSmth)                                         NEXT:[r(doSmth(3))]                                                                 PREV:[]
 -   r(doSmth(3))                                      NEXT:[<END>]                                                                        PREV:[]
 L1:
-L8 [stop [d0, d1]]:
     <END>                                             NEXT:[<SINK>]                                                                       PREV:[ret(*) L1, ret(*) L1]
 error:
     <ERROR>                                           NEXT:[<SINK>]                                                                       PREV:[jmp(error)]
@@ -1052,7 +1017,6 @@ L0:
     r(1)                                              NEXT:[r(doSmth)]                                                                    PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
     r(doSmth)                                         NEXT:[r(doSmth(1))]                                                                 PREV:[r(1)]
     r(doSmth(1))                                      NEXT:[jmp(L4 [afterCatches])]                                                       PREV:[r(doSmth)]
-d0:
     jmp(L4 [afterCatches])                            NEXT:[jmp(L7 [skipFinallyToErrorBlock])]                                            PREV:[r(doSmth(1))]
 L2 [onException]:
     v(e: UnsupportedOperationException)               NEXT:[w(e)]                                                                         PREV:[jmp?(L2 [onException])]
@@ -1064,7 +1028,6 @@ L5 [start finally]:
     r(doSmth(3))                                      NEXT:[ret(*) L1]                                                                    PREV:[r(doSmth)]
 L6 [finish finally]:
     ret(*) L1                                         NEXT:[<END>]                                                                        PREV:[r(doSmth(3))]
-d1:
 -   jmp(L4 [afterCatches])                            NEXT:[jmp(L7 [skipFinallyToErrorBlock])]                                            PREV:[]
 L4 [afterCatches]:
     jmp(L7 [skipFinallyToErrorBlock])                 NEXT:[r(3)]                                                                         PREV:[jmp(L4 [afterCatches])]
@@ -1078,7 +1041,6 @@ L7 [skipFinallyToErrorBlock]:
     r(doSmth)                                         NEXT:[r(doSmth(3))]                                                                 PREV:[r(3)]
     r(doSmth(3))                                      NEXT:[<END>]                                                                        PREV:[r(doSmth)]
 L1:
-L8 [stop [d0, d1]]:
     <END>                                             NEXT:[<SINK>]                                                                       PREV:[ret(*) L1, r(doSmth(3))]
 error:
     <ERROR>                                           NEXT:[<SINK>]                                                                       PREV:[jmp(error)]

compiler/testData/cfg/FinallyTestCopy.instructions

@@ -32,7 +32,6 @@ L0:
     jmp?(L3 [onExceptionToFinallyBlock])     NEXT:[r(1), r(doSmth)]                                             PREV:[jmp?(L2 [onException])]
     r(doSmth)                                NEXT:[r(doSmth())]                                                 PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
     r(doSmth())                              NEXT:[jmp(L4 [afterCatches])]                                      PREV:[r(doSmth)]
-d0:
     jmp(L4 [afterCatches])                   NEXT:[jmp(L6 [skipFinallyToErrorBlock])]                           PREV:[r(doSmth())]
 L2 [onException]:
     jmp?(L5 [catch 0])                       NEXT:[v(e: Exception), v(e: NullPointerException)]                 PREV:[jmp?(L2 [onException])]
@@ -40,14 +39,12 @@ L2 [onException]:
     w(e)                                     NEXT:[r(doSmth1)]                                                  PREV:[v(e: NullPointerException)]
     r(doSmth1)                               NEXT:[r(doSmth1())]                                                PREV:[w(e)]
     r(doSmth1())                             NEXT:[jmp(L4 [afterCatches])]                                      PREV:[r(doSmth1)]
-d1:
     jmp(L4 [afterCatches])                   NEXT:[jmp(L6 [skipFinallyToErrorBlock])]                           PREV:[r(doSmth1())]
 L5 [catch 0]:
     v(e: Exception)                          NEXT:[w(e)]                                                        PREV:[jmp?(L5 [catch 0])]
     w(e)                                     NEXT:[r(doSmth2)]                                                  PREV:[v(e: Exception)]
     r(doSmth2)                               NEXT:[r(doSmth2())]                                                PREV:[w(e)]
     r(doSmth2())                             NEXT:[jmp(L4 [afterCatches])]                                      PREV:[r(doSmth2)]
-d2:
     jmp(L4 [afterCatches])                   NEXT:[jmp(L6 [skipFinallyToErrorBlock])]                           PREV:[r(doSmth2())]
 L4 [afterCatches]:
     jmp(L6 [skipFinallyToErrorBlock])        NEXT:[r(1)]                                                        PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
@@ -61,7 +58,6 @@ L6 [skipFinallyToErrorBlock]:
     r(1)                                     NEXT:[ret(*) L1]                                                   PREV:[jmp(L6 [skipFinallyToErrorBlock])]
     ret(*) L1                                NEXT:[<END>]                                                       PREV:[r(1)]
 L1:
-L9 [stop [d0, d1, d2]]:
     <END>                                    NEXT:[<SINK>]                                                      PREV:[ret(*) L1, ret(*) L1]
 error:
     <ERROR>                                  NEXT:[<SINK>]                                                      PREV:[]
@@ -127,7 +123,6 @@ L4 [body entry point]:
     jmp?(L7 [onExceptionToFinallyBlock])         NEXT:[r(cond), r(doSmth)]                                          PREV:[jmp?(L6 [onException])]
     r(doSmth)                                    NEXT:[r(doSmth())]                                                 PREV:[jmp?(L7 [onExceptionToFinallyBlock])]
     r(doSmth())                                  NEXT:[jmp(L8 [afterCatches])]                                      PREV:[r(doSmth)]
-d0:
     jmp(L8 [afterCatches])                       NEXT:[jmp(L10 [skipFinallyToErrorBlock])]                          PREV:[r(doSmth())]
 L6 [onException]:
     jmp?(L9 [catch 0])                           NEXT:[v(e: Exception), v(e: NullPointerException)]                 PREV:[jmp?(L6 [onException])]
@@ -135,14 +130,12 @@ L6 [onException]:
     w(e)                                         NEXT:[r(doSmth1)]                                                  PREV:[v(e: NullPointerException)]
     r(doSmth1)                                   NEXT:[r(doSmth1())]                                                PREV:[w(e)]
     r(doSmth1())                                 NEXT:[jmp(L8 [afterCatches])]                                      PREV:[r(doSmth1)]
-d1:
     jmp(L8 [afterCatches])                       NEXT:[jmp(L10 [skipFinallyToErrorBlock])]                          PREV:[r(doSmth1())]
 L9 [catch 0]:
     v(e: Exception)                              NEXT:[w(e)]                                                        PREV:[jmp?(L9 [catch 0])]
     w(e)                                         NEXT:[r(doSmth2)]                                                  PREV:[v(e: Exception)]
     r(doSmth2)                                   NEXT:[r(doSmth2())]                                                PREV:[w(e)]
     r(doSmth2())                                 NEXT:[jmp(L8 [afterCatches])]                                      PREV:[r(doSmth2)]
-d2:
     jmp(L8 [afterCatches])                       NEXT:[jmp(L10 [skipFinallyToErrorBlock])]                          PREV:[r(doSmth2())]
 L8 [afterCatches]:
     jmp(L10 [skipFinallyToErrorBlock])           NEXT:[r(cond)]                                                     PREV:[jmp(L8 [afterCatches]), jmp(L8 [afterCatches]), jmp(L8 [afterCatches])]
@@ -165,7 +158,6 @@ L10 [skipFinallyToErrorBlock]:
     ret L1                                       NEXT:[<END>]                                                       PREV:[jf(copy L12)]
 -   jmp(copy L13)                                NEXT:[jmp(L2 [loop entry point])]                                  PREV:[]
     jmp(L2 [loop entry point])                   NEXT:[r(cond)]                                                     PREV:[jf(copy L12)]
-L15 [stop [d0, d1, d2]]:
 -   jmp(L2 [loop entry point])                   NEXT:[r(cond)]                                                     PREV:[]
 L3 [loop exit point]:
     read (Unit)                                  NEXT:[<END>]                                                       PREV:[jf(L3 [loop exit point])]
@@ -210,7 +202,6 @@ L0:
     jmp?(L3 [onExceptionToFinallyBlock])     NEXT:[r(while (cond())), r(doSmth)]                                PREV:[jmp?(L2 [onException])]
     r(doSmth)                                NEXT:[r(doSmth())]                                                 PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
     r(doSmth())                              NEXT:[jmp(L4 [afterCatches])]                                      PREV:[r(doSmth)]
-d0:
     jmp(L4 [afterCatches])                   NEXT:[jmp(L6 [skipFinallyToErrorBlock])]                           PREV:[r(doSmth())]
 L2 [onException]:
     jmp?(L5 [catch 0])                       NEXT:[v(e: Exception), v(e: NullPointerException)]                 PREV:[jmp?(L2 [onException])]
@@ -218,14 +209,12 @@ L2 [onException]:
     w(e)                                     NEXT:[r(doSmth1)]                                                  PREV:[v(e: NullPointerException)]
     r(doSmth1)                               NEXT:[r(doSmth1())]                                                PREV:[w(e)]
     r(doSmth1())                             NEXT:[jmp(L4 [afterCatches])]                                      PREV:[r(doSmth1)]
-d1:
     jmp(L4 [afterCatches])                   NEXT:[jmp(L6 [skipFinallyToErrorBlock])]                           PREV:[r(doSmth1())]
 L5 [catch 0]:
     v(e: Exception)                          NEXT:[w(e)]                                                        PREV:[jmp?(L5 [catch 0])]
     w(e)                                     NEXT:[r(doSmth2)]                                                  PREV:[v(e: Exception)]
     r(doSmth2)                               NEXT:[r(doSmth2())]                                                PREV:[w(e)]
     r(doSmth2())                             NEXT:[jmp(L4 [afterCatches])]                                      PREV:[r(doSmth2)]
-d2:
     jmp(L4 [afterCatches])                   NEXT:[jmp(L6 [skipFinallyToErrorBlock])]                           PREV:[r(doSmth2())]
 L4 [afterCatches]:
     jmp(L6 [skipFinallyToErrorBlock])        NEXT:[r(while (cond()))]                                           PREV:[jmp(L4 [afterCatches]), jmp(L4 [afterCatches]), jmp(L4 [afterCatches])]
@@ -251,7 +240,6 @@ L6 [skipFinallyToErrorBlock]:
     jmp(copy L8 [loop entry point])          NEXT:[r(cond)]                                                     PREV:[jf(copy L9 [loop exit point])]
     read (Unit)                              NEXT:[<END>]                                                       PREV:[jf(copy L9 [loop exit point])]
 L1:
-L13 [stop [d0, d1, d2]]:
     <END>                                    NEXT:[<SINK>]                                                      PREV:[read (Unit)]
 error:
     <ERROR>                                  NEXT:[<SINK>]                                                      PREV:[jmp(error)]
@@ -281,7 +269,6 @@ L0:
     jmp?(L2 [onExceptionToFinallyBlock])    NEXT:[r(list), r(doSmth)]                      PREV:[r(try { doSmth() } finally {..)]
     r(doSmth)                               NEXT:[r(doSmth())]                             PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
     r(doSmth())                             NEXT:[jmp(L3 [skipFinallyToErrorBlock])]       PREV:[r(doSmth)]
-d0:
     jmp(L3 [skipFinallyToErrorBlock])       NEXT:[r(list)]                                 PREV:[r(doSmth())]
 L2 [onExceptionToFinallyBlock]:
 L4 [start finally]:
@@ -307,7 +294,6 @@ L3 [skipFinallyToErrorBlock]:
     jmp(copy L6)                            NEXT:[<END>]                                   PREV:[read (Unit)]
     read (Unit)                             NEXT:[<END>]                                   PREV:[jf(copy L5)]
 L1:
-L8 [stop [d0]]:
     <END>                                   NEXT:[<SINK>]                                  PREV:[jmp(copy L6), read (Unit)]
 error:
     <ERROR>                                 NEXT:[<SINK>]                                  PREV:[jmp(error)]