Implement handling of arrow functions in the parser

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 733 matching lines @@
 
 Expression* ParserTraits::ParseV8Intrinsic(bool* ok) {
   return parser_->ParseV8Intrinsic(ok);
 }
 
 
 FunctionLiteral* ParserTraits::ParseFunctionLiteral(
     Handle<String> name,
     Scanner::Location function_name_location,
     bool name_is_strict_reserved,
-    bool is_generator,
+    FunctionParsingMode parsing_mode,
+    Expression* params_ast,
     int function_token_position,
     FunctionLiteral::FunctionType type,
     bool* ok) {
   return parser_->ParseFunctionLiteral(name, function_name_location,
-                                       name_is_strict_reserved, is_generator,
-                                       function_token_position, type, ok);
+                                       name_is_strict_reserved, parsing_mode,
+                                       params_ast, function_token_position,
+                                       type, ok);
 }
 
 
 Parser::Parser(CompilationInfo* info)
     : ParserBase<ParserTraits>(&scanner_,
                                info->isolate()->stack_guard()->real_climit(),
                                info->extension(),
                                NULL,
                                info->zone(),
                                this),
       isolate_(info->isolate()),
       symbol_cache_(0, info->zone()),
       script_(info->script()),
       scanner_(isolate_->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       cached_data_(NULL),
       cached_data_mode_(NO_CACHED_DATA),
       info_(info) {
   ASSERT(!script_.is_null());
   isolate_->set_ast_node_id(0);
   set_allow_harmony_scoping(!info->is_native() && FLAG_harmony_scoping);
   set_allow_modules(!info->is_native() && FLAG_harmony_modules);
   set_allow_natives_syntax(FLAG_allow_natives_syntax || info->is_native());
   set_allow_lazy(false);  // Must be explicitly enabled.
   set_allow_generators(FLAG_harmony_generators);
   set_allow_for_of(FLAG_harmony_iteration);
+  set_allow_arrow_functions(FLAG_harmony_arrow_functions);
   set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
 }
 
 
 FunctionLiteral* Parser::ParseProgram() {
   // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
   // see comment for HistogramTimerScope class.
   HistogramTimerScope timer_scope(isolate()->counters()->parse(), true);
   Handle<String> source(String::cast(script_->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
@@ skipping 115 matching lines @@
           body,
           function_state.materialized_literal_count(),
           function_state.expected_property_count(),
           function_state.handler_count(),
           0,
           FunctionLiteral::kNoDuplicateParameters,
           FunctionLiteral::ANONYMOUS_EXPRESSION,
           FunctionLiteral::kGlobalOrEval,
           FunctionLiteral::kNotParenthesized,
           FunctionLiteral::kNotGenerator,
+          FunctionLiteral::kNotArrow,
           0);
       result->set_ast_properties(factory()->visitor()->ast_properties());
       result->set_slot_processor(factory()->visitor()->slot_processor());
       result->set_dont_optimize_reason(
           factory()->visitor()->dont_optimize_reason());
     } else if (stack_overflow()) {
       isolate()->StackOverflow();
     }
   }
 
@@ skipping 65 matching lines @@
     original_scope_ = scope;
     FunctionState function_state(&function_state_, &scope_, scope, zone());
     ASSERT(scope->strict_mode() == SLOPPY || info()->strict_mode() == STRICT);
     ASSERT(info()->strict_mode() == shared_info->strict_mode());
     scope->SetStrictMode(shared_info->strict_mode());
     FunctionLiteral::FunctionType function_type = shared_info->is_expression()
         ? (shared_info->is_anonymous()
               ? FunctionLiteral::ANONYMOUS_EXPRESSION
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
+    FunctionParsingMode parsing_mode = shared_info->is_generator()

[rossberg, 2014/03/25 12:35:34]

Nit: I'd prefer formatting this like

FunctionParsingMode parsing_mode =
    shared_info->is_generator() ? kGeneratorFunction :
    shared_info->is_arrow() ? kArrowFunction : kNormalFunction;

+        ? kGeneratorFunction
+        : (shared_info->is_arrow() ? kArrowFunction : kNormalFunction);
     bool ok = true;
     result = ParseFunctionLiteral(name,
                                   Scanner::Location::invalid(),
                                   false,  // Strict mode name already checked.
-                                  shared_info->is_generator(),
+                                  parsing_mode,
+                                  EmptyExpression(),
                                   RelocInfo::kNoPosition,
                                   function_type,
                                   &ok);
     // Make sure the results agree.
     ASSERT(ok == (result != NULL));
   }
 
   // Make sure the target stack is empty.
   ASSERT(target_stack_ == NULL);
 
@@ skipping 828 matching lines @@
 
 
 Statement* Parser::ParseFunctionDeclaration(ZoneStringList* names, 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;
   Handle<String> name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
   FunctionLiteral* fun = ParseFunctionLiteral(name,
                                               scanner()->location(),
                                               is_strict_reserved,
-                                              is_generator,
+                                              parsing_mode,
+                                              EmptyExpression(),
                                               pos,
                                               FunctionLiteral::DECLARATION,
                                               CHECK_OK);
   // Even if we're not at the top-level of the global or a function
   // scope, we treat it as such and introduce the function with its
   // initial value upon entering the corresponding scope.
   // In extended mode, a function behaves as a lexical binding, except in the
   // global scope.
   VariableMode mode =
       FLAG_harmony_scoping &&
@@ skipping 1238 matching lines @@
   Smi* literal_type = Smi::cast(value->get(kLiteralTypeSlot));
   return static_cast<LiteralType>(literal_type->value());
 }
 
 
 Handle<FixedArray> CompileTimeValue::GetElements(Handle<FixedArray> value) {
   return Handle<FixedArray>(FixedArray::cast(value->get(kElementsSlot)));
 }
 
 
+Vector<VariableProxy*> Parser::ParameterListFromExpression(

[rossberg, 2014/03/25 12:35:34]

How does this rule out illegal parenthesis? For example, ((x)) or ((x, y)) would
seem to (incorrectly) parse as the parameter lists (x) and (x, y), wouldn't it?

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

True, this case is tricky to implement when re-interpreting an already-parsed
AST as a parameter list. Probably this is going to need some way of tracking
whether a parenthesized expression is inside another. I am going to add a 
TODO here for the moment.

+    Expression* expression, bool* ok) {
+  if (expression == NULL)

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

Normally having expression == NULL would be an error case; pls add a comment
here that this can actually happen in non-error cases. (Afaics it happens when
the argument list is empty.)

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

Yes, when the argument list is empty, “expression” is NULL. I will add
a comment about NULL being valid in this particular case.

+    return Vector<VariableProxy*>::empty();
+
+  Collector<VariableProxy*> collector;
+  while (expression->IsBinaryOperation()) {
+    BinaryOperation* binop = expression->AsBinaryOperation();
+
+    if (binop->op() != Token::COMMA) {
+      const char* token_name = Token::String(binop->op());
+      int pos = binop->position();
+      ParserTraits::ReportMessageAt(Scanner::Location(pos, pos),

[rossberg, 2014/03/25 12:35:34]

Can we refactor this a little to avoid all the error reporting code duplication?

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

Sure.

+                                    "unexpected_token",
+                                    Vector<const char*>(&token_name, 1));
+      *ok = false;
+      return Vector<VariableProxy*>::empty();
+    }
+
+    if (!binop->right()->IsVariableProxy()) {
+      const char* token_name = Token::String(binop->op());
+      int pos = binop->position();
+      ParserTraits::ReportMessageAt(Scanner::Location(pos, pos),
+                                    "unexpected_token",
+                                    Vector<const char*>(&token_name, 1));
+      *ok = false;
+      return Vector<VariableProxy*>::empty();
+    }
+
+    if (binop->right()->AsVariableProxy()->is_this()) {
+      const char* token_name = Token::String(Token::THIS);
+      int pos = binop->right()->position();
+      ParserTraits::ReportMessageAt(Scanner::Location(pos, pos + 4),
+                                    "unexpected_token",
+                                    Vector<const char*>(&token_name, 1));
+      *ok = false;
+      return Vector<VariableProxy*>::empty();
+    }
+
+    collector.Add(binop->right()->AsVariableProxy());
+    expression = binop->left();
+  }
+
+  if (!expression->IsVariableProxy()) {
+    int pos = expression->position();
+    ParserTraits::ReportMessageAt(Scanner::Location(pos, pos),
+                                  "unexpected_token",
+                                  Vector<const char*>());
+    *ok = false;
+    return Vector<VariableProxy*>::empty();
+  }
+
+  if (expression->AsVariableProxy()->is_this()) {
+    const char* token_name = Token::String(Token::THIS);
+    int pos = expression->position();
+    ParserTraits::ReportMessageAt(Scanner::Location(pos, pos + 4),
+                                  "unexpected_token",
+                                  Vector<const char*>(&token_name, 1));
+    *ok = false;
+    return Vector<VariableProxy*>::empty();
+  }
+
+  collector.Add(expression->AsVariableProxy());
+
+  return collector.ToVector();
+}
+
 FunctionLiteral* Parser::ParseFunctionLiteral(
     Handle<String> function_name,
     Scanner::Location function_name_location,
     bool name_is_strict_reserved,
-    bool is_generator,
+    FunctionParsingMode func_parsing_mode,
+    Expression* params_ast,
     int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
 
   int pos = function_token_pos == RelocInfo::kNoPosition
       ? peek_position() : function_token_pos;
 
   // Anonymous functions were passed either the empty symbol or a null
@@ skipping 45 matching lines @@
           : NewScope(scope_, FUNCTION_SCOPE);
   ZoneList<Statement*>* body = NULL;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   FunctionLiteral::ParameterFlag duplicate_parameters =
       FunctionLiteral::kNoDuplicateParameters;
   FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
       ? FunctionLiteral::kIsParenthesized
       : FunctionLiteral::kNotParenthesized;
-  FunctionLiteral::IsGeneratorFlag generator = is_generator
-      ? FunctionLiteral::kIsGenerator
-      : FunctionLiteral::kNotGenerator;
+  FunctionLiteral::IsGeneratorFlag generator =
+      (func_parsing_mode == kGeneratorFunction)
+        ? FunctionLiteral::kIsGenerator
+        : FunctionLiteral::kNotGenerator;
+  FunctionLiteral::IsArrowFlag arrow = (func_parsing_mode == kArrowFunction)
+      ? FunctionLiteral::kIsArrow
+      : FunctionLiteral::kNotArrow;
   DeferredFeedbackSlotProcessor* slot_processor;
   AstProperties ast_properties;
   BailoutReason dont_optimize_reason = kNoReason;
   // Parse function body.
   { FunctionState function_state(&function_state_, &scope_, scope, zone());
     scope_->SetScopeName(function_name);
 
-    if (is_generator) {
+    if (func_parsing_mode == kGeneratorFunction) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // expressions. This also marks the FunctionState as a generator.
       Variable* temp = scope_->DeclarationScope()->NewTemporary(
           isolate()->factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
-    //  FormalParameterList ::
-    //    '(' (Identifier)*[','] ')'
-    Expect(Token::LPAREN, CHECK_OK);
-    scope->set_start_position(scanner()->location().beg_pos);
-
     // 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_log = Scanner::Location::invalid();
     Scanner::Location dupe_error_loc = Scanner::Location::invalid();
     Scanner::Location reserved_loc = Scanner::Location::invalid();
 
-    bool done = (peek() == Token::RPAREN);
-    while (!done) {
-      bool is_strict_reserved = false;
-      Handle<String> param_name =
-          ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
-
-      // Store locations for possible future error reports.
-      if (!eval_args_error_log.IsValid() && IsEvalOrArguments(param_name)) {
-        eval_args_error_log = scanner()->location();
-      }
-      if (!reserved_loc.IsValid() && is_strict_reserved) {
-        reserved_loc = scanner()->location();
-      }
-      if (!dupe_error_loc.IsValid() && scope_->IsDeclared(param_name)) {
-        duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
-        dupe_error_loc = scanner()->location();
-      }
-
-      scope_->DeclareParameter(param_name, VAR);
-      num_parameters++;
-      if (num_parameters > Code::kMaxArguments) {
-        ReportMessageAt(scanner()->location(), "too_many_parameters");
+    //  FormalParameterList ::

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

This ParseFunctionLiteral is pretty monstrous as is, can it be split first
before adding another dimension for array funcs?

[rossberg, 2014/03/25 12:35:34]

+1. The arrow function case is parsing quite different syntax, so I'd rather
have it as a separate function. You can still factor out commonalities into
third functions (e.g. ParseFunctionParameterList, ParseFunctionBody, etc.).

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

I am in the process of moving parsing of arrow functions to a different
function, and trying to put it in ParserBase, which is making me having
to move/add some bits into the common parser stuff — IMHO this better for
new code than having to convert things later on.

+    //    '(' (Identifier)*[','] ')'
+
+    if (func_parsing_mode == kArrowFunction && peek() == Token::ARROW) {

[rossberg, 2014/03/25 12:35:34]

Can it ever happen that the first condition is true but the second isn't? Where
do you invoke ParseFunctionLiteral with kArrowFunction but have not parsed the
parameters yet?

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

It could happen when the function is parsed lazily: it is known in advance
that we would be parsing an arrow function (SharedFunctionInfo->is_arrow()
returns true), and we would start parsing at the start of the parameter list
(so peek() != Token::ARROW). Anyway, after moving arrow function parsing to
its own function this code will not be here anymore.

+      // The parameter list has already been scanned and turned into an AST
+      // and it is passed as "params_ast". Re-interpreting the AST avoids
+      // needing to rewind and re-parse the parameter list. The starting
+      // position of the parameter list is passed as "function_token_pos".
+      scope->set_start_position(function_token_pos);
+      Vector<VariableProxy*> params = ParameterListFromExpression(params_ast,
+                                                                  CHECK_OK);
+
+      if ((num_parameters = params.length()) > Code::kMaxArguments) {
+        ReportMessageAt(Scanner::Location(params_ast->position(), position()),
+                        "too_many_parameters");
         *ok = false;
         return NULL;
       }
-      done = (peek() == Token::RPAREN);
-      if (!done) Expect(Token::COMMA, CHECK_OK);
+
+      // The vector has the items in reverse order
+      for (int i = params.length() - 1; i >= 0; --i) {
+        Handle<String> param_name = params.at(i)->name();
+        int param_pos = params.at(i)->position();
+
+        if (!eval_args_error_log.IsValid() && IsEvalOrArguments(param_name)) {
+          eval_args_error_log =
+              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());
+          duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
+        }
+
+        scope_->DeclareParameter(param_name, VAR);
+      }
+    } else {
+      bool arrow_single_param =
+          (func_parsing_mode == kArrowFunction && peek() != Token::LPAREN);
+
+      if (!arrow_single_param) {
+        Expect(Token::LPAREN, CHECK_OK);
+      }
+
+      scope->set_start_position(scanner()->location().beg_pos);
+
+      bool done = (peek() == Token::RPAREN);
+      while (!done) {
+        bool is_strict_reserved = false;
+        Handle<String> param_name =
+            ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+
+        // Store locations for possible future error reports.
+        if (!eval_args_error_log.IsValid() && IsEvalOrArguments(param_name)) {
+          eval_args_error_log = scanner()->location();
+        }
+        if (!reserved_loc.IsValid() && is_strict_reserved) {
+          reserved_loc = scanner()->location();
+        }
+        if (!dupe_error_loc.IsValid() && scope_->IsDeclared(param_name)) {
+          duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
+          dupe_error_loc = scanner()->location();
+        }
+
+        scope_->DeclareParameter(param_name, VAR);
+        num_parameters++;
+        if (num_parameters > Code::kMaxArguments) {
+          ReportMessageAt(scanner()->location(), "too_many_parameters");
+          *ok = false;
+          return NULL;
+        }
+
+        done = (peek() == Token::RPAREN);
+        if (arrow_single_param) break;
+        if (!done) Expect(Token::COMMA, CHECK_OK);
+      }
+
+      if (!arrow_single_param) {
+        Expect(Token::RPAREN, CHECK_OK);
+      }
     }
-    Expect(Token::RPAREN, CHECK_OK);
-
-    Expect(Token::LBRACE, CHECK_OK);
-
-    // If we have a named function expression, we add a local variable
-    // declaration to the body of the function with the name of the
-    // function and let it refer to the function itself (closure).
-    // NOTE: We create a proxy and resolve it here so that in the
-    // future we can change the AST to only refer to VariableProxies
-    // instead of Variables and Proxis as is the case now.
-    Variable* fvar = NULL;
-    Token::Value fvar_init_op = Token::INIT_CONST_LEGACY;
-    if (function_type == FunctionLiteral::NAMED_EXPRESSION) {
-      if (FLAG_harmony_scoping && strict_mode() == STRICT) {
-        fvar_init_op = Token::INIT_CONST;
-      }
-      VariableMode fvar_mode = FLAG_harmony_scoping && strict_mode() == STRICT
-          ? CONST : CONST_LEGACY;
-      fvar = new(zone()) Variable(scope_,
-         function_name, fvar_mode, true /* is valid LHS */,
-         Variable::NORMAL, kCreatedInitialized, Interface::NewConst());
-      VariableProxy* proxy = factory()->NewVariableProxy(fvar);
-      VariableDeclaration* fvar_declaration = factory()->NewVariableDeclaration(
-          proxy, fvar_mode, scope_, RelocInfo::kNoPosition);
-      scope_->DeclareFunctionVar(fvar_declaration);
+
+    if (func_parsing_mode == kArrowFunction) {
+      Expect(Token::ARROW, CHECK_OK);
+
+      // The arrow function has a single-expression body
+      if (peek() != Token::LBRACE) {
+        int pos = position();
+        Expression* expression = ParseExpression(true, CHECK_OK);

[rossberg, 2014/03/25 12:35:34]

Shouldn't this be ParseAssignmentExpression?

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

Indeed.

+        body = new(zone()) ZoneList<Statement*>(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_end_position(scanner()->location().end_pos);
+      }
     }
 
-    // Determine if the function can be parsed lazily. Lazy parsing is different
-    // from lazy compilation; we need to parse more eagerly than we compile.
-
-    // We can only parse lazily if we also compile lazily. The heuristics for
-    // lazy compilation are:
-    // - It must not have been prohibited by the caller to Parse (some callers
-    //   need a full AST).
-    // - The outer scope must allow lazy compilation of inner functions.
-    // - The function mustn't be a function expression with an open parenthesis
-    //   before; we consider that a hint that the function will be called
-    //   immediately, and it would be a waste of time to make it lazily
-    //   compiled.
-    // These are all things we can know at this point, without looking at the
-    // function itself.
-
-    // In addition, we need to distinguish between these cases:
-    // (function foo() {
-    //   bar = function() { return 1; }
-    //  })();
-    // and
-    // (function foo() {
-    //   var a = 1;
-    //   bar = function() { return a; }
-    //  })();
-
-    // Now foo will be parsed eagerly and compiled eagerly (optimization: assume
-    // parenthesis before the function means that it will be called
-    // immediately). The inner function *must* be parsed eagerly to resolve the
-    // possible reference to the variable in foo's scope. However, it's possible
-    // that it will be compiled lazily.
-
-    // To make this additional case work, both Parser and PreParser implement a
-    // logic where only top-level functions will be parsed lazily.
-    bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
-                             scope_->AllowsLazyCompilation() &&
-                             !parenthesized_function_);
-    parenthesized_function_ = false;  // The bit was set for this function only.
-
-    if (is_lazily_parsed) {
-      int function_block_pos = position();
-      FunctionEntry entry;
-      if (cached_data_mode_ == CONSUME_CACHED_DATA) {
-        // If we have cached data, we use it to skip parsing the function body.
-        // The data contains the information we need to construct the lazy
-        // function.
-        entry = (*cached_data())->GetFunctionEntry(function_block_pos);
-        if (entry.is_valid()) {
-          if (entry.end_pos() <= function_block_pos) {
-            // End position greater than end of stream is safe, and hard
-            // to check.
-            ReportInvalidPreparseData(function_name, CHECK_OK);
+    // If an arrow function has a single-expression body,
+    // it was already parsed above and "body" is non-NULL.
+    if (body == NULL) {
+      Expect(Token::LBRACE, CHECK_OK);
+
+      // If we have a named function expression, we add a local variable
+      // declaration to the body of the function with the name of the
+      // function and let it refer to the function itself (closure).
+      // NOTE: We create a proxy and resolve it here so that in the
+      // future we can change the AST to only refer to VariableProxies
+      // instead of Variables and Proxis as is the case now.
+      Variable* fvar = NULL;
+      Token::Value fvar_init_op = Token::INIT_CONST_LEGACY;
+      if (function_type == FunctionLiteral::NAMED_EXPRESSION) {
+        if (FLAG_harmony_scoping && strict_mode() == STRICT) {
+          fvar_init_op = Token::INIT_CONST;
+        }
+        VariableMode fvar_mode = FLAG_harmony_scoping && strict_mode() == STRICT
+            ? CONST : CONST_LEGACY;
+        fvar = new(zone()) Variable(scope_,
+           function_name, fvar_mode, true /* is valid LHS */,
+           Variable::NORMAL, kCreatedInitialized, Interface::NewConst());
+        VariableProxy* proxy = factory()->NewVariableProxy(fvar);
+        VariableDeclaration* fvar_declaration =
+            factory()->NewVariableDeclaration(proxy, fvar_mode, scope_,
+                                              RelocInfo::kNoPosition);
+        scope_->DeclareFunctionVar(fvar_declaration);
+      }
+
+      // Determine if the function can be parsed lazily. Lazy parsing is
+      // different from lazy compilation; we need to parse more eagerly than
+      // we compile.
+
+      // We can only parse lazily if we also compile lazily. The heuristics for
+      // lazy compilation are:
+      // - It must not have been prohibited by the caller to Parse (some
+      //   callers need a full AST).
+      // - The outer scope must allow lazy compilation of inner functions.
+      // - The function mustn't be a function expression with an open
+      //   parenthesis before; we consider that a hint that the function will
+      //   be called immediately, and it would be a waste of time to make it
+      //   lazily compiled.
+      // These are all things we can know at this point, without looking at
+      // the function itself.
+
+      // In addition, we need to distinguish between these cases:
+      // (function foo() {
+      //   bar = function() { return 1; }
+      //  })();
+      // and
+      // (function foo() {
+      //   var a = 1;
+      //   bar = function() { return a; }
+      //  })();
+
+      // Now foo will be parsed eagerly and compiled eagerly (optimization:
+      // assume parenthesis before the function means that it will be called
+      // immediately). The inner function *must* be parsed eagerly to resolve
+      // the possible reference to the variable in foo's scope. However, it's
+      // possible that it will be compiled lazily.
+
+      // To make this additional case work, both Parser and PreParser implement
+      // a logic where only top-level functions will be parsed lazily.
+      bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
+                               scope_->AllowsLazyCompilation() &&
+                               !parenthesized_function_ &&
+                               (func_parsing_mode != kArrowFunction));
+
+      // The bit was set for this function only.
+      parenthesized_function_ = false;
+
+      if (is_lazily_parsed) {
+        int function_block_pos = position();
+        FunctionEntry entry;
+        if (cached_data_mode_ == CONSUME_CACHED_DATA) {
+          // If we have cached data, we use it to skip parsing the function
+          // body. The data contains the information we need to construct the
+          // lazy function.
+          entry = (*cached_data())->GetFunctionEntry(function_block_pos);
+          if (entry.is_valid()) {
+            if (entry.end_pos() <= function_block_pos) {
+              // End position greater than end of stream is safe, and hard
+              // to check.
+              ReportInvalidPreparseData(function_name, CHECK_OK);
+            }
+            scanner()->SeekForward(entry.end_pos() - 1);
+
+            scope->set_end_position(entry.end_pos());
+            Expect(Token::RBRACE, CHECK_OK);
+            isolate()->counters()->total_preparse_skipped()->Increment(
+                scope->end_position() - function_block_pos);
+            materialized_literal_count = entry.literal_count();
+            expected_property_count = entry.property_count();
+            scope_->SetStrictMode(entry.strict_mode());
+          } else {
+            // This case happens when we have preparse data but it doesn't
+            // contain an entry for the function. As a safety net, fall back
+            // to eager parsing. It is unclear whether PreParser's laziness
+            // analysis can produce different results than the Parser's
+            // laziness analysis (see https://codereview.chromium.org/7565003).
+            // In this case, we must discard all the preparse data, since the
+            // symbol data will be wrong.
+            is_lazily_parsed = false;
+            cached_data_mode_ = NO_CACHED_DATA;
           }
-          scanner()->SeekForward(entry.end_pos() - 1);
-
-          scope->set_end_position(entry.end_pos());
+        } else {
+          // With no cached data, we partially parse the function, without
+          // building an AST. This gathers the data needed to build a lazy
+          // function.
+          // FIXME(marja): Now the PreParser doesn't need to log functions /
+          // symbols; only errors -> clean that up.
+          SingletonLogger logger;
+          PreParser::PreParseResult result = LazyParseFunctionLiteral(&logger);
+          if (result == PreParser::kPreParseStackOverflow) {
+            // Propagate stack overflow.
+            set_stack_overflow();
+            *ok = false;
+            return NULL;
+          }
+          if (logger.has_error()) {
+            const char* arg = logger.argument_opt();
+            Vector<const char*> args;
+            if (arg != NULL) {
+              args = Vector<const char*>(&arg, 1);
+            }
+            ParserTraits::ReportMessageAt(
+                Scanner::Location(logger.start(), logger.end()),
+                logger.message(),
+                args);
+            *ok = false;
+            return NULL;
+          }
+          scope->set_end_position(logger.end());
           Expect(Token::RBRACE, CHECK_OK);
           isolate()->counters()->total_preparse_skipped()->Increment(
               scope->end_position() - function_block_pos);
-          materialized_literal_count = entry.literal_count();
-          expected_property_count = entry.property_count();
-          scope_->SetStrictMode(entry.strict_mode());
-        } else {
-          // This case happens when we have preparse data but it doesn't contain
-          // an entry for the function. As a safety net, fall back to eager
-          // parsing. It is unclear whether PreParser's laziness analysis can
-          // produce different results than the Parser's laziness analysis (see
-          // https://codereview.chromium.org/7565003 ). In this case, we must
-          // discard all the preparse data, since the symbol data will be wrong.
-          is_lazily_parsed = false;
-          cached_data_mode_ = NO_CACHED_DATA;
-        }
-      } else {
-        // With no cached data, we partially parse the function, without
-        // building an AST. This gathers the data needed to build a lazy
-        // function.
-        // FIXME(marja): Now the PreParser doesn't need to log functions /
-        // symbols; only errors -> clean that up.
-        SingletonLogger logger;
-        PreParser::PreParseResult result = LazyParseFunctionLiteral(&logger);
-        if (result == PreParser::kPreParseStackOverflow) {
-          // Propagate stack overflow.
-          set_stack_overflow();
-          *ok = false;
-          return NULL;
-        }
-        if (logger.has_error()) {
-          const char* arg = logger.argument_opt();
-          Vector<const char*> args;
-          if (arg != NULL) {
-            args = Vector<const char*>(&arg, 1);
+          materialized_literal_count = logger.literals();
+          expected_property_count = logger.properties();
+          scope_->SetStrictMode(logger.strict_mode());
+          if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
+            ASSERT(log_);
+            // Position right after terminal '}'.
+            int body_end = scanner()->location().end_pos;
+            log_->LogFunction(function_block_pos, body_end,
+                              materialized_literal_count,
+                              expected_property_count,
+                              scope_->strict_mode());
           }
-          ParserTraits::ReportMessageAt(
-              Scanner::Location(logger.start(), logger.end()),
-              logger.message(),
-              args);
-          *ok = false;
-          return NULL;
-        }
-        scope->set_end_position(logger.end());
+        }
+      }
+
+      if (!is_lazily_parsed) {
+        // Everything inside an eagerly parsed function will be parsed eagerly
+        // (see comment above).
+        ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
+        body = new(zone()) ZoneList<Statement*>(8, zone());
+        if (fvar != NULL) {
+          VariableProxy* fproxy = scope_->NewUnresolved(
+              factory(), function_name, Interface::NewConst());
+          fproxy->BindTo(fvar);
+          body->Add(factory()->NewExpressionStatement(
+              factory()->NewAssignment(fvar_init_op,
+                                       fproxy,
+                                       factory()->NewThisFunction(pos),
+                                       RelocInfo::kNoPosition),
+              RelocInfo::kNoPosition), zone());
+        }
+
+        // For generators, allocate and yield an iterator on function entry.
+        if (func_parsing_mode == kGeneratorFunction) {
+          ZoneList<Expression*>* arguments =
+              new(zone()) ZoneList<Expression*>(0, zone());
+          CallRuntime* allocation = factory()->NewCallRuntime(
+              isolate()->factory()->empty_string(),
+              Runtime::FunctionForId(Runtime::kCreateJSGeneratorObject),
+              arguments, pos);
+          VariableProxy* init_proxy = factory()->NewVariableProxy(
+              function_state_->generator_object_variable());
+          Assignment* assignment = factory()->NewAssignment(
+              Token::INIT_VAR, init_proxy, allocation, RelocInfo::kNoPosition);
+          VariableProxy* get_proxy = factory()->NewVariableProxy(
+              function_state_->generator_object_variable());
+          Yield* yield = factory()->NewYield(
+              get_proxy, assignment, Yield::INITIAL, RelocInfo::kNoPosition);
+          body->Add(factory()->NewExpressionStatement(
+              yield, RelocInfo::kNoPosition), zone());
+        }
+
+        ParseSourceElements(body, Token::RBRACE, false, false, CHECK_OK);
+
+        if (func_parsing_mode == kGeneratorFunction) {
+          VariableProxy* get_proxy = factory()->NewVariableProxy(
+              function_state_->generator_object_variable());
+          Expression *undefined = factory()->NewLiteral(
+              isolate()->factory()->undefined_value(), RelocInfo::kNoPosition);
+          Yield* yield = factory()->NewYield(
+              get_proxy, undefined, Yield::FINAL, RelocInfo::kNoPosition);
+          body->Add(factory()->NewExpressionStatement(
+              yield, RelocInfo::kNoPosition), zone());
+        }
+
+        materialized_literal_count =
+            function_state.materialized_literal_count();
+        expected_property_count = function_state.expected_property_count();
+        handler_count = function_state.handler_count();
+
         Expect(Token::RBRACE, CHECK_OK);
-        isolate()->counters()->total_preparse_skipped()->Increment(
-            scope->end_position() - function_block_pos);
-        materialized_literal_count = logger.literals();
-        expected_property_count = logger.properties();
-        scope_->SetStrictMode(logger.strict_mode());
-        if (cached_data_mode_ == PRODUCE_CACHED_DATA) {
-          ASSERT(log_);
-          // Position right after terminal '}'.
-          int body_end = scanner()->location().end_pos;
-          log_->LogFunction(function_block_pos, body_end,
-                            materialized_literal_count,
-                            expected_property_count,
-                            scope_->strict_mode());
-        }
-      }
-    }
-
-    if (!is_lazily_parsed) {
-      // Everything inside an eagerly parsed function will be parsed eagerly
-      // (see comment above).
-      ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
-      body = new(zone()) ZoneList<Statement*>(8, zone());
-      if (fvar != NULL) {
-        VariableProxy* fproxy = scope_->NewUnresolved(
-            factory(), function_name, Interface::NewConst());
-        fproxy->BindTo(fvar);
-        body->Add(factory()->NewExpressionStatement(
-            factory()->NewAssignment(fvar_init_op,
-                                     fproxy,
-                                     factory()->NewThisFunction(pos),
-                                     RelocInfo::kNoPosition),
-            RelocInfo::kNoPosition), zone());
-      }
-
-      // For generators, allocate and yield an iterator on function entry.
-      if (is_generator) {
-        ZoneList<Expression*>* arguments =
-            new(zone()) ZoneList<Expression*>(0, zone());
-        CallRuntime* allocation = factory()->NewCallRuntime(
-            isolate()->factory()->empty_string(),
-            Runtime::FunctionForId(Runtime::kCreateJSGeneratorObject),
-            arguments, pos);
-        VariableProxy* init_proxy = factory()->NewVariableProxy(
-            function_state_->generator_object_variable());
-        Assignment* assignment = factory()->NewAssignment(
-            Token::INIT_VAR, init_proxy, allocation, RelocInfo::kNoPosition);
-        VariableProxy* get_proxy = factory()->NewVariableProxy(
-            function_state_->generator_object_variable());
-        Yield* yield = factory()->NewYield(
-            get_proxy, assignment, Yield::INITIAL, RelocInfo::kNoPosition);
-        body->Add(factory()->NewExpressionStatement(
-            yield, RelocInfo::kNoPosition), zone());
-      }
-
-      ParseSourceElements(body, Token::RBRACE, false, false, CHECK_OK);
-
-      if (is_generator) {
-        VariableProxy* get_proxy = factory()->NewVariableProxy(
-            function_state_->generator_object_variable());
-        Expression *undefined = factory()->NewLiteral(
-            isolate()->factory()->undefined_value(), RelocInfo::kNoPosition);
-        Yield* yield = factory()->NewYield(
-            get_proxy, undefined, Yield::FINAL, RelocInfo::kNoPosition);
-        body->Add(factory()->NewExpressionStatement(
-            yield, RelocInfo::kNoPosition), zone());
-      }
-
-      materialized_literal_count = function_state.materialized_literal_count();
-      expected_property_count = function_state.expected_property_count();
-      handler_count = function_state.handler_count();
-
-      Expect(Token::RBRACE, CHECK_OK);
-      scope->set_end_position(scanner()->location().end_pos);
+        scope->set_end_position(scanner()->location().end_pos);
+      }
     }
 
     // Validate strict mode. We can do this only after parsing the function,
     // since the function can declare itself strict.
     if (strict_mode() == STRICT) {
       if (IsEvalOrArguments(function_name)) {
         ReportMessageAt(function_name_location, "strict_eval_arguments");
         *ok = false;
         return NULL;
       }
@@ skipping 36 matching lines @@
                                     body,
                                     materialized_literal_count,
                                     expected_property_count,
                                     handler_count,
                                     num_parameters,
                                     duplicate_parameters,
                                     function_type,
                                     FunctionLiteral::kIsFunction,
                                     parenthesized,
                                     generator,
+                                    arrow,
                                     pos);
   function_literal->set_function_token_position(function_token_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_slot_processor(slot_processor);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
 
 
 PreParser::PreParseResult Parser::LazyParseFunctionLiteral(
     SingletonLogger* logger) {
   HistogramTimerScope preparse_scope(isolate()->counters()->pre_parse());
   ASSERT_EQ(Token::LBRACE, scanner()->current_token());
 
   if (reusable_preparser_ == NULL) {
     intptr_t stack_limit = isolate()->stack_guard()->real_climit();
     reusable_preparser_ = new PreParser(&scanner_, NULL, stack_limit);
     reusable_preparser_->set_allow_harmony_scoping(allow_harmony_scoping());
     reusable_preparser_->set_allow_modules(allow_modules());
     reusable_preparser_->set_allow_natives_syntax(allow_natives_syntax());
     reusable_preparser_->set_allow_lazy(true);
     reusable_preparser_->set_allow_generators(allow_generators());
     reusable_preparser_->set_allow_for_of(allow_for_of());
+    reusable_preparser_->set_allow_arrow_functions(allow_arrow_functions());
     reusable_preparser_->set_allow_harmony_numeric_literals(
         allow_harmony_numeric_literals());
   }
   PreParser::PreParseResult result =
       reusable_preparser_->PreParseLazyFunction(strict_mode(),
                                                 is_generator(),
                                                 logger);
   return result;
 }
 
@@ skipping 1064 matching lines @@
 ScriptDataImpl* PreParserApi::PreParse(Isolate* isolate,
                                        Utf16CharacterStream* source) {
   CompleteParserRecorder recorder;
   HistogramTimerScope timer(isolate->counters()->pre_parse());
   Scanner scanner(isolate->unicode_cache());
   intptr_t stack_limit = isolate->stack_guard()->real_climit();
   PreParser preparser(&scanner, &recorder, stack_limit);
   preparser.set_allow_lazy(true);
   preparser.set_allow_generators(FLAG_harmony_generators);
   preparser.set_allow_for_of(FLAG_harmony_iteration);
+  preparser.set_allow_arrow_functions(FLAG_harmony_arrow_functions);
   preparser.set_allow_harmony_scoping(FLAG_harmony_scoping);
   preparser.set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
   scanner.Initialize(source);
   PreParser::PreParseResult result = preparser.PreParseProgram();
   if (result == PreParser::kPreParseStackOverflow) {
     isolate->StackOverflow();
     return NULL;
   }
 
   // Extract the accumulated data from the recorder as a single
@@ skipping 53 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal