Implement ES2015 labelled function declaration restrictions

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 7199 matching lines @@
     {"(function() { 'use strict'; {", "} })()"},
     { NULL, NULL }
   };
   const char* sloppy_context[][2] = {
     { "", "" },
     { "{", "}" },
     {"(function() {", "})()"},
     {"(function() { {", "} })()"},
     { NULL, NULL }
   };
+  // Invalid in all contexts
   const char* error_data[] = {
     "try function foo() {} catch (e) {}",
     NULL
   };
+  // Valid in sloppy mode only, and only when the
+  // --harmony-restrictive-declarations flag is off
   const char* unrestricted_data[] = {
     "do function foo() {} while (0);",
     "for (;false;) function foo() {}",
     "for (var i = 0; i < 1; i++) function f() { };",
     "for (var x in {a: 1}) function f() { };",
     "for (var x in {}) function f() { };",
     "for (var x in {}) function foo() {}",
     "for (x in {a: 1}) function f() { };",
     "for (x in {}) function f() { };",
     "var x; for (x in {}) function foo() {}",
     "with ({}) function f() { };",
+    "do label: function foo() {} while (0);",
+    "for (;false;) label: function foo() {}",
+    "for (var i = 0; i < 1; i++) label: function f() { };",
+    "for (var x in {a: 1}) label: function f() { };",
+    "for (var x in {}) label: function f() { };",
+    "for (var x in {}) label: function foo() {}",
+    "for (x in {a: 1}) label: function f() { };",
+    "for (x in {}) label: function f() { };",
+    "var x; for (x in {}) label: function foo() {}",
+    "with ({}) label: function f() { };",
+    "if (true) label: function f() {}",
+    "if (true) {} else label: function f() {}",
     NULL
   };
+  // Valid only in sloppy mode, with or without
+  // --harmony-restrictive-declarations
   const char* sloppy_data[] = {
     "if (true) function foo() {}",
     "if (false) {} else function f() { };",
     "label: function f() { }",
     "label: if (true) function f() { }",
     "label: if (true) {} else function f() { }",
-    "if (true) label: function f() {}",
-    "if (true) {} else label: function f() {}",
     NULL
   };
   // clang-format on
 
   static const ParserFlag restrictive_flags[] = {
       kAllowHarmonyRestrictiveDeclarations};
 
+  // Nothing parses in strict mode without a SyntaxError
   RunParserSyncTest(strict_context, error_data, kError);
   RunParserSyncTest(strict_context, error_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(strict_context, unrestricted_data, kError);
   RunParserSyncTest(strict_context, unrestricted_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(strict_context, sloppy_data, kError);
   RunParserSyncTest(strict_context, sloppy_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
 
+  // In sloppy mode, some things are successful, depending on the flag
   RunParserSyncTest(sloppy_context, error_data, kError);
   RunParserSyncTest(sloppy_context, error_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(sloppy_context, unrestricted_data, kSuccess);
   RunParserSyncTest(sloppy_context, unrestricted_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(sloppy_context, sloppy_data, kSuccess);
   RunParserSyncTest(sloppy_context, sloppy_data, kSuccess, restrictive_flags,
                     arraysize(restrictive_flags));
 }
@@ skipping 82 matching lines @@
     // "Array() **= 10",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {
       kAllowHarmonyExponentiationOperator};
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }