Implement handling of arrow functions in the parser

src/preparser.cc

 // Copyright 2011 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 118 matching lines @@
 
 PreParserExpression PreParserTraits::ParseV8Intrinsic(bool* ok) {
   return pre_parser_->ParseV8Intrinsic(ok);
 }
 
 
 PreParserExpression PreParserTraits::ParseFunctionLiteral(
     PreParserIdentifier name,
     Scanner::Location function_name_location,
     bool name_is_strict_reserved,
-    bool is_generator,
+    FunctionParsingMode parsing_mode,
+    PreParserExpression params_ast,
     int function_token_position,
     FunctionLiteral::FunctionType type,
     bool* ok) {
   return pre_parser_->ParseFunctionLiteral(
-      name, function_name_location, name_is_strict_reserved, is_generator,
-      function_token_position, type, ok);
+      name, function_name_location, name_is_strict_reserved, parsing_mode,
+      params_ast, function_token_position, type, ok);
 }
 
 
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
     StrictMode strict_mode, bool is_generator, ParserRecorder* log) {
   log_ = log;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
   PreParserScope top_scope(scope_, GLOBAL_SCOPE);
   FunctionState top_state(&function_state_, &scope_, &top_scope);
   scope_->SetStrictMode(strict_mode);
@@ skipping 192 matching lines @@
 
 
 PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
-  bool is_generator = allow_generators() && Check(Token::MUL);
+  FunctionParsingMode parsing_mode = (allow_generators() && Check(Token::MUL))
+      ? kGeneratorFunction
+      : kNormalFunction;
   bool is_strict_reserved = false;
   Identifier name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
   ParseFunctionLiteral(name,
                        scanner()->location(),
                        is_strict_reserved,
-                       is_generator,
+                       parsing_mode,
+                       EmptyExpression(),
                        pos,
                        FunctionLiteral::DECLARATION,
                        CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' Statement* '}'
@@ skipping 454 matching lines @@
 
 
 #undef CHECK_OK
 #define CHECK_OK  ok);                     \
   if (!*ok) return Expression::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 PreParser::Expression PreParser::ParseFunctionLiteral(

[marja, 2014/03/24 09:04:06]

... this doesn't handle arrow funcs yet? (Like, single statement body and so
on.)

You should add tests to cctest/test-parsing to check that the parser and
preparser accept the same set of arrow functions.

[aperez, 2014/04/09 08:47:16]

FWIW, I will add the tests, but provided that I am will be adding a new
ParseArrowFunctionLiteral() in ParserBase, both parser and preparser will
be in sync.

     Identifier function_name,
     Scanner::Location function_name_location,
     bool name_is_strict_reserved,
-    bool is_generator,
+    FunctionParsingMode parsing_mode,
+    PreParserExpression params_ast,
     int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
 
   // Parse function body.
   ScopeType outer_scope_type = scope_->type();
   bool inside_with = scope_->inside_with();
   PreParserScope function_scope(scope_, FUNCTION_SCOPE);
   FunctionState function_state(&function_state_, &scope_, &function_scope);
-  function_state.set_is_generator(is_generator);
+  function_state.set_is_generator(parsing_mode == kGeneratorFunction);
   //  FormalParameterList ::
   //    '(' (Identifier)*[','] ')'
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = position();
   bool done = (peek() == Token::RPAREN);
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   // We don't yet know if the function will be strict, so we cannot yet produce
   // errors for parameter names or duplicates. However, we remember the
   // locations of these errors if they occur and produce the errors later.
   Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
@@ skipping 112 matching lines @@
 
 
 void PreParser::LogSymbol() {
   if (log_->ShouldLogSymbols()) {
     scanner()->LogSymbol(log_, position());
   }
 }
 
 
 } }  // v8::internal