Implement handling of arrow functions in the parser

src/preparser.h

Index: src/preparser.h
diff --git a/src/preparser.h b/src/preparser.h
index 9dee863d591191a40de0a78d7d191347f9bc3966..056fb7e2287bc795f3dbb4d0de63acf94dbe002a 100644
--- a/src/preparser.h
+++ b/src/preparser.h
@@ -61,6 +61,7 @@ class ParserBase : public Traits {
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
   typedef typename Traits::Type::Identifier IdentifierT;
+  typedef typename Traits::Type::FunctionLiteral FunctionLiteralT;
 
   ParserBase(Scanner* scanner, uintptr_t stack_limit,
              v8::Extension* extension,
@@ -82,6 +83,7 @@ class ParserBase : public Traits {
         allow_natives_syntax_(false),
         allow_generators_(false),
         allow_for_of_(false),
+        allow_arrow_functions_(false),
         zone_(zone) { }
 
   // Getters that indicate whether certain syntactical constructs are
@@ -90,6 +92,7 @@ class ParserBase : public Traits {
   bool allow_natives_syntax() const { return allow_natives_syntax_; }
   bool allow_generators() const { return allow_generators_; }
   bool allow_for_of() const { return allow_for_of_; }
+  bool allow_arrow_functions() const { return allow_arrow_functions_; }
   bool allow_modules() const { return scanner()->HarmonyModules(); }
   bool allow_harmony_scoping() const { return scanner()->HarmonyScoping(); }
   bool allow_harmony_numeric_literals() const {
@@ -102,6 +105,7 @@ class ParserBase : public Traits {
   void set_allow_natives_syntax(bool allow) { allow_natives_syntax_ = allow; }
   void set_allow_generators(bool allow) { allow_generators_ = allow; }
   void set_allow_for_of(bool allow) { allow_for_of_ = allow; }
+  void set_allow_arrow_functions(bool allow) { allow_arrow_functions_ = allow; }
   void set_allow_modules(bool allow) { scanner()->SetHarmonyModules(allow); }
   void set_allow_harmony_scoping(bool allow) {
     scanner()->SetHarmonyScoping(allow);
@@ -150,6 +154,11 @@ class ParserBase : public Traits {
         typename Traits::Type::Scope** scope_stack,
         typename Traits::Type::Scope* scope,
         typename Traits::Type::Zone* zone = NULL);
+    FunctionState(
+        FunctionState** function_state_stack,
+        typename Traits::Type::Scope** scope_stack,
+        typename Traits::Type::Scope** scope,
+        typename Traits::Type::Zone* zone = NULL);
     ~FunctionState();
 
     int NextMaterializedLiteralIndex() {
@@ -401,6 +410,31 @@ class ParserBase : public Traits {
   ExpressionT ParseMemberExpressionContinuation(ExpressionT expression,
                                                 bool* ok);
 
+  // There are two ways of parsing arrow functions: if the beginning of an
+  // arrow function can be determined prior to process the parameter list
+  // (e.g. the current scanning position is known to be an arrow function
+  // and not an AssignmentExpression) then the first version is used. In
+  // most cases, we parse the parameter list as an AssignmentExpression
+  // and interpret the AST when the arrow "=>" token is found, using the
+  // second version.
+  // The overloaded ParseArrowFunctionLiteral() functions mainly deal with
+  // parsing/interpreting the parameter list, and then they both call
+  // ParseArrowFunctionLiteralBody() before consuming the arrow token.
+  ExpressionT ParseArrowFunctionLiteral(bool* ok);
+  ExpressionT ParseArrowFunctionLiteral(int start_pos,
+                                        ExpressionT params_ast,
+                                        bool* ok);
+  ExpressionT ParseArrowFunctionLiteralBody(
+      FunctionState* function_state,
+      typename Traits::Type::ScopePtr scope,
+      int num_parameters,
+      const Scanner::Location& eval_args_error_loc,
+      const Scanner::Location& dupe_error_loc,
+      const Scanner::Location& reserved_loc,
+      FunctionLiteral::IsParenthesizedFlag parenthesized,
+      int start_pos,
+      bool* ok);
+
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
@@ -484,6 +518,7 @@ class ParserBase : public Traits {
   bool allow_natives_syntax_;
   bool allow_generators_;
   bool allow_for_of_;
+  bool allow_arrow_functions_;
 
   typename Traits::Type::Zone* zone_;  // Only used by Parser.
 };
@@ -510,16 +545,23 @@ class PreParserIdentifier {
   static PreParserIdentifier Yield() {
     return PreParserIdentifier(kYieldIdentifier);
   }
-  bool IsEval() { return type_ == kEvalIdentifier; }
-  bool IsArguments() { return type_ == kArgumentsIdentifier; }
+  bool IsEval() const { return type_ == kEvalIdentifier; }
+  bool IsArguments() const { return type_ == kArgumentsIdentifier; }
   bool IsEvalOrArguments() { return type_ >= kEvalIdentifier; }
-  bool IsYield() { return type_ == kYieldIdentifier; }
+  bool IsYield() const { return type_ == kYieldIdentifier; }
   bool IsFutureReserved() { return type_ == kFutureReservedIdentifier; }
   bool IsFutureStrictReserved() {
     return type_ == kFutureStrictReservedIdentifier;
   }
   bool IsValidStrictVariable() { return type_ == kUnknownIdentifier; }
 
+  // Allow identifier->name()[->length()] to work. The preparser
+  // does not need the actual positions/lengths of the identifiers.
+  const PreParserIdentifier* operator->() const { return this; }
+  const PreParserIdentifier name() const { return *this; }
+  int position() const { return RelocInfo::kNoPosition; }
+  int length() const { return 0; }
+
  private:
   enum Type {
     kUnknownIdentifier,
@@ -618,6 +660,18 @@ class PreParserExpression {
   void set_index(int index) {}  // For YieldExpressions
   void set_parenthesized() {}
 
+  int position() const { return RelocInfo::kNoPosition; }
+  void set_function_token_position(int position) {}
+  void set_ast_properties(int* ast_properties) {}
+  void set_dont_optimize_reason(BailoutReason dont_optimize_reason) {}
+
+  bool operator==(const PreParserExpression& other) const {
+    return code_ == other.code_;
+  }
+  bool operator!=(const PreParserExpression& other) const {
+    return code_ != other.code_;
+  }
+
  private:
   // Least significant 2 bits are used as flags. Bits 0 and 1 represent
   // identifiers or strings literals, and are mutually exclusive, but can both
@@ -726,7 +780,9 @@ class PreParserStatementList {
 
 class PreParserScope {
  public:
-  explicit PreParserScope(PreParserScope* outer_scope, ScopeType scope_type)
+  explicit PreParserScope(PreParserScope* outer_scope,
+                          ScopeType scope_type,
+                          void* = NULL)
       : scope_type_(scope_type) {
     strict_mode_ = outer_scope ? outer_scope->strict_mode() : SLOPPY;
   }
@@ -734,6 +790,16 @@ class PreParserScope {
   ScopeType type() { return scope_type_; }
   StrictMode strict_mode() const { return strict_mode_; }
   void SetStrictMode(StrictMode strict_mode) { strict_mode_ = strict_mode; }
+  bool AllowsLazyCompilation() const { return true; }
+
+  void set_start_position(int position) {}
+  void set_end_position(int position) {}
+
+  bool IsDeclared(const PreParserIdentifier&) const { return false; }
+  void DeclareParameter(const PreParserIdentifier&, VariableMode) {}
+
+  // Allow scope->Foo() to work.
+  PreParserScope* operator->() { return this; }
 
  private:
   ScopeType scope_type_;
@@ -839,6 +905,32 @@ class PreParserFactory {
                                  int pos) {
     return PreParserExpression::Default();
   }
+  PreParserStatement NewReturnStatement(PreParserExpression expression,
+                                        int pos) {
+    return PreParserStatement::Default();
+  }
+  PreParserExpression
+  NewFunctionLiteral(PreParserIdentifier name,
+                     PreParserScope& scope,
+                     PreParserStatementList body,
+                     int materialized_literal_count,
+                     int expected_property_count,
+                     int handler_count,
+                     int parameter_count,
+                     FunctionLiteral::ParameterFlag has_duplicate_parameters,
+                     FunctionLiteral::FunctionType function_type,
+                     FunctionLiteral::IsFunctionFlag is_function,
+                     FunctionLiteral::IsParenthesizedFlag is_parenthesized,
+                     FunctionLiteral::KindFlag kind,
+                     int position) {
+    return PreParserExpression::Default();
+  }
+
+  // Return the object itself as AstVisitor and implement the needed
+  // dummy method right in this class.
+  PreParserFactory* visitor() { return this; }
+  BailoutReason dont_optimize_reason() { return kNoReason; }
+  int* ast_properties() { return NULL; }
 };
 
 
@@ -853,11 +945,16 @@ class PreParserTraits {
 
     // Used by FunctionState and BlockState.
     typedef PreParserScope Scope;
+    typedef PreParserScope ScopePtr;
+
     // PreParser doesn't need to store generator variables.
     typedef void GeneratorVariable;
     // No interaction with Zones.
     typedef void Zone;
 
+    typedef int AstProperties;
+    typedef Vector<const PreParserIdentifier> ParameterIdentifierVector;
+
     // Return types for traversing functions.
     typedef PreParserIdentifier Identifier;
     typedef PreParserExpression Expression;
@@ -920,6 +1017,11 @@ class PreParserTraits {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
+  static void InferFunctionName(FuncNameInferrer* fni,
+                                PreParserExpression expression) {
+    // PreParser should not use FuncNameInferrer.
+    UNREACHABLE();
+  }
 
   static void CheckFunctionLiteralInsideTopLevelObjectLiteral(
       PreParserScope* scope, PreParserExpression value, bool* has_function) {}
@@ -963,6 +1065,10 @@ class PreParserTraits {
       const char* type, Handle<Object> arg, int pos) {
     return PreParserExpression::Default();
   }
+  PreParserScope NewScope(PreParserScope* outer_scope,
+                          ScopeType scope_type) {
+    return PreParserScope(outer_scope, scope_type);
+  }
 
   // Reporting errors.
   void ReportMessageAt(Scanner::Location location,
@@ -979,6 +1085,9 @@ class PreParserTraits {
   static PreParserIdentifier EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
+  static PreParserIdentifier EmptyIdentifierString() {
+    return PreParserIdentifier::Default();
+  }
   static PreParserExpression EmptyExpression() {
     return PreParserExpression::Default();
   }
@@ -999,11 +1108,14 @@ class PreParserTraits {
   PreParserIdentifier GetSymbol(Scanner* scanner);
   static PreParserIdentifier NextLiteralString(Scanner* scanner,
                                                PretenureFlag tenured) {
+    // This is used by the regexp parsing, which does not use the
+    // positions of items from the preparser mini-AST.
     return PreParserIdentifier::Default();
   }
 
   static PreParserExpression ThisExpression(PreParserScope* scope,
-                                            PreParserFactory* factory) {
+                                            PreParserFactory* factory,
+                                            int pos) {
     return PreParserExpression::This();
   }
 
@@ -1035,6 +1147,29 @@ class PreParserTraits {
     return PreParserExpressionList();
   }
 
+  V8_INLINE void SkipLazyFunctionBody(
+      PreParserIdentifier function_name,
+      int* materialized_literal_count,
+      int* expected_property_count,
+      bool* ok);
+  V8_INLINE PreParserStatementList ParseEagerFunctionBody(
+      PreParserIdentifier function_name,
+      int pos,
+      Variable* fvar,
+      Token::Value fvar_init_op,
+      bool is_generator,
+      bool* ok);
+
+  // Utility functions
+  Vector<const PreParserIdentifier> ParameterListFromExpression(
+      PreParserExpression expression, bool* ok) {
+    return Vector<const PreParserIdentifier>::empty();
+  }
+
+  void CheckConflictingVarDeclarations(
+      PreParserScope scope,
+      bool* ok) {}
+
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression ParseFunctionLiteral(
@@ -1179,6 +1314,29 @@ class PreParser : public ParserBase<PreParserTraits> {
   bool CheckInOrOf(bool accept_OF);
 };
 
+
+void PreParserTraits::SkipLazyFunctionBody(
+    PreParserIdentifier function_name,
+    int* materialized_literal_count,
+    int* expected_property_count,
+    bool* ok) {
+  pre_parser_->SkipLazyFunctionBody(function_name,
+      materialized_literal_count, expected_property_count, ok);
+}
+
+
+PreParserStatementList PreParserTraits::ParseEagerFunctionBody(
+    PreParserIdentifier function_name,
+    int pos,
+    Variable* fvar,
+    Token::Value fvar_init_op,
+    bool is_generator,
+    bool* ok) {
+  return pre_parser_->ParseEagerFunctionBody(function_name,
+      pos, fvar, fvar_init_op, is_generator, ok);
+}
+
+
 template<class Traits>
 ParserBase<Traits>::FunctionState::FunctionState(
     FunctionState** function_state_stack,
@@ -1204,6 +1362,30 @@ ParserBase<Traits>::FunctionState::FunctionState(
 
 
 template<class Traits>
+ParserBase<Traits>::FunctionState::FunctionState(
+    FunctionState** function_state_stack,
+    typename Traits::Type::Scope** scope_stack,
+    typename Traits::Type::Scope** scope,
+    typename Traits::Type::Zone* extra_param)
+    : next_materialized_literal_index_(JSFunction::kLiteralsPrefixSize),
+      next_handler_index_(0),
+      expected_property_count_(0),
+      is_generator_(false),
+      generator_object_variable_(NULL),
+      function_state_stack_(function_state_stack),
+      outer_function_state_(*function_state_stack),
+      scope_stack_(scope_stack),
+      outer_scope_(*scope_stack),
+      saved_ast_node_id_(0),
+      extra_param_(extra_param),
+      factory_(extra_param) {
+  *scope_stack_ = *scope;
+  *function_state_stack = this;
+  Traits::SetUpFunctionState(this, extra_param);
+}
+
+
+template<class Traits>
 ParserBase<Traits>::FunctionState::~FunctionState() {
   *scope_stack_ = outer_scope_;
   *function_state_stack_ = outer_function_state_;
@@ -1371,7 +1553,7 @@ ParserBase<Traits>::ParsePrimaryExpression(bool* ok) {
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
-      result = this->ThisExpression(scope_, factory());
+      result = this->ThisExpression(scope_, factory(), position());
       break;
     }
 
@@ -1416,11 +1598,20 @@ ParserBase<Traits>::ParsePrimaryExpression(bool* ok) {
 
     case Token::LPAREN:
       Consume(Token::LPAREN);
-      // Heuristically try to detect immediately called functions before
-      // seeing the call parentheses.
-      parenthesized_function_ = (peek() == Token::FUNCTION);
-      result = this->ParseExpression(true, CHECK_OK);
-      Expect(Token::RPAREN, CHECK_OK);
+      if (allow_arrow_functions() && peek() == Token::RPAREN) {
+        // Arrow functions are the only expression type constructions
+        // for which an empty parameter list "()" is valid input.
+        Consume(Token::RPAREN);
+        return this->ParseArrowFunctionLiteral(pos,
+                                               this->EmptyExpression(),
+                                               CHECK_OK);

[marja, 2014/05/26 12:46:06]

I think there is a bug here.

So if we're here... but it's not an arrow function but a stray "()", what will
happen? I think you're changing the existing behavior of () here. And that's not
intentional, I guess?

For example, if the code is foo[()], we currently produce an error "Unexpected
token )", but now, if arrow functions are allowed, we'll produce an error
"Unexpected token ]", right? 

In any case, pls add test code which tests that possibility (and even better, a
test which would've exposed the bug, if you agree it's a bug... but that might
be difficult).

+      } else {
+        // Heuristically try to detect immediately called functions before
+        // seeing the call parentheses.
+        parenthesized_function_ = (peek() == Token::FUNCTION);
+        result = this->ParseExpression(true, CHECK_OK);
+        Expect(Token::RPAREN, CHECK_OK);
+      }
       break;
 
     case Token::MOD:
@@ -1449,6 +1640,12 @@ typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
   //   AssignmentExpression
   //   Expression ',' AssignmentExpression
 
+  if (allow_arrow_functions() && peek() == Token::RPAREN &&

[marja, 2014/05/26 12:46:06]

Pls add a test where this code path is taken but it turns out to not be an arrow
function.

+      scanner()->current_token() == Token::LPAREN) {
+    // Empty argument list for arrow functions: () => ...
+    return this->EmptyExpression();
+  }
+
   ExpressionT result = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
   while (peek() == Token::COMMA) {
     Expect(Token::COMMA, CHECK_OK);
@@ -1689,6 +1886,7 @@ typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN, bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
+  //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
 
@@ -1702,6 +1900,11 @@ ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN, bool* ok) {
   ExpressionT expression =
       this->ParseConditionalExpression(accept_IN, CHECK_OK);
 
+  if (allow_arrow_functions() && peek() == Token::ARROW)
+    return this->ParseArrowFunctionLiteral(lhs_location.beg_pos,
+                                           expression,
+                                           CHECK_OK);
+
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
@@ -2106,6 +2309,276 @@ ParserBase<Traits>::ParseMemberExpressionContinuation(ExpressionT expression,
 }
 
 
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseArrowFunctionLiteralBody(

[marja, 2014/05/26 12:46:06]

A lot of this function (starting from strict mode checking) is duplicate code;
pls refactor.

I'm happy to accept a separate CL which splits the strict mode checking out of
ParseFunctionLiteral where it currently is.

+    FunctionState* function_state,
+    typename Traits::Type::ScopePtr scope,
+    int num_parameters,
+    const Scanner::Location& eval_args_error_loc,
+    const Scanner::Location& dupe_error_loc,
+    const Scanner::Location& reserved_loc,
+    FunctionLiteral::IsParenthesizedFlag parenthesized,
+    int start_pos,
+    bool* ok) {
+
+  typename Traits::Type::StatementList body;
+  typename Traits::Type::AstProperties ast_properties;
+  FunctionLiteral::ParameterFlag duplicate_parameters = dupe_error_loc.IsValid()
+      ? FunctionLiteral::kHasDuplicateParameters
+      : FunctionLiteral::kNoDuplicateParameters;
+  BailoutReason dont_optimize_reason = kNoReason;
+  int materialized_literal_count = -1;
+  int expected_property_count = -1;
+  int handler_count = 0;
+
+  Expect(Token::ARROW, CHECK_OK);
+
+  if (peek() == Token::LBRACE) {
+    // Multiple statemente body
+    Consume(Token::LBRACE);
+
+    bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
+                             scope_->AllowsLazyCompilation() &&
+                             !parenthesized_function_);
+    parenthesized_function_ = false;  // This Was set for this funciton only.
+
+    if (is_lazily_parsed) {
+      this->SkipLazyFunctionBody(this->EmptyIdentifier(),
+                                 &materialized_literal_count,
+                                 &expected_property_count,
+                                 CHECK_OK);
+    } else {
+      body = this->ParseEagerFunctionBody(this->EmptyIdentifier(),
+                                          RelocInfo::kNoPosition,
+                                          NULL,
+                                          Token::INIT_VAR,
+                                          false,  // Not a generator.
+                                          CHECK_OK);
+      materialized_literal_count =
+          function_state->materialized_literal_count();
+      expected_property_count = function_state->expected_property_count();
+      handler_count = function_state->handler_count();
+    }
+  } else {
+    // Single-expression body
+    int pos = position();
+    parenthesized_function_ = false;
+    ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
+    body = this->NewStatementList(1, zone());
+    body->Add(factory()->NewReturnStatement(expression, pos), zone());
+    materialized_literal_count = function_state->materialized_literal_count();
+    expected_property_count = function_state->expected_property_count();
+    handler_count = function_state->handler_count();
+  }
+
+  scope->set_start_position(start_pos);
+  scope->set_end_position(scanner()->location().end_pos);
+
+  // Validate strict mode.
+  if (strict_mode() == STRICT) {
+    if (eval_args_error_loc.IsValid()) {
+      this->ReportMessageAt(eval_args_error_loc, "strict_eval_arguments");
+      *ok = false;
+      return this->EmptyExpression();
+    }
+    if (dupe_error_loc.IsValid()) {
+      this->ReportMessageAt(dupe_error_loc, "strict_param_dupe");
+      *ok = false;
+      return this->EmptyExpression();
+    }
+    if (reserved_loc.IsValid()) {
+      this->ReportMessageAt(reserved_loc, "unexpected_strict_reserved");
+      *ok = false;
+      return this->EmptyExpression();
+    }
+    CheckOctalLiteral(start_pos,
+                      scanner()->location().end_pos,
+                      CHECK_OK);
+  }
+
+  if (allow_harmony_scoping() && strict_mode() == STRICT)
+    this->CheckConflictingVarDeclarations(scope, CHECK_OK);
+
+  ast_properties = *factory()->visitor()->ast_properties();
+  dont_optimize_reason = factory()->visitor()->dont_optimize_reason();
+
+  FunctionLiteralT function_literal =
+      factory()->NewFunctionLiteral(this->EmptyIdentifierString(),
+                                    scope,
+                                    body,
+                                    materialized_literal_count,
+                                    expected_property_count,
+                                    handler_count,
+                                    num_parameters,
+                                    duplicate_parameters,
+                                    FunctionLiteral::ANONYMOUS_EXPRESSION,
+                                    FunctionLiteral::kIsFunction,
+                                    parenthesized,
+                                    FunctionLiteral::kArrowFunction,
+                                    start_pos);
+  function_literal->set_function_token_position(start_pos);
+  function_literal->set_ast_properties(&ast_properties);
+  function_literal->set_dont_optimize_reason(dont_optimize_reason);
+
+  if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
+
+  return function_literal;
+}
+
+
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseArrowFunctionLiteral(bool* ok) {
+  // TODO(aperez): Change this to use ARROW_SCOPE
+  typename Traits::Type::ScopePtr scope =
+      this->NewScope(scope_, FUNCTION_SCOPE);
+
+  FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
+      ? FunctionLiteral::kIsParenthesized
+      : FunctionLiteral::kNotParenthesized;
+  parenthesized_function_ = false;
+
+  int start_pos = position();
+  int num_parameters = 0;
+  FunctionState function_state(&function_state_, &scope_, &scope, zone());
+
+  Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
+  Scanner::Location dupe_error_loc = Scanner::Location::invalid();
+  Scanner::Location reserved_loc = Scanner::Location::invalid();
+
+  if (peek() == Token::LPAREN) {
+    // Parse a parenthesized parameter list.
+    Consume(Token::LPAREN);
+    bool done = (peek() == Token::RPAREN);
+    while (!done) {
+      bool is_strict_reserved = false;
+      IdentifierT param_name =
+          ParseIdentifierOrStrictReservedWord(&is_strict_reserved,
+                                              CHECK_OK);
+
+      // Store locations for possible future error reports.
+      if (!eval_args_error_loc.IsValid() &&
+          this->IsEvalOrArguments(param_name)) {
+        eval_args_error_loc = scanner()->location();
+      }
+      if (!reserved_loc.IsValid() && is_strict_reserved) {
+        reserved_loc = scanner()->location();
+      }
+      if (!dupe_error_loc.IsValid() && scope_->IsDeclared(param_name)) {
+        dupe_error_loc = scanner()->location();
+      }
+
+      scope_->DeclareParameter(param_name, VAR);
+      num_parameters++;
+      if (num_parameters > Code::kMaxArguments) {
+        this->ReportMessageAt(scanner()->location(), "too_many_parameters");
+        *ok = false;
+        return this->EmptyExpression();
+      }
+      done = (peek() == Token::RPAREN);
+      if (!done) Expect(Token::COMMA, CHECK_OK);
+    }
+    Expect(Token::RPAREN, CHECK_OK);
+  } else {
+    // Parse a single parameter identifier.
+    bool is_strict_reserved = false;
+    IdentifierT param_name =
+        ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+
+    // Store locations for possible future error reports.
+    if (this->IsEvalOrArguments(param_name))
+      eval_args_error_loc = scanner()->location();
+    if (is_strict_reserved)
+      reserved_loc = scanner()->location();
+
+    scope_->DeclareParameter(param_name, VAR);
+  }
+
+  ExpressionT literal = ParseArrowFunctionLiteralBody(&function_state,
+                                                      scope,
+                                                      num_parameters,
+                                                      eval_args_error_loc,
+                                                      dupe_error_loc,
+                                                      reserved_loc,
+                                                      parenthesized,
+                                                      start_pos,
+                                                      CHECK_OK);
+  return literal;
+}
+
+
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseArrowFunctionLiteral(int start_pos,
+                                              ExpressionT params_ast,
+                                              bool* ok) {
+  // TODO(aperez): Change this to use ARROW_SCOPE
+  typename Traits::Type::ScopePtr scope =
+      this->NewScope(scope_, FUNCTION_SCOPE);
+
+  FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
+      ? FunctionLiteral::kIsParenthesized
+      : FunctionLiteral::kNotParenthesized;
+  parenthesized_function_ = false;
+
+  FunctionState function_state(&function_state_, &scope_, &scope, zone());
+
+  Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
+  Scanner::Location dupe_error_loc = Scanner::Location::invalid();
+  Scanner::Location reserved_loc = Scanner::Location::invalid();
+
+  // Function parameters are already parsed into an AST
+  typename Traits::Type::ParameterIdentifierVector params =
+      Traits::ParameterListFromExpression(params_ast, CHECK_OK);
+
+  if ((params.length() != 1 || start_pos < params.last()->position()) &&
+      !scanner()->IsValidParameterList(start_pos)) {
+    ReportMessageAt(Scanner::Location(start_pos, position()),
+                    "malformed_parameter_list");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
+  if (params.length() > Code::kMaxArguments) {
+    ReportMessageAt(Scanner::Location(params_ast->position(), position()),
+                    "too_many_parameters");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
+  // The vector has the items in reverse order.
+  for (int i = params.length() - 1; i >= 0; --i) {
+    const IdentifierT param_name = params.at(i)->name();
+    int param_pos = params.at(i)->position();
+
+    // Store locations for possible future error reports.
+    if (!eval_args_error_loc.IsValid() &&
+        this->IsEvalOrArguments(param_name)) {
+      eval_args_error_loc =
+          Scanner::Location(param_pos, param_pos + param_name->length());
+    }
+    if (!dupe_error_loc.IsValid() && scope_->IsDeclared(param_name)) {
+      dupe_error_loc =
+          Scanner::Location(param_pos, param_pos + param_name->length());
+    }
+
+    scope_->DeclareParameter(param_name, VAR);
+  }
+
+  ExpressionT literal = ParseArrowFunctionLiteralBody(&function_state,
+                                                      scope,
+                                                      params.length(),
+                                                      eval_args_error_loc,
+                                                      dupe_error_loc,
+                                                      reserved_loc,
+                                                      parenthesized,
+                                                      start_pos,
+                                                      CHECK_OK);
+  return literal;
+}
+
+
 template <typename Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::CheckAndRewriteReferenceExpression(