Treat yield expressions as an AssignmentPattern error

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 2290 matching lines @@
   const char* statement_data[] = {
     "(function * yield() { })",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsGenerator) {
+  // clang-format off
   const char* context_data[][2] = {
     { "function * gen() {", "}" },
     { "(function * gen() {", "})" },
     { "(function * () {", "})" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     // A generator without a body is valid.
     ""
@@ skipping 17 matching lines @@
     // You can return in a generator.
     "yield 1; return",
     "yield * 1; return",
     "yield 1; return 37",
     "yield * 1; return 37",
     "yield 1; return 37; yield 'dead';",
     "yield * 1; return 37; yield * 'dead';",
     // Yield is still a valid key in object literals.
     "({ yield: 1 })",
     "({ get yield() { } })",
+    // And in assignment pattern computed properties
+    "({ [yield]: x } = { })",
     // Yield without RHS.
     "yield;",
     "yield",
     "yield\n",
     "yield /* comment */"
     "yield // comment\n"
     "(yield)",
     "[yield]",
     "{yield}",
     "yield, yield",
     "yield; yield",
     "(yield) ? yield : yield",
     "(yield) \n ? yield : yield",
     // If there is a newline before the next token, we don't look for RHS.
     "yield\nfor (;;) {}",
     NULL
   };
+  // clang-format on
 
-  RunParserSyncTest(context_data, statement_data, kSuccess);
+  static const ParserFlag always_flags[] = {
+      kAllowHarmonyDestructuringAssignment};
+  RunParserSyncTest(context_data, statement_data, kSuccess, nullptr, 0,
+                    always_flags, arraysize(always_flags));
 }
 
 
 TEST(ErrorsYieldGenerator) {
+  // clang-format off
   const char* context_data[][2] = {
     { "function * gen() {", "}" },
     { "\"use strict\"; function * gen() {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     // Invalid yield expressions inside generators.
     "var yield;",
     "var foo, yield;",
@@ skipping 20 matching lines @@
     "yield / yield",
     "+ yield",
     "+ yield 3",
     // Invalid (no newline allowed between yield and *).
     "yield\n*3",
     // Invalid (we see a newline, so we parse {yield:42} as a statement, not an
     // object literal, and yield is not a valid label).
     "yield\n{yield: 42}",
     "yield /* comment */\n {yield: 42}",
     "yield //comment\n {yield: 42}",
+    // Destructuring binding and assignment are both disallowed
+    "var [yield] = [42];",
+    "var {foo: yield} = {a: 42};",
+    "[yield] = [42];",
+    "({a: yield} = {a: 42});",
+    // Also disallow full yield expressions on LHS
+    "var [yield 24] = [42];",
+    "var {foo: yield 24} = {a: 42};",
+    "[yield 24] = [42];",
+    "({a: yield 24} = {a: 42});",
     NULL
   };
+  // clang-format on
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsNameOfStrictFunction) {
   // Tests that illegal tokens as names of a strict function produce the correct
   // errors.
   const char* context_data[][2] = {
     { "function ", ""},
@@ skipping 5533 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);
 }