[parser] don't report error for CoverInitializedNames in async arrow formals

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 7486 matching lines @@
     "var asyncFn = async function() { await 1; };",
     "var asyncFn = async function withName() { await 1; };",
     "var asyncFn = async () => await 'test';",
     "var asyncFn = async x => await x + 'test';",
     "async function asyncFn() { await 1; }",
     "var O = { async method() { await 1; } }",
     "var O = { async ['meth' + 'od']() { await 1; } }",
     "var O = { async 'method'() { await 1; } }",
     "var O = { async 0() { await 1; } }",
     "async function await() {}",
+
+    "var asyncFn = async({ foo = 1 }) => foo;",
+    "var asyncFn = async({ foo = 1 } = {}) => foo;",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 
   // clang-format off
   const char* async_body_context_data[][2] = {
@@ skipping 141 matching lines @@
     "(async['foo'] () => 1)",
     "(async()['foo'] => 1)",
     "(async()['foo'] foo => 1)",
     "(async()['foo'] () => 1)",
     "(async`foo` => 1)",
     "(async`foo` foo => 1)",
     "(async`foo` () => 1)",
     "(async`foo`.bar => 1)",
     "(async`foo`.bar foo => 1)",
     "(async`foo`.bar () => 1)",
+
+    // v8:5148 assert that errors are still thrown for calls that may have been
+    // async functions
+    "async({ foo = 1 })",
     NULL
   };
 
   const char* strict_error_data[] = {
     "var O = { async method(eval) {} }",
     "var O = { async ['meth' + 'od'](eval) {} }",
     "var O = { async 'method'(eval) {} }",
     "var O = { async 0(eval) {} }",
 
     "var O = { async method(arguments) {} }",
     "var O = { async ['meth' + 'od'](arguments) {} }",
     "var O = { async 'method'(arguments) {} }",
     "var O = { async 0(arguments) {} }",
 
     "var O = { async method(dupe, dupe) {} }",
 
     // TODO(caitp): preparser needs to report duplicate parameter errors, too.
     // "var f = async(dupe, dupe) => {}",
 
     NULL
   };
+
+  const char* formal_parameters_data[] = {
+    "var f = async({ await }) => 1;",
+    "var f = async({ await = 1 }) => 1;",
+    "var f = async({ await } = {}) => 1;",
+    "var f = async({ await = 1 } = {}) => 1;",
+    "var f = async([await]) => 1;",
+    "var f = async([await] = []) => 1;",
+    "var f = async([await = 1]) => 1;",
+    "var f = async([await = 1] = []) => 1;",
+    "var f = async(...await) => 1;",
+    "var f = async(await) => 1;",
+    "var f = async(await = 1) => 1;",
+    "var f = async(...[await]) => 1;",
+    NULL
+  };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(strict_context_data, strict_error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
+  {
+    // TODO(caitp): support these early errors in preparser
+    USE(formal_parameters_data);
+    // const bool kIsModule = false;
+    // const bool kTestPreparser = false;
+    // TODO(caitp): These tests seem to fail test-parsing.cc, even with
+    // test_preparser disabled.
+    // RunParserSyncTest(context_data, formal_parameters_data, kError, NULL, 0,
+    //                 always_flags, arraysize(always_flags), NULL, 0,
+    //                 kIsModule, kTestPreparser);
+  }
 }
 
 TEST(AsyncAwaitModule) {
   // clang-format off
   const char* context_data[][2] = {
     { "", "" },
     { NULL, NULL }
   };
 
   const char* data[] = {
@@ skipping 101 matching lines @@
                               NULL};
   static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
   // The preparser doesn't enforce the restriction, so turn it off.
   bool test_preparser = false;
   RunParserSyncTest(block_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags), NULL, 0, false,
                     test_preparser);
   RunParserSyncTest(top_level_context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }