[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 })",

[Dan Ehrenberg, 2016/06/24 17:30:41]

Maybe verify that await is banned in this context 

[caitp (gmail), 2016/06/24 18:05:40]

why would await be banned in this context, other than in a module?

`async({ await = 1 }) => 1` would be an error, but is currently only reported as
an error in the full parser, not the preparser, so I think that's a separate
issue (similar to other cases where arrow functions don't produce early errors
in the preparser).

[Dan Ehrenberg, 2016/06/24 18:30:14]

test-parsing.cc has a way of invoking just the parser. We should take advantage
of that mode to test these things.

[caitp (gmail), 2016/06/24 19:24:43]

I've added tests and a TODO, will deal with fixing the banned "await" parameter
separately.

     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) {} }",
@@ skipping 129 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));
 }