In analyzer, catch use of continue and break in inappropriate places

compiler/java/com/google/dart/compiler/parser/DartParser.java

 // Copyright (c) 2012, 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.
 
 package com.google.dart.compiler.parser;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.io.CharStreams;
 import com.google.dart.compiler.DartCompilationError;
 import com.google.dart.compiler.DartCompilerListener;
@@ skipping 203 matching lines @@
     } finally {
       reader.close();
     }
   }
 
   /**
    * A flag indicating whether function expressions are allowed.  See
    * {@link #setAllowFunctionExpression(boolean)}.
    */
   private boolean allowFunctionExpression = true;
+  
+  /**
+   * 'break' (with no labels) and 'continue' stmts are not valid 
+   * just anywhere, they must be inside a loop or a case stmt.  
+   * 
+   * A break with a label may be valid and is allowed through and
+   * checked in the resolver.
+   */
+  private boolean inLoopOrCaseStatement = false;
 
   /**
    * Set the {@link #allowFunctionExpression} flag indicating whether function expressions are
    * allowed, returning the old value. This is required to avoid ambiguity in a few places in the
    * grammar.
    *
    * @param allow true if function expressions are allowed, false if not
    * @return previous value of the flag, which should be restored
    */
   private boolean setAllowFunctionExpression(boolean allow) {
@@ skipping 2831 matching lines @@
    * <pre>
    * functionStatementBody
    *    : '=>' expression ';'
    *    | block
    * </pre>
    *
    * @param requireSemicolonForArrow true if a semicolon is required after an arrow expression
    * @return {@link DartBlock} instance containing function body
    */
   private DartBlock parseFunctionStatementBody(boolean requireSemicolonForArrow) {
+    // A break inside a function body should have nothing to do with a loop in
+    // the code surrounding the definition.
+    boolean oldInLoopOrCaseStatement = inLoopOrCaseStatement;
+    inLoopOrCaseStatement = false;
+    DartBlock result;
     if (isDietParse) {
-      DartBlock emptyBlock = new DartBlock(new ArrayList<DartStatement>());
-      if (optional(Token.ARROW)) {
-        while (true) {
-          Token token = next();
-          if (token == Token.SEMICOLON) {
-            break;
-          }
-        }
-      } else {
-        if (!peek(0).equals(Token.LBRACE) && looksLikeTopLevelKeyword()) {
-          // Allow recovery back to the top level.
-          reportErrorWithoutAdvancing(ParserErrorCode.UNEXPECTED_TOKEN);
-          return done(emptyBlock);
-        }
-        expect(Token.LBRACE);
-        int nesting = 1;
-        while (nesting > 0) {
-          Token token = next();
-          switch (token) {
-            case LBRACE:
-              ++nesting;
-              break;
-            case RBRACE:
-              --nesting;
-              break;
-            case EOS:
-              return emptyBlock;
-          }
-        }
-      }
-      // Return an empty block so we don't generate unparseable code.
-      return emptyBlock;
+      result = dietParseFunctionStatementBody();
     } else {
       beginFunctionStatementBody();
       if (optional(Token.ARROW)) {
         DartExpression expr = parseExpression();
         if (expr == null) {
           expr = new DartSyntheticErrorExpression();
         }
         if (requireSemicolonForArrow) {
           expect(Token.SEMICOLON);
         }
-        return done(makeReturnBlock(expr));
+        result = done(makeReturnBlock(expr));
       } else {
-        return done(parseBlock());
+        result = done(parseBlock());
       }
     }
+    inLoopOrCaseStatement = oldInLoopOrCaseStatement;
+    return result;
+  }
+
+  private DartBlock dietParseFunctionStatementBody() {
+    DartBlock emptyBlock = new DartBlock(new ArrayList<DartStatement>());
+    if (optional(Token.ARROW)) {
+      while (true) {
+        Token token = next();
+        if (token == Token.SEMICOLON) {
+          break;
+        }
+      }
+    } else {
+      if (!peek(0).equals(Token.LBRACE) && looksLikeTopLevelKeyword()) {
+        // Allow recovery back to the top level.
+        reportErrorWithoutAdvancing(ParserErrorCode.UNEXPECTED_TOKEN);
+        return done(emptyBlock);
+      }
+      expect(Token.LBRACE);
+      int nesting = 1;
+      while (nesting > 0) {
+        Token token = next();
+        switch (token) {
+          case LBRACE:
+            ++nesting;
+            break;
+          case RBRACE:
+            --nesting;
+            break;
+          case EOS:
+            return emptyBlock;
+        }
+      }
+    }
+    // Return an empty block so we don't generate unparseable code.
+    return emptyBlock;
   }
 
   /**
    * Create a block containing a single return statement.
    *
    * @param returnVal return value expression
    * @return block containing a single return statement
    */
   private DartBlock makeReturnBlock(DartExpression returnVal) {
     return new DartReturnBlock(returnVal);
@@ skipping 41 matching lines @@
    *     | THROW expression? ';'
    *     ;
    *  </pre>
    */
   private DartBreakStatement parseBreakStatement() {
     beginBreakStatement();
     expect(Token.BREAK);
     DartIdentifier label = null;
     if (match(Token.IDENTIFIER)) {
       label = parseIdentifier();
+    } else if (!inLoopOrCaseStatement) {
+      // The validation of matching of labels to break statements is done later.
+      reportErrorWithoutAdvancing(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP);      
     }
     expectStatmentTerminator();
     return done(new DartBreakStatement(label));
   }
 
   private DartContinueStatement parseContinueStatement() {
     beginContinueStatement();
     expect(Token.CONTINUE);
     DartIdentifier label = null;
+    if (!inLoopOrCaseStatement) {
+      reportErrorWithoutAdvancing(ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP);      
+    }
     if (peek(0) == Token.IDENTIFIER) {
       label = parseIdentifier();
     }
     expectStatmentTerminator();
     return done(new DartContinueStatement(label));
   }
 
   private DartReturnStatement parseReturnStatement() {
     beginReturnStatement();
     expect(Token.RETURN);
@@ skipping 443 matching lines @@
    *     | FOR '(' forLoopParts ')' statement
    *     ;
    *  </pre>
    */
   private DartWhileStatement parseWhileStatement() {
     beginWhileStatement();
     expect(Token.WHILE);
     expect(Token.LPAREN);
     DartExpression condition = parseExpression();
     expectCloseParen();
-    DartStatement body = parseStatement();
+    DartStatement body = parseLoopOrCaseStatement();
     return done(new DartWhileStatement(condition, body));
   }
 
   /**
    * <pre>
    * iterationStatement
    *     : WHILE '(' expression ')' statement
    *     | DO statement WHILE '(' expression ')' ';'
    *     | FOR '(' forLoopParts ')' statement
    *     ;
    *  </pre>
    */
   private DartDoWhileStatement parseDoWhileStatement() {
     beginDoStatement();
     expect(Token.DO);
-    DartStatement body = parseStatement();
+    DartStatement body = parseLoopOrCaseStatement();
     expect(Token.WHILE);
     expect(Token.LPAREN);
     DartExpression condition = parseExpression();
     expectCloseParen();
     expectStatmentTerminator();
     return done(new DartDoWhileStatement(condition, body));
   }
 
   /**
+   * Use this wrapper to parse the body of a loop or case statement.
+   * 
+   * Sets up flag variables to make sure continue and break are properly 
+   * marked as errors when in wrong context. 
+   */
+  private DartStatement parseLoopOrCaseStatement() {
+    boolean oldInBreakable = inLoopOrCaseStatement;
+    inLoopOrCaseStatement = true;
+    DartStatement stmt = parseStatement();
+    inLoopOrCaseStatement = oldInBreakable;
+    return stmt;
+  }
+
+  /**
    * <pre>
    * iterationStatement
    *     : WHILE '(' expression ')' statement
    *     | DO statement WHILE '(' expression ')' ';'
    *     | FOR '(' forLoopParts ')' statement
    *     ;
    *
    * forLoopParts
    *     : forInitializerStatement expression? ';' expressionList?
    *     | constVarOrType? identifier IN expression
@@ skipping 46 matching lines @@
       } else {
         DartExpression expression = ((DartExprStmt) setup).getExpression();
         if (!(expression instanceof DartIdentifier)) {
           reportError(setup, ParserErrorCode.FOR_IN_WITH_COMPLEX_VARIABLE);
         }
       }
 
       DartExpression iterable = parseExpression();
       expectCloseParen();
 
-      DartStatement body = parseStatement();
+      DartStatement body = parseLoopOrCaseStatement();
       return done(new DartForInStatement(setup, iterable, body));
 
     } else if (optional(Token.SEMICOLON)) {
 
       // Condition
       DartExpression condition = null;
       if (peek(0) != Token.SEMICOLON) {
         condition = parseExpression();
       }
       expect(Token.SEMICOLON);
 
       // Next
       DartExpression next = null;
       if (peek(0) != Token.RPAREN) {
         next = parseExpressionList();
       }
       expectCloseParen();
 
-      DartStatement body = parseStatement();
+      DartStatement body = parseLoopOrCaseStatement();
       return done(new DartForStatement(setup, condition, next, body));
     } else {
       reportUnexpectedToken(position(), null, peek(0));
       return done(parseErrorStatement());
     }
   }
 
   /**
    * <pre>
    * selectionStatement
@@ skipping 27 matching lines @@
     List<DartStatement> statements = new ArrayList<DartStatement>();
     DartStatement statement = null;
     while (true) {
       switch (peek(0)) {
         case CASE:
         case DEFAULT:
         case RBRACE:
         case EOS:
           return statements;
         default:
-          if ((statement = parseStatement()) == null) {
+          if ((statement = parseLoopOrCaseStatement()) == null) {
             return statements;
           }
           statements.add(statement);
           if (statement.isAbruptCompletingStatement()) {
             /*
              * TODO(jat): is this correct? It seems like we would get better
              * error messages if we parsed dead code as part of this case block
              * and gave an error for unreachable code
              */
             return statements;
@@ skipping 376 matching lines @@
   }
 
   private void reportError(DartNode node, ErrorCode errorCode, Object... arguments) {
     reportError(new DartCompilationError(node, errorCode, arguments));
   }
 
   private boolean currentlyParsingToplevel() {
     return   !(isParsingInterface || isTopLevelAbstract || isParsingClass);
   }
 }