Implement handling of arrow functions in the parser

src/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/func-name-inferrer.h"
@@ skipping 44 matching lines @@
 //   };
 //   // ...
 // };
 
 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;
+  typedef typename Traits::Type::FunctionLiteral FunctionLiteralT;
 
   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 27 matching lines @@
     typename Traits::Type::Scope* outer_scope_;
     typename Traits::Type::Scope* scope_;
   };
 
   class FunctionState BASE_EMBEDDED {
    public:
     FunctionState(
         FunctionState** function_state_stack,
         typename Traits::Type::Scope** scope_stack,
         typename Traits::Type::Scope* scope,
-        typename Traits::Type::Zone* zone = NULL,
-        AstValueFactory* ast_value_factory = NULL);
+        typename Traits::Type::Zone* zone,
+        AstValueFactory* ast_value_factory);
+    FunctionState(
+        FunctionState** function_state_stack,
+        typename Traits::Type::Scope** scope_stack,
+        typename Traits::Type::Scope** scope,
+        typename Traits::Type::Zone* zone,
+        AstValueFactory* ast_value_factory);
     ~FunctionState();
 
     int NextMaterializedLiteralIndex() {
       return next_materialized_literal_index_++;
     }
     int materialized_literal_count() {
       return next_materialized_literal_index_ - JSFunction::kLiteralsPrefixSize;
     }
 
     int NextHandlerIndex() { return next_handler_index_++; }
@@ skipping 271 matching lines @@
   ExpressionT ParseConditionalExpression(bool accept_IN, bool* ok);
   ExpressionT ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
   ExpressionT ParseUnaryExpression(bool* ok);
   ExpressionT ParsePostfixExpression(bool* ok);
   ExpressionT ParseLeftHandSideExpression(bool* ok);
   ExpressionT ParseMemberWithNewPrefixesExpression(bool* ok);
   ExpressionT ParseMemberExpression(bool* ok);
   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);

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

Isn't this one dead code? (And isn't the comment above wrong...?)

+  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.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression,
       Scanner::Location location, const char* message, bool* ok);
 
   // Used to detect duplicates in object literals. Each of the values
   // kGetterProperty, kSetterProperty and kValueProperty represents
   // a type of object literal property. When parsing a property, its
@@ skipping 63 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);
   }
   static PreParserIdentifier Eval() {
     return PreParserIdentifier(kEvalIdentifier);
   }
   static PreParserIdentifier Arguments() {
     return PreParserIdentifier(kArgumentsIdentifier);
   }
   static PreParserIdentifier FutureReserved() {
     return PreParserIdentifier(kFutureReservedIdentifier);
   }
   static PreParserIdentifier FutureStrictReserved() {
     return PreParserIdentifier(kFutureStrictReservedIdentifier);
   }
   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() {
+  bool IsFutureStrictReserved() const {
     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 raw_name() const { return *this; }
+
+  int position() const {
+      return 0;
+  }
+
+  int length() const {

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

This is used for duplicate parameter error message positions, right? Is it use
elsewhere? Might be okay to just always return 0... the PreParser doesn't check
duplicate positions yet anyway. (Or does something observable change if you
return 0 here?)

+      if (IsEval()) return 4;
+      if (IsArguments()) return 9;
+      if (IsYield()) return 5;
+      return 0;
+  }
+
  private:
   enum Type {
     kUnknownIdentifier,
     kFutureReservedIdentifier,
     kFutureStrictReservedIdentifier,
     kYieldIdentifier,
     kEvalIdentifier,
     kArgumentsIdentifier
   };
   explicit PreParserIdentifier(Type type) : type_(type) {}
   Type type_;
 
   friend class PreParserExpression;
+  friend class PreParserScope;
 };
 
 
 // Bits 0 and 1 are used to identify the type of expression:
 // If bit 0 is set, it's an identifier.
 // if bit 1 is set, it's a string literal.
 // If neither is set, it's no particular type, and both set isn't
 // use yet.
 class PreParserExpression {
  public:
   static PreParserExpression Default() {
     return PreParserExpression(kUnknownExpression);
   }
 
   static PreParserExpression FromIdentifier(PreParserIdentifier id) {
-    return PreParserExpression(kIdentifierFlag |
+    return PreParserExpression(kTypeIdentifier |
                                (id.type_ << kIdentifierShift));
   }
 
+  static PreParserExpression BinaryOperation(PreParserExpression left,
+                                             Token::Value op,
+                                             PreParserExpression right) {
+    int code = ((op == Token::COMMA) &&
+                !left.is_parenthesized() &&
+                !right.is_parenthesized())
+        ? left.ArrowParamListBit() & right.ArrowParamListBit() : 0;
+    return PreParserExpression(kTypeBinaryOperation | code);
+  }
+
+  static PreParserExpression EmptyArrowParamList() {
+    // Any expression for which IsValidArrowParamList() returns true
+    // will work here.
+    return FromIdentifier(PreParserIdentifier::Default());
+  }
+
   static PreParserExpression StringLiteral() {
     return PreParserExpression(kUnknownStringLiteral);
   }
 
   static PreParserExpression UseStrictStringLiteral() {
     return PreParserExpression(kUseStrictString);
   }
 
   static PreParserExpression This() {
     return PreParserExpression(kThisExpression);
   }
 
   static PreParserExpression ThisProperty() {
     return PreParserExpression(kThisPropertyExpression);
   }
 
   static PreParserExpression Property() {
     return PreParserExpression(kPropertyExpression);
   }
 
   static PreParserExpression Call() {
     return PreParserExpression(kCallExpression);
   }
 
-  bool IsIdentifier() { return (code_ & kIdentifierFlag) != 0; }
+  bool IsIdentifier() const {
+      return (code_ & kTypeMask) == kTypeIdentifier;
+  }
 
-  PreParserIdentifier AsIdentifier() {
+  PreParserIdentifier AsIdentifier() const {
     ASSERT(IsIdentifier());
     return PreParserIdentifier(
         static_cast<PreParserIdentifier::Type>(code_ >> kIdentifierShift));
   }
 
-  bool IsStringLiteral() { return (code_ & kStringLiteralFlag) != 0; }
+  bool IsStringLiteral() const {
+      return (code_ & kTypeMask) == kTypeStringLiteral;
+  }
 
   bool IsUseStrictLiteral() {
-    return (code_ & kStringLiteralMask) == kUseStrictString;
+    return (code_ & kUseStrictString) == kUseStrictString;
   }
 
   bool IsThis() { return code_ == kThisExpression; }
 
   bool IsThisProperty() { return code_ == kThisPropertyExpression; }
 
   bool IsProperty() {
     return code_ == kPropertyExpression || code_ == kThisPropertyExpression;
   }
 
   bool IsCall() { return code_ == kCallExpression; }
 
   bool IsValidReferenceExpression() {
     return IsIdentifier() || IsProperty();
   }
 
+  bool IsValidArrowParamList() const {
+    return (ArrowParamListBit() & kBinaryOperationArrowParamList) != 0
+        && (code_ & kMultiParenthesizedExpression) == 0;
+  }
+
   // At the moment PreParser doesn't track these expression types.
   bool IsFunctionLiteral() const { return false; }
   bool IsCallNew() const { return false; }
 
   PreParserExpression AsFunctionLiteral() { return *this; }
 
+  bool IsBinaryOperation() const {
+    return (code_ & kTypeMask) == kTypeBinaryOperation;
+  }
+
+  bool is_parenthesized() const {
+    return (code_ & kParenthesizedExpression) != 0;
+  }
+  void set_is_parenthesized(bool value) {
+    if (value) {
+      code_ |= is_parenthesized()
+          ? kMultiParenthesizedExpression
+          : kParenthesizedExpression;
+    } else {
+      code_ &= ~kParenthesizedExpression;
+    }
+  }
+
   // Dummy implementation for making expression->somefunc() work in both Parser
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   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
-  // be absent. If the expression is an identifier or a string literal, the
-  // other bits describe the type (see PreParserIdentifier::Type and string
-  // literal constants below).
+  // Least significant 2 bits are used as expression type. The third least
+  // significant bit tracks whether an expression is parenthesized. If the
+  // expression is an identifier or a string literal, the other bits
+  // describe the type/ (see PreParserIdentifier::Type and string literal
+  // constants below). For binary operations, the other bits are flags
+  // which further describe the contents of the expression.
   enum {
     kUnknownExpression = 0,
+
+    kTypeMask = 1 | 2,
+    kParenthesizedExpression = (1 << 2),
+    kMultiParenthesizedExpression = (1 << 3),
+
     // Identifiers
-    kIdentifierFlag = 1,  // Used to detect labels.
-    kIdentifierShift = 3,
+    kTypeIdentifier = 1,  // Used to detect labels.
+    kIdentifierShift = 5,
 
-    kStringLiteralFlag = 2,  // Used to detect directive prologue.
-    kUnknownStringLiteral = kStringLiteralFlag,
-    kUseStrictString = kStringLiteralFlag | 8,
+    kTypeStringLiteral = 2,  // Used to detect directive prologue.
+    kUnknownStringLiteral = kTypeStringLiteral,
+    kUseStrictString = kTypeStringLiteral | 32,
     kStringLiteralMask = kUseStrictString,
 
+    // Binary operations. Those are needed to detect certain keywords and
+    // duplicated identifier in parameter lists for arrow functions, because
+    // they are initially parsed as comma-separated expressions.
+    kTypeBinaryOperation = 3,
+    kBinaryOperationArrowParamList = (1 << 4),
+
     // Below here applies if neither identifier nor string literal. Reserve the
     // 2 least significant bits for flags.
-    kThisExpression = 1 << 2,
-    kThisPropertyExpression = 2 << 2,
-    kPropertyExpression = 3 << 2,
-    kCallExpression = 4 << 2
+    kThisExpression = (1 << 4),
+    kThisPropertyExpression = (2 << 4),
+    kPropertyExpression = (3 << 4),
+    kCallExpression = (4 << 4)
   };
 
   explicit PreParserExpression(int expression_code) : code_(expression_code) {}
 
+  V8_INLINE int ArrowParamListBit() const {
+    if (IsBinaryOperation())
+      return code_ & kBinaryOperationArrowParamList;
+    if (IsIdentifier()) {
+      const PreParserIdentifier ident = AsIdentifier();
+      // A valid identifier can be an arrow function parameter list
+      // except for eval, arguments, yield, and reserved keywords.
+      if (ident.IsEval() || ident.IsArguments() || ident.IsYield()
+          || ident.IsFutureStrictReserved())
+        return 0;
+      return kBinaryOperationArrowParamList;
+    }
+    return 0;
+  }
+
   int code_;
 };
 
 
 // PreParserExpressionList doesn't actually store the expressions because
 // PreParser doesn't need to.
 class PreParserExpressionList {
  public:
   // These functions make list->Add(some_expression) work (and do nothing).
   PreParserExpressionList() : length_(0) {}
@@ skipping 61 matching lines @@
  public:
   // These functions make list->Add(some_expression) work as no-ops.
   PreParserStatementList() {}
   PreParserStatementList* operator->() { return this; }
   void Add(PreParserStatement, void*) {}
 };
 
 
 class PreParserScope {
  public:
-  explicit PreParserScope(PreParserScope* outer_scope, ScopeType scope_type)
-      : scope_type_(scope_type) {
+  explicit PreParserScope(PreParserScope* outer_scope,
+                          ScopeType scope_type,
+                          void* = NULL)
+      : scope_type_(scope_type), declared_parameters_(0) {
     strict_mode_ = outer_scope ? outer_scope->strict_mode() : SLOPPY;
   }
 
   ScopeType type() { return scope_type_; }
   StrictMode strict_mode() const { return strict_mode_; }
   void SetStrictMode(StrictMode strict_mode) { strict_mode_ = strict_mode; }
 
+  // TODO(aperezdc): Would allowing lazy compilation in preparser make sense?
+  bool AllowsLazyCompilation() const { return false; }
+
+  void set_start_position(int position) {}
+  void set_end_position(int position) {}
+
+  bool IsDeclared(const PreParserIdentifier& identifier) const {
+      return (declared_parameters_ & (1 << identifier.type_)) != 0;
+  }
+
+  void DeclareParameter(const PreParserIdentifier& identifier, VariableMode) {
+      declared_parameters_ |= (1 << identifier.type_);
+  }
+
+  // Allow scope->Foo() to work.
+  PreParserScope* operator->() { return this; }
+
  private:
   ScopeType scope_type_;
   StrictMode strict_mode_;
+  int declared_parameters_;
 };
 
 
 class PreParserFactory {
  public:
   explicit PreParserFactory(void* extra_param1, void* extra_param2) {}
   PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
                                        int pos) {
     return PreParserExpression::Default();
   }
@@ skipping 40 matching lines @@
     return PreParserExpression::Property();
   }
   PreParserExpression NewUnaryOperation(Token::Value op,
                                         PreParserExpression expression,
                                         int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewBinaryOperation(Token::Value op,
                                          PreParserExpression left,
                                          PreParserExpression right, int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::BinaryOperation(left, op, right);
   }
   PreParserExpression NewCompareOperation(Token::Value op,
                                           PreParserExpression left,
                                           PreParserExpression right, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewAssignment(Token::Value op,
                                     PreParserExpression left,
                                     PreParserExpression right,
                                     int pos) {
@@ skipping 20 matching lines @@
   PreParserExpression NewCall(PreParserExpression expression,
                               PreParserExpressionList arguments,
                               int pos) {
     return PreParserExpression::Call();
   }
   PreParserExpression NewCallNew(PreParserExpression expression,
                                  PreParserExpressionList arguments,
                                  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::IsGeneratorFlag is_generator,
+                     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() { static int dummy = 42; return &dummy; }
 };
 
 
 class PreParser;
 
 class PreParserTraits {
  public:
   struct Type {
     // TODO(marja): To be removed. The Traits object should contain all the data
     // it needs.
     typedef PreParser* Parser;
 
     // 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<PreParserIdentifier> ParameterIdentifierVector;
+
     // Return types for traversing functions.
     typedef PreParserIdentifier Identifier;
     typedef PreParserExpression Expression;
     typedef PreParserExpression YieldExpression;
     typedef PreParserExpression FunctionLiteral;
     typedef PreParserExpression ObjectLiteralProperty;
     typedef PreParserExpression Literal;
     typedef PreParserExpressionList ExpressionList;
     typedef PreParserExpressionList PropertyList;
     typedef PreParserStatementList StatementList;
@@ skipping 22 matching lines @@
   }
 
   static bool IsIdentifier(PreParserExpression expression) {
     return expression.IsIdentifier();
   }
 
   static PreParserIdentifier AsIdentifier(PreParserExpression expression) {
     return expression.AsIdentifier();
   }
 
+  static bool IsFutureStrictReserved(PreParserIdentifier identifier) {
+      return identifier.IsYield() || identifier.IsFutureStrictReserved();
+  }
+
   static bool IsBoilerplateProperty(PreParserExpression property) {
     // PreParser doesn't count boilerplate properties.
     return false;
   }
 
   static bool IsArrayIndex(PreParserIdentifier string, uint32_t* index) {
     return false;
   }
 
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
   static void PushLiteralName(FuncNameInferrer* fni, PreParserIdentifier id) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
   static void PushPropertyName(FuncNameInferrer* fni,
                                PreParserExpression expression) {
     // 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) {}
 
   static void CheckAssigningFunctionLiteralToProperty(
       PreParserExpression left, PreParserExpression right) {}
 
   // PreParser doesn't need to keep track of eval calls.
   static void CheckPossibleEvalCall(PreParserExpression expression,
                                     PreParserScope* scope) {}
@@ skipping 23 matching lines @@
     return PreParserExpression::Default();
   }
   PreParserExpression NewThrowSyntaxError(
       const char* type, Handle<Object> arg, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewThrowTypeError(
       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,
                        const char* message,
                        const char* arg = NULL,
                        bool is_reference_error = false);
   void ReportMessageAt(int start_pos,
                        int end_pos,
                        const char* message,
                        const char* arg = NULL,
                        bool is_reference_error = false);
 
   // "null" return type creators.
   static PreParserIdentifier EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
+  static PreParserIdentifier EmptyIdentifierString() {
+    return PreParserIdentifier::Default();
+  }
   static PreParserExpression EmptyExpression() {
     return PreParserExpression::Default();
   }
+  static PreParserExpression EmptyArrowParamList() {
+    return PreParserExpression::EmptyArrowParamList();
+  }
   static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
 
   // Odd-ball literal creators.
   static PreParserExpression GetLiteralTheHole(int position,
                                                PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   // Producing data during the recursive descent.
   PreParserIdentifier GetSymbol(Scanner* scanner);
 
   static PreParserIdentifier GetNextSymbol(Scanner* scanner) {
     return PreParserIdentifier::Default();
   }
 
   static PreParserExpression ThisExpression(PreParserScope* scope,
-                                            PreParserFactory* factory) {
+                                            PreParserFactory* factory,
+                                            int pos) {
     return PreParserExpression::This();
   }
 
   static PreParserExpression ExpressionFromLiteral(
       Token::Value token, int pos, Scanner* scanner,
       PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   static PreParserExpression ExpressionFromIdentifier(
@@ skipping 11 matching lines @@
   }
 
   static PreParserStatementList NewStatementList(int size, void* zone) {
     return PreParserStatementList();
   }
 
   static PreParserExpressionList NewPropertyList(int size, void* zone) {
     return PreParserExpressionList();
   }
 
+  V8_INLINE void SkipLazyFunctionBody(
+      PreParserIdentifier function_name,
+      int* materialized_literal_count,
+      int* expected_property_count,
+      bool* ok) {
+    UNREACHABLE();
+  }
+
+  V8_INLINE PreParserStatementList ParseEagerFunctionBody(
+      PreParserIdentifier function_name,
+      int pos,
+      Variable* fvar,
+      Token::Value fvar_init_op,
+      bool is_generator,
+      bool* ok);
+
+  // Utility functions
+  Vector<PreParserIdentifier> ParameterListFromExpression(
+      PreParserExpression expression) {
+    return Vector<PreParserIdentifier>::empty();
+  }
+  bool IsValidArrowFunctionParameterList(PreParserExpression expression) {
+    // TODO(aperez): Detect duplicated identifiers in paramlists.
+    return expression.IsValidArrowParamList();
+  }
+  static AstValueFactory* ast_value_factory() { return NULL; }
+
+  void CheckConflictingVarDeclarations(
+      PreParserScope scope,
+      bool* ok) {}
+
   // 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,
       int function_token_position,
       FunctionLiteral::FunctionType type,
       FunctionLiteral::ArityRestriction arity_restriction,
@@ skipping 30 matching lines @@
   PreParser(Scanner* scanner, ParserRecorder* log, uintptr_t stack_limit)
       : ParserBase<PreParserTraits>(scanner, stack_limit, NULL, log, NULL,
                                     this) {}
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
   PreParseResult PreParseProgram() {
     PreParserScope scope(scope_, GLOBAL_SCOPE);
-    FunctionState top_scope(&function_state_, &scope_, &scope, NULL);
+    FunctionState top_scope(&function_state_, &scope_, &scope,
+                            zone(), this->ast_value_factory());
     bool ok = true;
     int start_position = scanner()->peek_location().beg_pos;
     ParseSourceElements(Token::EOS, &ok);
     if (stack_overflow()) return kPreParseStackOverflow;
     if (!ok) {
       ReportUnexpectedToken(scanner()->current_token());
     } else if (scope_->strict_mode() == STRICT) {
       CheckOctalLiteral(start_position, scanner()->location().end_pos, &ok);
     }
     return kPreParseSuccess;
@@ skipping 61 matching lines @@
   Statement ParseDoWhileStatement(bool* ok);
   Statement ParseWhileStatement(bool* ok);
   Statement ParseForStatement(bool* ok);
   Statement ParseThrowStatement(bool* ok);
   Statement ParseTryStatement(bool* ok);
   Statement ParseDebuggerStatement(bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseObjectLiteral(bool* ok);
   Expression ParseV8Intrinsic(bool* ok);
 
+  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);
+
   Expression ParseFunctionLiteral(
       Identifier name,
       Scanner::Location function_name_location,
       bool name_is_strict_reserved,
       bool is_generator,
       int function_token_pos,
       FunctionLiteral::FunctionType function_type,
       FunctionLiteral::ArityRestriction arity_restriction,
       bool* ok);
   void ParseLazyFunctionLiteralBody(bool* ok);
 
   bool CheckInOrOf(bool accept_OF);
 };
 
+
+PreParserStatementList PreParser::ParseEagerFunctionBody(
+    PreParserIdentifier function_name,
+    int pos,
+    Variable* fvar,
+    Token::Value fvar_init_op,
+    bool is_generator,
+    bool* ok) {
+  ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
+
+  ParseSourceElements(Token::RBRACE, ok);
+  if (!*ok) return PreParserStatementList();
+
+  Expect(Token::RBRACE, ok);
+  return PreParserStatementList();
+}
+
+
+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,
     typename Traits::Type::Scope** scope_stack,
     typename Traits::Type::Scope* scope,
     typename Traits::Type::Zone* extra_param,
     AstValueFactory* ast_value_factory)
     : 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, ast_value_factory) {
   *scope_stack_ = scope;
   *function_state_stack = this;
   Traits::SetUpFunctionState(this, extra_param);
 }
 
 
 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,
+    AstValueFactory* ast_value_factory)
+    : 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, ast_value_factory) {
+  *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_;
   Traits::TearDownFunctionState(this, extra_param_);
 }
 
 
 template<class Traits>
 void ParserBase<Traits>::ReportUnexpectedToken(Token::Value token) {
   Scanner::Location source_location = scanner()->location();
@@ skipping 146 matching lines @@
   //   ObjectLiteral
   //   RegExpLiteral
   //   '(' Expression ')'
 
   int pos = peek_position();
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
-      result = this->ThisExpression(scope_, factory());
+      result = this->ThisExpression(scope_, factory(), position());
       break;
     }
 
     case Token::NULL_LITERAL:
     case Token::TRUE_LITERAL:
     case Token::FALSE_LITERAL:
     case Token::NUMBER:
       Next();
       result = this->ExpressionFromLiteral(token, pos, scanner(), factory());
       break;
@@ skipping 24 matching lines @@
     case Token::LBRACK:
       result = this->ParseArrayLiteral(CHECK_OK);
       break;
 
     case Token::LBRACE:
       result = this->ParseObjectLiteral(CHECK_OK);
       break;
 
     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->EmptyArrowParamList(),
+                                               CHECK_OK);
+      } else {
+        // Heuristically try to detect immediately called functions before
+        // seeing the call parentheses.
+        parenthesized_function_ = (peek() == Token::FUNCTION);
+        result = this->ParseExpression(true, CHECK_OK);
+        result->set_is_parenthesized(true);
+        Expect(Token::RPAREN, CHECK_OK);
+      }
       break;
 
     case Token::MOD:
       if (allow_natives_syntax() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
@@ skipping 247 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->ParseArrowFunctionLiteral(lhs_location.beg_pos,
+                                           expression,
+                                           CHECK_OK);
+
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
 
   expression = this->CheckAndRewriteReferenceExpression(
       expression, lhs_location, "invalid_lhs_in_assignment", CHECK_OK);
   expression = this->MarkExpressionAsLValue(expression);
 
@@ skipping 385 matching lines @@
       }
       default:
         return expression;
     }
   }
   ASSERT(false);
   return this->EmptyExpression();
 }
 
 
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseArrowFunctionLiteralBody(

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

Nit: reorder the functions here to match the order of the definitions.

+    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;
+  int materialized_literal_count = -1;
+  int expected_property_count = -1;
+
+  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.

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

1) Why do you need to set parenthesized_function_ here? It's not set outside
arrow functions anyway, because it's only set when we see the function keyword,
right?

Afaics, where this code originally was, it used to detect these cases:

(function foo() { << this is parenthised, so parenthesized_function_ is set to
true
   << here, parenthesized_function_ is set to false
   function bar() {}<< so that this function doesn't appear as parenthesized
})();

But I don't think we need it here...

2) The same code is in the if branch and else branch
3) the comment is pretty malformed :)

+
+    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);
+    }
+  } else {
+    // Single-expression body
+    parenthesized_function_ = false;
+    ParseAssignmentExpression(true, CHECK_OK);
+  }
+
+  scope->set_start_position(start_pos);
+  scope->set_end_position(scanner()->location().end_pos);
+
+  this->CheckStrictFunctionNameAndParameters(this->EmptyIdentifier(),
+                                             false,
+                                             Scanner::Location::invalid(),
+                                             Scanner::Location::invalid(),
+                                             dupe_error_loc,
+                                             Scanner::Location::invalid(),
+                                             CHECK_OK);
+
+  // Validate strict mode.
+  if (strict_mode() == STRICT) {
+    CheckOctalLiteral(start_pos,
+                      scanner()->location().end_pos,
+                      CHECK_OK);
+  }
+
+  if (allow_harmony_scoping() && strict_mode() == STRICT)
+    this->CheckConflictingVarDeclarations(scope, CHECK_OK);
+
+  return this->EmptyExpression();
+}
+
+
+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(), this->ast_value_factory());
+
+  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);
+  }
+
+  return ParseArrowFunctionLiteralBody(&function_state,
+                                       scope,
+                                       num_parameters,
+                                       eval_args_error_loc,
+                                       dupe_error_loc,
+                                       reserved_loc,
+                                       parenthesized,
+                                       start_pos,
+                                       CHECK_OK);
+}
+
+
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseArrowFunctionLiteral(int start_pos,
+                                              ExpressionT params_ast,
+                                              bool* ok) {
+  if (!this->IsValidArrowFunctionParameterList(params_ast)) {
+    ReportMessageAt(
+        Scanner::Location(start_pos, scanner()->location().beg_pos),
+        "strict_parameter_list");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
+  // 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(), this->ast_value_factory());
+  typename Traits::Type::ParameterIdentifierVector params =
+      Traits::ParameterListFromExpression(params_ast);
+  Scanner::Location dupe_error_loc = Scanner::Location::invalid();
+
+  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)->raw_name();
+    if (!dupe_error_loc.IsValid() && scope_->IsDeclared(param_name)) {
+      int param_pos = params.at(i)->position();
+      dupe_error_loc = Scanner::Location(param_pos,
+                                         param_pos + param_name->length());
+    }
+    scope_->DeclareParameter(param_name, VAR);
+  }
+
+  return ParseArrowFunctionLiteralBody(&function_state,
+                                       scope,
+                                       params.length(),
+                                       Scanner::Location::invalid(),
+                                       dupe_error_loc,
+                                       Scanner::Location::invalid(),
+                                       parenthesized,
+                                       start_pos,
+                                       CHECK_OK);
+}
+
+
 template <typename Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::CheckAndRewriteReferenceExpression(
     ExpressionT expression,
     Scanner::Location location, const char* message, bool* ok) {
   if (strict_mode() == STRICT && this->IsIdentifier(expression) &&
       this->IsEvalOrArguments(this->AsIdentifier(expression))) {
     this->ReportMessageAt(location, "strict_eval_arguments", false);
     *ok = false;
     return this->EmptyExpression();
@@ skipping 43 matching lines @@
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H