Implement handling of arrow functions in the parser

src/preparser.h

 // 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 60 matching lines @@
 //     typedef ObjectLiteralProperty;
 //     typedef Literal;
 //     typedef ExpressionList;
 //     typedef PropertyList;
 //     // For constructing objects returned by the traversing functions.
 //     typedef Factory;
 //   };
 //   // ...
 // };
 
+enum FunctionParsingMode {
+  kNormalFunction,
+  kArrowFunction,
+  kGeneratorFunction
+};
+
+
 template <typename Traits>
 class ParserBase : public Traits {
  public:
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
   typedef typename Traits::Type::Identifier IdentifierT;
 
   ParserBase(Scanner* scanner, uintptr_t stack_limit,
              v8::Extension* extension,
              ParserRecorder* log,
              typename Traits::Type::Zone* zone,
              typename Traits::Type::Parser this_object)
       : Traits(this_object),
         parenthesized_function_(false),
         scope_(NULL),
         function_state_(NULL),
         extension_(extension),
         fni_(NULL),
         log_(log),
         mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
         scanner_(scanner),
         stack_limit_(stack_limit),
         stack_overflow_(false),
         allow_lazy_(false),
         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
   // allowed to be parsed by this instance of the parser.
   bool allow_lazy() const { return allow_lazy_; }
   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 {
     return scanner()->HarmonyNumericLiterals();
   }
 
   // Setters that determine whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   void set_allow_lazy(bool allow) { allow_lazy_ = allow; }
   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);
   }
   void set_allow_harmony_numeric_literals(bool allow) {
     scanner()->SetHarmonyNumericLiterals(allow);
   }
 
  protected:
   enum AllowEvalOrArgumentsAsIdentifier {
@@ skipping 356 matching lines @@
 
  private:
   Scanner* scanner_;
   uintptr_t stack_limit_;
   bool stack_overflow_;
 
   bool allow_lazy_;
   bool allow_natives_syntax_;
   bool allow_generators_;
   bool allow_for_of_;
+  bool allow_arrow_functions_;
 
   typename Traits::Type::Zone* zone_;  // Only used by Parser.
 };
 
 
 class PreParserIdentifier {
  public:
   PreParserIdentifier() : type_(kUnknownIdentifier) {}
   static PreParserIdentifier Default() {
     return PreParserIdentifier(kUnknownIdentifier);
@@ skipping 469 matching lines @@
   static PreParserExpressionList NewPropertyList(int size, void* zone) {
     return PreParserExpressionList();
   }
 
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression 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);
 
  private:
   PreParser* pre_parser_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
@@ skipping 153 matching lines @@
   Statement ParseTryStatement(bool* ok);
   Statement ParseDebuggerStatement(bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseObjectLiteral(bool* ok);
   Expression ParseV8Intrinsic(bool* ok);
 
   Expression ParseFunctionLiteral(
       Identifier name,
       Scanner::Location function_name_location,
       bool name_is_strict_reserved,
-      bool is_generator,
+      FunctionParsingMode parsing_mode,
+      Expression params_ast,
       int function_token_pos,
       FunctionLiteral::FunctionType function_type,
       bool* ok);
   void ParseLazyFunctionLiteralBody(bool* ok);
 
   // Logs the currently parsed literal as a symbol in the preparser data.
   void LogSymbol();
   // Log the currently parsed string literal.
   Expression GetStringSymbol();
 
@@ skipping 263 matching lines @@
 }
 
 // Precedence = 1
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
     bool accept_IN, bool* ok) {
   // Expression ::
   //   AssignmentExpression
   //   Expression ',' AssignmentExpression
 
+  if (allow_arrow_functions() && peek() == Token::RPAREN) {

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

This doesn't sound right. I guess the idea is that we see the (, then parse the
expression inside the () with ParseExpression. But what if we see a lonely )
when we expect an expression? That should be an error, but this looks like it'll
accept it.

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

It was causing an unexpected token error most of the time, because of
the requirement that parens are balanced, but there was a case (parsing
a single expression-statement) which caused infinite recursion. I am
updating this to check for:

  scanner()->current_token() == Token::LPAREN && peek() == Token::RPAREN

+    // 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);
     int pos = position();
     ExpressionT right = this->ParseAssignmentExpression(accept_IN, CHECK_OK);
     result = factory()->NewBinaryOperation(Token::COMMA, result, right, pos);
   }
   return result;
 }
 
@@ skipping 82 matching lines @@
             return this->EmptyLiteral();
           }
           // Validate the property.
           PropertyKind type = is_getter ? kGetterProperty : kSetterProperty;
           checker.CheckProperty(next, type, CHECK_OK);
           IdentifierT name = this->GetSymbol(scanner_);
           typename Traits::Type::FunctionLiteral value =
               this->ParseFunctionLiteral(
                   name, scanner()->location(),
                   false,  // reserved words are allowed here
-                  false,  // not a generator
+                  kNormalFunction,
+                  this->EmptyExpression(),
                   RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
                   CHECK_OK);
           // Allow any number of parameters for compatibilty with JSC.
           // Specification only allows zero parameters for get and one for set.
           typename Traits::Type::ObjectLiteralProperty property =
               factory()->NewObjectLiteralProperty(is_getter, value, next_pos);
           if (this->IsBoilerplateProperty(property)) {
             number_of_boilerplate_properties++;
           }
           properties->Add(property, zone());
@@ skipping 117 matching lines @@
   Expect(Token::RPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   return result;
 }
 
 // Precedence = 2
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN, bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
+  //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
 
   Scanner::Location lhs_location = scanner()->peek_location();
 
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(ok);
   }
 
   if (fni_ != NULL) fni_->Enter();
   ExpressionT expression =
       this->ParseConditionalExpression(accept_IN, CHECK_OK);
 
+  if (allow_arrow_functions() && peek() == Token::ARROW) {
+    return this->ParseFunctionLiteral(Traits::EmptyIdentifier(),
+                                      Scanner::Location::invalid(),
+                                      false,
+                                      kArrowFunction,
+                                      expression,
+                                      lhs_location.beg_pos,
+                                      FunctionLiteral::ANONYMOUS_EXPRESSION,
+                                      CHECK_OK);
+  }
+
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
 
   if (!expression->IsValidLeftHandSide()) {
     this->ReportMessageAt(lhs_location, "invalid_lhs_in_assignment", true);
     *ok = false;
     return this->EmptyExpression();
@@ skipping 341 matching lines @@
 
   // The '[' Expression ']' and '.' Identifier parts are parsed by
   // ParseMemberExpressionContinuation, and the Arguments part is parsed by the
   // caller.
 
   // Parse the initial primary or function expression.
   ExpressionT result = this->EmptyExpression();
   if (peek() == Token::FUNCTION) {
     Consume(Token::FUNCTION);
     int function_token_position = position();
-    bool is_generator = allow_generators() && Check(Token::MUL);
+    FunctionParsingMode parsing_mode =
+        (allow_generators() && Check(Token::MUL))
+          ? kGeneratorFunction
+          : kNormalFunction;
     IdentifierT name;
     bool is_strict_reserved_name = false;
     Scanner::Location function_name_location = Scanner::Location::invalid();
     FunctionLiteral::FunctionType function_type =
         FunctionLiteral::ANONYMOUS_EXPRESSION;
     if (peek_any_identifier()) {
       name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
                                                  CHECK_OK);
       function_name_location = scanner()->location();
       function_type = FunctionLiteral::NAMED_EXPRESSION;
     }
     result = this->ParseFunctionLiteral(name,
                                         function_name_location,
                                         is_strict_reserved_name,
-                                        is_generator,
+                                        parsing_mode,
+                                        this->EmptyExpression(),
                                         function_token_position,
                                         function_type,
                                         CHECK_OK);
   } else {
     result = ParsePrimaryExpression(CHECK_OK);
   }
 
   result = ParseMemberExpressionContinuation(result, CHECK_OK);
   return result;
 }
@@ skipping 71 matching lines @@
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H