Properly disallow 'yield' in class expressions and arrow parameters

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 2314 matching lines @@
     "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 (;;) {}",
+    "x = class extends (yield) {}",
+    "x = class extends f(yield) {}",
+    "x = class extends (null, yield) { }",
+    "x = class extends (a ? null : yield) { }",
     NULL
   };
   // clang-format on
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsYieldGenerator) {
   // clang-format off
@@ skipping 44 matching lines @@
     "({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});",
     "for (yield 'x' in {});",
     "for (yield 'x' of {});",
     "for (yield 'x' in {} in {});",
     "for (yield 'x' in {} of {});",
+    "class C extends yield { }",
     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
@@ skipping 4314 matching lines @@
   };
 
   const char* strict_arrow_context_data[][2] = {
     {"'use strict'; ((", ")=>{});"},
     {NULL, NULL}
   };
 
   const char* generator_context_data[][2] = {
     {"'use strict'; (function *g(", ") { });"},
     {"(function *g(", ") { });"},
+    // Arrow function within generator has the same rules.
+    {"'use strict'; (function *g() { (", ") => {} });"},
+    {"(function *g() { (", ") => {} });"},
     {NULL, NULL}
   };
 
   const char* parameter_data[] = {
     "x=yield",
     "x, y=yield",
     "{x=yield}",
     "[x=yield]",
 
     "x=(yield)",
@@ skipping 10 matching lines @@
     "[x]=yield",
 
     "{x}=(yield)",
     "[x]=(yield)",
 
     "{x}=f(yield)",
     "[x]=f(yield)",
     NULL
   };
 
+  // Because classes are always in strict mode, these are always errors.
+  const char* always_error_param_data[] = {
+    "x = class extends (yield) { }",
+    "x = class extends f(yield) { }",
+    "x = class extends (null, yield) { }",
+    "x = class extends (a ? null : yield) { }",
+    "[x] = [class extends (a ? null : yield) { }]",
+    "[x = class extends (a ? null : yield) { }]",
+    "[x = class extends (a ? null : yield) { }] = [null]",
+    NULL
+  };
   // clang-format on
 
   RunParserSyncTest(sloppy_function_context_data, parameter_data, kSuccess);
   RunParserSyncTest(sloppy_arrow_context_data, parameter_data, kSuccess);
 
   RunParserSyncTest(strict_function_context_data, parameter_data, kError);
   RunParserSyncTest(strict_arrow_context_data, parameter_data, kError);
 
   RunParserSyncTest(generator_context_data, parameter_data, kError);
+  RunParserSyncTest(generator_context_data, always_error_param_data, kError);
 }
 
-
 TEST(SpreadArray) {
   const char* context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "[...a]",
     "[a, ...b]",
     "[...a,]",
     "[...a, ,]",
@@ skipping 645 matching lines @@
     "for (const x = 0 in {});",
     "for (let x = 0 in {});",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonyForIn};
   RunParserSyncTest(context_data, error_data, kError, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }