Implement handling of arrow functions in the parser

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 265 matching lines @@
 }
 
 
 TEST(StandAlonePreParser) {
   v8::V8::Initialize();
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(GetCurrentStackPosition() -
                                                     128 * 1024);
 
   const char* programs[] = {
-      "{label: 42}",
-      "var x = 42;",
-      "function foo(x, y) { return x + y; }",
-      "%ArgleBargle(glop);",
-      "var x = new new Function('this.x = 42');",
-      NULL
-  };
+      "{label: 42}",                              "var x = 42;",
+      "function foo(x, y) { return x + y; }",     "%ArgleBargle(glop);",
+      "var x = new new Function('this.x = 42');", "var f = (x, y) => x + y;",
+      NULL};
 
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; programs[i]; i++) {
     const char* program = programs[i];
     i::Utf8ToUtf16CharacterStream stream(
         reinterpret_cast<const i::byte*>(program),
         static_cast<unsigned>(strlen(program)));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
     i::PreParser preparser(&scanner, &log, stack_limit);
     preparser.set_allow_lazy(true);
     preparser.set_allow_natives_syntax(true);
+    preparser.set_allow_arrow_functions(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     CHECK(!data.has_error());
   }
 }
 
 
 TEST(StandAlonePreParserNoNatives) {
   v8::V8::Initialize();
@@ skipping 844 matching lines @@
 }
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNativesSyntax,
   kAllowHarmonyScoping,
   kAllowModules,
   kAllowGenerators,
   kAllowForOf,
-  kAllowHarmonyNumericLiterals
+  kAllowHarmonyNumericLiterals,
+  kAllowArrowFunctions
 };
 
 
 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_syntax(flags.Contains(kAllowNativesSyntax));
   parser->set_allow_harmony_scoping(flags.Contains(kAllowHarmonyScoping));
   parser->set_allow_modules(flags.Contains(kAllowModules));
   parser->set_allow_generators(flags.Contains(kAllowGenerators));
   parser->set_allow_for_of(flags.Contains(kAllowForOf));
   parser->set_allow_harmony_numeric_literals(
       flags.Contains(kAllowHarmonyNumericLiterals));
+  parser->set_allow_arrow_functions(flags.Contains(kAllowArrowFunctions));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
   uintptr_t stack_limit = isolate->stack_guard()->real_climit();
@@ skipping 181 matching lines @@
     NULL
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(GetCurrentStackPosition() -
                                                     128 * 1024);
 
-  static const ParserFlag flags1[] = {
-    kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
-    kAllowForOf
-  };
+  static const ParserFlag flags1[] = {kAllowLazy,    kAllowHarmonyScoping,
+                                      kAllowModules, kAllowGenerators,
+                                      kAllowForOf,   kAllowArrowFunctions};
   for (int i = 0; context_data[i][0] != NULL; ++i) {
     for (int j = 0; statement_data[j] != NULL; ++j) {
       for (int k = 0; termination_data[k] != NULL; ++k) {
         int kPrefixLen = i::StrLength(context_data[i][0]);
         int kStatementLen = i::StrLength(statement_data[j]);
         int kTerminationLen = i::StrLength(termination_data[k]);
         int kSuffixLen = i::StrLength(context_data[i][1]);
         int kProgramSize = kPrefixLen + kStatementLen + kTerminationLen
             + kSuffixLen + i::StrLength("label: for (;;) {  }");
 
@@ skipping 54 matching lines @@
                        const ParserFlag* always_true_flags = NULL,
                        int always_true_flags_len = 0) {
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(GetCurrentStackPosition() -
                                                     128 * 1024);
 
   static const ParserFlag default_flags[] = {
-    kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
-    kAllowForOf, kAllowNativesSyntax
-  };
+      kAllowLazy,  kAllowHarmonyScoping, kAllowModules,       kAllowGenerators,
+      kAllowForOf, kAllowNativesSyntax,  kAllowArrowFunctions};
   ParserFlag* generated_flags = NULL;
   if (flags == NULL) {
     flags = default_flags;
     flags_len = ARRAY_SIZE(default_flags);
     if (always_true_flags != NULL) {
       // Remove always_true_flags from default_flags.
       CHECK(always_true_flags_len < flags_len);
       generated_flags = new ParserFlag[flags_len - always_true_flags_len];
       int flag_index = 0;
       for (int i = 0; i < flags_len; ++i) {
@@ skipping 43 matching lines @@
   // using "eval" and "arguments" as identifiers. Without the strict mode, it's
   // ok to use "eval" or "arguments" as identifiers. With the strict mode, it
   // isn't.
   const char* context_data[][2] = {
     { "\"use strict\";", "" },
     { "var eval; function test_func() {\"use strict\"; ", "}"},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
-    "var eval;",
-    "var arguments",
-    "var foo, eval;",
-    "var foo, arguments;",
-    "try { } catch (eval) { }",
-    "try { } catch (arguments) { }",
-    "function eval() { }",
-    "function arguments() { }",
-    "function foo(eval) { }",
-    "function foo(arguments) { }",
-    "function foo(bar, eval) { }",
-    "function foo(bar, arguments) { }",
-    "eval = 1;",
-    "arguments = 1;",
-    "var foo = eval = 1;",
-    "var foo = arguments = 1;",
-    "++eval;",
-    "++arguments;",
-    "eval++;",
-    "arguments++;",
-    NULL
-  };
+      "var eval;",                   "var arguments",
+      "var foo, eval;",              "var foo, arguments;",
+      "try { } catch (eval) { }",    "try { } catch (arguments) { }",
+      "function eval() { }",         "function arguments() { }",
+      "function foo(eval) { }",      "function foo(arguments) { }",
+      "function foo(bar, eval) { }", "function foo(bar, arguments) { }",
+      "(eval) => { }",               "(arguments) => { }",
+      "(foo, eval) => { }",          "(foo, arguments) => { }",
+      "eval = 1;",                   "arguments = 1;",
+      "var foo = eval = 1;",         "var foo = arguments = 1;",
+      "++eval;",                     "++arguments;",
+      "eval++;",                     "arguments++;",
+      NULL};
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsEvalAndArgumentsSloppy) {
   // Tests that both preparsing and parsing accept "eval" and "arguments" as
   // identifiers when needed.
   const char* context_data[][2] = {
     { "", "" },
@@ skipping 24 matching lines @@
     "arguments++;",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(NoErrorsEvalAndArgumentsStrict) {
   const char* context_data[][2] = {
-    { "\"use strict\";", "" },
-    { "function test_func() { \"use strict\";", "}" },
-    { NULL, NULL }
-  };
+      {"\"use strict\";", ""},
+      {"function test_func() { \"use strict\";", "}"},
+      {"() => { \"use strict\"; ", "}"},
+      {NULL, NULL}};
 
   const char* statement_data[] = {
     "eval;",
     "arguments;",
     "var foo = eval;",
     "var foo = arguments;",
     "var foo = { eval: 1 };",
     "var foo = { arguments: 1 };",
     "var foo = { }; foo.eval = {};",
     "var foo = { }; foo.arguments = {};",
     NULL
   };
 
-  RunParserSyncTest(context_data, statement_data, kSuccess);
+  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+                    always_flags, ARRAY_SIZE(always_flags));
 }
 
 
 TEST(ErrorsFutureStrictReservedWords) {
   // Tests that both preparsing and parsing produce the right kind of errors for
   // using future strict reserved words as identifiers. Without the strict mode,
   // it's ok to use future strict reserved words as identifiers. With the strict
   // mode, it isn't.
   const char* context_data[][2] = {
-    { "\"use strict\";", "" },
-    { "function test_func() {\"use strict\"; ", "}"},
-    { NULL, NULL }
-  };
+      {"\"use strict\";", ""},
+      {"function test_func() {\"use strict\"; ", "}"},
+      {"() => { \"use strict\"; ", "}"},
+      {NULL, NULL}};
 
   const char* statement_data[] = {
     "var interface;",
     "var foo, interface;",
     "try { } catch (interface) { }",
     "function interface() { }",
     "function foo(interface) { }",
     "function foo(bar, interface) { }",
     "interface = 1;",
     "var foo = interface = 1;",
     "++interface;",
     "interface++;",
     "var yield = 13;",
     NULL
   };
 
-  RunParserSyncTest(context_data, statement_data, kError);
+  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  RunParserSyncTest(context_data, statement_data, kError, NULL, 0, always_flags,
+                    ARRAY_SIZE(always_flags));
 }
 
 
 TEST(NoErrorsFutureStrictReservedWords) {
-  const char* context_data[][2] = {
-    { "", "" },
-    { "function test_func() {", "}"},
-    { NULL, NULL }
-  };
+  const char* context_data[][2] = {{"", ""},
+                                   {"function test_func() {", "}"},
+                                   {"() => {", "}"},
+                                   {NULL, NULL}};
 
   const char* statement_data[] = {
     "var interface;",
     "var foo, interface;",
     "try { } catch (interface) { }",
     "function interface() { }",
     "function foo(interface) { }",
     "function foo(bar, interface) { }",
     "interface = 1;",
     "var foo = interface = 1;",
     "++interface;",
     "interface++;",
     "var yield = 13;",
     NULL
   };
 
-  RunParserSyncTest(context_data, statement_data, kSuccess);
+  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+                    always_flags, ARRAY_SIZE(always_flags));
 }
 
 
 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\";", "" },
-    { "var eval; function test_func() {", "}"},
-    { "var eval; function test_func() {\"use strict\"; ", "}"},
-    { NULL, NULL }
-  };
+      {"", ""},
+      {"\"use strict\";", ""},
+      {"var eval; function test_func() {", "}"},
+      {"var eval; function test_func() {\"use strict\"; ", "}"},
+      {"var eval; () => {", "}"},
+      {"var eval; () => {\"use strict\"; ", "}"},
+      {NULL, NULL}};
 
   const char* statement_data[] = {
-    "var super;",
-    "var foo, super;",
-    "try { } catch (super) { }",
-    "function super() { }",
-    "function foo(super) { }",
-    "function foo(bar, super) { }",
-    "super = 1;",
-    "var foo = super = 1;",
-    "++super;",
-    "super++;",
-    "function foo super",
-    NULL
-  };
+      "var super;",                "var foo, super;",
+      "try { } catch (super) { }", "function super() { }",
+      "function foo(super) { }",   "function foo(bar, super) { }",
+      "(super) => { }",            "(bar, super) => { }",
+      "super = 1;",                "var foo = super = 1;",
+      "++super;",                  "super++;",
+      "function foo super",        NULL};
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsYieldSloppyAllModes) {
   // In sloppy mode, it's okay to use "yield" as identifier, *except* inside a
   // generator (see next test).
   const char* context_data[][2] = {
     { "", "" },
@@ skipping 15 matching lines @@
     "++yield;",
     "yield++;",
     "yield: 34",
     "function yield(yield) { yield: yield (yield + yield (0)); }",
     "({ yield: 1 })",
     "({ get yield() { 1 } })",
     "yield (100)",
     NULL
   };
 
-  RunParserSyncTest(context_data, statement_data, kSuccess);
+  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+                    always_flags, ARRAY_SIZE(always_flags));
 }
 
 
 TEST(NoErrorsYieldSloppyGeneratorsEnabled) {
   // In sloppy mode, it's okay to use "yield" as identifier, *except* inside a
   // generator (see next test).
   const char* context_data[][2] = {
     { "", "" },
     { "function not_gen() {", "}" },
     { "function * gen() { function not_gen() {", "} }" },
@@ skipping 28 matching lines @@
   static const ParserFlag always_true_flags[] = {
     kAllowGenerators
   };
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_true_flags, 1);
 }
 
 
 TEST(ErrorsYieldStrict) {
   const char* context_data[][2] = {
-    { "\"use strict\";", "" },
-    { "\"use strict\"; function not_gen() {", "}" },
-    { "function test_func() {\"use strict\"; ", "}"},
-    { "\"use strict\"; function * gen() { function not_gen() {", "} }" },
-    { "\"use strict\"; (function not_gen() {", "})" },
-    { "\"use strict\"; (function * gen() { (function not_gen() {", "}) })" },
-    { NULL, NULL }
-  };
+      {"\"use strict\";", ""},
+      {"\"use strict\"; function not_gen() {", "}"},
+      {"function test_func() {\"use strict\"; ", "}"},
+      {"\"use strict\"; function * gen() { function not_gen() {", "} }"},
+      {"\"use strict\"; (function not_gen() {", "})"},
+      {"\"use strict\"; (function * gen() { (function not_gen() {", "}) })"},
+      {"() => {\"use strict\"; ", "}"},
+      {NULL, NULL}};
 
   const char* statement_data[] = {
     "var yield;",
     "var foo, yield;",
     "try { } catch (yield) { }",
     "function yield() { }",
     "(function yield() { })",
     "function foo(yield) { }",
     "function foo(bar, yield) { }",
     "function * yield() { }",
@@ skipping 185 matching lines @@
   static const ParserFlag always_true_flags[] = {
     kAllowGenerators
   };
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_true_flags, 1);
 }
 
 
 TEST(ErrorsIllegalWordsAsLabelsSloppy) {
   // Using future reserved words as labels is always an error.
-  const char* context_data[][2] = {
-    { "", ""},
-    { "function test_func() {", "}" },
-    { NULL, NULL }
-  };
+  const char* context_data[][2] = {{"", ""},
+                                   {"function test_func() {", "}"},
+                                   {"() => {", "}"},
+                                   {NULL, NULL}};
 
   const char* statement_data[] = {
     "super: while(true) { break super; }",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsIllegalWordsAsLabelsStrict) {
   // Tests that illegal tokens as labels produce the correct errors.
   const char* context_data[][2] = {
-    { "\"use strict\";", "" },
-    { "function test_func() {\"use strict\"; ", "}"},
-    { NULL, NULL }
-  };
+      {"\"use strict\";", ""},
+      {"function test_func() {\"use strict\"; ", "}"},
+      {"() => {\"use strict\"; ", "}"},
+      {NULL, NULL}};
 
   const char* statement_data[] = {
     "super: while(true) { break super; }",
     "interface: while(true) { break interface; }",
     "yield: while(true) { break yield; }",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsIllegalWordsAsLabels) {
   // Using eval and arguments as labels is legal even in strict mode.
   const char* context_data[][2] = {
-    { "", ""},
-    { "function test_func() {", "}" },
-    { "\"use strict\";", "" },
-    { "\"use strict\"; function test_func() {", "}" },
-    { NULL, NULL }
-  };
+      {"", ""},
+      {"function test_func() {", "}"},
+      {"() => {", "}"},
+      {"\"use strict\";", ""},
+      {"\"use strict\"; function test_func() {", "}"},
+      {"\"use strict\"; () => {", "}"},
+      {NULL, NULL}};
 
   const char* statement_data[] = {
     "mylabel: while(true) { break mylabel; }",
     "eval: while(true) { break eval; }",
     "arguments: while(true) { break arguments; }",
     NULL
   };
 
-  RunParserSyncTest(context_data, statement_data, kSuccess);
+  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+                    always_flags, ARRAY_SIZE(always_flags));
 }
 
 
 TEST(ErrorsParenthesizedLabels) {
   // Parenthesized identifiers shouldn't be recognized as labels.
-  const char* context_data[][2] = {
-    { "", ""},
-    { "function test_func() {", "}" },
-    { NULL, NULL }
-  };
+  const char* context_data[][2] = {{"", ""},
+                                   {"function test_func() {", "}"},
+                                   {"() => {", "}"},
+                                   {NULL, NULL}};
 
   const char* statement_data[] = {
     "(mylabel): while(true) { break mylabel; }",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
@@ skipping 820 matching lines @@
   LocalContext env;
   int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
   global_use_counts = use_counts;
   CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
   CompileRun("\"use asm\";\n"
              "var foo = 1;\n"
              "\"use asm\";\n"  // Only the first one counts.
              "function bar() { \"use asm\"; var baz = 1; }");
   CHECK_EQ(2, use_counts[v8::Isolate::kUseAsm]);
 }
+
+
+TEST(ErrorsArrowFunctions) {
+  // Tests that parser and preparser generate the same kind of errors
+  // on invalid arrow function syntax.
+  const char* context_data[][2] = {{"", ";"},
+                                   {"v = ", ";"},
+                                   {"bar ? (", ") : baz;"},
+                                   {"bar ? baz : (", ");"},
+                                   {"bar[", "];"},
+                                   {"bar, ", ";"},
+                                   {"", ", bar;"},
+                                   {NULL, NULL}};
+
+  const char* statement_data[] = {
+      "=> 0",                       "=>",
+      "() =>",                      "=> {}",
+      ") => {}",                    ", => {}",
+      "(,) => {}",                  "return => {}",
+      "() => {'value': 42}",
+
+      // Check that the early return introduced in ParsePrimaryExpression
+      // does not accept stray closing parentheses.
+      ")",                          ") => 0",
+      "foo[()]",                    "()",
+
+      // Parameter lists with extra parens should be recognized as errors.
+      "(()) => 0",                  "((x)) => 0",
+      "((x, y)) => 0",              "(x, (y)) => 0",
+      "((x, y, z)) => 0",           "(x, (y, z)) => 0",
+      "((x, y), z) => 0",
+
+      // Parameter lists are always validated as strict, so those are errors.
+      "eval => {}",                 "arguments => {}",
+      "yield => {}",                "interface => {}",
+      "(eval) => {}",               "(arguments) => {}",
+      "(yield) => {}",              "(interface) => {}",
+      "(eval, bar) => {}",          "(bar, eval) => {}",
+      "(bar, arguments) => {}",     "(bar, yield) => {}",
+      "(bar, interface) => {}",
+      // TODO(aperez): Detecting duplicates does not work in PreParser.
+      // "(bar, bar) => {}",
+
+      // The parameter list is parsed as an expression, but only
+      // a comma-separated list of identifier is valid.
+      "32 => {}",                   "(32) => {}",
+      "(a, 32) => {}",              "if => {}",
+      "(if) => {}",                 "(a, if) => {}",
+      "a + b => {}",                "(a + b) => {}",
+      "(a + b, c) => {}",           "(a, b - c) => {}",
+      "\"a\" => {}",                "(\"a\") => {}",
+      "(\"a\", b) => {}",           "(a, \"b\") => {}",
+      "-a => {}",                   "(-a) => {}",
+      "(-a, b) => {}",              "(a, -b) => {}",
+      "{} => {}",                   "({}) => {}",
+      "(a, {}) => {}",              "({}, a) => {}",
+      "a++ => {}",                  "(a++) => {}",
+      "(a++, b) => {}",             "(a, b++) => {}",
+      "[] => {}",                   "([]) => {}",
+      "(a, []) => {}",              "([], a) => {}",
+      "(a = b) => {}",              "(a = b, c) => {}",
+      "(a, b = c) => {}",           "(foo ? bar : baz) => {}",
+      "(a, foo ? bar : baz) => {}", "(foo ? bar : baz, a) => {}",
+      NULL};
+
+  RunParserSyncTest(context_data, statement_data, kError);
+}
+
+
+TEST(NoErrorsArrowFunctions) {
+  // Tests that parser and preparser accept valid arrow functions syntax.
+  const char* context_data[][2] = {{"", ";"},
+                                   {"bar ? (", ") : baz;"},
+                                   {"bar ? baz : (", ");"},
+                                   {"bar, ", ";"},
+                                   {"", ", bar;"},
+                                   {NULL, NULL}};
+
+  const char* statement_data[] = {
+      "() => {}",                    "() => { return 42 }",
+      "x => { return x; }",          "(x) => { return x; }",
+      "(x, y) => { return x + y; }", "(x, y, z) => { return x + y + z; }",
+      "(x, y) => { x.a = y; }",      "() => 42",
+      "x => x",                      "x => x * x",
+      "(x) => x",                    "(x) => x * x",
+      "(x, y) => x + y",             "(x, y, z) => x, y, z",
+      "(x, y) => x.a = y",           "() => ({'value': 42})",
+      "x => y => x + y",             "(x, y) => (u, v) => x*u + y*v",
+      "(x, y) => z => z * (x + y)",  "x => (y, z) => z * (x + y)",
+
+      // Those are comma-separated expressions, with arrow functions as items.
+      // They stress the code for validating arrow function parameter lists.
+      "a, b => 0",                   "a, b, (c, d) => 0",
+      "(a, b, (c, d) => 0)",         "(a, b) => 0, (c, d) => 1",
+      "(a, b => {}, a => a + 1)",    "((a, b) => {}, (a => a + 1))",
+      "(a, (a, (b, c) => 0))",
+
+      // Arrow has more precedence, this is the same as: foo ? bar : (baz = {})
+      "foo ? bar : baz => {}",       NULL};
+
+  static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+                    always_flags, ARRAY_SIZE(always_flags));
+}