[strong] Implement static restrictions on switch statement

src/parser.cc

Index: src/parser.cc
diff --git a/src/parser.cc b/src/parser.cc
index 77c98b77e4c0cd6aadb003ec1965f82d879c30c8..c450bfb73d496dbe4d7bbda2f8439a130af439fb 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -1819,13 +1819,40 @@ Statement* Parser::ParseSubStatement(ZoneList<const AstRawString*>* labels,
       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);
@@ -1834,7 +1861,16 @@ Statement* Parser::ParseSubStatement(ZoneList<const AstRawString*>* labels,
       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
@@ -2845,13 +2881,19 @@ CaseClause* Parser::ParseCaseClause(bool* default_seen_ptr, bool* 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);
 }