Disallow yield in default parameter initializers

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 6734 matching lines @@
     "(...{}) => {}",
     "(...{x}) => {}",
     "(...[x]) => {}",
     nullptr};
   // clang-format on
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
+TEST(DefaultParametersYieldInInitializers) {
+  // clang-format off
+  const char* sloppy_function_context_data[][2] = {
+    {"(function f(", ") { });"},
+    // TODO(wingo): Add arrow functions.
+    {NULL, NULL}
+  };
+
+  const char* strict_function_context_data[][2] = {
+    {"'use strong'; (function f(", ") { });"},
+    {"'use strict'; (function f(", ") { });"},
+    // TODO(wingo,conradw): These should also signal early errors.
+    // {"(function f(", ") {'use strong'; });"},
+    // {"(function f(", ") {'use strict'; });"},
+    // TODO(wingo): Add arrow functions.
+    {NULL, NULL}
+  };
+
+  const char* generator_context_data[][2] = {
+    {"'use strong'; (function *g(", ") { });"},
+    {"'use strict'; (function *g(", ") { });"},
+    // TODO(wingo,conradw): These should also signal early errors.
+    // {"(function *g(", ") {'use strong'; });"},
+    // {"(function *g(", ") {'use strict'; });"},
+    {"(function *g(", ") { });"},
+    {NULL, NULL}
+  };
+
+  const char* formal_parameter_data[] = {
+    "x=yield",
+    "x, y=yield",
+    "{x=yield}",
+    "[x=yield]",
+    "{x}=yield",
+    "[x]=yield",
+
+    "x=(yield)",
+    "x, y=(yield)",
+    "{x=(yield)}",
+    "[x=(yield)]",
+    "{x}=(yield)",
+    "[x]=(yield)",
+
+    "x=f(yield)",
+    "x, y=f(yield)",
+    "{x=f(yield)}",
+    "[x=f(yield)]",
+    "{x}=f(yield)",
+    "[x]=f(yield)",
+    NULL
+  };
+
+  // clang-format on
+  static const ParserFlag always_flags[] = {
+      kAllowHarmonyDestructuring, kAllowHarmonyDefaultParameters,
+      kAllowHarmonyArrowFunctions, kAllowStrongMode};
+  RunParserSyncTest(sloppy_function_context_data, formal_parameter_data,
+                    kSuccess, NULL, 0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_function_context_data, formal_parameter_data, kError,
+                    NULL, 0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(generator_context_data, formal_parameter_data, kError, NULL,
+                    0, always_flags, arraysize(always_flags));
+}
+
+
 TEST(SpreadArray) {
   i::FLAG_harmony_spread_arrays = true;
 
   const char* context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "[...a]",
     "[a, ...b]",
@@ skipping 240 matching lines @@
       NULL};
 
   static const ParserFlag always_flags[] = {
       kAllowHarmonyArrowFunctions, kAllowHarmonyDefaultParameters,
       kAllowHarmonyDestructuring, kAllowHarmonyRestParameters,
       kAllowHarmonySloppy, kAllowStrongMode
   };
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }