Remove --harmony-arrow-functions 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 209 matching lines @@
       "var w = /RegExp Literal\\u0020With Escape/gin;"
       "var y = { get getter() { return 42; }, "
       "          set setter(v) { this.value = v; }};"
       "var f = a => function (b) { return a + b; };"
       "var g = a => b => a + b;";
   int source_length = i::StrLength(source);
 
   // ScriptResource will be deleted when the corresponding String is GCd.
   v8::ScriptCompiler::Source script_source(v8::String::NewExternal(
       isolate, new ScriptResource(source, source_length)));
-  i::FLAG_harmony_arrow_functions = true;
   i::FLAG_min_preparse_length = 0;
   v8::ScriptCompiler::Compile(isolate, &script_source,
                               v8::ScriptCompiler::kProduceParserCache);
   CHECK(script_source.GetCachedData());
 
   // Compile the script again, using the cached data.
   bool lazy_flag = i::FLAG_lazy;
   i::FLAG_lazy = true;
   v8::ScriptCompiler::Compile(isolate, &script_source,
                               v8::ScriptCompiler::kConsumeParserCache);
   i::FLAG_lazy = false;
   v8::ScriptCompiler::CompileUnbound(isolate, &script_source,
                                      v8::ScriptCompiler::kConsumeParserCache);
   i::FLAG_lazy = lazy_flag;
 }
 
 
 TEST(PreparseFunctionDataIsUsed) {
   // This tests that we actually do use the function data generated by the
   // preparser.
 
   // Make preparsing work for short scripts.
   i::FLAG_min_preparse_length = 0;
-  i::FLAG_harmony_arrow_functions = true;
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handles(isolate);
   v8::Local<v8::Context> context = v8::Context::New(isolate);
   v8::Context::Scope context_scope(context);
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
   const char* good_code[] = {
       "function this_is_lazy() { var a; } function foo() { return 25; } foo();",
@@ skipping 58 matching lines @@
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
     i::Zone zone;
     i::AstValueFactory ast_value_factory(
         &zone, CcTest::i_isolate()->heap()->HashSeed());
     i::PreParser preparser(&zone, &scanner, &ast_value_factory, &log,
                            stack_limit);
     preparser.set_allow_lazy(true);
     preparser.set_allow_natives(true);
-    preparser.set_allow_harmony_arrow_functions(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     CHECK(!log.HasError());
   }
 }
 
 
 TEST(StandAlonePreParserNoNatives) {
   v8::V8::Initialize();
 
@@ skipping 173 matching lines @@
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
 
   i::Zone zone;
   i::AstValueFactory ast_value_factory(&zone,
                                        CcTest::i_isolate()->heap()->HashSeed());
   i::PreParser preparser(&zone, &scanner, &ast_value_factory, &log,
                          stack_limit);
   preparser.set_allow_lazy(true);
-  preparser.set_allow_harmony_arrow_functions(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   CHECK_EQ(i::PreParser::kPreParseStackOverflow, result);
 }
 
 
 class TestExternalResource: public v8::String::ExternalStringResource {
  public:
   explicit TestExternalResource(uint16_t* data, int length)
       : data_(data), length_(static_cast<size_t>(length)) { }
 
@@ skipping 519 matching lines @@
       i::ScopedVector<char> program(kProgramByteSize + 1);
       i::SNPrintF(program, "%s%s%s", surroundings[j].prefix,
                   source_data[i].body, surroundings[j].suffix);
       i::Handle<i::String> source =
           factory->NewStringFromUtf8(i::CStrVector(program.start()))
               .ToHandleChecked();
       i::Handle<i::Script> script = factory->NewScript(source);
       i::Zone zone;
       i::ParseInfo info(&zone, script);
       i::Parser parser(&info);
-      parser.set_allow_harmony_arrow_functions(true);
       parser.set_allow_harmony_sloppy(true);
       info.set_global();
       CHECK(parser.Parse(&info));
       CHECK(i::Rewriter::Rewrite(&info));
       CHECK(i::Scope::Analyze(&info));
       CHECK(info.literal() != NULL);
 
       i::Scope* script_scope = info.literal()->scope();
       CHECK(script_scope->is_script_scope());
       CHECK_EQ(1, script_scope->inner_scopes()->length());
@@ skipping 33 matching lines @@
   full_source += "; }";
 
   i::Handle<i::String> source_code =
       factory->NewStringFromUtf8(i::CStrVector(full_source.c_str()))
           .ToHandleChecked();
 
   i::Handle<i::Script> script = factory->NewScript(source_code);
 
   i::ParseInfo info(handles.main_zone(), script);
   i::Parser parser(&info);
-  parser.set_allow_harmony_arrow_functions(true);
   parser.set_allow_harmony_sloppy(true);
   info.set_global();
   info.set_lazy(false);
   info.set_allow_lazy_parsing(false);
   info.set_toplevel(true);
 
   i::CompilationInfo compilation_info(&info);
   CHECK(i::Compiler::ParseAndAnalyze(&info));
 
   CHECK(info.scope()->declarations()->length() == 1);
@@ skipping 236 matching lines @@
 
     // Parse program source.
     i::Handle<i::String> source = factory->NewStringFromUtf8(
         i::CStrVector(program.start())).ToHandleChecked();
     CHECK_EQ(source->length(), kProgramSize);
     i::Handle<i::Script> script = factory->NewScript(source);
     i::Zone zone;
     i::ParseInfo info(&zone, script);
     i::Parser parser(&info);
     parser.set_allow_lazy(true);
-    parser.set_allow_harmony_arrow_functions(true);
     info.set_global();
     info.set_language_mode(source_data[i].language_mode);
     parser.Parse(&info);
     CHECK(info.literal() != NULL);
 
     // Check scope types and positions.
     i::Scope* scope = info.literal()->scope();
     CHECK(scope->is_script_scope());
     CHECK_EQ(scope->start_position(), 0);
     CHECK_EQ(scope->end_position(), kProgramSize);
@@ skipping 101 matching lines @@
   }
 
   data.Dispose();
   return i::MessageTemplate::FormatMessage(isolate, message, arg_object);
 }
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
-  kAllowHarmonyArrowFunctions,
   kAllowHarmonyDefaultParameters,
   kAllowHarmonyRestParameters,
   kAllowHarmonySloppy,
   kAllowHarmonySloppyLet,
   kAllowHarmonySpreadCalls,
   kAllowHarmonyDestructuring,
   kAllowHarmonySpreadArrays,
   kAllowHarmonyNewTarget,
   kAllowStrongMode,
   kNoLegacyConst
 };
 
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 template <typename Traits>
 void SetParserFlags(i::ParserBase<Traits>* parser,
                     i::EnumSet<ParserFlag> flags) {
   parser->set_allow_lazy(flags.Contains(kAllowLazy));
   parser->set_allow_natives(flags.Contains(kAllowNatives));
-  parser->set_allow_harmony_arrow_functions(
-      flags.Contains(kAllowHarmonyArrowFunctions));
   parser->set_allow_harmony_default_parameters(
       flags.Contains(kAllowHarmonyDefaultParameters));
   parser->set_allow_harmony_rest_parameters(
       flags.Contains(kAllowHarmonyRestParameters));
   parser->set_allow_harmony_spread_calls(
       flags.Contains(kAllowHarmonySpreadCalls));
   parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
   parser->set_allow_harmony_sloppy_let(flags.Contains(kAllowHarmonySloppyLet));
   parser->set_allow_harmony_destructuring(
       flags.Contains(kAllowHarmonyDestructuring));
@@ skipping 462 matching lines @@
     "arguments;",
     "var foo = eval;",
     "var foo = arguments;",
     "var foo = { eval: 1 };",
     "var foo = { arguments: 1 };",
     "var foo = { }; foo.eval = {};",
     "var foo = { }; foo.arguments = {};",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 #define FUTURE_STRICT_RESERVED_WORDS(V) \
   V(implements)                         \
   V(interface)                          \
   V(let)                                \
   V(package)                            \
   V(private)                            \
   V(protected)                          \
@@ skipping 58 matching lines @@
     { "function test_func() {", "}"},
     { "() => {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
-
-  static const ParserFlag classes_flags[] = {kAllowHarmonyArrowFunctions};
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    classes_flags, arraysize(classes_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsReservedWords) {
   // Tests that both preparsing and parsing produce the right kind of errors for
   // using future reserved words as identifiers. These tests don't depend on the
   // strict mode.
   const char* context_data[][2] = {
     { "", "" },
     { "\"use strict\";", "" },
@@ skipping 406 matching lines @@
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "mylabel: while(true) { break mylabel; }",
     "eval: while(true) { break eval; }",
     "arguments: while(true) { break arguments; }",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(NoErrorsFutureStrictReservedAsLabelsSloppy) {
   const char* context_data[][2] = {
     { "", ""},
     { "function test_func() {", "}" },
     { "() => {", "}" },
     { NULL, NULL }
   };
 
 #define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
   const char* statement_data[] {
     FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
     NULL
   };
 #undef LABELLED_WHILE
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsParenthesizedLabels) {
   // Parenthesized identifiers shouldn't be recognized as labels.
   const char* context_data[][2] = {
     { "", ""},
     { "function test_func() {", "}" },
     { "() => {", "}" },
     { NULL, NULL }
@@ skipping 1054 matching lines @@
     "c++",
     "`c`",
     "`${c}`",
     "`template-head${c}`",
     "`${c}template-tail`",
     "`template-head${c}template-tail`",
     "`${c}template-tail`",
     nullptr
   };
 
-  static const ParserFlag always_flags[] = { kAllowHarmonyArrowFunctions,
-                                             kAllowHarmonyRestParameters };
+  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters};
   RunParserSyncTest(context_data, assignment_expression_suffix_data, kError,
                     NULL, 0, always_flags, arraysize(always_flags));
 }
 
 
 TEST(ErrorsArrowFunctions) {
   // Tests that parser and preparser generate the same kind of errors
   // on invalid arrow function syntax.
   const char* context_data[][2] = {
     {"", ";"},
@@ skipping 93 matching lines @@
     "(foo ? bar : baz, a) => {}",
     "(a.b, c) => {}",
     "(c, a.b) => {}",
     "(a['b'], c) => {}",
     "(c, a['b']) => {}",
     NULL
   };
 
   // The test is quite slow, so run it with a reduced set of flags.
   static const ParserFlag flags[] = {kAllowLazy};
-  static const ParserFlag always_flags[] = { kAllowHarmonyArrowFunctions };
   RunParserSyncTest(context_data, statement_data, kError, flags,
-                    arraysize(flags), always_flags, arraysize(always_flags));
+                    arraysize(flags));
 }
 
 
 TEST(NoErrorsArrowFunctions) {
   // Tests that parser and preparser accept valid arrow functions syntax.
   const char* context_data[][2] = {
     {"", ";"},
     {"bar ? (", ") : baz;"},
     {"bar ? baz : (", ");"},
     {"bar, ", ";"},
@@ skipping 49 matching lines @@
     "(x, y = 9, ...a) => {}",
     "(x, y = 9, {b}, z = 8, ...a) => {}",
     // TODO(wingo, rossberg): This is not accepted right now.
     // "({a} = {}) => {}",
     // "([x] = []) => {}",
     "({a = 42}) => {}",
     "([x = 0]) => {}",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDefaultParameters,
-      kAllowHarmonyRestParameters, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDefaultParameters,
+                                            kAllowHarmonyRestParameters,
+                                            kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ArrowFunctionsSloppyParameterNames) {
   const char* strong_context_data[][2] = {
     {"'use strong'; ", ";"},
     {"'use strong'; bar ? (", ") : baz;"},
     {"'use strong'; bar ? baz : (", ");"},
@@ skipping 34 matching lines @@
     "(bar, arguments) => {}",
     "(bar, yield) => {}",
     "(bar, interface) => {}",
     "(interface, eval) => {}",
     "(interface, arguments) => {}",
     "(eval, interface) => {}",
     "(arguments, interface) => {}",
     NULL
   };
 
-  static const ParserFlag always_flags[] = { kAllowHarmonyArrowFunctions,
-                                             kAllowStrongMode};
+  static const ParserFlag always_flags[] = {kAllowStrongMode};
   RunParserSyncTest(strong_context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(sloppy_context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ArrowFunctionsYieldParameterNameInGenerator) {
@@ skipping 22 matching lines @@
     "(yield, a) => {}",
     "(yield, ...a) => {}",
     "(a, ...yield) => {}",
     "({yield}) => {}",
     "([yield]) => {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = { kAllowHarmonyDestructuring,
                                              kAllowHarmonyRestParameters,
-                                             kAllowHarmonyArrowFunctions,
                                              kAllowStrongMode};
   RunParserSyncTest(sloppy_function_context_data, arrow_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_function_context_data, arrow_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(generator_context_data, arrow_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
@@ skipping 12 matching lines @@
     "super[27]",
     "new super.x",
     "new super.x()",
     "new super[27]",
     "new super[27]()",
     "z.super",  // Ok, property lookup.
     NULL
   };
 
   static const ParserFlag always_flags[] = {
-    kAllowHarmonyArrowFunctions,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(SuperErrors) {
   const char* context_data[][2] = {
     {"class C { m() { ", "; } }"},
@@ skipping 26 matching lines @@
 TEST(SuperCall) {
   const char* context_data[][2] = {{"", ""},
                                    {NULL, NULL}};
 
   const char* success_data[] = {
     "class C extends B { constructor() { super(); } }",
     "class C extends B { constructor() { () => super(); } }",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonySloppy};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   const char* error_data[] = {
     "class C { constructor() { super(); } }",
     "class C { method() { super(); } }",
     "class C { method() { () => super(); } }",
     "class C { *method() { super(); } }",
     "class C { get x() { super(); } }",
     "class C { set x(_) { super(); } }",
@@ skipping 29 matching lines @@
   };
 
   const char* expression_data[] = {
     "new super.x;",
     "new super.x();",
     "() => new super.x;",
     "() => new super.x();",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonySloppy};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(context_data, expression_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(SuperNewErrors) {
   const char* context_data[][2] = {
     {"class C { method() { ", " } }"},
     {"class C { *method() { ", " } }"},
     {"class C { get x() { ", " } }"},
@@ skipping 12 matching lines @@
   };
 
   const char* statement_data[] = {
     "new super;",
     "new super();",
     "() => new super;",
     "() => new super();",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonySloppy};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(SuperErrorsNonMethods) {
   // super is only allowed in methods, accessors and constructors.
   const char* context_data[][2] = {
     {"", ";"},
     {"k = ", ";"},
@@ skipping 1960 matching lines @@
       "class C { constructor() { this.a = {b: 1}; this.a.b } }",
       "class C { constructor() { this.a = {b: 1}; this.a.b = 0 } }",
       "class C { constructor() { this.a = function(){}; this.a() } }",
       NULL};
 
   const char* success_data[] = {
       "class C { constructor() { this.a = 0; } }",
       "class C { constructor() { label: 0; this.a = 0; this.b = 6; } }",
       NULL};
 
-  static const ParserFlag always_flags[] = {kAllowStrongMode,
-                                            kAllowHarmonyArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowStrongMode};
   RunParserSyncTest(sloppy_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strong_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   RunParserSyncTest(sloppy_context_data, success_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, success_data, kSuccess, NULL, 0,
@@ skipping 32 matching lines @@
       "class C extends Object { constructor() { super().a; } }",
       NULL};
 
   const char* success_data[] = {
       "class C extends Object { constructor() { super(); } }",
       "class C extends Object { constructor() { label: 66; super(); } }",
       "class C extends Object { constructor() { super(3); this.x = 0; } }",
       "class C extends Object { constructor() { 3; super(3); this.x = 0; } }",
       NULL};
 
-  static const ParserFlag always_flags[] = {kAllowStrongMode,
-                                            kAllowHarmonyArrowFunctions};
+  static const ParserFlag always_flags[] = {kAllowStrongMode};
   RunParserSyncTest(sloppy_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strong_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   RunParserSyncTest(sloppy_context_data, success_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, success_data, kSuccess, NULL, 0,
@@ skipping 120 matching lines @@
       "((a, b, undefined) => {return});",
       NULL};
 
   const char* local_strong[] = {
       "(undefined => {'use strong';});",
       "((undefined, b, c) => {'use strong';});",
       "((a, undefined, c) => {'use strong';});",
       "((a, b, undefined) => {'use strong';});",
       NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowStrongMode, kAllowHarmonyArrowFunctions
-  };
+  static const ParserFlag always_flags[] = {kAllowStrongMode};
   RunParserSyncTest(sloppy_context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(strict_context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(strong_context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(sloppy_context_data, local_strong, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
@@ skipping 95 matching lines @@
                                    {NULL, NULL}};
 
   const char* data[] = {
       "(a\n=> a)(1)",
       "(a/*\n*/=> a)(1)",
       "((a)\n=> a)(1)",
       "((a)/*\n*/=> a)(1)",
       "((a, b)\n=> a + b)(1, 2)",
       "((a, b)/*\n*/=> a + b)(1, 2)",
       NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(StrongModeFreeVariablesDeclaredByPreviousScript) {
   i::FLAG_strong_mode = true;
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(v8::Context::New(CcTest::isolate()));
   v8::TryCatch try_catch(CcTest::isolate());
 
@@ skipping 135 matching lines @@
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }
 
 
 TEST(DestructuringPositiveTests) {
   i::FLAG_harmony_destructuring = true;
-  i::FLAG_harmony_arrow_functions = true;
 
   const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                    {"var ", " = {};"},
                                    {"'use strict'; const ", " = {};"},
                                    {"function f(", ") {}"},
                                    {"function f(argument1, ", ") {}"},
                                    {"var f = (", ") => {};"},
                                    {"var f = (argument1,", ") => {};"},
                                    {NULL, NULL}};
 
@@ skipping 30 matching lines @@
     "{var: x = 42}",
     "{[x] : z}",
     "{[1+1] : z}",
     "{[foo()] : z}",
     "{}",
     "[...rest]",
     "[a,b,...rest]",
     "[a,,...rest]",
     NULL};
   // clang-format on
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringNegativeTests) {
   i::FLAG_harmony_destructuring = true;
-  i::FLAG_harmony_arrow_functions = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
 
   {  // All modes.
     const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                      {"var ", " = {};"},
                                      {"'use strict'; const ", " = {};"},
                                      {"function f(", ") {}"},
                                      {"function f(argument1, ", ") {}"},
                                      {"var f = (", ") => {};"},
                                      {"var f = ", " => {};"},
                                      {"var f = (argument1,", ") => {};"},
@@ skipping 146 matching lines @@
     "for (var x = {} in null);",
     NULL};
   // clang-format on
   RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringDuplicateParams) {
   i::FLAG_harmony_destructuring = true;
-  i::FLAG_harmony_arrow_functions = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function outer() { 'use strict';", "}"},
                                    {nullptr, nullptr}};
 
 
   // clang-format off
   const char* error_data[] = {
     "function f(x,x){}",
     "function f(x, {x : x}){}",
     "function f(x, {x}){}",
     "function f({x,x}) {}",
     "function f([x,x]) {}",
     "function f(x, [y,{z:x}]) {}",
     "function f([x,{y:x}]) {}",
     // non-simple parameter list causes duplicates to be errors in sloppy mode.
     "function f(x, x, {a}) {}",
     nullptr};
   // clang-format on
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringDuplicateParamsSloppy) {
   i::FLAG_harmony_destructuring = true;
-  i::FLAG_harmony_arrow_functions = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {
       {"", ""}, {"function outer() {", "}"}, {nullptr, nullptr}};
 
 
   // clang-format off
   const char* error_data[] = {
     // non-simple parameter list causes duplicates to be errors in sloppy mode.
     "function f(x, {x : x}){}",
     "function f(x, {x}){}",
     "function f({x,x}) {}",
     "function f(x, x, {a}) {}",
     nullptr};
   // clang-format on
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringDisallowPatternsInSingleParamArrows) {
   i::FLAG_harmony_destructuring = true;
-  i::FLAG_harmony_arrow_functions = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function outer() { 'use strict';", "}"},
                                    {"", ""},
                                    {"function outer() { ", "}"},
                                    {nullptr, nullptr}};
 
   // clang-format off
   const char* error_data[] = {
     "var f = {x} => {};",
     "var f = {x,y} => {};",
     nullptr};
   // clang-format on
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringDisallowPatternsInRestParams) {
   i::FLAG_harmony_destructuring = true;
-  i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_rest_parameters = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions,
-                                            kAllowHarmonyRestParameters,
+  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters,
                                             kAllowHarmonyDestructuring};
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function outer() { 'use strict';", "}"},
                                    {"", ""},
                                    {"function outer() { ", "}"},
                                    {nullptr, nullptr}};
 
   // clang-format off
   const char* error_data[] = {
     "function(...{}) {}",
@@ skipping 68 matching lines @@
 
     "{x}=(yield)",
     "[x]=(yield)",
 
     "{x}=f(yield)",
     "[x]=f(yield)",
     NULL
   };
 
   // clang-format on
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyDestructuring, kAllowHarmonyDefaultParameters,
-      kAllowHarmonyArrowFunctions, kAllowStrongMode};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring,
+                                            kAllowHarmonyDefaultParameters,
+                                            kAllowStrongMode};
 
   RunParserSyncTest(sloppy_function_context_data, parameter_data, kSuccess,
                     NULL, 0, always_flags, arraysize(always_flags));
   RunParserSyncTest(sloppy_function_context_data, destructuring_assignment_data,
                     kSuccess, NULL, 0, always_flags, arraysize(always_flags));
   RunParserSyncTest(sloppy_arrow_context_data, parameter_data, kSuccess, NULL,
                     0, always_flags, arraysize(always_flags));
   // TODO(wingo): Will change to kSuccess when destructuring assignment lands.
   RunParserSyncTest(sloppy_arrow_context_data, destructuring_assignment_data,
                     kError, NULL, 0, always_flags, arraysize(always_flags));
@@ skipping 94 matching lines @@
     "() => { new.target }",
     "() => new.target",
     "if (1) { new.target }",
     "if (1) {} else { new.target }",
     "while (0) { new.target }",
     "do { new.target } while (0)",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
-    kAllowHarmonyArrowFunctions,
     kAllowHarmonyNewTarget,
     kAllowHarmonySloppy,
   };
   // clang-format on
 
   RunParserSyncTest(good_context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(bad_context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
@@ skipping 145 matching lines @@
       "initializer = true",
       "a, b, c = 1",
       "...args",
       "a, b, ...rest",
       "[a, b, ...rest]",
       "{ bindingPattern = {} }",
       "{ initializedBindingPattern } = { initializedBindingPattern: true }",
       NULL};
 
   static const ParserFlag always_flags[] = {
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDefaultParameters,
-      kAllowHarmonyDestructuring, kAllowHarmonyRestParameters,
-      kAllowHarmonySloppy, kAllowStrongMode
-  };
+      kAllowHarmonyDefaultParameters, kAllowHarmonyDestructuring,
+      kAllowHarmonyRestParameters, kAllowHarmonySloppy, kAllowStrongMode};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(LetSloppyOnly) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"{", "}"},
@@ skipping 12 matching lines @@
     "for (let in {}) {}",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
                                             kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }