diff --git a/.idea/runConfigurations/All_Tests.xml b/.idea/runConfigurations/All_Tests.xml
index fe9f201fd2d1808f45b6a23d211ad1e9a929e880..80abd8cce40814ab374cf4fee0f2c06af6a5ca23 100644
--- a/.idea/runConfigurations/All_Tests.xml
+++ b/.idea/runConfigurations/All_Tests.xml
@@ -16,7 +16,6 @@
     <option name="VM_PARAMETERS" value="" />
     <option name="PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
-    <option name="FORK_MODE" />
     <option name="ENV_VARIABLES" />
     <option name="PASS_PARENT_ENVS" value="true" />
     <option name="TEST_SEARCH_SCOPE">
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java b/idea/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
index d9d2840aca7e582bff92b286bb6274b90e500c7a..6531bdf05b35c3419514c0e4a804486675e531d3 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
@@ -3,7 +3,6 @@ package org.jetbrains.jet.lang.cfg;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.psi.JetFunction;
 
 import java.util.Collection;
 
@@ -13,10 +12,16 @@ import java.util.Collection;
 public interface JetFlowInformationProvider {
     JetFlowInformationProvider ERROR = new JetFlowInformationProvider() {
         @Override
-        public void collectReturnedInformation(@NotNull JetFunction function, Collection<JetExpression> returnedExpressions, Collection<JetElement> elementsReturningUnit) {
+        public void collectReturnedInformation(@NotNull JetElement subroutine, Collection<JetExpression> returnedExpressions, Collection<JetElement> elementsReturningUnit) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void collectUnreachableExpressions(@NotNull JetElement subroutine, Collection<JetElement> unreachableElements) {
             throw new UnsupportedOperationException();
         }
     };
 
-    void collectReturnedInformation(@NotNull JetFunction function, Collection<JetExpression> returnedExpressions, Collection<JetElement> elementsReturningUnit);
+    void collectReturnedInformation(@NotNull JetElement subroutine, Collection<JetExpression> returnedExpressions, Collection<JetElement> elementsReturningUnit);
+    void collectUnreachableExpressions(@NotNull JetElement subroutine, Collection<JetElement> unreachableElements);
 }
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java
index 297b1d41c0a816cc4c97f625bc80e7540f205285..521a28723ba0338bd997720bea560c77d84ec0e6 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java
@@ -1,7 +1,11 @@
 package org.jetbrains.jet.lang.cfg.pseudocode;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.cfg.Label;
 
+import java.util.Collection;
+import java.util.Collections;
+
 /**
 * @author abreslav
 */
@@ -21,6 +25,12 @@ public abstract class AbstractJumpInstruction extends Instruction {
         return resolvedTarget;
     }
 
+    @NotNull
+    @Override
+    public Collection<Instruction> getNextInstructions() {
+        return Collections.singleton(getResolvedTarget());
+    }
+
     public void setResolvedTarget(Instruction resolvedTarget) {
         this.resolvedTarget = outgoingEdgeTo(resolvedTarget);
     }
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java
index 263d16667b504c997f61f8be38c0bf8d9a068f08..c37a665ada62d607bada8803871187213230c881 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java
@@ -1,7 +1,11 @@
 package org.jetbrains.jet.lang.cfg.pseudocode;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.cfg.Label;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 /**
 * @author abreslav
 */
@@ -35,6 +39,12 @@ public class ConditionalJumpInstruction extends AbstractJumpInstruction {
         this.nextOnFalse = outgoingEdgeTo(nextOnFalse);
     }
 
+    @NotNull
+    @Override
+    public Collection<Instruction> getNextInstructions() {
+        return Arrays.asList(getNextOnFalse(), getNextOnTrue());
+    }
+
     @Override
     public void accept(InstructionVisitor visitor) {
         visitor.visitConditionalJump(this);
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java
index d5a73b7884f798ef97670077527664b8f3945727..d2ae263ddd298a1a1b64253af0a974fada4d2f58 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java
@@ -1,5 +1,6 @@
 package org.jetbrains.jet.lang.cfg.pseudocode;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Collection;
@@ -15,6 +16,9 @@ public abstract class Instruction {
         return previousInstructions;
     }
 
+    @NotNull
+    public abstract Collection<Instruction> getNextInstructions();
+
     @Nullable
     protected Instruction outgoingEdgeTo(@Nullable Instruction target) {
         if (target != null) {
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java
index d7c7b16c1a811384b80d1786f5ea3953dc695067..a50bbf2cb08bc1302eb9ea7193a1d3b21d794a90 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java
@@ -3,6 +3,9 @@ package org.jetbrains.jet.lang.cfg.pseudocode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetElement;
 
+import java.util.Collection;
+import java.util.Collections;
+
 /**
  * @author abreslav
  */
@@ -17,6 +20,12 @@ public abstract class InstructionWithNext extends JetElementInstruction {
         return next;
     }
 
+    @NotNull
+    @Override
+    public Collection<Instruction> getNextInstructions() {
+        return Collections.singleton(next);
+    }
+
     public void setNext(Instruction next) {
         this.next = outgoingEdgeTo(next);
     }
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java
index f9a10afe6d4565f0a09df9e41285c5a143ebbf57..20a34886ddedaf0c960fbdf9fc8e312296fc0b06 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java
@@ -1,7 +1,11 @@
 package org.jetbrains.jet.lang.cfg.pseudocode;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.cfg.Label;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 /**
 * @author abreslav
 */
@@ -26,6 +30,12 @@ public class NondeterministicJumpInstruction extends AbstractJumpInstruction {
         this.next = next;
     }
 
+    @NotNull
+    @Override
+    public Collection<Instruction> getNextInstructions() {
+        return Arrays.asList(getResolvedTarget(), getNext());
+    }
+
     @Override
     public String toString() {
         return "jmp?(" + getTargetLabel().getName() + ")";
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java
index 4c912b8e1b425c018ec113b621d1f72a5393ff63..26514ff8eb2ba01c38b590992888fc71b428e07c 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java
@@ -69,6 +69,11 @@ public class Pseudocode {
         return label;
     }
 
+    @NotNull
+    public Collection<Instruction> getInstructions() {
+        return instructions;
+    }
+
     public void addInstruction(Instruction instruction) {
         instructions.add(instruction);
         if (instruction instanceof SubroutineExitInstruction) {
@@ -83,6 +88,11 @@ public class Pseudocode {
         return exitInstruction;
     }
 
+    @NotNull
+    public SubroutineEnterInstruction getEnterInstruction() {
+        return (SubroutineEnterInstruction) instructions.get(0);
+    }
+
     public void bindLabel(Label label) {
         ((PseudocodeLabel) label).setTargetInstructionIndex(instructions.size());
     }
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java
index a479b00d5e6e3d5f84e5c16e47692c046ccb08cb..169a51c048a7b3954de61419792465f98e941c5a 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java
@@ -27,6 +27,6 @@ public class ReturnNoValueInstruction extends AbstractJumpInstruction {
 
     @Override
     public String toString() {
-        return "ret";
+        return "ret " + getTargetLabel();
     }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java
index 0779d3c24b433816538a5b4129e7cb55a2113549..88166b8da6dc283957a9846c4d51848c955ceb44 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java
@@ -18,6 +18,6 @@ public class ReturnValueInstruction extends AbstractJumpInstruction {
 
     @Override
     public String toString() {
-        return "ret(*)";
+        return "ret(*) " + getTargetLabel();
     }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java
index c9c4138af3e27fc263526138d87d3cf93d6437c5..e46750724e42894f8f4705c908a8c39775906e42 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java
+++ b/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java
@@ -3,6 +3,9 @@ package org.jetbrains.jet.lang.cfg.pseudocode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetElement;
 
+import java.util.Collection;
+import java.util.Collections;
+
 /**
  * @author abreslav
  */
@@ -17,6 +20,12 @@ public class SubroutineExitInstruction extends Instruction {
         return subroutine;
     }
 
+    @NotNull
+    @Override
+    public Collection<Instruction> getNextInstructions() {
+        return Collections.emptyList();
+    }
+
     @Override
     public void accept(InstructionVisitor visitor) {
         visitor.visitSubroutineExit(this);
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
index 773f969e38c1b9eaccc066e5d639f3e024a98468..93073375829e204ab1018b4a8039c4c46b2c6805 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
@@ -268,21 +268,27 @@ public class TopDownAnalyzer {
                 JetFunction function = (JetFunction) declaration;
                 FunctionDescriptorImpl functionDescriptorImpl = (FunctionDescriptorImpl) descriptor;
                 if (bodyExpression != null) {
-                    JetFlowInformationProvider flowInformationProvider = computeFlowData(declaration, bodyExpression);
+                    JetFlowInformationProvider flowInformationProvider = computeFlowData(function, bodyExpression);
                     JetTypeInferrer typeInferrer = semanticServices.getTypeInferrer(trace, flowInformationProvider);
 
                     assert readyToProcessExpressions : "Must be ready collecting types";
 
                     if (function.getReturnTypeRef() != null) {
-                        typeInferrer.checkFunctionReturnType(declaringScope, function, descriptor);
+                        typeInferrer.checkFunctionReturnType(declaringScope, function, functionDescriptorImpl);
                     }
                     else {
-                        JetType returnType = typeInferrer.getFunctionReturnType(declaringScope, function, descriptor);
+                        JetType returnType = typeInferrer.getFunctionReturnType(declaringScope, function, functionDescriptorImpl);
                         if (returnType == null) {
                             returnType = ErrorUtils.createErrorType("Unable to infer body type");
                         }
                         functionDescriptorImpl.setUnsubstitutedReturnType(returnType);
                     }
+
+                    List<JetElement> unreachableElements = new ArrayList<JetElement>();
+                    flowInformationProvider.collectUnreachableExpressions(function, unreachableElements);
+                    for (JetElement unreachableElement : unreachableElements) {
+                        semanticServices.getErrorHandler().genericError(unreachableElement.getNode(), "Unreachable code");
+                    }
                 }
                 else {
                     if (function.getReturnTypeRef() == null) {
@@ -327,17 +333,44 @@ public class TopDownAnalyzer {
         wrappedTrace.close();
         return new JetFlowInformationProvider() {
             @Override
-            public void collectReturnedInformation(@NotNull JetFunction function, Collection<JetExpression> returnedExpressions, Collection<JetElement> elementsReturningUnit) {
-                Pseudocode pseudocode = pseudocodeMap.get(function);
+            public void collectReturnedInformation(@NotNull JetElement subroutine, Collection<JetExpression> returnedExpressions, Collection<JetElement> elementsReturningUnit) {
+                Pseudocode pseudocode = pseudocodeMap.get(subroutine);
                 assert pseudocode != null;
 
                 SubroutineExitInstruction exitInstruction = pseudocode.getExitInstruction();
-                processPreviousInstructions(exitInstruction, returnedExpressions, elementsReturningUnit);
+                processPreviousInstructions(exitInstruction, new HashSet<Instruction>(), returnedExpressions, elementsReturningUnit);
+            }
+
+            @Override
+            public void collectUnreachableExpressions(@NotNull JetElement subroutine, Collection<JetElement> unreachableElements) {
+                Pseudocode pseudocode = pseudocodeMap.get(subroutine);
+                assert pseudocode != null;
+
+                SubroutineEnterInstruction enterInstruction = pseudocode.getEnterInstruction();
+                Set<Instruction> visited = new HashSet<Instruction>();
+                collectReachable(enterInstruction, visited);
+
+                for (Instruction instruction : pseudocode.getInstructions()) {
+                    if (!visited.contains(instruction) && instruction instanceof JetElementInstruction) {
+                        unreachableElements.add(((JetElementInstruction) instruction).getElement());
+                    }
+                }
+
             }
         };
     }
 
-    private void processPreviousInstructions(Instruction previousFor, final Collection<JetExpression> returnedExpressions, final Collection<JetElement> elementsReturningUnit) {
+    private void collectReachable(Instruction current, Set<Instruction> visited) {
+        if (!visited.add(current)) return;
+
+        for (Instruction nextInstruction : current.getNextInstructions()) {
+            collectReachable(nextInstruction, visited);
+        }
+    }
+
+    private void processPreviousInstructions(Instruction previousFor, final Set<Instruction> visited, final Collection<JetExpression> returnedExpressions, final Collection<JetElement> elementsReturningUnit) {
+        if (!visited.add(previousFor)) return;
+
         Collection<Instruction> previousInstructions = previousFor.getPreviousInstructions();
         InstructionVisitor visitor = new InstructionVisitor() {
             @Override
@@ -347,7 +380,7 @@ public class TopDownAnalyzer {
 
             @Override
             public void visitReturnValue(ReturnValueInstruction instruction) {
-                processPreviousInstructions(instruction, returnedExpressions, elementsReturningUnit);
+                processPreviousInstructions(instruction, visited, returnedExpressions, elementsReturningUnit);
             }
 
             @Override
@@ -372,7 +405,7 @@ public class TopDownAnalyzer {
 
             @Override
             public void visitJump(AbstractJumpInstruction instruction) {
-                processPreviousInstructions(instruction, returnedExpressions, elementsReturningUnit);
+                processPreviousInstructions(instruction, visited, returnedExpressions, elementsReturningUnit);
             }
 
             @Override
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
index a13080a35f18be01089b036e8fc02622d1171eca..dd763d70bc82783d18ae7fac5e53870e86ac7468 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
+++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
@@ -348,7 +348,9 @@ public class JetTypeInferrer {
     }
 
     private JetType getBlockReturnedTypeWithWritableScope(@NotNull WritableScope scope, @NotNull List<? extends JetElement> block) {
-        assert !block.isEmpty();
+        if (block.isEmpty()) {
+            return JetStandardClasses.getUnitType();
+        }
 
         TypeInferrerVisitorWithWritableScope blockLevelVisitor = new TypeInferrerVisitorWithWritableScope(scope, true);
 
diff --git a/idea/testData/cfg/Nonlocals.instructions b/idea/testData/cfg/Nonlocals.instructions
index 042f52d49afc77c77dd84402236f466215718c07..baf838b01321b25fea127679b440de310ff39585 100644
--- a/idea/testData/cfg/Nonlocals.instructions
+++ b/idea/testData/cfg/Nonlocals.instructions
@@ -9,7 +9,7 @@ l6:
     r(b)
     jf(l8)
     r(1)
-    ret(*)
+    ret(*) l5
     jmp(l9)
 l8:
     read (Unit)
@@ -32,7 +32,7 @@ l4:
     <START>
     r(2)
     r(5)
-    ret(*)
+    ret(*) l5
 l5:
     <END>
 =====================
@@ -60,7 +60,7 @@ l0:
     r(a)
     jf(l2)
     r(1)
-    ret(*)
+    ret(*) l1
     jmp(l3)
 l2:
     read (Unit)
@@ -84,7 +84,7 @@ l4:
     <START>
     r(2)
     r(5)
-    ret(*)
+    ret(*) l5
 l5:
     <END>
 =====================
diff --git a/idea/testData/cfg/ReturnFromExpression.instructions b/idea/testData/cfg/ReturnFromExpression.instructions
index 1051a3a5a150a2000a44bbbba48da0d17aa55d83..43f3284ac471da0d17c956bcfbe24264333378d0 100644
--- a/idea/testData/cfg/ReturnFromExpression.instructions
+++ b/idea/testData/cfg/ReturnFromExpression.instructions
@@ -1,17 +1,16 @@
 == blockAndAndMismatch ==
 fun blockAndAndMismatch() : Boolean {
-  (return true) || (return false)
+  false || (return false)
 }
 ---------------------
 l0:
     <START>
-    r(true)
-    ret(*)
+    r(false)
     jt(l2)
     r(false)
-    ret(*)
+    ret(*) l1
 l2:
-    r((return true) || (return false))
+    r(false || (return false))
 l1:
     <END>
 =====================
diff --git a/idea/testData/cfg/ReturnFromExpression.jet b/idea/testData/cfg/ReturnFromExpression.jet
index 2bc7603b44b8204e1cd95469538480cffcb80c37..afbd008d8f577d1551c1609fdd6e19f56a1e5dea 100644
--- a/idea/testData/cfg/ReturnFromExpression.jet
+++ b/idea/testData/cfg/ReturnFromExpression.jet
@@ -1,3 +1,3 @@
 fun blockAndAndMismatch() : Boolean {
-  (return true) || (return false)
+  false || (return false)
 }
diff --git a/idea/testData/checker/UnreachableCode.jet b/idea/testData/checker/UnreachableCode.jet
new file mode 100644
index 0000000000000000000000000000000000000000..4b6afe5dab1e11e2bc1758f3b0bbd2f691608388
--- /dev/null
+++ b/idea/testData/checker/UnreachableCode.jet
@@ -0,0 +1,38 @@
+fun t1() {
+  return
+  <error>1</error>
+}
+
+fun t2() {
+  if (1 > 2)
+    return
+  else return
+  <error>1</error>
+}
+
+fun t3() {
+  if (1 > 2)
+    return 2
+  else return ""
+  <error>1</error>
+}
+
+fun t4(a : Boolean) {
+  do {
+    return
+  }
+  while (<error>a</error>)
+  <error>1</error>
+}
+
+//fun t5() {
+//  do {
+//    return
+//  }
+//  while (1 > 2)
+//  1
+//}
+
+//fun blockAndAndMismatch() : Boolean {
+//  (return true) || (return false)
+//}