Remove --harmony-async-await runtime flag

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 1256 matching lines @@
     result[i] = start[i + 1];
   }
   result[length] = '\0';
   return result;
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
-  kAllowHarmonyAsyncAwait,
   kAllowHarmonyRestrictiveGenerators,
   kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
   kAllowHarmonyObjectSpread,
 };
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 void SetGlobalFlags(i::EnumSet<ParserFlag> flags) {
   i::FLAG_allow_natives_syntax = flags.Contains(kAllowNatives);
   i::FLAG_harmony_function_sent = flags.Contains(kAllowHarmonyFunctionSent);
-  i::FLAG_harmony_async_await = flags.Contains(kAllowHarmonyAsyncAwait);
   i::FLAG_harmony_restrictive_generators =
       flags.Contains(kAllowHarmonyRestrictiveGenerators);
   i::FLAG_harmony_trailing_commas = flags.Contains(kAllowHarmonyTrailingCommas);
   i::FLAG_harmony_class_fields = flags.Contains(kAllowHarmonyClassFields);
   i::FLAG_harmony_object_spread = flags.Contains(kAllowHarmonyObjectSpread);
 }
 
 void SetParserFlags(i::PreParser* parser, i::EnumSet<ParserFlag> flags) {
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
-  parser->set_allow_harmony_async_await(
-      flags.Contains(kAllowHarmonyAsyncAwait));
   parser->set_allow_harmony_restrictive_generators(
       flags.Contains(kAllowHarmonyRestrictiveGenerators));
   parser->set_allow_harmony_trailing_commas(
       flags.Contains(kAllowHarmonyTrailingCommas));
   parser->set_allow_harmony_class_fields(
       flags.Contains(kAllowHarmonyClassFields));
   parser->set_allow_harmony_object_spread(
       flags.Contains(kAllowHarmonyObjectSpread));
 }
 
@@ skipping 1403 matching lines @@
     "*x",
     "*get x(){}",
     "*set x(y){}",
     "get *x(){}",
     "set *x(y){}",
     "get x*(){}",
     "set x*(y){}",
     "x = 0",
     "* *x(){}",
     "x*(){}",
-    // This should fail without --harmony-async-await
-    "async x(){}",
-    NULL
-  };
-  // clang-format on
-
-  RunParserSyncTest(context_data, statement_data, kError);
-
-  // clang-format off
-  const char* async_data[] = {
     "static async x(){}",
     "static async x : 0",
     "static async get x : 0",
     "async static x(){}",
     "*async x(){}",
     "async *x(){}",
     "async x*(){}",
     "async x : 0",
     "async 0 : 0",
     "async get x(){}",
     "async get *x(){}",
     "async set x(y){}",
     "async get : 0",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, async_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsObjectLiteralChecking) {
   // clang-format off
   const char* context_data[][2] = {
     {"var myobject = {", "};"},
     {"var myobject = {", ",};"},
     {"\"use strict\"; var myobject = {", "};"},
     {"\"use strict\"; var myobject = {", ",};"},
@@ skipping 53 matching lines @@
     "set : 0",
     "static : 0",
     "async : 0",
     // Keywords, future reserved and strict future reserved are also allowed as
     // property names.
     "if: 4",
     "interface: 5",
     "super: 6",
     "eval: 7",
     "arguments: 8",
-    NULL
-  };
-  // clang-format on
-
-  RunParserSyncTest(context_data, statement_data, kSuccess);
-
-  // clang-format off
-  const char* async_data[] = {
     "async x(){}",
     "async 0(){}",
     "async get(){}",
     "async set(){}",
     "async static(){}",
     "async async(){}",
     "async : 0",
     "async(){}",
     "*async(){}",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, async_data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(TooManyArguments) {
   const char* context_data[][2] = {
     {"foo(", "0)"},
     { NULL, NULL }
   };
 
   using v8::internal::Code;
@@ skipping 1637 matching lines @@
     // Escaped 'static' should be allowed anywhere
     // static-as-PropertyName is.
     "st\\u0061tic() {}",
     "get st\\u0061tic() {}",
     "set st\\u0061tic(v) {}",
     "static st\\u0061tic() {}",
     "static get st\\u0061tic() {}",
     "static set st\\u0061tic(v) {}",
     "*st\\u0061tic() {}",
     "static *st\\u0061tic() {}",
-    NULL};
-  // clang-format on
 
-  RunParserSyncTest(context_data, class_body_data, kSuccess);
-
-  // clang-format off
-  const char* async_data[] = {
     "static async x(){}",
     "static async(){}",
     "static *async(){}",
     "async x(){}",
     "async 0(){}",
     "async get(){}",
     "async set(){}",
     "async static(){}",
     "async async(){}",
     "async(){}",
     "*async(){}",
-    NULL
-  };
+    NULL};
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, async_data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kSuccess);
 }
 
 
 TEST(ClassPropertyNameNoErrors) {
   const char* context_data[][2] = {{"(class {", "() {}});"},
                                    {"(class { get ", "() {}});"},
                                    {"(class { set ", "(v) {}});"},
                                    {"(class { static ", "() {}});"},
                                    {"(class { static get ", "() {}});"},
                                    {"(class { static set ", "(v) {}});"},
@@ skipping 107 matching lines @@
 
     // ASI edge cases
     "a\n get",
     "get\n *a(){}",
     "a\n static",
 
     // Misc edge cases
     "yield",
     "yield = 0",
     "yield\n a",
-    NULL
-  };
-  // clang-format on
-
-  static const ParserFlag without_async[] = {kAllowHarmonyClassFields};
-  RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
-                    without_async, arraysize(without_async));
-
-  // clang-format off
-  const char* async_data[] = {
     "async;",
     "async = 0;",
     "static async;"
     "async",
     "async = 0",
     "static async",
     "async\n a(){}",  // a field named async, and a method named a.
     "async\n a",
     "await;",
     "await = 0;",
     "await\n a",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag with_async[] = {kAllowHarmonyClassFields,
-                                          kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, async_data, kSuccess, NULL, 0, with_async,
-                    arraysize(with_async));
+  static const ParserFlag always_flags[] = {kAllowHarmonyClassFields};
+  RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
+                    always_flags, arraysize(always_flags));
 }
 
 TEST(ClassFieldsErrors) {
   // clang-format off
   // Tests proposed class fields syntax.
   const char* context_data[][2] = {{"(class {", "});"},
                                    {"(class extends Base {", "});"},
                                    {"class C {", "}"},
                                    {"class C extends Base {", "}"},
                                    {NULL, NULL}};
   const char* class_body_data[] = {
     "a : 0",
     "a =",
     "*a = 0",
     "*a",
     "get a",
     "yield a",
     "a : 0;",
     "a =;",
     "*a = 0;",
     "*a;",
     "get a;",
     "yield a;",
+    "async a = 0",
+    "async a",
 
     // ASI requires a linebreak
     "a b",
     "a = 0 b",
 
     // ASI requires that the next token is not part of any legal production
     "a = 0\n *b(){}",
     "a = 0\n ['b'](){}",
     "get\n a",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag without_async[] = {kAllowHarmonyClassFields};
+  static const ParserFlag always_flags[] = {kAllowHarmonyClassFields};
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
-                    without_async, arraysize(without_async));
-
-  // clang-format off
-  const char* async_data[] = {
-    "async a = 0",
-    "async a",
-    NULL
-  };
-  // clang-format on
-
-  static const ParserFlag with_async[] = {kAllowHarmonyClassFields,
-                                          kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, async_data, kError, NULL, 0, with_async,
-                    arraysize(with_async));
+                    always_flags, arraysize(always_flags));
 }
 
 TEST(ClassExpressionErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
     "class name",
@@ skipping 68 matching lines @@
     "static async *(){}",
     "static async *x(){}",
     "static async get x(){}",
     "static async set x(y){}",
     "static async x : 0",
     "static async : 0",
     NULL
   };
   // clang-format on
 
-  // All of these are illegal whether or not async functions are permitted,
-  // although for different reasons.
   RunParserSyncTest(context_data, async_data, kError);
-
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, async_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
 }
 
 TEST(ClassNameErrors) {
   const char* context_data[][2] = {{"class ", "{}"},
                                    {"(class ", "{});"},
                                    {"'use strict'; class ", "{}"},
                                    {"'use strict'; (class ", "{});"},
                                    {NULL, NULL}};
   const char* class_name[] = {
     "arguments",
@@ skipping 1743 matching lines @@
     "{ ...1}",
     "{ ...null}",
     "{ ...undefined}",
     "{ ...1 in {}}",
     "{ ...[]}",
     "{ ...async function() { }}",
     "{ ...async () => { }}",
     "{ ...new Foo()}",
     NULL};
 
-  static const ParserFlag flags[] = {kAllowHarmonyObjectSpread,
-                                     kAllowHarmonyAsyncAwait};
+  static const ParserFlag flags[] = {kAllowHarmonyObjectSpread};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
                     arraysize(flags));
 }
 
 TEST(ObjectSpreadNegativeTests) {
   {
     const char* context_data[][2] = {{"x = ", ""},
                                      {"'use strict'; x = ", ""},
                                      {NULL, NULL}};
 
@@ skipping 1479 matching lines @@
 
     "var asyncFn = async({ foo = 1 }) => foo;",
     "var asyncFn = async({ foo = 1 } = {}) => foo;",
 
     "function* g() { var f = async(yield); }",
     "function* g() { var f = async(x = yield); }",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 
   // 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() => {", "}" },
@@ skipping 33 matching lines @@
     "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
 
-  RunParserSyncTest(async_body_context_data, body_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
-  RunParserSyncTest(body_context_data, body_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(async_body_context_data, body_data, kSuccess);
+  RunParserSyncTest(body_context_data, body_data, kSuccess);
 }
 
 TEST(AsyncAwaitErrors) {
   // clang-format off
   const char* context_data[][2] = {
     { "'use strict';", "" },
     { "", "" },
     { NULL, NULL }
   };
 
@@ skipping 116 matching lines @@
     "var f = async(x = async(await)) => 1;",
     "var f = async(x = { [await]: 1 }) => 1;",
     "var f = async(x = class extends (await) { }) => 1;",
     "var f = async(x = class { static [await]() {} }) => 1;",
     "var f = async({ x = 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));
-
-  RunParserSyncTest(context_data, formal_parameters_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
+  RunParserSyncTest(strict_context_data, strict_error_data, kError);
+  RunParserSyncTest(context_data, formal_parameters_data, kError);
 
   // 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() => {", "}" },
@@ skipping 20 matching lines @@
     "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));
+  RunParserSyncTest(async_body_context_data, async_body_error_data, kError);
 }
 
 TEST(AsyncAwaitModule) {
   // clang-format off
   const char* context_data[][2] = {
     { "", "" },
     { NULL, NULL }
   };
 
   const char* data[] = {
     "export default async function() { await 1; }",
     "export default async function async() { await 1; }",
     "export async function async() { await 1; }",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunModuleParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                          arraysize(always_flags), NULL, 0, false);
+  RunModuleParserSyncTest(context_data, data, kSuccess, NULL, 0, NULL, 0, NULL,
+                          0, false);
 }
 
 TEST(AsyncAwaitModuleErrors) {
   // clang-format off
   const char* context_data[][2] = {
     { "", "" },
     { NULL, NULL }
   };
 
   const char* error_data[] = {
     "export default (async function await() {})",
     "export default async function await() {}",
     "export async function await() {}",
     "export async function() {}",
     "export async",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
-  RunModuleParserSyncTest(context_data, error_data, kError, NULL, 0,
-                          always_flags, arraysize(always_flags), NULL, 0,
-                          false);
+  RunModuleParserSyncTest(context_data, error_data, kError, NULL, 0, NULL, 0,
+                          NULL, 0, false);
 }
 
 TEST(RestrictiveForInErrors) {
   // clang-format off
   const char* strict_context_data[][2] = {
     { "'use strict'", "" },
     { NULL, NULL }
   };
   const char* sloppy_context_data[][2] = {
     { "", "" },
@@ skipping 56 matching lines @@
       {"(function() {'use strict';", "})()"},
       {NULL, NULL}};
   const char* error_data[] = {"async function x() {} async function x() {}",
                               "function x() {} async function x() {}",
                               "async function x() {} function x() {}",
                               "function* x() {} async function x() {}",
                               "function* x() {} async function x() {}",
                               "async function x() {} function* x() {}",
                               "function* x() {} async function x() {}",
                               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));
+  RunParserSyncTest(block_context_data, error_data, kError, NULL, 0, NULL, 0,
+                    NULL, 0, false, test_preparser);
+  RunParserSyncTest(top_level_context_data, error_data, kSuccess);
 }
 
 TEST(TrailingCommasInParameters) {
   // clang-format off
   const char* context_data[][2] = {
     { "", "" },
     { "'use strict';", "" },
     { "function foo() {", "}" },
     { "function foo() {'use strict';", "}" },
     { NULL, NULL }
@@ skipping 426 matching lines @@
     DCHECK_NOT_NULL(scope);
     DCHECK_NULL(scope->sibling());
     DCHECK(scope->is_function_scope());
     const i::AstRawString* var_name =
         info.ast_value_factory()->GetOneByteString("my_var");
     i::Variable* var = scope->Lookup(var_name);
     CHECK_EQ(inners[i].ctxt_allocate,
              i::ScopeTestHelper::MustAllocateInContext(var));
   }
 }