improved processing of local declarations in cfg construction

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

@@ -93,7 +93,10 @@ public class JetControlFlowGraphTraverser<D> {
             Collection<D> incomingEdgesData = Sets.newHashSet();
 
             for (Instruction previousInstruction : allPreviousInstructions) {
-                incomingEdgesData.add(dataMap.get(previousInstruction).getSecond());
+                Pair<D, D> previousData = dataMap.get(previousInstruction);
+                if (previousData != null) {
+                    incomingEdgesData.add(previousData.getSecond());
+                }
             }
             Pair<D, D> mergedData = instructionsMergeStrategy.execute(instruction, incomingEdgesData);
             if (!mergedData.equals(previousDataValue)) {

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

@@ -22,6 +22,7 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 
 /**
 * @author abreslav
+* @author svtk
 */
 public class JetControlFlowProcessor {
 
@@ -547,7 +548,10 @@ public class JetControlFlowProcessor {
         public void visitNamedFunction(JetNamedFunction function) {
             JetExpression bodyExpression = function.getBodyExpression();
             if (bodyExpression != null) {
+                Label afterFunctionLabel = builder.createUnboundLabel();
+                builder.nondeterministicJump(afterFunctionLabel);
                 generate(function, bodyExpression);
+                builder.bindLabel(afterFunctionLabel);
             }
         }
 
@@ -557,7 +561,10 @@ public class JetControlFlowProcessor {
             JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
             if (bodyExpression != null) {
                 List<JetElement> statements = bodyExpression.getStatements();
+                Label afterFunctionLiteralLabel = builder.createUnboundLabel();
+                builder.nondeterministicJump(afterFunctionLiteralLabel);
                 generateSubroutineControlFlow(functionLiteral, statements);
+                builder.bindLabel(afterFunctionLiteralLabel);
             }
             builder.read(expression);
         }
@@ -744,28 +751,9 @@ public class JetControlFlowProcessor {
                     functions.add(localDeclaration);
                 }
             }
-            Queue<Label> declarationLabels = new LinkedList<Label>();
             for (JetDeclaration function : functions) {
-                declarationLabels.add(builder.createUnboundLabel());
+                value(function, inCondition);
             }
-            builder.nondeterministicJump(Lists.newArrayList(declarationLabels));
-
-            for (JetDeclaration function : functions) {
-                if (function instanceof JetNamedDeclaration) {
-                    if (function instanceof JetDeclarationWithBody) {
-                        JetExpression bodyExpression = ((JetDeclarationWithBody) function).getBodyExpression();
-                        generate(function, bodyExpression != null ? bodyExpression : function);
-                    }
-                    else {
-                        generate(function, function);
-                    }
-                }
-                else {
-                    generate(declaration, function);
-                }
-                builder.bindLabel(declarationLabels.remove());
-            }
-
             builder.read(expression);
         }
 

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

@@ -92,11 +92,20 @@ public class JetFlowInformationProvider {
 
                 @Override
                 public void visitUnconditionalJump(UnconditionalJumpInstruction instruction) {
+                    redirectToPrevInstructions(instruction);
+                }
+
+                private void redirectToPrevInstructions(Instruction instruction) {
                     for (Instruction previousInstruction : instruction.getPreviousInstructions()) {
                         previousInstruction.accept(this);
                     }
                 }
 
+                @Override
+                public void visitNondeterministicJump(NondeterministicJumpInstruction instruction) {
+                    redirectToPrevInstructions(instruction);
+                }
+
                 @Override
                 public void visitInstruction(Instruction instruction) {
                     if (instruction instanceof JetElementInstruction) {
@@ -127,7 +136,7 @@ public class JetFlowInformationProvider {
         final Pseudocode pseudocode = pseudocodeMap.get(subroutine);
         assert pseudocode != null;
 
-        JetControlFlowGraphTraverser<Map<VariableDescriptor, InitializationPoints>> traverser = JetControlFlowGraphTraverser.create(pseudocode, true);
+        JetControlFlowGraphTraverser<Map<VariableDescriptor, InitializationPoints>> traverser = JetControlFlowGraphTraverser.create(pseudocode, false);
 
         JetControlFlowGraphTraverser.InstructionsMergeStrategy<Map<VariableDescriptor, InitializationPoints>> instructionsMergeStrategy =
                 new JetControlFlowGraphTraverser.InstructionsMergeStrategy<Map<VariableDescriptor, InitializationPoints>>() {
@@ -218,7 +227,7 @@ public class JetFlowInformationProvider {
                             JetProperty property = psiElement instanceof JetProperty ? (JetProperty) psiElement : null;
                             trace.report(Errors.VAL_REASSIGNMENT.on(expression, variableDescriptor, property == null ? new JetProperty[0] : new JetProperty[] { property }));
                         }
-                        if (expression instanceof JetSimpleNameExpression && !analyzeLocalDeclaration && inAnonymousInitializers &&
+                        if (expression instanceof JetSimpleNameExpression && inAnonymousInitializers &&
                             variableDescriptor instanceof PropertyDescriptor && !enterInitializationPoints.isInitialized() && exitInitializationPoints.isInitialized()) {
                             JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
                             if (simpleNameExpression.getReferencedNameElementType() != JetTokens.FIELD_IDENTIFIER) {
@@ -238,6 +247,14 @@ public class JetFlowInformationProvider {
                 trace.record(BindingContext.IS_INITIALIZED, (PropertyDescriptor) variable, initializationPoints.isInitialized());
             }
         }
+        for (Instruction instruction : pseudocode.getInstructions()) {
+            if (instruction instanceof LocalDeclarationInstruction) {
+                JetElement element = ((LocalDeclarationInstruction) instruction).getElement();
+                if (element instanceof JetNamedFunction) {
+                    markUninitializedVariables(element, false, analyzeLocalDeclaration);
+                }
+            }
+        }
     }
 
     private Map<VariableDescriptor, InitializationPoints> prepareInitialMapForStartInstruction(Collection<VariableDescriptor> usedVariables, Collection<VariableDescriptor> declaredVariables) {

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

@@ -178,8 +178,7 @@ public class Pseudocode {
                 @Override
                 public void visitLocalDeclarationInstruction(LocalDeclarationInstruction instruction) {
                     instruction.getBody().postProcess();
-                    instruction.setSink(getSinkInstruction());
+                    instruction.setNext(getSinkInstruction());
-                    super.visitLocalDeclarationInstruction(instruction);
                 }
 
                 @Override
@@ -224,29 +223,12 @@ public class Pseudocode {
     @NotNull
     private Instruction getJumpTarget(@NotNull Label targetLabel) {
         return ((PseudocodeLabel)targetLabel).resolveToInstruction();
-        //return getTargetInstruction(((PseudocodeLabel) targetLabel).resolve());
     }
 
-//    @NotNull
-//    private Instruction getTargetInstruction(@NotNull List<Instruction> instructions) {
-//        while (true) {
-//            assert instructions != null;
-//            Instruction targetInstruction = instructions.get(0);
-//
-//            //if (false == targetInstruction instanceof UnconditionalJumpInstruction) {
-//                return targetInstruction;
-//            //}
-//
-////            Label label = ((UnconditionalJumpInstruction) targetInstruction).getTargetLabel();
-////            instructions = ((PseudocodeLabel)label).resolve();
-//        }
-//    }
-
     @NotNull
     private Instruction getNextPosition(int currentPosition) {
         int targetPosition = currentPosition + 1;
         assert targetPosition < instructions.size() : currentPosition;
         return instructions.get(targetPosition);
-        //return getTargetInstruction(instructions.subList(targetPosition, instructions.size()));
     }
 }

compiler/testData/cfg/Basic.instructions

@@ -1,10 +1,10 @@
 == anonymous_0 ==
 {1}
 ---------------------
-l2:
+l3:
     <START>    NEXT:[r(1)]      PREV:[]
     r(1)       NEXT:[<END>]     PREV:[<START>]
-l3:
+l4:
     <END>      NEXT:[<SINK>]    PREV:[r(1)]
 error:
     <ERROR>    NEXT:[]          PREV:[]
@@ -42,9 +42,11 @@ l0:
     r(foo)              NEXT:[r(foo(a, 3))]               PREV:[r(3)]
     r(foo(a, 3))        NEXT:[r(genfun)]                  PREV:[r(foo)]
     r(genfun)           NEXT:[r(genfun<Any>())]           PREV:[r(foo(a, 3))]
-    r(genfun<Any>())    NEXT:[df({1})]                    PREV:[r(genfun)]
+    r(genfun<Any>())    NEXT:[jmp?(l2)]                   PREV:[r(genfun)]
-    df({1})             NEXT:[<SINK>, r({1})]             PREV:[r(genfun<Any>())]
+    jmp?(l2)            NEXT:[r({1}), df({1})]            PREV:[r(genfun<Any>())]
-    r({1})              NEXT:[r(flfun)]                   PREV:[df({1})]
+    df({1})             NEXT:[<SINK>]                     PREV:[jmp?(l2)]
+l2:
+    r({1})              NEXT:[r(flfun)]                   PREV:[jmp?(l2)]
     r(flfun)            NEXT:[r(flfun {1})]               PREV:[r({1})]
     r(flfun {1})        NEXT:[r(3)]                       PREV:[r(flfun)]
     r(3)                NEXT:[r(4)]                       PREV:[r(flfun {1})]
@@ -60,26 +62,26 @@ l0:
     r(2)                NEXT:[r(+)]                       PREV:[r(1)]
     r(+)                NEXT:[r(1 + 2)]                   PREV:[r(2)]
     r(1 + 2)            NEXT:[r(a)]                       PREV:[r(+)]
-    r(a)                NEXT:[jf(l4)]                     PREV:[r(1 + 2)]
+    r(a)                NEXT:[jf(l5)]                     PREV:[r(1 + 2)]
-    jf(l4)              NEXT:[r(a && true), r(true)]      PREV:[r(a)]
+    jf(l5)              NEXT:[r(a && true), r(true)]      PREV:[r(a)]
-    r(true)             NEXT:[r(a && true)]               PREV:[jf(l4)]
+    r(true)             NEXT:[r(a && true)]               PREV:[jf(l5)]
-l4:
-    r(a && true)        NEXT:[r(a)]                       PREV:[jf(l4), r(true)]
-    r(a)                NEXT:[jt(l5)]                     PREV:[r(a && true)]
-    jt(l5)              NEXT:[r(false), r(a || false)]    PREV:[r(a)]
-    r(false)            NEXT:[r(a || false)]              PREV:[jt(l5)]
 l5:
-    r(a || false)       NEXT:[<END>]                      PREV:[jt(l5), r(false)]
+    r(a && true)        NEXT:[r(a)]                       PREV:[jf(l5), r(true)]
+    r(a)                NEXT:[jt(l6)]                     PREV:[r(a && true)]
+    jt(l6)              NEXT:[r(false), r(a || false)]    PREV:[r(a)]
+    r(false)            NEXT:[r(a || false)]              PREV:[jt(l6)]
+l6:
+    r(a || false)       NEXT:[<END>]                      PREV:[jt(l6), r(false)]
 l1:
     <END>               NEXT:[<SINK>]                     PREV:[r(a || false)]
 error:
     <ERROR>             NEXT:[]                           PREV:[]
 sink:
     <SINK>              NEXT:[]                           PREV:[df({1}), <END>]
-l2:
+l3:
     <START>    NEXT:[r(1)]      PREV:[]
     r(1)       NEXT:[<END>]     PREV:[<START>]
-l3:
+l4:
     <END>      NEXT:[<SINK>]    PREV:[r(1)]
 error:
     <ERROR>    NEXT:[]          PREV:[]

compiler/testData/cfg/Finally.instructions

@@ -1,5 +1,5 @@
-== t3 ==
+== t1 ==
-fun t3() {
+fun t1() {
   try {
     1
   } finally {
@@ -20,8 +20,8 @@ error:
 sink:
     <SINK>      NEXT:[]              PREV:[<END>]
 =====================
-== t3 ==
+== t2 ==
-fun t3() {
+fun t2() {
   try {
     1
     if (2 > 3) {
@@ -63,20 +63,20 @@ sink:
         }
     }
 ---------------------
-l3:
+l4:
     <START>        NEXT:[r(2)]                   PREV:[]
     r(2)           NEXT:[r(3)]                   PREV:[<START>]
     r(3)           NEXT:[r(>)]                   PREV:[r(2)]
     r(>)           NEXT:[r(2 > 3)]               PREV:[r(3)]
-    r(2 > 3)       NEXT:[jf(l5)]                 PREV:[r(>)]
+    r(2 > 3)       NEXT:[jf(l6)]                 PREV:[r(>)]
-    jf(l5)         NEXT:[read (Unit), ret l4]    PREV:[r(2 > 3)]
+    jf(l6)         NEXT:[read (Unit), ret l5]    PREV:[r(2 > 3)]
-    ret l4         NEXT:[<END>]                  PREV:[jf(l5)]
+    ret l5         NEXT:[<END>]                  PREV:[jf(l6)]
-*   jmp(l6)        NEXT:[<END>]                  PREV:[]
+*   jmp(l7)        NEXT:[<END>]                  PREV:[]
-l5:
-    read (Unit)    NEXT:[<END>]                  PREV:[jf(l5)]
-l4:
 l6:
-    <END>          NEXT:[<SINK>]                 PREV:[ret l4, read (Unit)]
+    read (Unit)    NEXT:[<END>]                  PREV:[jf(l6)]
+l5:
+l7:
+    <END>          NEXT:[<SINK>]                 PREV:[ret l5, read (Unit)]
 error:
     <ERROR>        NEXT:[]                       PREV:[]
 sink:
@@ -97,41 +97,43 @@ fun t3() {
 }
 ---------------------
 l0:
-    <START>                 NEXT:[jmp?(l2)]                                   PREV:[]
+    <START>                 NEXT:[jmp?(l2)]                                                            PREV:[]
-    jmp?(l2)                NEXT:[r(2), r(1)]                                 PREV:[<START>]
+    jmp?(l2)                NEXT:[r(2), r(1)]                                                          PREV:[<START>]
-    r(1)                    NEXT:[df({ () => if (2 > 3) { retu..)]            PREV:[jmp?(l2)]
+    r(1)                    NEXT:[jmp?(l3)]                                                            PREV:[jmp?(l2)]
+    jmp?(l3)                NEXT:[r({ () => if (2 > 3) { retur..), df({ () => if (2 > 3) { retu..)]    PREV:[r(1)]
     df({ () =>          
             if (2 > 3) {
               return@   
             }           
-        })                  NEXT:[<SINK>, r({ () => if (2 > 3) { retur..)]    PREV:[r(1)]
+        })                  NEXT:[<SINK>]                                                              PREV:[jmp?(l3)]
+l3:
     r({ () =>           
             if (2 > 3) {
               return@   
             }           
-        })                  NEXT:[r(2)]                                       PREV:[df({ () => if (2 > 3) { retu..)]
+        })                  NEXT:[r(2)]                                                                PREV:[jmp?(l3)]
 l2:
-    r(2)                    NEXT:[<END>]                                      PREV:[jmp?(l2), r({ () => if (2 > 3) { retur..)]
+    r(2)                    NEXT:[<END>]                                                               PREV:[jmp?(l2), r({ () => if (2 > 3) { retur..)]
 l1:
-    <END>                   NEXT:[<SINK>]                                     PREV:[r(2)]
+    <END>                   NEXT:[<SINK>]                                                              PREV:[r(2)]
 error:
-    <ERROR>                 NEXT:[]                                           PREV:[]
+    <ERROR>                 NEXT:[]                                                                    PREV:[]
 sink:
-    <SINK>                  NEXT:[]                                           PREV:[df({ () => if (2 > 3) { retu..), <END>]
+    <SINK>                  NEXT:[]                                                                    PREV:[df({ () => if (2 > 3) { retu..), <END>]
-l3:
+l4:
     <START>        NEXT:[r(2)]                   PREV:[]
     r(2)           NEXT:[r(3)]                   PREV:[<START>]
     r(3)           NEXT:[r(>)]                   PREV:[r(2)]
     r(>)           NEXT:[r(2 > 3)]               PREV:[r(3)]
-    r(2 > 3)       NEXT:[jf(l5)]                 PREV:[r(>)]
+    r(2 > 3)       NEXT:[jf(l6)]                 PREV:[r(>)]
-    jf(l5)         NEXT:[read (Unit), ret l4]    PREV:[r(2 > 3)]
+    jf(l6)         NEXT:[read (Unit), ret l5]    PREV:[r(2 > 3)]
-    ret l4         NEXT:[<END>]                  PREV:[jf(l5)]
+    ret l5         NEXT:[<END>]                  PREV:[jf(l6)]
-*   jmp(l6)        NEXT:[<END>]                  PREV:[]
+*   jmp(l7)        NEXT:[<END>]                  PREV:[]
-l5:
-    read (Unit)    NEXT:[<END>]                  PREV:[jf(l5)]
-l4:
 l6:
-    <END>          NEXT:[<SINK>]                 PREV:[ret l4, read (Unit)]
+    read (Unit)    NEXT:[<END>]                  PREV:[jf(l6)]
+l5:
+l7:
+    <END>          NEXT:[<SINK>]                 PREV:[ret l5, read (Unit)]
 error:
     <ERROR>        NEXT:[]                       PREV:[]
 sink:
@@ -149,32 +151,32 @@ sink:
     }
   }
 ---------------------
-l2:
+l3:
-    <START>        NEXT:[jmp?(l4)]             PREV:[]
+    <START>        NEXT:[jmp?(l5)]             PREV:[]
-    jmp?(l4)       NEXT:[r(2), r(1)]           PREV:[<START>]
+    jmp?(l5)       NEXT:[r(2), r(1)]           PREV:[<START>]
-    r(1)           NEXT:[r(2)]                 PREV:[jmp?(l4)]
+    r(1)           NEXT:[r(2)]                 PREV:[jmp?(l5)]
     r(2)           NEXT:[r(3)]                 PREV:[r(1)]
     r(3)           NEXT:[r(>)]                 PREV:[r(2)]
     r(>)           NEXT:[r(2 > 3)]             PREV:[r(3)]
-    r(2 > 3)       NEXT:[jf(l5)]               PREV:[r(>)]
+    r(2 > 3)       NEXT:[jf(l6)]               PREV:[r(>)]
-    jf(l5)         NEXT:[read (Unit), r(2)]    PREV:[r(2 > 3)]
+    jf(l6)         NEXT:[read (Unit), r(2)]    PREV:[r(2 > 3)]
-    r(2)           NEXT:[ret l3]               PREV:[jf(l5)]
+    r(2)           NEXT:[ret l4]               PREV:[jf(l6)]
-    ret l3         NEXT:[<END>]                PREV:[r(2)]
+    ret l4         NEXT:[<END>]                PREV:[r(2)]
-*   jmp(l6)        NEXT:[r(2)]                 PREV:[]
+*   jmp(l7)        NEXT:[r(2)]                 PREV:[]
-l5:
-    read (Unit)    NEXT:[r(2)]                 PREV:[jf(l5)]
-l4:
 l6:
-    r(2)           NEXT:[<END>]                PREV:[jmp?(l4), read (Unit)]
+    read (Unit)    NEXT:[r(2)]                 PREV:[jf(l6)]
-l3:
+l5:
-    <END>          NEXT:[<SINK>]               PREV:[ret l3, r(2)]
+l7:
+    r(2)           NEXT:[<END>]                PREV:[jmp?(l5), read (Unit)]
+l4:
+    <END>          NEXT:[<SINK>]               PREV:[ret l4, r(2)]
 error:
     <ERROR>        NEXT:[]                     PREV:[]
 sink:
     <SINK>         NEXT:[]                     PREV:[<END>]
 =====================
-== t3 ==
+== t4 ==
-fun t3() {
+fun t4() {
   @{ () =>
     try {
       1
@@ -188,7 +190,8 @@ fun t3() {
 }
 ---------------------
 l0:
-    <START>               NEXT:[df({ () => try { 1 if (2 > 3..)]            PREV:[]
+    <START>               NEXT:[jmp?(l2)]                                                            PREV:[]
+    jmp?(l2)              NEXT:[r({ () => try { 1 if (2 > 3)..), df({ () => try { 1 if (2 > 3..)]    PREV:[<START>]
     df({ () =>        
         try {         
           1           
@@ -198,7 +201,8 @@ l0:
         } finally {   
           2           
         }             
-      })                  NEXT:[<SINK>, r({ () => try { 1 if (2 > 3)..)]    PREV:[<START>]
+      })                  NEXT:[<SINK>]                                                              PREV:[jmp?(l2)]
+l2:
     r({ () =>         
         try {         
           1           
@@ -208,39 +212,39 @@ l0:
         } finally {   
           2           
         }             
-      })                  NEXT:[<END>]                                      PREV:[df({ () => try { 1 if (2 > 3..)]
+      })                  NEXT:[<END>]                                                               PREV:[jmp?(l2)]
 l1:
-    <END>                 NEXT:[<SINK>]                                     PREV:[r({ () => try { 1 if (2 > 3)..)]
+    <END>                 NEXT:[<SINK>]                                                              PREV:[r({ () => try { 1 if (2 > 3)..)]
 error:
-    <ERROR>               NEXT:[]                                           PREV:[]
+    <ERROR>               NEXT:[]                                                                    PREV:[]
 sink:
-    <SINK>                NEXT:[]                                           PREV:[df({ () => try { 1 if (2 > 3..), <END>]
+    <SINK>                NEXT:[]                                                                    PREV:[df({ () => try { 1 if (2 > 3..), <END>]
-l2:
+l3:
-    <START>        NEXT:[jmp?(l4)]             PREV:[]
+    <START>        NEXT:[jmp?(l5)]             PREV:[]
-    jmp?(l4)       NEXT:[r(2), r(1)]           PREV:[<START>]
+    jmp?(l5)       NEXT:[r(2), r(1)]           PREV:[<START>]
-    r(1)           NEXT:[r(2)]                 PREV:[jmp?(l4)]
+    r(1)           NEXT:[r(2)]                 PREV:[jmp?(l5)]
     r(2)           NEXT:[r(3)]                 PREV:[r(1)]
     r(3)           NEXT:[r(>)]                 PREV:[r(2)]
     r(>)           NEXT:[r(2 > 3)]             PREV:[r(3)]
-    r(2 > 3)       NEXT:[jf(l5)]               PREV:[r(>)]
+    r(2 > 3)       NEXT:[jf(l6)]               PREV:[r(>)]
-    jf(l5)         NEXT:[read (Unit), r(2)]    PREV:[r(2 > 3)]
+    jf(l6)         NEXT:[read (Unit), r(2)]    PREV:[r(2 > 3)]
-    r(2)           NEXT:[ret l3]               PREV:[jf(l5)]
+    r(2)           NEXT:[ret l4]               PREV:[jf(l6)]
-    ret l3         NEXT:[<END>]                PREV:[r(2)]
+    ret l4         NEXT:[<END>]                PREV:[r(2)]
-*   jmp(l6)        NEXT:[r(2)]                 PREV:[]
+*   jmp(l7)        NEXT:[r(2)]                 PREV:[]
-l5:
-    read (Unit)    NEXT:[r(2)]                 PREV:[jf(l5)]
-l4:
 l6:
-    r(2)           NEXT:[<END>]                PREV:[jmp?(l4), read (Unit)]
+    read (Unit)    NEXT:[r(2)]                 PREV:[jf(l6)]
-l3:
+l5:
-    <END>          NEXT:[<SINK>]               PREV:[ret l3, r(2)]
+l7:
+    r(2)           NEXT:[<END>]                PREV:[jmp?(l5), read (Unit)]
+l4:
+    <END>          NEXT:[<SINK>]               PREV:[ret l4, r(2)]
 error:
     <ERROR>        NEXT:[]                     PREV:[]
 sink:
     <SINK>         NEXT:[]                     PREV:[<END>]
 =====================
-== t3 ==
+== t5 ==
-fun t3() {
+fun t5() {
   @ while(true) {
     try {
       1
@@ -285,8 +289,8 @@ error:
 sink:
     <SINK>         NEXT:[]                         PREV:[<END>]
 =====================
-== t3 ==
+== t6 ==
-fun t3() {
+fun t6() {
   try {
     @ while(true) {
         1
@@ -332,8 +336,8 @@ error:
 sink:
     <SINK>         NEXT:[]                        PREV:[<END>]
 =====================
-== t3 ==
+== t7 ==
-fun t3() {
+fun t7() {
   try {
     @ while(true) {
         1
@@ -377,8 +381,8 @@ error:
 sink:
     <SINK>         NEXT:[]                        PREV:[<END>]
 =====================
-== t3 ==
+== t8 ==
-fun t3(a : Int) {
+fun t8(a : Int) {
   @ for (i in 1..a) {
     try {
       1
@@ -427,8 +431,8 @@ error:
 sink:
     <SINK>         NEXT:[]                         PREV:[<END>]
 =====================
-== t3 ==
+== t9 ==
-fun t3(a : Int) {
+fun t9(a : Int) {
   try {
     @ for (i in 1..a) {
         1
@@ -478,8 +482,8 @@ error:
 sink:
     <SINK>         NEXT:[]                        PREV:[<END>]
 =====================
-== t3 ==
+== t10 ==
-fun t3(a : Int) {
+fun t10(a : Int) {
   try {
     @ for (i in 1..a) {
         1
@@ -527,8 +531,8 @@ error:
 sink:
     <SINK>         NEXT:[]                        PREV:[<END>]
 =====================
-== tf ==
+== t11 ==
-fun tf() {
+fun t11() {
   try {
     return 1
   }

compiler/testData/cfg/Finally.jet

@@ -1,4 +1,4 @@
-fun t3() {
+fun t1() {
   try {
     1
   } finally {
@@ -6,7 +6,7 @@ fun t3() {
   }
 }
 
-fun t3() {
+fun t2() {
   try {
     1
     if (2 > 3) {
@@ -30,7 +30,7 @@ fun t3() {
   }
 }
 
-fun t3() {
+fun t4() {
   @{ () =>
     try {
       1
@@ -43,7 +43,7 @@ fun t3() {
   }
 }
 
-fun t3() {
+fun t5() {
   @ while(true) {
     try {
       1
@@ -56,7 +56,7 @@ fun t3() {
   }
 }
 
-fun t3() {
+fun t6() {
   try {
     @ while(true) {
         1
@@ -70,7 +70,7 @@ fun t3() {
   }
 }
 
-fun t3() {
+fun t7() {
   try {
     @ while(true) {
         1
@@ -83,7 +83,7 @@ fun t3() {
   }
 }
 
-fun t3(a : Int) {
+fun t8(a : Int) {
   @ for (i in 1..a) {
     try {
       1
@@ -96,7 +96,7 @@ fun t3(a : Int) {
   }
 }
 
-fun t3(a : Int) {
+fun t9(a : Int) {
   try {
     @ for (i in 1..a) {
         1
@@ -110,7 +110,7 @@ fun t3(a : Int) {
   }
 }
 
-fun t3(a : Int) {
+fun t10(a : Int) {
   try {
     @ for (i in 1..a) {
         1
@@ -123,7 +123,7 @@ fun t3(a : Int) {
   }
 }
 
-fun tf() {
+fun t11() {
   try {
     return 1
   }

compiler/testData/cfg/LocalDeclarations.instructions

@@ -0,0 +1,402 @@
+== C ==
+class C() {
+    val a: Int = 1
+
+    class object {
+        val x : Int
+
+        {
+            $x = 1
+        }
+
+
+        fun foo() {
+            val b : Int = 1
+            doSmth(b)
+        }
+    }
+}
+---------------------
+l0:
+    <START>    NEXT:[r(1)]      PREV:[]
+    r(1)       NEXT:[w(a)]      PREV:[<START>]
+    w(a)       NEXT:[<END>]     PREV:[r(1)]
+l1:
+    <END>      NEXT:[<SINK>]    PREV:[w(a)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== null ==
+object {
+        val x : Int
+
+        {
+            $x = 1
+        }
+
+
+        fun foo() {
+            val b : Int = 1
+            doSmth(b)
+        }
+    }
+---------------------
+l0:
+    <START>    NEXT:[r(1)]      PREV:[]
+    r(1)       NEXT:[w($x)]     PREV:[<START>]
+    w($x)      NEXT:[<END>]     PREV:[r(1)]
+l1:
+    <END>      NEXT:[<SINK>]    PREV:[w($x)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== O ==
+object O {
+    val x : Int
+    {
+        $x = 1
+    }
+}
+---------------------
+l0:
+    <START>    NEXT:[r(1)]      PREV:[]
+    r(1)       NEXT:[w($x)]     PREV:[<START>]
+    w($x)      NEXT:[<END>]     PREV:[r(1)]
+l1:
+    <END>      NEXT:[<SINK>]    PREV:[w($x)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== doSmth ==
+fun doSmth(i: Int) {}
+---------------------
+l0:
+    <START>        NEXT:[read (Unit)]    PREV:[]
+    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+l1:
+    <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
+error:
+    <ERROR>        NEXT:[]               PREV:[]
+sink:
+    <SINK>         NEXT:[]               PREV:[<END>]
+=====================
+== test1 ==
+fun test1() {
+    val a = object {
+        val x : Int
+        {
+            $x = 1
+        }
+    }
+}
+---------------------
+l0:
+    <START>                NEXT:[r(1)]                               PREV:[]
+    r(1)                   NEXT:[w($x)]                              PREV:[<START>]
+    w($x)                  NEXT:[r(object { val x : Int { $x ..)]    PREV:[r(1)]
+    r(object {         
+            val x : Int
+            {          
+                $x = 1 
+            }          
+        })                 NEXT:[w(a)]                               PREV:[w($x)]
+    w(a)                   NEXT:[<END>]                              PREV:[r(object { val x : Int { $x ..)]
+l1:
+    <END>                  NEXT:[<SINK>]                             PREV:[w(a)]
+error:
+    <ERROR>                NEXT:[]                                   PREV:[]
+sink:
+    <SINK>                 NEXT:[]                                   PREV:[<END>]
+=====================
+== test2 ==
+fun test2() {
+    val b = 1
+    val a = object {
+        val x = b
+    }
+}
+---------------------
+l0:
+    <START>              NEXT:[r(1)]                        PREV:[]
+    r(1)                 NEXT:[w(b)]                        PREV:[<START>]
+    w(b)                 NEXT:[r(b)]                        PREV:[r(1)]
+    r(b)                 NEXT:[w(x)]                        PREV:[w(b)]
+    w(x)                 NEXT:[r(object { val x = b }) ]    PREV:[r(b)]
+    r(object {       
+            val x = b
+        })               NEXT:[w(a)]                        PREV:[w(x)]
+    w(a)                 NEXT:[<END>]                       PREV:[r(object { val x = b }) ]
+l1:
+    <END>                NEXT:[<SINK>]                      PREV:[w(a)]
+error:
+    <ERROR>              NEXT:[]                            PREV:[]
+sink:
+    <SINK>               NEXT:[]                            PREV:[<END>]
+=====================
+== inner_bar ==
+fun inner_bar() {
+            y = 10
+        }
+---------------------
+l3:
+    <START>    NEXT:[r(10)]     PREV:[]
+    r(10)      NEXT:[w(y)]      PREV:[<START>]
+    w(y)       NEXT:[<END>]     PREV:[r(10)]
+l4:
+    <END>      NEXT:[<SINK>]    PREV:[w(y)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== test3 ==
+fun test3() {
+    val a = object {
+        val y : Int
+        fun inner_bar() {
+            y = 10
+        }
+    }
+}
+---------------------
+l0:
+    <START>                      NEXT:[jmp?(l2)]                                                            PREV:[]
+    jmp?(l2)                     NEXT:[r(object { val y : Int fun i..), df(fun inner_bar() { y = 10 ..)]    PREV:[<START>]
+    df(fun inner_bar() {     
+                y = 10       
+            })                   NEXT:[<SINK>]                                                              PREV:[jmp?(l2)]
+l2:
+    r(object {               
+            val y : Int      
+            fun inner_bar() {
+                y = 10       
+            }                
+        })                       NEXT:[w(a)]                                                                PREV:[jmp?(l2)]
+    w(a)                         NEXT:[<END>]                                                               PREV:[r(object { val y : Int fun i..)]
+l1:
+    <END>                        NEXT:[<SINK>]                                                              PREV:[w(a)]
+error:
+    <ERROR>                      NEXT:[]                                                                    PREV:[]
+sink:
+    <SINK>                       NEXT:[]                                                                    PREV:[df(fun inner_bar() { y = 10 ..), <END>]
+l3:
+    <START>    NEXT:[r(10)]     PREV:[]
+    r(10)      NEXT:[w(y)]      PREV:[<START>]
+    w(y)       NEXT:[<END>]     PREV:[r(10)]
+l4:
+    <END>      NEXT:[<SINK>]    PREV:[w(y)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== ggg ==
+fun ggg() {
+            y = 10
+        }
+---------------------
+l3:
+    <START>    NEXT:[r(10)]     PREV:[]
+    r(10)      NEXT:[w(y)]      PREV:[<START>]
+    w(y)       NEXT:[<END>]     PREV:[r(10)]
+l4:
+    <END>      NEXT:[<SINK>]    PREV:[w(y)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== test4 ==
+fun test4() {
+    val a = object {
+        val x : Int
+        val y : Int
+        {
+            $x = 1
+        }
+        fun ggg() {
+            y = 10
+        }
+    }
+}
+---------------------
+l0:
+    <START>                NEXT:[r(1)]                                                          PREV:[]
+    r(1)                   NEXT:[w($x)]                                                         PREV:[<START>]
+    w($x)                  NEXT:[jmp?(l2)]                                                      PREV:[r(1)]
+    jmp?(l2)               NEXT:[r(object { val x : Int val y..), df(fun ggg() { y = 10 }) ]    PREV:[w($x)]
+    df(fun ggg() {     
+                y = 10 
+            })             NEXT:[<SINK>]                                                        PREV:[jmp?(l2)]
+l2:
+    r(object {         
+            val x : Int
+            val y : Int
+            {          
+                $x = 1 
+            }          
+            fun ggg() {
+                y = 10 
+            }          
+        })                 NEXT:[w(a)]                                                          PREV:[jmp?(l2)]
+    w(a)                   NEXT:[<END>]                                                         PREV:[r(object { val x : Int val y..)]
+l1:
+    <END>                  NEXT:[<SINK>]                                                        PREV:[w(a)]
+error:
+    <ERROR>                NEXT:[]                                                              PREV:[]
+sink:
+    <SINK>                 NEXT:[]                                                              PREV:[df(fun ggg() { y = 10 }) , <END>]
+l3:
+    <START>    NEXT:[r(10)]     PREV:[]
+    r(10)      NEXT:[w(y)]      PREV:[<START>]
+    w(y)       NEXT:[<END>]     PREV:[r(10)]
+l4:
+    <END>      NEXT:[<SINK>]    PREV:[w(y)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== foo ==
+fun foo() {
+            x = 3
+        }
+---------------------
+l3:
+    <START>    NEXT:[r(3)]      PREV:[]
+    r(3)       NEXT:[w(x)]      PREV:[<START>]
+    w(x)       NEXT:[<END>]     PREV:[r(3)]
+l4:
+    <END>      NEXT:[<SINK>]    PREV:[w(x)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== bar ==
+fun bar() {
+            x = 4
+        }
+---------------------
+l6:
+    <START>    NEXT:[r(4)]      PREV:[]
+    r(4)       NEXT:[w(x)]      PREV:[<START>]
+    w(x)       NEXT:[<END>]     PREV:[r(4)]
+l7:
+    <END>      NEXT:[<SINK>]    PREV:[w(x)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== test5 ==
+fun test5() {
+    val a = object {
+        var x = 1
+        {
+            $x = 2
+        }
+        fun foo() {
+            x = 3
+        }
+        fun bar() {
+            x = 4
+        }
+    }
+}
+---------------------
+l0:
+    <START>                NEXT:[r(1)]                                                         PREV:[]
+    r(1)                   NEXT:[w(x)]                                                         PREV:[<START>]
+    w(x)                   NEXT:[r(2)]                                                         PREV:[r(1)]
+    r(2)                   NEXT:[w($x)]                                                        PREV:[w(x)]
+    w($x)                  NEXT:[jmp?(l2)]                                                     PREV:[r(2)]
+    jmp?(l2)               NEXT:[jmp?(l5), df(fun foo() { x = 3 }) ]                           PREV:[w($x)]
+    df(fun foo() {     
+                x = 3  
+            })             NEXT:[<SINK>]                                                       PREV:[jmp?(l2)]
+l2:
+    jmp?(l5)               NEXT:[r(object { var x = 1 { $x = ..), df(fun bar() { x = 4 }) ]    PREV:[jmp?(l2)]
+    df(fun bar() {     
+                x = 4  
+            })             NEXT:[<SINK>]                                                       PREV:[jmp?(l5)]
+l5:
+    r(object {         
+            var x = 1  
+            {          
+                $x = 2 
+            }          
+            fun foo() {
+                x = 3  
+            }          
+            fun bar() {
+                x = 4  
+            }          
+        })                 NEXT:[w(a)]                                                         PREV:[jmp?(l5)]
+    w(a)                   NEXT:[<END>]                                                        PREV:[r(object { var x = 1 { $x = ..)]
+l1:
+    <END>                  NEXT:[<SINK>]                                                       PREV:[w(a)]
+error:
+    <ERROR>                NEXT:[]                                                             PREV:[]
+sink:
+    <SINK>                 NEXT:[]                                                             PREV:[df(fun foo() { x = 3 }) , df(fun bar() { x = 4 }) , <END>]
+l3:
+    <START>    NEXT:[r(3)]      PREV:[]
+    r(3)       NEXT:[w(x)]      PREV:[<START>]
+    w(x)       NEXT:[<END>]     PREV:[r(3)]
+l4:
+    <END>      NEXT:[<SINK>]    PREV:[w(x)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+l6:
+    <START>    NEXT:[r(4)]      PREV:[]
+    r(4)       NEXT:[w(x)]      PREV:[<START>]
+    w(x)       NEXT:[<END>]     PREV:[r(4)]
+l7:
+    <END>      NEXT:[<SINK>]    PREV:[w(x)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================
+== foo ==
+fun foo() {
+            val b : Int = 1
+            doSmth(b)
+        }
+---------------------
+l0:
+    <START>         NEXT:[r(1)]            PREV:[]
+    r(1)            NEXT:[w(b)]            PREV:[<START>]
+    w(b)            NEXT:[r(b)]            PREV:[r(1)]
+    r(b)            NEXT:[r(doSmth)]       PREV:[w(b)]
+    r(doSmth)       NEXT:[r(doSmth(b))]    PREV:[r(b)]
+    r(doSmth(b))    NEXT:[<END>]           PREV:[r(doSmth)]
+l1:
+    <END>           NEXT:[<SINK>]          PREV:[r(doSmth(b))]
+error:
+    <ERROR>         NEXT:[]                PREV:[]
+sink:
+    <SINK>          NEXT:[]                PREV:[<END>]
+=====================
+== a ==
+val a: Int = 1
+---------------------
+l0:
+    <START>    NEXT:[r(1)]      PREV:[]
+    r(1)       NEXT:[<END>]     PREV:[<START>]
+l1:
+    <END>      NEXT:[<SINK>]    PREV:[r(1)]
+error:
+    <ERROR>    NEXT:[]          PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<END>]
+=====================

compiler/testData/cfg/LocalDeclarations.jet

@@ -0,0 +1,77 @@
+class C() {
+    val a: Int = 1
+
+    class object {
+        val x : Int
+
+        {
+            $x = 1
+        }
+
+
+        fun foo() {
+            val b : Int = 1
+            doSmth(b)
+        }
+    }
+}
+
+fun doSmth(i: Int) {}
+
+fun test1() {
+    val a = object {
+        val x : Int
+        {
+            $x = 1
+        }
+    }
+}
+
+object O {
+    val x : Int
+    {
+        $x = 1
+    }
+}
+
+fun test2() {
+    val b = 1
+    val a = object {
+        val x = b
+    }
+}
+fun test3() {
+    val a = object {
+        val y : Int
+        fun inner_bar() {
+            y = 10
+        }
+    }
+}
+fun test4() {
+    val a = object {
+        val x : Int
+        val y : Int
+        {
+            $x = 1
+        }
+        fun ggg() {
+            y = 10
+        }
+    }
+}
+
+fun test5() {
+    val a = object {
+        var x = 1
+        {
+            $x = 2
+        }
+        fun foo() {
+            x = 3
+        }
+        fun bar() {
+            x = 4
+        }
+    }
+}

compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet

@@ -269,17 +269,45 @@ fun foo() {
     val a = object {
         val x : Int
         val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
+        val z : Int
         {
             $x = 1
+            $z = 3
+        }
+        fun foo() {
+            <!VAL_REASSIGNMENT!>y<!> = 10
+            <!VAL_REASSIGNMENT!>z<!> = 13
         }
-//todo
-/*        fun foo() {
-            <VAL_REASSIGNMENT>y<> = 10
-        }*/
     }
 }
 
-object O {
+class TestObjectExpression() {
+    val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!> : Int
+    fun foo() {
+        val a = object {
+            val x : Int
+            val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
+            {
+                if (true)
+                    <!INITIALIZATION_USING_BACKING_FIELD!>x<!> = 12
+                else
+                    $x = 1
+            }
+            fun inner1() {
+                <!VAL_REASSIGNMENT!>y<!> = 101
+                <!VAL_REASSIGNMENT!>a<!> = 231
+            }
+            fun inner2() {
+                <!VAL_REASSIGNMENT!>y<!> = 101
+                <!VAL_REASSIGNMENT!>a<!> = 231
+            }
+        }
+    }
+}
+
+
+
+object TestObjectDeclaration {
     val x : Int
     val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
     {
@@ -296,7 +324,7 @@ object O {
     }
 }
 
-fun foo() {
+fun func() {
     val b = 1
     val a = object {
         val x = b

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

@@ -275,7 +275,7 @@ public class JetControlFlowTest extends JetLiteFixture {
 
                 @Override
                 public void visitUnconditionalJump(UnconditionalJumpInstruction instruction) {
-                    // Nothing
+                    printEdge(out, nodeToName.get(instruction), nodeToName.get(instruction.getResolvedTarget()), null);
                 }
 
                 @Override
@@ -334,9 +334,6 @@ public class JetControlFlowTest extends JetLiteFixture {
 
     public void dumpNodes(List<Instruction> instructions, PrintStream out, int[] count, Map<Instruction, String> nodeToName) {
         for (Instruction node : instructions) {
-            if (node instanceof UnconditionalJumpInstruction) {
-                continue;
-            }
             String name = "n" + count[0]++;
             nodeToName.put(node, name);
             String text = node.toString();
@@ -345,7 +342,7 @@ public class JetControlFlowTest extends JetLiteFixture {
                 text = text.substring(0, newline);
             }
             String shape = "box";
-            if (node instanceof ConditionalJumpInstruction) {
+            if (node instanceof ConditionalJumpInstruction || node instanceof UnconditionalJumpInstruction) {
                 shape = "diamond";
             }
             else if (node instanceof NondeterministicJumpInstruction) {