[strong] Implement static restrictions on switch statement

src/parser.cc

 // Copyright 2012 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 "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 1801 matching lines @@
     case Token::DO:
       return ParseDoWhileStatement(labels, ok);
 
     case Token::WHILE:
       return ParseWhileStatement(labels, ok);
 
     case Token::FOR:
       return ParseForStatement(labels, ok);
 
     case Token::CONTINUE:
-      return ParseContinueStatement(ok);
-
     case Token::BREAK:
-      return ParseBreakStatement(labels, ok);
-
     case Token::RETURN:
-      return ParseReturnStatement(ok);
+    case Token::THROW:
+    case Token::TRY: {
+      // These statements must have their labels preserved in an enclosing
+      // block
+      if (labels == NULL) {
+        return ParseStatementAsUnlabelled(labels, ok);
+      } else {
+        Block* result =
+            factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
+        Target target(&this->target_stack_, result);
+        Statement* statement = ParseStatementAsUnlabelled(labels, CHECK_OK);
+        if (result) result->AddStatement(statement, zone());
+        return result;
+      }
+    }
 
     case Token::WITH:
       return ParseWithStatement(labels, ok);
 
     case Token::SWITCH:
       return ParseSwitchStatement(labels, ok);
 
-    case Token::THROW:
-      return ParseThrowStatement(ok);
-
-    case Token::TRY: {
-      // NOTE: It is somewhat complicated to have labels on
-      // try-statements. When breaking out of a try-finally statement,
-      // one must take great care not to treat it as a
-      // fall-through. It is much easier just to wrap the entire
-      // try-statement in a statement block and put the labels there
-      Block* result =
-          factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
-      Target target(&this->target_stack_, result);
-      TryStatement* statement = ParseTryStatement(CHECK_OK);
-      if (result) result->AddStatement(statement, zone());
-      return result;
-    }
-
     case Token::FUNCTION: {
       // FunctionDeclaration is only allowed in the context of SourceElements
       // (Ecma 262 5th Edition, clause 14):
       // SourceElement:
       //    Statement
       //    FunctionDeclaration
       // Common language extension is to allow function declaration in place
       // of any statement. This language extension is disabled in strict mode.
       //
       // In Harmony mode, this case also handles the extension:
@@ skipping 20 matching lines @@
       if (is_sloppy(language_mode())) {
         return ParseVariableStatement(kStatement, NULL, ok);
       }
 
     // Fall through.
     default:
       return ParseExpressionOrLabelledStatement(labels, ok);
   }
 }
 
+Statement* Parser::ParseStatementAsUnlabelled(
+    ZoneList<const AstRawString*>* labels, bool* ok) {
+  switch (peek()) {
+    case Token::CONTINUE:
+      return ParseContinueStatement(ok);
+
+    case Token::BREAK:
+      return ParseBreakStatement(labels, ok);
+
+    case Token::RETURN:
+      return ParseReturnStatement(ok);
+
+    case Token::THROW:
+      return ParseThrowStatement(ok);
+
+    case Token::TRY:
+      return ParseTryStatement(ok);
+
+    default:
+      UNREACHABLE();
+      return NULL;
+  }
+}
+
 
 VariableProxy* Parser::NewUnresolved(const AstRawString* name,
                                      VariableMode mode) {
   // If we are inside a function, a declaration of a var/const variable is a
   // truly local variable, and the scope of the variable is always the function
   // scope.
   // Let/const variables in harmony mode are always added to the immediately
   // enclosing scope.
   return DeclarationScope(mode)->NewUnresolved(factory(), name,
                                                scanner()->location().beg_pos,
@@ skipping 935 matching lines @@
       ReportMessage("multiple_defaults_in_switch");
       *ok = false;
       return NULL;
     }
     *default_seen_ptr = true;
   }
   Expect(Token::COLON, CHECK_OK);
   int pos = position();
   ZoneList<Statement*>* statements =
       new(zone()) ZoneList<Statement*>(5, zone());
+  Statement* stat = NULL;
   while (peek() != Token::CASE &&
          peek() != Token::DEFAULT &&
          peek() != Token::RBRACE) {
-    Statement* stat = ParseStatementListItem(CHECK_OK);
+    stat = ParseStatementListItem(CHECK_OK);
     statements->Add(stat, zone());
   }
-
+  if (is_strong(language_mode()) && stat != NULL && !stat->IsJump() &&
+      peek() != Token::RBRACE) {
+    ReportMessageAt(scanner()->location(), "strong_switch_fallthrough");
+    *ok = false;
+    return NULL;
+  }
   return factory()->NewCaseClause(label, statements, pos);
 }
 
 
 SwitchStatement* Parser::ParseSwitchStatement(
     ZoneList<const AstRawString*>* labels, bool* ok) {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
 
   SwitchStatement* statement =
@@ skipping 1596 matching lines @@
         : Scanner::Location(position, position + 1);
     ParserTraits::ReportMessageAt(location, "var_redeclaration", name);
     *ok = false;
   }
 }
 
 
 // ----------------------------------------------------------------------------
 // Parser support
 
-
 bool Parser::TargetStackContainsLabel(const AstRawString* label) {
   for (Target* t = target_stack_; t != NULL; t = t->previous()) {
     if (ContainsLabel(t->statement()->labels(), label)) return true;
   }
   return false;
 }
 
 
 BreakableStatement* Parser::LookupBreakTarget(const AstRawString* label,
                                               bool* ok) {
@@ skipping 1291 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 } }  // namespace v8::internal