Test that "yield" expressions are disallowed in arrow formal 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 6738 matching lines @@
   // 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* sloppy_arrow_context_data[][2] = {
+    {"((", ")=>{});"},
+    {NULL, NULL}
+  };
+
+  const char* strict_arrow_context_data[][2] = {
+    {"'use strong'; ((", ")=>{});"},
+    {"'use strict'; ((", ")=>{});"},
     {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[] = {
+  const char* 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)]",
+    NULL
+  };
+
+  // TODO(wingo): These aren't really destructuring assignment patterns; we're
+  // just splitting them for now until the parser gets support for arrow
+  // function arguments that look like destructuring assignments.  When that
+  // happens we should unify destructuring_assignment_data and parameter_data.
+  const char* destructuring_assignment_data[] = {
+    "{x}=yield",
+    "[x]=yield",
+
+    "{x}=(yield)",
+    "[x]=(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,
+
+  RunParserSyncTest(sloppy_function_context_data, parameter_data, kSuccess,
+                    NULL, 0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(sloppy_function_context_data, destructuring_assignment_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,
+  RunParserSyncTest(sloppy_arrow_context_data, parameter_data, kSuccess, NULL,
                     0, always_flags, arraysize(always_flags));
+  // TODO(wingo): Will change to kSuccess when destructuring assignment lands.
+  RunParserSyncTest(sloppy_arrow_context_data, destructuring_assignment_data,
+                    kError, NULL, 0, always_flags, arraysize(always_flags));
+
+  RunParserSyncTest(strict_function_context_data, parameter_data, kError, NULL,
+                    0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_function_context_data, destructuring_assignment_data,
+                    kError, NULL, 0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_arrow_context_data, parameter_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_arrow_context_data, destructuring_assignment_data,
+                    kError, NULL, 0, always_flags, arraysize(always_flags));
+
+  RunParserSyncTest(generator_context_data, parameter_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(generator_context_data, destructuring_assignment_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
@@ skipping 243 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));
 }