[parser] only parse async arrow function when necessary

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 7622 matching lines @@
     "class C { static async prototype() {} }",
     "class C {}; class C2 extends C { static async prototype() {} }",
 
     "var f = async() => ((async(x = await 1) => x)();",
 
     "var asyncFn = async function() { function await() {} }",
     "var asyncFn = async() => { function await() {} }",
     "var O = { async method() { function await() {} } }",
     "async function foo() { function await() {} }",
 
+    // Henrique Ferreiro's bug (tm)
+    "(async function foo() { } foo => 1)",
+    "(async function foo() { } () => 1)",
+    "(async function foo() { } => 1)",
+    "(async function() { } foo => 1)",
+    "(async function() { } () => 1)",
+    "(async function() { } => 1)",
+    "(async.foo => 1)",
+    "(async.foo foo => 1)",
+    "(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'] => 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)",
     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));
 }