Fix not throwing error when redefine eval or arguments in strict mode.

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 6532 matching lines @@
       "var q, x; ({ q } = { x = 10 } = {});",
       "var x; [{ x = 10 } = {}]",
       "var x; (true ? { x = true } = {} : { x = false } = {})",
       "var q, x; (q, { x = 10 } = {});",
       "var { x = 10 } = { x = 20 } = {};",
       "var { x = 10 } = (o = { x = 20 } = {});",
       "var x; (({ x = 10 } = { x = 20 } = {}) => x)({})",
       NULL,
   };
   RunParserSyncTest(empty_context_data, ambiguity_data, kSuccess);
+
+  // v8:5201
+  {
+    const char* context_data[][2] = {
+      {"var {", "} = {};"},
+      {"(() => { function f({", " = false } = {}) {} })()"},
+      {NULL, NULL}
+    };
+
+    const char* data[] = {
+      "eval",

[adamk, 2016/08/09 17:00:51]

I think this test case belongs with the other destructuring bind tests in
DestructuringPositiveTests

You'll want to add a section there for strict/sloppy, just like there is in this
one. But there's no need for a whole separate call for RunParserSyncTest.

Once you're there, you'll want to add a bunch more test cases. In particular, I
think this actually will fail, though it shouldn't:


{eval: x}

which means "bind the property named 'eval' to the variable 'x'". So more work
is needed in the code too.

+      NULL,
+    };
+
+    RunParserSyncTest(context_data, data, kSuccess);
+  }
 }
 
 
 TEST(DestructuringAssignmentNegativeTests) {
   const char* context_data[][2] = {
       {"'use strict'; let x, y, z; (", " = {});"},
       {"var x, y, z; (", " = {});"},
       {"'use strict'; let x, y, z; for (x in ", " = {});"},
       {"'use strict'; let x, y, z; for (x of ", " = {});"},
       {"var x, y, z; for (x in ", " = {});"},
@@ skipping 145 matching lines @@
                                "[ (arguments) = 0 ]",
                                "[ ...(eval) ]",
                                "[ ...(arguments) ]",
                                "[ ...(eval = 0) ]",
                                "[ ...(arguments = 0) ]",
                                "[ ...(eval) = 0 ]",
                                "[ ...(arguments) = 0 ]",
 
                                NULL};
   RunParserSyncTest(strict_context_data, strict_data, kError);
+
+  // v8:5201
+  {
+    // clang-format off
+    const char* context_data[][2] = {
+      {"'use strict'; var {", "} = {};"},
+      {"(() => { 'use strict'; function a({", " = false } = {}) {} })()"},
+      {NULL, NULL}
+    };
+
+    const char* data[] = {
+      "eval",
+      "arguments",
+      NULL
+    };
+
+    // clang-format on
+    RunParserSyncTest(context_data, data, kError);
+  }
 }
 
 
 TEST(DestructuringDisallowPatternsInForVarIn) {
   const char* context_data[][2] = {
       {"", ""}, {"function f() {", "}"}, {NULL, NULL}};
   // clang-format off
   const char* error_data[] = {
     "for (let x = {} in null);",
     "for (let x = {} of null);",
@@ skipping 1256 matching lines @@
     "(a,);",
     "(a,b,c,);",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonyTrailingCommas};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }