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 137 matching lines @@
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; tests[i]; i++) {
     const i::byte* source =
         reinterpret_cast<const i::byte*>(tests[i]);
     i::Utf8ToUtf16CharacterStream stream(source, i::StrLength(tests[i]));
     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_arrow_functions(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     CHECK(!data.has_error());
   }
 
   for (int i = 0; fail_tests[i]; i++) {
     const i::byte* source =
         reinterpret_cast<const i::byte*>(fail_tests[i]);
     i::Utf8ToUtf16CharacterStream stream(source, i::StrLength(fail_tests[i]));
     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_arrow_functions(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     // Even in the case of a syntax error, kPreParseSuccess is returned.
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     CHECK(data.has_error());
   }
 }
 
 
 class ScriptResource : public v8::String::ExternalAsciiStringResource {
  public:
   ScriptResource(const char* data, size_t length)
       : data_(data), length_(length) { }
 
   const char* data() const { return data_; }
   size_t length() const { return length_; }
 
  private:
   const char* data_;
   size_t length_;
 };
 
 
 TEST(UsingCachedData) {
+  i::FLAG_harmony_arrow_functions = true;

[marja, 2014/06/26 14:38:14]

I don't think you need to add this to existing tests.

When I said that you should make sure that existing tests run with arrow
functions enabled, I meant the RunParserSync tests.

For them, it should be enough to add this flag to the ParserFlagEnum and
default_flags (like you did).

   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handles(isolate);
   v8::Local<v8::Context> context = v8::Context::New(isolate);
   v8::Context::Scope context_scope(context);
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
 
   // Source containing functions that might be lazily compiled  and all types
   // of symbols (string, propertyName, regexp).
@@ skipping 27 matching lines @@
   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);
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
 
-  const char* good_code =
-      "function this_is_lazy() { var a; } function foo() { return 25; } foo();";
+  const char* good_code[] = {

[marja, 2014/06/26 14:38:14]

I whined about this change before, I'm still whining about it :)

+    "function this_is_lazy() { var a; } function foo() { return 25; } foo();",
+    NULL
+  };
 
   // Insert a syntax error inside the lazy function.
-  const char* bad_code =
-      "function this_is_lazy() { if (   } function foo() { return 25; } foo();";
+  const char* bad_code[] = {
+    "function this_is_lazy() { if (   } function foo() { return 25; } foo();",
+    NULL
+  };
 
-  v8::ScriptCompiler::Source good_source(v8_str(good_code));
-  v8::ScriptCompiler::Compile(isolate, &good_source,
-                              v8::ScriptCompiler::kProduceDataToCache);
+  for (int i = 0; good_code[i]; i++) {
+    v8::ScriptCompiler::Source good_source(v8_str(good_code[i]));
+    v8::ScriptCompiler::Compile(isolate, &good_source,
+                                v8::ScriptCompiler::kProduceDataToCache);
 
-  const v8::ScriptCompiler::CachedData* cached_data =
-      good_source.GetCachedData();
-  CHECK(cached_data->data != NULL);
-  CHECK_GT(cached_data->length, 0);
+    const v8::ScriptCompiler::CachedData* cached_data =
+        good_source.GetCachedData();
+    CHECK(cached_data->data != NULL);
+    CHECK_GT(cached_data->length, 0);
 
-  // Now compile the erroneous code with the good preparse data. If the preparse
-  // data is used, the lazy function is skipped and it should compile fine.
-  v8::ScriptCompiler::Source bad_source(
-      v8_str(bad_code), new v8::ScriptCompiler::CachedData(
-                            cached_data->data, cached_data->length));
-  v8::Local<v8::Value> result =
-      v8::ScriptCompiler::Compile(isolate, &bad_source)->Run();
-  CHECK(result->IsInt32());
-  CHECK_EQ(25, result->Int32Value());
+    // Now compile the erroneous code with the good preparse data. If the
+    // preparse data is used, the lazy function is skipped and it should
+    // compile fine.
+    v8::ScriptCompiler::Source bad_source(
+        v8_str(bad_code[i]), new v8::ScriptCompiler::CachedData(
+                              cached_data->data, cached_data->length));
+    v8::Local<v8::Value> result =
+        v8::ScriptCompiler::Compile(isolate, &bad_source)->Run();
+    CHECK(result->IsInt32());
+    CHECK_EQ(25, result->Int32Value());
+  }
 }
 
 
 TEST(StandAlonePreParser) {
   v8::V8::Initialize();
 
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 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');",
+      "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 14 matching lines @@
     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);
 
     // Preparser defaults to disallowing natives syntax.
     i::PreParser preparser(&scanner, &log, stack_limit);
     preparser.set_allow_lazy(true);
+    preparser.set_allow_arrow_functions(true);

[marja, 2014/06/26 14:38:14]

And these shouldn't be needed either. For these tests, we don't run them with
all experimental features anyway, so no need to make an exception for arrow
functions.

     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     // Data contains syntax error.
     CHECK(data.has_error());
   }
 }
 
 
 TEST(PreparsingObjectLiterals) {
   // Regression test for a bug where the symbol stream produced by PreParser
   // didn't match what Parser wanted to consume.
+  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);
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
 
   {
     const char* source = "var myo = {if: \"foo\"}; myo.if;";
@@ skipping 38 matching lines @@
 
   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,
                          CcTest::i_isolate()->stack_guard()->real_climit());
   preparser.set_allow_lazy(true);
+  preparser.set_allow_arrow_functions(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   // Even in the case of a syntax error, kPreParseSuccess is returned.
   CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   i::ScriptData data(log.ExtractData());
   CHECK(data.has_error());
 }
 
 
 TEST(Regress928) {
   v8::V8::Initialize();
@@ skipping 14 matching lines @@
 
   v8::HandleScope handles(CcTest::isolate());
   i::Handle<i::String> source = factory->NewStringFromAsciiChecked(program);
   i::GenericStringUtf16CharacterStream stream(source, 0, source->length());
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
   i::PreParser preparser(&scanner, &log,
                          CcTest::i_isolate()->stack_guard()->real_climit());
   preparser.set_allow_lazy(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());
   data.Initialize();
 
   int first_function =
       static_cast<int>(strstr(program, "function") - program);
   int first_lbrace = first_function + i::StrLength("function () ");
   CHECK_EQ('{', program[first_lbrace]);
@@ skipping 27 matching lines @@
 
   i::Utf8ToUtf16CharacterStream stream(
       reinterpret_cast<const i::byte*>(program.get()),
       static_cast<unsigned>(kProgramSize));
   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_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 401 matching lines @@
         i += input_offset;
         character_length -= output_adjust;
       }
     }
   }
   return character_length;
 }
 
 
 TEST(ScopePositions) {
-  v8::internal::FLAG_harmony_scoping = true;

[marja, 2014/06/26 14:38:14]

Why this change?

-
   // Test the parser for correctly setting the start and end positions
   // of a scope. We check the scope positions of exactly one scope
   // nested in the global scope of a program. 'inner source' is the
   // source code that determines the part of the source belonging
   // to the nested scope. 'outer_prefix' and 'outer_suffix' are
   // parts of the source that belong to the global scope.
   struct SourceData {
     const char* outer_prefix;
     const char* inner_source;
     const char* outer_suffix;
@@ skipping 34 matching lines @@
       "  }", "\n"
       "  more;", i::BLOCK_SCOPE, i::STRICT },
     { "  start;\n"
       "  function fun", "(a,b) { infunction; }", " more;",
       i::FUNCTION_SCOPE, i::SLOPPY },
     { "  start;\n"
       "  function fun", "(a,b) {\n"
       "    infunction;\n"
       "  }", "\n"
       "  more;", i::FUNCTION_SCOPE, i::SLOPPY },
-    { "  (function fun", "(a,b) { infunction; }", ")();",
+    { "  start;\n"
+      "  (function fun", "(a,b) { infunction; }", ")();",
       i::FUNCTION_SCOPE, i::SLOPPY },
     { "  for ", "(let x = 1 ; x < 10; ++ x) { block; }", " more;",
       i::BLOCK_SCOPE, i::STRICT },
     { "  for ", "(let x = 1 ; x < 10; ++ x) { block; }", "; more;",
       i::BLOCK_SCOPE, i::STRICT },
     { "  for ", "(let x = 1 ; x < 10; ++ x) {\n"
       "    block;\n"
       "  }", "\n"
       "  more;", i::BLOCK_SCOPE, i::STRICT },
     { "  for ", "(let x = 1 ; x < 10; ++ x) statement;", " more;",
@@ skipping 134 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::CompilationInfoWithZone info(script);
     i::Parser parser(&info);
     parser.set_allow_lazy(true);
     parser.set_allow_harmony_scoping(true);
+    parser.set_allow_arrow_functions(true);
     info.MarkAsGlobal();
     info.SetStrictMode(source_data[i].strict_mode);
     parser.Parse();
     CHECK(info.function() != NULL);
 
     // Check scope types and positions.
     i::Scope* scope = info.function()->scope();
     CHECK(scope->is_global_scope());
     CHECK_EQ(scope->start_position(), 0);
     CHECK_EQ(scope->end_position(), kProgramSize);
@@ skipping 36 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 182 matching lines @@
   };
 
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
 
+  static const ParserFlag always_flags[] = { kAllowArrowFunctions };

[marja, 2014/06/26 14:38:14]

Instead of this, you should add the flag to flags1 below, so the test gets run
with and without it.

   static const ParserFlag flags1[] = {
     kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
     kAllowForOf
   };
   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 (;;) {  }");
 
         // Plug the source code pieces together.
         i::ScopedVector<char> program(kProgramSize + 1);
         int length = i::SNPrintF(program,
             "label: for (;;) { %s%s%s%s }",
             context_data[i][0],
             statement_data[j],
             termination_data[k],
             context_data[i][1]);
         CHECK(length == kProgramSize);
-        TestParserSync(program.start(), flags1, ARRAY_SIZE(flags1));
+        TestParserSync(program.start(), flags1, ARRAY_SIZE(flags1),
+            kSuccessOrError, always_flags, ARRAY_SIZE(always_flags));
       }
     }
   }
 
   // Neither Harmony numeric literals nor our natives syntax have any
   // interaction with the flags above, so test these separately to reduce
   // the combinatorial explosion.
   static const ParserFlag flags2[] = { kAllowHarmonyNumericLiterals };
-  TestParserSync("0o1234", flags2, ARRAY_SIZE(flags2));
-  TestParserSync("0b1011", flags2, ARRAY_SIZE(flags2));
+  TestParserSync("0o1234", flags2, ARRAY_SIZE(flags2),
+      kSuccessOrError, always_flags, ARRAY_SIZE(always_flags));
+  TestParserSync("0b1011", flags2, ARRAY_SIZE(flags2),
+      kSuccessOrError, always_flags, ARRAY_SIZE(always_flags));
 
   static const ParserFlag flags3[] = { kAllowNativesSyntax };
-  TestParserSync("%DebugPrint(123)", flags3, ARRAY_SIZE(flags3));
+  TestParserSync("%DebugPrint(123)", flags3, ARRAY_SIZE(flags3),
+      kSuccessOrError, always_flags, ARRAY_SIZE(always_flags));
 }
 
 
 TEST(StrictOctal) {
   // Test that syntax error caused by octal literal is reported correctly as
   // such (issue 2220).
   v8::V8::Initialize();
+  i::FLAG_harmony_arrow_functions = true;
+
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(
       v8::Context::New(CcTest::isolate()));
   v8::TryCatch try_catch;
   const char* script =
       "\"use strict\";       \n"
       "a = function() {      \n"
       "  b = function() {    \n"
       "    01;               \n"
       "  };                  \n"
@@ skipping 16 matching lines @@
   v8::HandleScope handles(CcTest::isolate());
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
 
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
 
   static const ParserFlag default_flags[] = {
     kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
-    kAllowForOf, kAllowNativesSyntax
+    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;
@@ skipping 56 matching lines @@
     "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
   };
@@ skipping 36 matching lines @@
   };
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(NoErrorsEvalAndArgumentsStrict) {
   const char* context_data[][2] = {
     { "\"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\"; ", "}"},
+    { "() => { \"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) => { }",
+    "(bar, interface) => { }",
     "interface = 1;",
     "var foo = interface = 1;",
     "++interface;",
     "interface++;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;

[marja, 2014/06/26 14:38:13]

Instead of this, you should use always_true_flags...

Otherwise this test takes longer than needed, because it's run with both the
flag and without the flag (via the default_flags permutation thingy) and then
this FLAG just overrides them.

   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsFutureStrictReservedWords) {
   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++;",
     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\"; ", "}"},
+    { "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) => { }",
+    "(bar, super) => { }",
     "super = 1;",
     "var foo = super = 1;",
     "++super;",
     "super++;",
     "function foo super",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;

[marja, 2014/06/26 14:38:14]

Here too... in all places, where you need the flag, you should use
always_true_flags.

   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsYieldSloppy) {
   // In sloppy mode, it's okay to use "yield" as identifier, *except* inside a
   // generator (see next test).
   const char* context_data[][2] = {
     { "", "" },
     { "function is_not_gen() {", "}" },
+    { "() => {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var yield;",
     "var foo, yield;",
     "try { } catch (yield) { }",
     "function yield() { }",
     "function foo(yield) { }",
     "function foo(bar, yield) { }",
     "yield = 1;",
     "var foo = yield = 1;",
     "++yield;",
     "yield++;",
     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(ErrorsYieldSloppyGenerator) {
   const char* context_data[][2] = {
     { "function * is_gen() {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var yield;",
     "var foo, yield;",
     "try { } catch (yield) { }",
     "function yield() { }",
     // BUG: These should not be allowed, but they are (if kAllowGenerators is
     // set)
     // "function foo(yield) { }",
     // "function foo(bar, yield) { }",
     "yield = 1;",
     "var foo = yield = 1;",
     "++yield;",
     "yield++;",
     NULL
   };
 
   // If generators are not allowed, the error will be produced at the '*' token,
   // so this test works both with and without the kAllowGenerators flag.
+  i::FLAG_harmony_arrow_functions = true;

[marja, 2014/06/26 14:38:14]

And this is completely unnecessary; the test should be ran both with and without
arrow functions (and the default_flags permutation takes care of it if you
remove this line).


(And this goes on throughout this file; pls see all occurrences of
i::FLAG_harmony_arrow_functions.)

   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsYieldStrict) {
   const char* context_data[][2] = {
     { "\"use strict\";", "" },
     { "\"use strict\"; function is_not_gen() {", "}" },
     { "function test_func() {\"use strict\"; ", "}"},
+    { "() => {\"use strict\"; ", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var yield;",
     "var foo, yield;",
     "try { } catch (yield) { }",
     "function yield() { }",
     "function foo(yield) { }",
     "function foo(bar, yield) { }",
+    "(yield) => { }",
+    "(bar, yield) => { }",
     "yield = 1;",
     "var foo = yield = 1;",
     "++yield;",
     "yield++;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsYield) {
   const char* context_data[][2] = {
     { "function * is_gen() {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "yield 2;",  // this is legal inside generator
     "yield * 2;",  // this is legal inside generator
     NULL
   };
 
   // This test requires kAllowGenerators to succeed.
   static const ParserFlag always_true_flags[] = {
     kAllowGenerators
   };
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_true_flags, 1);
 }
 
 
 TEST(ErrorsNameOfStrictFunction) {
   // Tests that illegal tokens as names of a strict function produce the correct
   // errors.
   const char* context_data[][2] = {
     { "", ""},
     { "\"use strict\";", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "function eval() {\"use strict\";}",
     "function arguments() {\"use strict\";}",
     "function interface() {\"use strict\";}",
     "function yield() {\"use strict\";}",
     // Future reserved words are always illegal
     "function super() { }",
     "function super() {\"use strict\";}",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsNameOfStrictFunction) {
   const char* context_data[][2] = {
     { "", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "function eval() { }",
     "function arguments() { }",
     "function interface() { }",
     "function yield() { }",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 
 TEST(ErrorsIllegalWordsAsLabelsSloppy) {
   // Using future reserved words as labels is always an error.
   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\"; ", "}"},
+    { "() => {\"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() {", "}" },
+    { "\"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* statement_data[] = {
     "(mylabel): while(true) { break mylabel; }",
     NULL
   };
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsParenthesizedDirectivePrologue) {
   // Parenthesized directive prologue shouldn't be recognized.
   const char* context_data[][2] = {
     { "", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "(\"use strict\"); var eval;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsNotAnIdentifierName) {
   const char* context_data[][2] = {
     { "", ""},
     { "\"use strict\";", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var foo = {}; foo.{;",
     "var foo = {}; foo.};",
     "var foo = {}; foo.=;",
     "var foo = {}; foo.888;",
     "var foo = {}; foo.-;",
     "var foo = {}; foo.--;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsIdentifierNames) {
   // Keywords etc. are valid as property names.
   const char* context_data[][2] = {
     { "", ""},
     { "\"use strict\";", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "var foo = {}; foo.if;",
     "var foo = {}; foo.yield;",
     "var foo = {}; foo.super;",
     "var foo = {}; foo.interface;",
     "var foo = {}; foo.eval;",
     "var foo = {}; foo.arguments;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(DontRegressPreParserDataSizes) {
   // These tests make sure that Parser doesn't start producing less "preparse
   // data" (data which the embedder can cache).
   v8::V8::Initialize();
+  i::FLAG_harmony_arrow_functions = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handles(isolate);
 
   int marker;
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
 
   struct TestCase {
     const char* program;
     int functions;
@@ skipping 63 matching lines @@
   const char* strict_statement_data[] = {
     "\"use strict\";",
     NULL
   };
 
   const char* non_strict_statement_data[] = {
     ";",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, strict_statement_data, kError);
   RunParserSyncTest(context_data, non_strict_statement_data, kSuccess);
 }
 
 
 TEST(ErrorsTryWithoutCatchOrFinally) {
   const char* context_data[][2] = {
     {"", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "try { }",
     "try { } foo();",
     "try { } catch (e) foo();",
     "try { } catch { }",
     "try { } finally foo();",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsTryCatchFinally) {
   const char* context_data[][2] = {
     {"", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "try { } catch (e) { }",
     "try { } catch (e) { } finally { }",
     "try { } finally { }",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsRegexpLiteral) {
   const char* context_data[][2] = {
     {"var r = ", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "/unterminated",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsRegexpLiteral) {
   const char* context_data[][2] = {
     {"var r = ", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "/foo/",
     "/foo/g",
     "/foo/whatever",  // This is an error but not detected by the parser.
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(Intrinsics) {
   const char* context_data[][2] = {
     {"", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "%someintrinsic(arg)",
     NULL
   };
 
   // This test requires kAllowNativesSyntax to succeed.
   static const ParserFlag always_true_flags[] = {
     kAllowNativesSyntax
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_true_flags, 1);
+  RunParserSyncTest(context_data, statement_data, kSuccessOrError);
 }
 
 
 TEST(NoErrorsNewExpression) {
   const char* context_data[][2] = {
     {"", ""},
     {"var f =", ""},
     { NULL, NULL }
   };
 
@@ skipping 18 matching lines @@
     "new foo[bar]()[baz];",
     "new foo[bar].baz(baz)()[bar].baz;",
     "new \"foo\"",  // Runtime error
     "new 1",  // Runtime error
     // This even runs:
     "(new new Function(\"this.x = 1\")).x;",
     "new new Test_Two(String, 2).v(0123).length;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsNewExpression) {
   const char* context_data[][2] = {
     {"", ""},
     {"var f =", ""},
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
     "new foo bar",
     "new ) foo",
     "new ++foo",
     "new foo ++",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(StrictObjectLiteralChecking) {
   const char* strict_context_data[][2] = {
     {"\"use strict\"; var myobject = {", "};"},
     {"\"use strict\"; var myobject = {", ",};"},
     { NULL, NULL }
   };
   const char* non_strict_context_data[][2] = {
     {"var myobject = {", "};"},
     {"var myobject = {", ",};"},
     { NULL, NULL }
   };
 
   // These are only errors in strict mode.
   const char* statement_data[] = {
     "foo: 1, foo: 2",
     "\"foo\": 1, \"foo\": 2",
     "foo: 1, \"foo\": 2",
     "1: 1, 1: 2",
     "1: 1, \"1\": 2",
     "get: 1, get: 2",  // Not a getter for real, just a property called get.
     "set: 1, set: 2",  // Not a setter for real, just a property called set.
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(non_strict_context_data, statement_data, kSuccess);
   RunParserSyncTest(strict_context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsObjectLiteralChecking) {
   const char* context_data[][2] = {
     {"\"use strict\"; var myobject = {", "};"},
     {"var myobject = {", "};"},
     { NULL, NULL }
@@ skipping 22 matching lines @@
     "get bar(x) {}",
     "get bar(x, y) {}",
     "set bar() {}",
     "set bar(x, y) {}",
     // Parsing FunctionLiteral for getter or setter fails
     "get foo( +",
     "get foo() \"error\"",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsObjectLiteralChecking) {
   const char* context_data[][2] = {
     {"var myobject = {", "};"},
     {"var myobject = {", ",};"},
     {"\"use strict\"; var myobject = {", "};"},
     {"\"use strict\"; var myobject = {", ",};"},
@@ skipping 25 matching lines @@
     // Keywords, future reserved and strict future reserved are also allowed as
     // property names.
     "if: 4",
     "interface: 5",
     "super: 6",
     "eval: 7",
     "arguments: 8",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(TooManyArguments) {
   const char* context_data[][2] = {
     {"foo(", "0)"},
     { NULL, NULL }
   };
 
   using v8::internal::Code;
   char statement[Code::kMaxArguments * 2 + 1];
   for (int i = 0; i < Code::kMaxArguments; ++i) {
     statement[2 * i] = '0';
     statement[2 * i + 1] = ',';
   }
   statement[Code::kMaxArguments * 2] = 0;
 
   const char* statement_data[] = {
     statement,
     NULL
   };
 
   // The test is quite slow, so run it with a reduced set of flags.
+  i::FLAG_harmony_arrow_functions = true;
   static const ParserFlag empty_flags[] = {kAllowLazy};
   RunParserSyncTest(context_data, statement_data, kError, empty_flags, 1);
 }
 
 
 TEST(StrictDelete) {
   // "delete <Identifier>" is not allowed in strict mode.
   const char* strict_context_data[][2] = {
     {"\"use strict\"; ", ""},
     { NULL, NULL }
@@ skipping 28 matching lines @@
     "delete new foo(bar);",
     NULL
   };
 
   // These are always errors
   const char* bad_statement_data[] = {
     "delete if;",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
+
   RunParserSyncTest(strict_context_data, sloppy_statement_data, kError);
   RunParserSyncTest(sloppy_context_data, sloppy_statement_data, kSuccess);
 
   RunParserSyncTest(strict_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(sloppy_context_data, good_statement_data, kSuccess);
 
   RunParserSyncTest(strict_context_data, bad_statement_data, kError);
   RunParserSyncTest(sloppy_context_data, bad_statement_data, kError);
 }
 
@@ skipping 56 matching lines @@
   };
 
   // These are not okay for assignment, but okay for prefix / postix.
   const char* bad_statement_data_for_assignment[] = {
     "++foo",
     "foo++",
     "foo + bar",
     NULL
   };
 
+  i::FLAG_harmony_arrow_functions = true;
+
   RunParserSyncTest(assignment_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(assignment_context_data, bad_statement_data_common, kError);
   RunParserSyncTest(assignment_context_data, bad_statement_data_for_assignment,
                     kError);
 
   RunParserSyncTest(prefix_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(prefix_context_data, bad_statement_data_common, kError);
 
   RunParserSyncTest(postfix_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(postfix_context_data, bad_statement_data_common, kError);
 }
 
 
 TEST(FuncNameInferrerBasic) {
   // Tests that function names are inferred properly.
   i::FLAG_allow_natives_syntax = true;
+  i::FLAG_harmony_arrow_functions = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   CompileRun("var foo1 = function() {}; "
              "var foo2 = function foo3() {}; "
              "function not_ctor() { "
              "  var foo4 = function() {}; "
              "  return %FunctionGetInferredName(foo4); "
              "} "
              "function Ctor() { "
@@ skipping 21 matching lines @@
   ExpectString("%FunctionGetInferredName(obj4[1])", "");
   ExpectString("%FunctionGetInferredName(obj5['foo9'])", "obj5.foo9");
   ExpectString("%FunctionGetInferredName(obj6.obj7.foo10)", "obj6.obj7.foo10");
 }
 
 
 TEST(FuncNameInferrerTwoByte) {
   // Tests function name inferring in cases where some parts of the inferred
   // function name are two-byte strings.
   i::FLAG_allow_natives_syntax = true;
+  i::FLAG_harmony_arrow_functions = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   uint16_t* two_byte_source = AsciiToTwoByteString(
       "var obj1 = { oXj2 : { foo1: function() {} } }; "
       "%FunctionGetInferredName(obj1.oXj2.foo1)");
   uint16_t* two_byte_name = AsciiToTwoByteString("obj1.oXj2.foo1");
   // Make it really non-ASCII (replace the Xs with a non-ASCII character).
   two_byte_source[14] = two_byte_source[78] = two_byte_name[6] = 0x010d;
   v8::Local<v8::String> source =
       v8::String::NewFromTwoByte(isolate, two_byte_source);
   v8::Local<v8::Value> result = CompileRun(source);
   CHECK(result->IsString());
   v8::Local<v8::String> expected_name =
       v8::String::NewFromTwoByte(isolate, two_byte_name);
   CHECK(result->Equals(expected_name));
   i::DeleteArray(two_byte_source);
   i::DeleteArray(two_byte_name);
 }
 
 
 TEST(FuncNameInferrerEscaped) {
   // The same as FuncNameInferrerTwoByte, except that we express the two-byte
   // character as a unicode escape.
   i::FLAG_allow_natives_syntax = true;
+  i::FLAG_harmony_arrow_functions = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   uint16_t* two_byte_source = AsciiToTwoByteString(
       "var obj1 = { o\\u010dj2 : { foo1: function() {} } }; "
       "%FunctionGetInferredName(obj1.o\\u010dj2.foo1)");
   uint16_t* two_byte_name = AsciiToTwoByteString("obj1.oXj2.foo1");
   // Fix to correspond to the non-ASCII name in two_byte_source.
   two_byte_name[6] = 0x010d;
   v8::Local<v8::String> source =
@@ skipping 16 matching lines @@
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   i::FLAG_lazy = true;
   i::FLAG_min_preparse_length = 0;
   CompileRun("function this_is_lazy() {\n"
              "  break p;\n"
              "}\n"
              "this_is_lazy();\n");
 }
+
+
+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] = {
+    {"", ";"},
+    // TODO(aperez): Uncomment this when ParseArrowFunctionLiteral()
+    // generates code and returns a non-NULL expression. Currently it
+    // crashes when expression->set_is_parenthesized(true) is called.
+    //{"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)",
+    // TODO(aperez): Uncomment this when ParseArrowFunctionLiteral()
+    // generates code and returns a non-NULL expression. Currently it
+    // crashes when expression->set_is_parenthesized(true) is called.
+    //"((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));
+}