Version 3.6.5

test/preparser/strict-identifiers.pyt

 # Copyright 2011 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 120 matching lines @@
 """)
 
 read_var = StrictTemplate("read-reserved-$id", """
   var x = $id;
 """)
 
 setter_arg = StrictTemplate("setter-param-$id", """
   var x = {set foo($id) { }};
 """)
 
+label_normal = Template("label-normal-$id", """
+  $id: '';
+""")
+
+label_strict = StrictTemplate("label-strict-$id", """
+  $id: '';
+""")
+
+break_normal = Template("break-normal-$id", """
+  for (;;) {
+    break $id;
+  }
+""")
+
+break_strict = StrictTemplate("break-strict-$id", """
+  for (;;) {
+    break $id;
+  }
+""")
+
+continue_normal = Template("continue-normal-$id", """
+  for (;;) {
+    continue $id;
+  }
+""")
+
+continue_strict = StrictTemplate("continue-strict-$id", """
+  for (;;) {
+    continue $id;
+  }
+""")
+
 non_strict_use = Template("nonstrict-$id", """
   var $id = 42;
   $id++;
   $id--;
   ++$id;
   --$id;
   $id += 10;
   $id -= 10;
   try {} catch ($id) { }
   function $id($id) { }
   var x = {$id: 42};
   x = {get $id() {}, set $id(value) {}};
   function foo() { "use strict;" }
   var $id = 42;
   $id++;
   $id--;
   ++$id;
   --$id;
   $id += 10;
   $id -= 10;
   try {} catch ($id) { }
   function $id($id) { }
   x = {$id: 42};
   x = {get $id() {}, set $id(value) {}};
+  $id: '';
 """)
 
 identifier_name_source = """
   var x = {$id: 42};
   x = {get $id() {}, set $id(value) {}};
   x.$id = 42;
   function foo() { "use strict;" }
   x = {$id: 42};
   x = {get $id() {}, set $id(value) {}};
   x.$id = 42;
@@ skipping 15 matching lines @@
   setter_arg({"id": id}, "strict_param_name")
   for op in assign_ops.keys():
     assign_var({"id": id, "op":op, "opname": assign_ops[op]},
                "strict_lhs_assignment")
   catch_var({"id": id}, "strict_catch_variable")
   declare_var({"id": id}, "strict_var_name")
   prefix_var({"id": id, "op":"++", "opname":"inc"}, "strict_lhs_prefix")
   prefix_var({"id": id, "op":"--", "opname":"dec"}, "strict_lhs_prefix")
   postfix_var({"id": id, "op":"++", "opname":"inc"}, "strict_lhs_postfix")
   postfix_var({"id": id, "op":"--", "opname":"dec"}, "strict_lhs_postfix")
+  label_normal({"id": id}, None)
+  label_strict({"id": id}, None)
+  break_normal({"id": id}, None)
+  break_strict({"id": id}, None)
+  continue_normal({"id": id}, None)
+  continue_strict({"id": id}, None)
   non_strict_use({"id": id}, None)
 
 
 # Reserved words just throw the same exception in all cases
 # (with "const" being special, as usual).
 for reserved_word in reserved_words + strict_reserved_words:
   if (reserved_word in strict_reserved_words):
     message = "strict_reserved_word"
+    label_message = None
   elif (reserved_word == "const"):
     message = "unexpected_token"
+    label_message = message
   else:
     message = "reserved_word"
+    label_message = message
   arg_name_own({"id":reserved_word}, message)
   arg_name_nested({"id":reserved_word}, message)
   setter_arg({"id": reserved_word}, message)
   func_name_own({"id":reserved_word}, message)
   func_name_nested({"id":reserved_word}, message)
   for op in assign_ops.keys():
     assign_var({"id":reserved_word, "op":op, "opname": assign_ops[op]}, message)
   catch_var({"id":reserved_word}, message)
   declare_var({"id":reserved_word}, message)
   prefix_var({"id":reserved_word, "op":"++", "opname":"inc"}, message)
   prefix_var({"id":reserved_word, "op":"--", "opname":"dec"}, message)
   postfix_var({"id":reserved_word, "op":"++", "opname":"inc"}, message)
   postfix_var({"id":reserved_word, "op":"--", "opname":"dec"}, message)
   read_var({"id": reserved_word}, message)
   identifier_name({"id": reserved_word}, None);
   identifier_name_strict({"id": reserved_word}, None);
+  label_normal({"id": reserved_word}, label_message)
+  break_normal({"id": reserved_word}, label_message)
+  continue_normal({"id": reserved_word}, label_message)
+  if (reserved_word == "const"):
+    # The error message for this case is different because
+    # ParseLabelledStatementOrExpression will try to parse this as an expression
+    # first, effectively disallowing the use in ParseVariableDeclarations, i.e.
+    # the preparser never sees that 'const' was intended to be a label.
+    label_strict({"id": reserved_word}, "strict_const")
+  else:
+    label_strict({"id": reserved_word}, message)
+  break_strict({"id": reserved_word}, message)
+  continue_strict({"id": reserved_word}, message)
 
 
 # Future reserved words in strict mode behave like normal identifiers
 # in a non strict context.
 for reserved_word in strict_reserved_words:
   non_strict_use({"id": id}, None)