If an if or do statement always exits, following statements are dead.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 2042 matching lines @@
       }
       if (element == null) {
         _errorReporter
             .reportErrorForNode(hintCode, name, [library.identifier, nameStr]);
       }
     }
   }
 
   /**
    * Given some [NodeList] of [Statement]s, from either a [Block] or
-   * [SwitchMember], this loops through the list in reverse order searching for statements
-   * after a return, unlabeled break or unlabeled continue statement to mark them as dead code.
+   * [SwitchMember], this loops through the list searching for dead statements.
+   *
+   * Dead statements are found after a return, an unlabeled break, an unlabeled
+   * continue, (A THROW?), or an if statement that unconditionally exits.
    *
    * @param statements some ordered list of statements in a [Block] or [SwitchMember]
    */
   void _checkForDeadStatementsInNodeList(NodeList<Statement> statements) {
+    bool statementExits(Statement statement) {

[Brian Wilkerson, 2016/05/04 17:28:19]

With the exception of the handling of the break and continue statements, it
looks like all of this is already handled by the ExitDetector. Could this be
replaced by the following?

if (statement is BreakStatement) {
  return statement.label == null;
} else if (statement is BreakStatement) {
  return statement.label == null;
}
return ExitDetector.exits(statement);

I'd prefer to keep as much of this logic as possible in the ExitDetector. (In
fact, I don't know why the break and continue statements aren't handled by it.

[srawlins, 2016/05/19 18:36:44]

Done! Dramatically simpler!

+      if (statement is ReturnStatement) {
+        return true;
+      }
+      if ((statement is BreakStatement && statement.label == null) ||
+          (statement is ContinueStatement && statement.label == null)) {
+        return true;
+      }
+      if (statement is IfStatement) {
+        Statement thenStatement = statement.thenStatement;
+        Statement elseStatement = statement.elseStatement;
+        if (elseStatement != null) {
+          if (ExitDetector.exits(thenStatement) &&
+              ExitDetector.exits(elseStatement)) {
+            return true;
+          }
+        }
+      } else if (statement is DoStatement) {
+        if (statement.body != null && ExitDetector.exits(statement.body)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
     int size = statements.length;
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
       currentStatement?.accept(this);
-      bool returnOrBreakingStatement = currentStatement is ReturnStatement ||
-          (currentStatement is BreakStatement &&
-              currentStatement.label == null) ||
-          (currentStatement is ContinueStatement &&
-              currentStatement.label == null);
-      if (returnOrBreakingStatement && i != size - 1) {
+      if (statementExits(currentStatement) && i != size - 1) {
         Statement nextStatement = statements[i + 1];
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
         _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length);
         return;
       }
     }
   }
 
@@ skipping 8794 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }