[async functions] Disallow 'await' in arrow params inside async functions

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 7785 matching lines @@
   const char* body_data[] = {
     "var async = 1; return async;",
     "let async = 1; return async;",
     "const async = 1; return async;",
     "function async() {} return async();",
     "var async = async => async; return async();",
     "function foo() { var await = 1; return await; }",
     "function foo(await) { return await; }",
     "function* foo() { var await = 1; return await; }",
     "function* foo(await) { return await; }",
-    "var f = (await) => await;",
     "var f = () => { var await = 1; return await; }",
     "var O = { method() { var await = 1; return await; } };",
     "var O = { method(await) { return await; } };",
     "var O = { *method() { var await = 1; return await; } };",
     "var O = { *method(await) { return await; } };",
 
     "(function await() {})",
     NULL
   };
   // clang-format on
@@ skipping 11 matching lines @@
     { "", "" },
     { NULL, NULL }
   };
 
   const char* strict_context_data[][2] = {
     { "'use strict';", "" },
     { NULL, NULL }
   };
 
   const char* error_data[] = {
-    "var asyncFn = async function() { var await = 1; };",
-    "var asyncFn = async function() { var { await } = 1; };",
-    "var asyncFn = async function() { var [ await ] = 1; };",
     "var asyncFn = async function await() {};",
     "var asyncFn = async () => var await = 'test';",
     "var asyncFn = async await => await + 'test';",
     "var asyncFn = async function(await) {};",
-    "var asyncFn = async function() { return async (await) => {}; }",
     "var asyncFn = async (await) => 'test';",
-    "var asyncFn = async x => { var await = 1; }",
-    "var asyncFn = async x => { var { await } = 1; }",
-    "var asyncFn = async x => { var [ await ] = 1; }",
     "async function f(await) {}",
-    "async function f() { var await = 1; }",
-    "async function f() { var { await } = 1; }",
-    "async function f() { var [ await ] = 1; }",
 
     "var O = { async method(a, a) {} }",
     "var O = { async ['meth' + 'od'](a, a) {} }",
     "var O = { async 'method'(a, a) {} }",
     "var O = { async 0(a, a) {} }",
 
-    "async function f() { var O = { async [await](a, a) {} } }",
-
-    "var asyncFn = async function() { await; }",
-    "async function f() { await; }",
-    "var O = { async method() { await; } };",
     "var f = async() => await;",
-    "var f = async() => { await; };",
-
-    "async function f() { return {await} }",
 
     "var asyncFn = async function*() {}",
     "async function* f() {}",
     "var O = { *async method() {} };",
     "var O = { async *method() {} };",
     "var O = { async method*() {} };",
 
     "var asyncFn = async function(x = await 1) { return x; }",
     "async function f(x = await 1) { return x; }",
     "var f = async(x = await 1) => x;",
     "var O = { async method(x = await 1) { return x; } };",
 
     "var f = async(x = await) => 1;",
 
     "class C { async constructor() {} }",
     "class C {}; class C2 extends C { async constructor() {} }",
     "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 foo1() { } foo2 => 1)",
     "(async function foo3() { } () => 1)",
     "(async function foo4() { } => 1)",
     "(async function() { } foo5 => 1)",
     "(async function() { } () => 1)",
     "(async function() { } => 1)",
     "(async.foo6 => 1)",
     "(async.foo7 foo8 => 1)",
     "(async.foo9 () => 1)",
@@ skipping 64 matching lines @@
   // 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));
 
   RunParserSyncTest(context_data, formal_parameters_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
+
+  // clang-format off
+  const char* async_body_context_data[][2] = {
+    { "async function f() {", "}" },
+    { "var f = async function() {", "}" },
+    { "var f = async() => {", "}" },
+    { "var O = { async method() {", "} }" },
+    { "'use strict'; async function f() {", "}" },
+    { "'use strict'; var f = async function() {", "}" },
+    { "'use strict'; var f = async() => {", "}" },
+    { "'use strict'; var O = { async method() {", "} }" },
+    { NULL, NULL }
+  };
+
+  const char* async_body_error_data[] = {
+    "var await = 1;",
+    "var { await } = 1;",
+    "var [ await ] = 1;",
+    "return async (await) => {};",
+    "var O = { async [await](a, a) {} }",
+    "await;",
+
+    "function await() {}",
+
+    "var f = await => 42;",
+    "var f = (await) => 42;",
+    "var f = (await, a) => 42;",
+    "var f = (...await) => 42;",
+
+    "var e = (await);",
+    "var e = (await, f);",
+    "var e = (await = 42)",
+
+    "var e = [await];",
+    "var e = {await};",
+
+    NULL
+  };
+  // clang-format on
+
+  RunParserSyncTest(async_body_context_data, async_body_error_data, kError,
+                    NULL, 0, always_flags, arraysize(always_flags));
 }
 
 TEST(AsyncAwaitModule) {
   // clang-format off
   const char* context_data[][2] = {
     { "", "" },
     { NULL, NULL }
   };
 
   const char* data[] = {
@@ skipping 205 matching lines @@
     "(a,);",
     "(a,b,c,);",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonyTrailingCommas};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }