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 2350 matching lines @@
     // If there is a newline before the next token, we don't look for RHS.
     "yield\nfor (;;) {}",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 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});",

[rossberg, 2016/01/26 19:33:09]

Maybe add cases for {[yield]: x} = {...}, just to be sure.

[adamk, 2016/01/26 19:39:57]

Do you mean for valid parsing of {[yield]: x} (that's a computed property name
as part of a binding pattern)? Or did you mean {x: [yield]}?

[rossberg, 2016/01/26 19:56:26]

The former.

     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);
 }