[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);
+      if (labels == NULL) {

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

To avoid the code duplication, how about introducing a single helper function,
say

  Statement NewLabelledStatement(ZoneList* labels, Statement)

that does the wrapping if lables isn't null, and just returns the statement
otherwise.

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

Done, with the caveat that the ordering is kind of tricky, I wanted to use this
function for the TRY case as well, but it makes assumptions that the wrapper
block has already been created before the try-block is parsed. Ended up doing it
in two functions.

+        return ParseContinueStatement(ok);
+      } else {
+        Block* result =
+            factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
+        Target target(&this->target_stack_, result);
+        Statement* statement = ParseContinueStatement(CHECK_OK);
+        if (result) result->AddStatement(statement, zone());
+        return result;
+      }
 
     case Token::BREAK:
-      return ParseBreakStatement(labels, ok);
+      if (labels == NULL) {
+        return ParseBreakStatement(labels, ok);
+      } else {
+        Block* result =
+            factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
+        Target target(&this->target_stack_, result);
+        Statement* statement = ParseBreakStatement(labels, CHECK_OK);
+        if (result) result->AddStatement(statement, zone());
+        return result;
+      }
 
     case Token::RETURN:
-      return ParseReturnStatement(ok);
+      if (labels == NULL) {
+        return ParseReturnStatement(ok);
+      } else {
+        Block* result =
+            factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
+        Target target(&this->target_stack_, result);
+        Statement* statement = ParseReturnStatement(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);
+      if (labels == NULL) {
+        return ParseThrowStatement(ok);
+      } else {
+        Block* result =
+            factory()->NewBlock(labels, 1, false, RelocInfo::kNoPosition);
+        Target target(&this->target_stack_, result);
+        Statement* statement = ParseThrowStatement(CHECK_OK);
+        if (result) result->AddStatement(statement, zone());
+        return result;
+      }
 
     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);
@@ skipping 990 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->IsStrongSwitchTerminatingStatement()) {
+    ReportMessageAt(scanner()->location(), "strong_unterminated_switch");
+    *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 2908 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