[strong] Implement static restrictions on switch statement

src/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 217 matching lines @@
   if (!*ok) return Statement::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 PreParser::Statement PreParser::ParseStatement(bool* ok) {
   // Statement ::
   //   EmptyStatement
   //   ...
+
+  if (peek() == Token::SEMICOLON) {

[rossberg, 2015/04/14 20:19:49]

Did you add a test covering this?

[conradw, 2015/04/15 11:40:03]

Done, was indirectly covered before but now directly covered.

+    Next();
+    return Statement::Default();
+  }
   return ParseSubStatement(ok);
 }
 
 
 PreParser::Statement PreParser::ParseSubStatement(bool* ok) {
   // Statement ::
   //   Block
   //   VariableStatement
   //   EmptyStatement
   //   ExpressionStatement
@@ skipping 140 matching lines @@
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' Statement* '}'
 
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   Expect(Token::LBRACE, CHECK_OK);
+  Statement final = Statement::Default();
   while (peek() != Token::RBRACE) {
     if (is_strict(language_mode())) {
-      ParseStatementListItem(CHECK_OK);
+      final = ParseStatementListItem(CHECK_OK);
     } else {
-      ParseStatement(CHECK_OK);
+      final = ParseStatement(CHECK_OK);
     }
   }
   Expect(Token::RBRACE, ok);
-  return Statement::Default();
+  return final;
 }
 
 
 PreParser::Statement PreParser::ParseVariableStatement(
     VariableDeclarationContext var_context,
     bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
   Statement result = ParseVariableDeclarations(var_context, nullptr, nullptr,
@@ skipping 121 matching lines @@
   // Even if the expression starts with an identifier, it is not necessarily an
   // identifier. For example, "foo + bar" starts with an identifier but is not
   // an identifier.
   if (starts_with_identifier && expr.IsIdentifier() && peek() == Token::COLON) {
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
     DCHECK(!expr.AsIdentifier().IsFutureReserved());
     DCHECK(is_sloppy(language_mode()) ||
            !IsFutureStrictReserved(expr.AsIdentifier()));
     Consume(Token::COLON);
-    return ParseStatement(ok);
+    Statement statement = ParseStatement(ok);
+    if (statement.IsStrongSwitchTerminatingStatement()) {
+      return Statement::Default();
+    }
+    return statement;
     // Preparsing is disabled for extensions (because the extension details
     // aren't passed to lazily compiled functions), so we don't
     // accept "native function" in the preparser.
   }
   // Parsed expression statement.
   // Detect attempts at 'let' declarations in sloppy mode.
   if (peek() == Token::IDENTIFIER && is_sloppy(language_mode()) &&
       expr.IsIdentifier() && expr.AsIdentifier().IsLet()) {
     ReportMessage("sloppy_lexical", NULL);
     *ok = false;
@@ skipping 28 matching lines @@
   Expect(Token::CONTINUE, CHECK_OK);
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
-  return Statement::Default();
+  return Statement::Terminating();
 }
 
 
 PreParser::Statement PreParser::ParseBreakStatement(bool* ok) {
   // BreakStatement ::
   //   'break' [no line terminator] Identifier? ';'
 
   Expect(Token::BREAK, CHECK_OK);
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
-  return Statement::Default();
+  return Statement::Terminating();
 }
 
 
 PreParser::Statement PreParser::ParseReturnStatement(bool* ok) {
   // ReturnStatement ::
   //   'return' [no line terminator] Expression? ';'
 
   // Consume the return token. It is necessary to do before
   // reporting any errors on it, because of the way errors are
   // reported (underlining).
@@ skipping 14 matching lines @@
         i::IsConstructor(function_state_->kind())) {
       int pos = peek_position();
       ReportMessageAt(Scanner::Location(pos, pos + 1),
                       "strong_constructor_return_value");
       *ok = false;
       return Statement::Default();
     }
     ParseExpression(true, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
-  return Statement::Default();
+  return Statement::Terminating();
 }
 
 
 PreParser::Statement PreParser::ParseWithStatement(bool* ok) {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
   Expect(Token::WITH, CHECK_OK);
   if (is_strict(language_mode())) {
     ReportMessageAt(scanner()->location(), "strict_mode_with");
     *ok = false;
@@ skipping 23 matching lines @@
   Token::Value token = peek();
   while (token != Token::RBRACE) {
     if (token == Token::CASE) {
       Expect(Token::CASE, CHECK_OK);
       ParseExpression(true, CHECK_OK);
     } else {
       Expect(Token::DEFAULT, CHECK_OK);
     }
     Expect(Token::COLON, CHECK_OK);
     token = peek();
+    Statement statement = Statement::Terminating();
     while (token != Token::CASE &&
            token != Token::DEFAULT &&
            token != Token::RBRACE) {
-      ParseStatementListItem(CHECK_OK);
+      statement = ParseStatementListItem(CHECK_OK);
       token = peek();
     }
+    if (is_strong(language_mode()) &&
+        !statement.IsStrongSwitchTerminatingStatement()) {
+      ReportMessageAt(scanner()->location(), "strong_unterminated_switch");
+      *ok = false;
+      return Statement::Default();
+    }
   }
   Expect(Token::RBRACE, ok);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseDoWhileStatement(bool* ok) {
   // DoStatement ::
   //   'do' Statement 'while' '(' Expression ')' ';'
 
@@ skipping 110 matching lines @@
   //   'throw' [no line terminator] Expression ';'
 
   Expect(Token::THROW, CHECK_OK);
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
     ReportMessageAt(scanner()->location(), "newline_after_throw");
     *ok = false;
     return Statement::Default();
   }
   ParseExpression(true, CHECK_OK);
   ExpectSemicolon(ok);
-  return Statement::Default();
+  return Statement::Terminating();
 }
 
 
 PreParser::Statement PreParser::ParseTryStatement(bool* ok) {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
@@ skipping 204 matching lines @@
 
   DCHECK(!spread_pos.IsValid());
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal