Add label support to ExitDetector

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 3452 matching lines @@
  * to terminate by executing a `return` statement, `throw` expression, `rethrow`
  * expression, or simple infinite loop such as `while(true)`.
  */
 class ExitDetector extends GeneralizingAstVisitor<bool> {
   /**
    * Set to `true` when a `break` is encountered, and reset to `false` when a
    * `do`, `while`, `for` or `switch` block is entered.
    */
   bool _enclosingBlockContainsBreak = false;
 
+  /**
+   * Add node when a labelled `break` is encountered.
+   */
+  Set<AstNode> _enclosingBlockBreaksLabel = new Set<AstNode>();
+
   @override
   bool visitArgumentList(ArgumentList node) =>
       _visitExpressions(node.arguments);
 
   @override
   bool visitAsExpression(AsExpression node) => _nodeExits(node.expression);
 
   @override
   bool visitAssertStatement(AssertStatement node) => false;
 
@@ skipping 55 matching lines @@
 
   @override
   bool visitBlock(Block node) => _visitStatements(node.statements);
 
   @override
   bool visitBlockFunctionBody(BlockFunctionBody node) => _nodeExits(node.block);
 
   @override
   bool visitBreakStatement(BreakStatement node) {
     _enclosingBlockContainsBreak = true;
+    if (node.label != null) {
+      _enclosingBlockBreaksLabel.add(node.target);
+    }
     return false;
   }
 
   @override
   bool visitCascadeExpression(CascadeExpression node) =>
       _nodeExits(node.target) || _visitExpressions(node.cascadeSections);
 
   @override
   bool visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
@@ skipping 69 matching lines @@
       if (node.initialization != null && _nodeExits(node.initialization)) {
         return true;
       }
       Expression conditionExpression = node.condition;
       if (conditionExpression != null && _nodeExits(conditionExpression)) {
         return true;
       }
       if (_visitExpressions(node.updaters)) {
         return true;
       }
+      bool blockReturns = _nodeExits(node.body);
       // TODO(jwren) Do we want to take all constant expressions into account?
       // If for(; true; ) (or for(;;)), and the body doesn't return or the body
       // doesn't have a break, then return true.
       bool implicitOrExplictTrue = conditionExpression == null ||
           (conditionExpression is BooleanLiteral && conditionExpression.value);
       if (implicitOrExplictTrue) {
-        bool blockReturns = _nodeExits(node.body);
         if (blockReturns || !_enclosingBlockContainsBreak) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
@@ skipping 19 matching lines @@
   bool visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     Statement thenStatement = node.thenStatement;
     Statement elseStatement = node.elseStatement;
     if (_nodeExits(conditionExpression)) {
       return true;
     }
     // TODO(jwren) Do we want to take all constant expressions into account?
     if (conditionExpression is BooleanLiteral) {
       if (conditionExpression.value) {
-        // if(true) ...
+        // if (true) ...
         return _nodeExits(thenStatement);
       } else if (elseStatement != null) {
         // if (false) ...
         return _nodeExits(elseStatement);
       }
     }
+    bool thenExits = _nodeExits(thenStatement);
+    bool elseExits = _nodeExits(elseStatement);
     if (thenStatement == null || elseStatement == null) {
       return false;
     }
-    bool thenExits = _nodeExits(thenStatement);
-    bool elseExits = _nodeExits(elseStatement);
     return thenExits && elseExits;
   }
 
   @override
   bool visitIndexExpression(IndexExpression node) {
     Expression target = node.realTarget;
     if (_nodeExits(target)) {
       return true;
     }
     if (_nodeExits(node.index)) {
       return true;
     }
     return false;
   }
 
   @override
   bool visitInstanceCreationExpression(InstanceCreationExpression node) =>
       _nodeExits(node.argumentList);
 
   @override
   bool visitIsExpression(IsExpression node) => node.expression.accept(this);
 
   @override
   bool visitLabel(Label node) => false;
 
   @override
-  bool visitLabeledStatement(LabeledStatement node) =>
-      node.statement.accept(this);
+  bool visitLabeledStatement(LabeledStatement node) {
+    try {
+      bool statementExits = _nodeExits(node.statement);
+      bool neverBrokeFromLabel =
+          !_enclosingBlockBreaksLabel.contains(node.statement);
+      return statementExits && neverBrokeFromLabel;
+    } finally {
+      _enclosingBlockBreaksLabel.remove(node.statement);
+    }
+  }
 
   @override
   bool visitLiteral(Literal node) => false;
 
   @override
   bool visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     if (target != null) {
       if (target.accept(this)) {
         return true;
@@ skipping 133 matching lines @@
 
   @override
   bool visitWhileStatement(WhileStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
       Expression conditionExpression = node.condition;
       if (conditionExpression.accept(this)) {
         return true;
       }
+      bool blockReturns = node.body.accept(this);
       // TODO(jwren) Do we want to take all constant expressions into account?
       if (conditionExpression is BooleanLiteral) {
         // If while(true), and the body doesn't return or the body doesn't have
         // a break, then return true.
-        bool blockReturns = node.body.accept(this);
         if (conditionExpression.value &&
             (blockReturns || !_enclosingBlockContainsBreak)) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
@@ skipping 14 matching lines @@
   bool _visitExpressions(NodeList<Expression> expressions) {
     for (int i = expressions.length - 1; i >= 0; i--) {
       if (expressions[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
   bool _visitStatements(NodeList<Statement> statements) {
-    for (int i = statements.length - 1; i >= 0; i--) {
+    for (int i = 0; i < statements.length; i++) {
       if (statements[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
   bool _visitVariableDeclarations(
       NodeList<VariableDeclaration> variableDeclarations) {
     for (int i = variableDeclarations.length - 1; i >= 0; i--) {
@@ skipping 7055 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }