Implement basic code generation for arrow functions

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 992 matching lines @@
   }
   PreParserExpression NewFunctionLiteral(
       PreParserIdentifier name, AstValueFactory* ast_value_factory,
       const 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) {
+      FunctionLiteral::KindFlag kind, int position) {
     return PreParserExpression::Default();
   }
 
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   BailoutReason dont_optimize_reason() { return kNoReason; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
@@ skipping 81 matching lines @@
   // 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 576 matching lines @@
     case Token::LBRACE:
       result = this->ParseObjectLiteral(CHECK_OK);
       break;
 
     case Token::LPAREN:
       Consume(Token::LPAREN);
       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);
+        result = 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->increase_parenthesization_level();
         Expect(Token::RPAREN, CHECK_OK);
       }
       break;
 
@@ skipping 273 matching lines @@
   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 (allow_arrow_functions() && peek() == Token::ARROW) {
+    expression = this->ParseArrowFunctionLiteral(lhs_location.beg_pos,
+                                                 expression, CHECK_OK);
+    return expression;
+  }
 
   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->MarkExpressionAsAssigned(expression);
@@ skipping 450 matching lines @@
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::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) {
+  typename Traits::Type::StatementList body;
+  typename Traits::Type::AstProperties ast_properties;
+  BailoutReason dont_optimize_reason = kNoReason;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
+  int handler_count = 0;
 
   Expect(Token::ARROW, CHECK_OK);
 
   if (peek() == Token::LBRACE) {
     // Multiple statemente body
     Consume(Token::LBRACE);
     bool is_lazily_parsed =
         (mode() == PARSE_LAZILY && scope_->AllowsLazyCompilation());
     if (is_lazily_parsed) {
+      body = this->NewStatementList(0, zone());
       this->SkipLazyFunctionBody(this->EmptyIdentifier(),
                                  &materialized_literal_count,
                                  &expected_property_count, CHECK_OK);
     } else {
-      this->ParseEagerFunctionBody(this->EmptyIdentifier(),
-                                   RelocInfo::kNoPosition, NULL,
-                                   Token::INIT_VAR, false,  // Not a generator.
-                                   CHECK_OK);
+      body = this->ParseEagerFunctionBody(
+          this->EmptyIdentifier(), RelocInfo::kNoPosition, NULL,
+          Token::INIT_VAR, false,  // Not a generator.
+          CHECK_OK);
+      materialized_literal_count = function_state->materialized_literal_count();
+      expected_property_count = function_state->expected_property_count();
+      handler_count = function_state->handler_count();
     }
   } else {
     // Single-expression body
-    ParseAssignmentExpression(true, CHECK_OK);
+    int pos = position();
+    parenthesized_function_ = false;
+    ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
+    body = this->NewStatementList(1, zone());
+    body->Add(factory()->NewReturnStatement(expression, pos), zone());
+    materialized_literal_count = function_state->materialized_literal_count();
+    expected_property_count = function_state->expected_property_count();
+    handler_count = function_state->handler_count();
   }
 
   scope->set_start_position(start_pos);
   scope->set_end_position(scanner()->location().end_pos);
 
   // Arrow function *parameter lists* are always checked as in strict mode.
   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);
 
-  // TODO(aperez): Generate a proper FunctionLiteral instead of
-  // returning a dummy value.
+  ast_properties = *factory()->visitor()->ast_properties();
+  dont_optimize_reason = factory()->visitor()->dont_optimize_reason();
+
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
-      this->EmptyIdentifierString(), this->ast_value_factory(), scope,
-      this->NewStatementList(0, zone()), 0, 0, 0, num_parameters,
-      FunctionLiteral::kNoDuplicateParameters,
+      this->EmptyIdentifierString(), this->ast_value_factory(), scope, body,
+      materialized_literal_count, expected_property_count, handler_count,
+      num_parameters, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
-      FunctionLiteral::kNotParenthesized, FunctionLiteral::kNotGenerator,
-      start_pos);
+      parenthesized, FunctionLiteral::kArrowFunction, start_pos);
+
   function_literal->set_function_token_position(start_pos);
+  function_literal->set_ast_properties(&ast_properties);
+  function_literal->set_dont_optimize_reason(dont_optimize_reason);
+
+  if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
+
   return function_literal;
 }
 
 
 template <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) &&
@@ skipping 47 matching lines @@
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H