[parser] Allow duplicate __proto__ keys in patterns

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 6324 matching lines @@
     "{'hi' : x = 42}",
     "{var: x}",
     "{var: x = 42}",
     "{[x] : z}",
     "{[1+1] : z}",
     "{[foo()] : z}",
     "{}",
     "[...rest]",
     "[a,b,...rest]",
     "[a,,...rest]",
+    "{ __proto__: x, __proto__: y}",
     "{arguments: x}",
     "{eval: x}",
     NULL};
   // clang-format on
   RunParserSyncTest(context_data, data, kSuccess);
 
   // v8:5201
   // TODO(lpy): The two test sets below should be merged once
   // we fix https://bugs.chromium.org/p/v8/issues/detail?id=4577
   {
@@ skipping 267 matching lines @@
     "{ x : { foo: y = 10 } = {} }",
     "{ x : { foo: foo().y = 10 } = {} }",
     "{ x : { foo: foo()[y] = 10 } = {} }",
     "{ x : { foo: y.z = 10 } = {} }",
     "{ x : { foo: y[z] = 10 } = {} }",
     "{ x : [ y = 10 ] = {} }",
     "{ x : [ foo().y = 10 ] = {} }",
     "{ x : [ foo()[y] = 10 ] = {} }",
     "{ x : [ y.z = 10 ] = {} }",
     "{ x : [ y[z] = 10 ] = {} }",
+    "{ z : { __proto__: x, __proto__: y } = z }"
 
     "[ x ]",
     "[ foo().x ]",
     "[ foo()[x] ]",
     "[ x.y ]",
     "[ x[y] ]",
     "[ { x } ]",
     "[ { x : y } ]",
     "[ { x : foo().y } ]",
     "[ { x : foo()[y] } ]",
@@ skipping 99 matching lines @@
       "var foo = { x = 10 } = {};",
       "var foo = { q } = { x = 10 } = {};",
       "var foo; foo = { x = 10 } = {};",
       "var foo; foo = { q } = { x = 10 } = {};",
       "var x; ({ x = 10 } = {});",
       "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 { __proto__: x, __proto__: y } = {}",
+      "({ __proto__: x, __proto__: y } = {})",
       "var { x = 10 } = (o = { x = 20 } = {});",
       "var x; (({ x = 10 } = { x = 20 } = {}) => x)({})",
       NULL,
   };
   RunParserSyncTest(empty_context_data, ambiguity_data, kSuccess);
 }
 
 
 TEST(DestructuringAssignmentNegativeTests) {
   const char* context_data[][2] = {
@@ skipping 15 matching lines @@
     "{ x: y() }",
     "{ this }",
     "{ x: this }",
     "{ x: this = 1 }",
     "{ super }",
     "{ x: super }",
     "{ x: super = 1 }",
     "{ new.target }",
     "{ x: new.target }",
     "{ x: new.target = 1 }",
+    "{{ __proto__: x, __proto__: y}}",

[adamk, 2016/08/19 23:27:35]

Why the double braces? Isn't that already an error for other reasons?

+    "({ __proto__: x, __proto__: y})",

[adamk, 2016/08/19 23:27:35]

Same here, I think the parens are already an error.

     "[x--]",
     "[--x = 1]",
     "[x()]",
     "[this]",
     "[this = 1]",
     "[new.target]",
     "[new.target = 1]",
     "[super]",
     "[super = 1]",
     "[function f() {}]",
@@ skipping 67 matching lines @@
       "var foo; foo = { x = 10 };",
       "var foo; foo = { q } = { x = 10 };",
       "var x; ({ x = 10 });",
       "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)({})",
+      "var {{ __proto__: x, __proto__: y}}",

[adamk, 2016/08/19 23:27:35]

And here and below.

+      "({ __proto__: x, __proto__: y}) => ()",
 
       // Not ambiguous, but uses same context data
       "switch([window %= []] = []) { default: }",
 
       NULL,
   };
   RunParserSyncTest(empty_context_data, ambiguity_data, kError);
 
   // Strict mode errors
   const char* strict_context_data[][2] = {{"'use strict'; (", " = {})"},
@@ skipping 1304 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));
 }