Fix handling of escaped "let" and "static" tokens

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 4408 matching lines @@
     "class name extends (F, G) {}",
     "class name extends class {} {}",
     "class name extends class base {} {}",
     NULL};
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ClassBodyNoErrors) {
+  // clang-format off
   // Tests that parser and preparser accept valid class syntax.
   const char* context_data[][2] = {{"(class {", "});"},
                                    {"(class extends Base {", "});"},
                                    {"class C {", "}"},
                                    {"class C extends Base {", "}"},
                                    {NULL, NULL}};
   const char* class_body_data[] = {
     ";",
     ";;",
     "m() {}",
     "m() {};",
     "; m() {}",
     "m() {}; n(x) {}",
     "get x() {}",
     "set x(v) {}",
     "get() {}",
     "set() {}",
     "*g() {}",
     "*g() {};",
     "; *g() {}",
     "*g() {}; *h(x) {}",
     "static() {}",
+    "get static() {}",
+    "set static(v) {}",
     "static m() {}",
     "static get x() {}",
     "static set x(v) {}",
     "static get() {}",
     "static set() {}",
     "static static() {}",
     "static get static() {}",
     "static set static(v) {}",
     "*static() {}",
+    "static *static() {}",
     "*get() {}",
     "*set() {}",
     "static *g() {}",
+
+    // Escaped 'static' should be allowed anywhere

[caitp (gmail), 2016/01/19 21:17:03]

missing a `st\u{61}tic foo() {}` error case, since it shouldn't be interpreted
as the static keyword in that case.

[adamk, 2016/01/19 21:21:34]

That's already tested down in EscapedKeywords.

+    // static-as-PropertyName is.
+    "st\\u0061tic() {}",
+    "get st\\u0061tic() {}",
+    "set st\\u0061tic(v) {}",
+    "static st\\u0061tic() {}",
+    "static get st\\u0061tic() {}",
+    "static set st\\u0061tic(v) {}",
+    "*st\\u0061tic() {}",
+    "static *st\\u0061tic() {}",
     NULL};
+  // clang-format on
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassPropertyNameNoErrors) {
@@ skipping 3197 matching lines @@
     "for (const let in {}) {}",
     "for (const let of []) {}",
     "let [let] = 1",
     "for (let [let] = 1; let < 1; let++) {}",
     "for (let [let] in {}) {}",
     "for (let [let] of []) {}",
     "const [let] = 1",
     "for (const [let] = 1; let < 1; let++) {}",
     "for (const [let] in {}) {}",
     "for (const [let] of []) {}",
+
+    // Sprinkle in the escaped version too.
+    "let l\\u0065t = 1",
+    "const l\\u0065t = 1",
+    "let [l\\u0065t] = 1",
+    "const [l\\u0065t] = 1",
+    "for (let l\\u0065t in {}) {}",
     NULL
   };
   // clang-format on
 
   static const ParserFlag fail_flags[] = {
       kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst,
       kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, fail_data, kError, NULL, 0, fail_flags,
                     arraysize(fail_flags));
 }
@@ skipping 38 matching lines @@
     "th\\u0069s.a = 1;",
     "thr\\u006fw 'boo';",
     "t\\u0072y { true } catch (e) {}",
     "var x = typ\\u0065of 'blah'",
     "v\\u0061r a = true",
     "var v\\u0061r = true",
     "(function() { return v\\u006fid 0; })()",
     "wh\\u0069le (true) { }",
     "w\\u0069th (this.scope) { }",
     "(function*() { y\\u0069eld 1; })()",
+    "(function*() { var y\\u0069eld = 1; })()",
 
     "var \\u0065num = 1;",
     "var { \\u0065num } = {}",
     "(\\u0065num = 1);",
 
     // Null / Boolean literals
     "(x === n\\u0075ll);",
     "var x = n\\u0075ll;",
     "var n\\u0075ll = 1;",
     "var { n\\u0075ll } = { 1 };",
@@ skipping 17 matching lines @@
     "class C \\u0065xtends function B() {} {}",
     "for (var a i\\u006e this) {}",
     "if ('foo' \\u0069n this) {}",
     "if (this \\u0069nstanceof Array) {}",
     "(n\\u0065w function f() {})",
     "(typ\\u0065of 123)",
     "(v\\u006fid 0)",
     "do { ; } wh\\u0069le (true) { }",
     "(function*() { return (n++, y\\u0069eld 1); })()",
     "class C { st\\u0061tic bar() {} }",
+    "class C { st\\u0061tic *bar() {} }",
+    "class C { st\\u0061tic get bar() {} }",
+    "class C { st\\u0061tic set bar() {} }",
 
+    // TODO(adamk): These should not be errors in sloppy mode.
     "(y\\u0069eld);",
     "var y\\u0069eld = 1;",
     "var { y\\u0069eld } = {};",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
                                             kAllowHarmonyDestructuring};
   RunParserSyncTest(sloppy_context_data, fail_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, fail_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunModuleParserSyncTest(sloppy_context_data, fail_data, kError, NULL, 0,
                           always_flags, arraysize(always_flags));
 
   // clang-format off
   const char* let_data[] = {
     "var l\\u0065t = 1;",
     "l\\u0065t = 1;",
     "(l\\u0065t === 1);",
     NULL
   };
   // clang-format on
 
-  RunParserSyncTest(sloppy_context_data, let_data, kError, NULL, 0,
+  RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, let_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   static const ParserFlag sloppy_let_flags[] = {
       kAllowHarmonySloppy, kAllowHarmonySloppyLet, kAllowHarmonyDestructuring};
-  RunParserSyncTest(sloppy_context_data, let_data, kError, NULL, 0,
+  RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
                     sloppy_let_flags, arraysize(sloppy_let_flags));
 
   // Non-errors in sloppy mode
   const char* valid_data[] = {"(\\u0069mplements = 1);",
                               "var impl\\u0065ments = 1;",
                               "var { impl\\u0065ments  } = {};",
                               "(\\u0069nterface = 1);",
                               "var int\\u0065rface = 1;",
                               "var { int\\u0065rface  } = {};",
                               "(p\\u0061ckage = 1);",
                               "var packa\\u0067e = 1;",
                               "var { packa\\u0067e  } = {};",
                               "(p\\u0072ivate = 1);",
                               "var p\\u0072ivate;",
                               "var { p\\u0072ivate } = {};",
                               "(prot\\u0065cted);",
                               "var prot\\u0065cted = 1;",
                               "var { prot\\u0065cted  } = {};",
                               "(publ\\u0069c);",
                               "var publ\\u0069c = 1;",
                               "var { publ\\u0069c } = {};",
+                              "(st\\u0061tic);",
+                              "var st\\u0061tic = 1;",
+                              "var { st\\u0061tic } = {};",
                               NULL};
   RunParserSyncTest(sloppy_context_data, valid_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunModuleParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
                           always_flags, arraysize(always_flags));
 }
 
 
 TEST(MiscSyntaxErrors) {
   const char* context_data[][2] = {
       {"'use strict'", ""}, {"", ""}, {NULL, NULL}};
   const char* error_data[] = {"for (();;) {}", NULL};
 
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, NULL, 0);
 }