[parser] reject parenthesized patterns as DestructuringAssignmentTargets

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 6942 matching lines @@
     "[x,,...z]",
     "{ x: y }",
     "[x, y]",
     "[((x, y) => z).x]",
     "{x: ((y, z) => z).x}",
     "[((x, y) => z)['x']]",
     "{x: ((y, z) => z)['x']}",
 
     "{x: { y = 10 } }",
     "[(({ x } = { x: 1 }) => x).a]",
+
+    // v8:4662
+    "{ x: (y) }",
+    "{ x: (y) = [] }",
+    "{ x: (foo.bar) }",
+    "{ x: (foo['bar']) }",
+    "[ ...(a) ]",
+    "[ ...(foo['bar']) ]",
+    "[ ...(foo.bar) ]",
+    "[ (y) ]",
+    "[ (foo.bar) ]",
+    "[ (foo['bar']) ]",
+
     NULL};
   // clang-format on
   static const ParserFlag always_flags[] = {
       kAllowHarmonyDestructuringAssignment, kAllowHarmonyDestructuring,
       kAllowHarmonyDefaultParameters};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 
   RunParserSyncTest(mixed_assignments_context_data, data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
@@ skipping 86 matching lines @@
     "(({ x: x4, x: (x+=1e4) } = {}))",
     "(({ x: x4, x: (x+=1e4) }) = {})",
     "({ x: y } = {})",
     "(({ x: y } = {}))",
     "(({ x: y }) = {})",
     "([a])",
     "(([a]))",
     "([a] = [])",
     "(([a] = []))",
     "(([a]) = [])",
+
+    // v8:4662
+    "{ x: ([y]) }",
+    "{ x: ([y] = []) }",
+    "{ x: ({y}) }",
+    "{ x: ({y} = {}) }",
+    "{ x: (++y) }",
+    "[ (...[a]) ]",
+    "[ ...([a]) ]",
+    "[ ...([a] = [])",
+    "[ ...[ ( [ a ] ) ] ]",
+    "[ ([a]) ]",
+    "[ (...[a]) ]",
+    "[ ([a] = []) ]",
+    "[ (++y) ]",
+    "[ ...(++y) ]",
+
     NULL};
   // clang-format on
   static const ParserFlag always_flags[] = {
       kAllowHarmonyDestructuringAssignment, kAllowHarmonyDestructuring,
       kAllowHarmonyDefaultParameters};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 
   const char* empty_context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
@@ skipping 11 matching lines @@
       "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, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   // Strict mode errors
-  const char* strict_context_data[][2] = {{"'use strict'; ", " = {}"},
+  const char* strict_context_data[][2] = {{"'use strict'; (", " = {})"},
                                           {"'use strict'; for (", " of {}) {}"},
                                           {"'use strict'; for (", " in {}) {}"},
                                           {NULL, NULL}};
   const char* strict_data[] = {"{ eval }",
                                "{ arguments }",
                                "{ foo: eval }",
                                "{ foo: arguments }",
                                "{ eval = 0 }",
                                "{ arguments = 0 }",
                                "{ foo: eval = 0 }",
                                "{ foo: arguments = 0 }",
                                "[ eval ]",
                                "[ arguments ]",
                                "[ eval = 0 ]",
                                "[ arguments = 0 ]",
+
+                               // v8:4662
+                               "{ x: (eval) }",
+                               "{ x: (arguments) }",
+                               "{ x: (eval = 0) }",
+                               "{ x: (arguments = 0) }",
+                               "{ x: (eval) = 0 }",
+                               "{ x: (arguments) = 0 }",
+                               "[ (eval) ]",
+                               "[ (arguments) ]",
+                               "[ (eval = 0) ]",
+                               "[ (arguments = 0) ]",
+                               "[ (eval) = 0 ]",
+                               "[ (arguments) = 0 ]",
+                               "[ ...(eval) ]",
+                               "[ ...(arguments) ]",
+                               "[ ...(eval = 0) ]",
+                               "[ ...(arguments = 0) ]",
+                               "[ ...(eval) = 0 ]",
+                               "[ ...(arguments) = 0 ]",
+
                                NULL};
   RunParserSyncTest(strict_context_data, strict_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(DestructuringDisallowPatternsInForVarIn) {
   i::FLAG_harmony_destructuring_bind = true;
   static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {
@@ skipping 646 matching lines @@
 }
 
 
 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);
 }