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 739 matching lines @@
 
 
 Handle<String> ParserTraits::NextLiteralString(Scanner* scanner,
                                                PretenureFlag tenured) {
   return scanner->AllocateNextLiteralString(parser_->isolate(), tenured);
 }
 
 
 Expression* ParserTraits::ThisExpression(
     Scope* scope,
-    AstNodeFactory<AstConstructionVisitor>* factory) {
-  return factory->NewVariableProxy(scope->receiver());
+    AstNodeFactory<AstConstructionVisitor>* factory,
+    int pos) {
+  return factory->NewVariableProxy(scope->receiver(), pos);
 }
 
 
 Literal* ParserTraits::ExpressionFromLiteral(
     Token::Value token, int pos,
     Scanner* scanner,
     AstNodeFactory<AstConstructionVisitor>* factory) {
   Factory* isolate_factory = parser_->isolate()->factory();
   switch (token) {
     case Token::NULL_LITERAL:
@@ skipping 80 matching lines @@
       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;
+    bool is_generator = shared_info->is_generator();
     bool ok = true;
-    result = ParseFunctionLiteral(name,
-                                  Scanner::Location::invalid(),
-                                  false,  // Strict mode name already checked.
-                                  shared_info->is_generator(),
-                                  RelocInfo::kNoPosition,
-                                  function_type,
-                                  &ok);
+
+    if (shared_info->is_arrow()) {
+      ASSERT(!is_generator);
+      result = reinterpret_cast<FunctionLiteral*>(
+          ParseArrowFunctionLiteral(shared_info->start_position(), NULL, &ok));
+    } else {
+      result = ParseFunctionLiteral(name,
+                                    Scanner::Location::invalid(),
+                                    false,  // Strict mode name already checked.
+                                    is_generator,
+                                    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);
 
   if (result == NULL) {
     if (stack_overflow()) isolate()->StackOverflow();
   } else {
@@ skipping 2081 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*> ParserTraits::ParameterListFromExpression(

[marja, 2014/04/24 08:08:06]

It looks like this doesn't check that the expression is parenthesized, so this
would accept foo, bar => { baz }. You should add tests for such cases in the
style of test-parsing.cc.

[aperez, 2014/04/24 12:38:37]

The example you mention would be a comma-expression with two items, and it
is a valid expression, equivalent to:

  foo, (bar  => { baz })
  (foo, bar => { baz })
  (foo, (bar => { baz }))

So the case you mention is valid syntax, and it is already handled by the
grammar because comma has more precedence than expressions, and an arrow
function is an expression (the whole arrrow function, including the
parameter list).

There is no need to check for those cases here, because the input up
to the comma has already been parsed as a comma-expression when the
ParseArrowFunction() function is called.

[marja, 2014/04/29 09:38:44]

Hmm, okay. It would be good to add test cases to make sure these expressions are
interpreted correctly.

+    Expression* expression, bool* ok) {
+
+  // Parsing the parameter list of an arrow function does not have parameters
+  // (as in: () => ...) returns NULL, so expression being NULL is not an error,
+  // but an valid empty parameter list.
+  if (expression == NULL)
+    return Vector<VariableProxy*>::empty();
+
+  const char* error_token = Token::String(Token::THIS);
+  int error_pos = RelocInfo::kNoPosition;
+
+  Collector<VariableProxy*> collector;
+  while (expression->IsBinaryOperation()) {
+    BinaryOperation* binop = expression->AsBinaryOperation();
+
+    if (binop->op() != Token::COMMA) {
+      error_token = Token::String(expression->AsBinaryOperation()->op());
+      goto invalid_token;

[marja, 2014/04/24 08:08:06]

Afaics, it would be possible to write this in a goto-less way; just set some
error condition and break from the while loop, after the loop, check the error
conditions.

[aperez, 2014/04/24 12:38:37]

Sure thing, I will do that. The function will not be as terse, though.

+    }
+
+    expression = binop->right();
+    if (!expression->IsVariableProxy())
+      goto not_variable_proxy;
+    if (expression->AsVariableProxy()->is_this())
+      goto invalid_token;
+
+    collector.Add(expression->AsVariableProxy());
+    expression = binop->left();
+  }
+
+  if (!expression->IsVariableProxy())
+    goto not_variable_proxy;
+  if (expression->AsVariableProxy()->is_this())
+    goto invalid_token;
+
+  collector.Add(expression->AsVariableProxy());
+  return collector.ToVector();
+
+ not_variable_proxy:
+  error_token = "";
+  // fall-through
+ invalid_token:
+  error_pos = expression->position();
+  ParserTraits::ReportMessageAt(
+      Scanner::Location(error_pos, error_pos + strlen(error_token)),
+      "unexpected_token",
+      Vector<const char*>(&error_token, *error_token ? 1 : 0));
+  *ok = false;
+  return Vector<VariableProxy*>::empty();
+}
+
+
 FunctionLiteral* Parser::ParseFunctionLiteral(
     Handle<String> function_name,
     Scanner::Location function_name_location,
     bool name_is_strict_reserved,
     bool is_generator,
     int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
@@ skipping 245 matching lines @@
                                     body,
                                     materialized_literal_count,
                                     expected_property_count,
                                     handler_count,
                                     num_parameters,
                                     duplicate_parameters,
                                     function_type,
                                     FunctionLiteral::kIsFunction,
                                     parenthesized,
                                     generator,
+                                    FunctionLiteral::kNotArrow,
                                     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;
 }
 
@@ skipping 147 matching lines @@
 
   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 1060 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal