[es6] support rest parameters in 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/bailout-reason.h"
@@ skipping 320 matching lines @@
   bool stack_overflow() const { return stack_overflow_; }
   void set_stack_overflow() { stack_overflow_ = true; }
   Mode mode() const { return mode_; }
   Zone* zone() const { return zone_; }
 
   INLINE(Token::Value peek()) {
     if (stack_overflow_) return Token::ILLEGAL;
     return scanner()->peek();
   }
 
+  INLINE(Token::Value peek(int n)) {
+    if (stack_overflow_) return Token::ILLEGAL;
+    return scanner()->peek(n);
+  }
+
   INLINE(Token::Value Next()) {
     if (stack_overflow_) return Token::ILLEGAL;
     {
       if (GetCurrentStackPosition() < stack_limit_) {
         // Any further calls to Next or peek will return the illegal token.
         // The current call must return the next token, which might already
         // have been peek'ed.
         stack_overflow_ = true;
       }
     }
     return scanner()->Next();
   }
 
+  void PeekScan(int until);
+
   void Consume(Token::Value token) {
     Token::Value next = Next();
     USE(next);
     USE(token);
     DCHECK(next == token);
   }
 
   bool Check(Token::Value token) {
     Token::Value next = peek();
     if (next == token) {
@@ skipping 168 matching lines @@
     Traits::ReportMessageAt(source_location, message, arg, error_type);
   }
 
   void ReportMessageAt(Scanner::Location location, const char* message,
                        ParseErrorType error_type = kSyntaxError) {
     Traits::ReportMessageAt(location, message, reinterpret_cast<const char*>(0),
                             error_type);
   }
 
   void ReportUnexpectedToken(Token::Value token);
+  void ReportUnexpectedTokenAt(Scanner::Location location, Token::Value token);
 
   // Recursive descent functions:
 
   // Parses an identifier that is valid for the current scope, in particular it
   // fails on strict mode future reserved keywords in a strict scope. If
   // allow_eval_or_arguments is kAllowEvalOrArguments, we allow "eval" or
   // "arguments" as identifier even in strict mode (this is needed in cases like
   // "var foo = eval;").
   IdentifierT ParseIdentifier(
       AllowEvalOrArgumentsAsIdentifier,
@@ skipping 224 matching lines @@
  public:
   static PreParserExpression Default() {
     return PreParserExpression(TypeField::encode(kExpression));
   }
 
   static PreParserExpression FromIdentifier(PreParserIdentifier id) {
     return PreParserExpression(TypeField::encode(kIdentifierExpression) |
                                IdentifierTypeField::encode(id.type_));
   }
 
+  static PreParserExpression SpreadOperation(PreParserExpression expr) {
+    return PreParserExpression(TypeField::encode(
+        kSpreadExpression) | expr.code_);
+  }
+
   static PreParserExpression BinaryOperation(PreParserExpression left,
                                              Token::Value op,
                                              PreParserExpression right) {
     bool valid_arrow_param_list =
         op == Token::COMMA && !left.is_parenthesized() &&
         !right.is_parenthesized() && left.IsValidArrowParams() &&
         right.IsValidArrowParams();
     return PreParserExpression(
         TypeField::encode(kBinaryOperationExpression) |
         IsValidArrowParamListField::encode(valid_arrow_param_list));
@@ skipping 94 matching lines @@
   bool IsValidReferenceExpression() const {
     return IsIdentifier() || IsProperty();
   }
 
   bool IsValidArrowParamList() const {
     return IsValidArrowParams() &&
            ParenthesizationField::decode(code_) !=
                kMultiParenthesizedExpression;
   }
 
+  bool IsSpreadOperation() const {
+    return TypeField::decode(code_) & kSpreadExpression;

[marja, 2015/03/10 09:11:19]

Hmm... so this works because kSpreadExpression happens to be 4 (which is a
single bit), right? But it's fragile and wouldn't work if somebody reorders the
Type enum...

+  }
+
+  PreParserExpression SpreadExpression() const {
+    DCHECK(IsSpreadOperation());
+    return PreParserExpression(TypeField::decode(code_) & ~kSpreadExpression);
+  }
+
   // At the moment PreParser doesn't track these expression types.
   bool IsFunctionLiteral() const { return false; }
   bool IsCallNew() const { return false; }
 
   bool IsNoTemplateTag() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kNoTemplateTagExpression;
   }
 
   PreParserExpression AsFunctionLiteral() { return *this; }
@@ skipping 21 matching lines @@
   void set_parenthesized() {}
 
   int position() const { return RelocInfo::kNoPosition; }
   void set_function_token_position(int position) {}
 
  private:
   enum Type {
     kExpression,
     kIdentifierExpression,
     kStringLiteralExpression,
-    kBinaryOperationExpression
+    kBinaryOperationExpression,
+    kSpreadExpression

[marja, 2015/03/10 09:11:19]

So maybe add "= 1 << 3 " here to hint that kSpreadExpression needs to be a
single-bit thing.

   };
 
   enum Parenthesization {
     kNotParenthesized,
     kParanthesizedExpression,
     kMultiParenthesizedExpression
   };
 
   enum ExpressionType {

[marja, 2015/03/10 09:11:19]

(Huh, why do we have Type and ExpressionType? Urgh. Seems to be coming from
https://codereview.chromium.org/422363002 .)

     kThisExpression,
     kThisPropertyExpression,
     kPropertyExpression,
     kCallExpression,
     kNoTemplateTagExpression
   };
 
   explicit PreParserExpression(uint32_t expression_code)
       : code_(expression_code) {}
 
   V8_INLINE bool IsValidArrowParams() const {
+    if (IsSpreadOperation()) {
+      return SpreadExpression().IsValidArrowParams();
+    }
     return IsBinaryOperation()
                ? IsValidArrowParamListField::decode(code_)
                : (IsIdentifier() && AsIdentifier().IsValidArrowParam());
   }
 
   // The first four bits are for the Type and Parenthesization.
-  typedef BitField<Type, 0, 2> TypeField;
+  typedef BitField<Type, 0, 3> TypeField;
   typedef BitField<Parenthesization, TypeField::kNext, 2> ParenthesizationField;
 
   // The rest of the bits are interpreted depending on the value
   // of the Type field, so they can share the storage.
   typedef BitField<ExpressionType, ParenthesizationField::kNext, 3>
       ExpressionTypeField;
   typedef BitField<bool, ParenthesizationField::kNext, 1> IsUseStrictField;
   typedef BitField<bool, IsUseStrictField::kNext, 1> IsUseStrongField;
   typedef BitField<bool, ParenthesizationField::kNext, 1>
       IsValidArrowParamListField;
@@ skipping 195 matching lines @@
       PreParserIdentifier name, AstValueFactory* ast_value_factory,
       Scope* 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, FunctionKind kind,
       int position) {
     return PreParserExpression::Default();
   }
+  PreParserExpression NewSpreadOperation(PreParserExpression expr, int pos) {
+    return PreParserExpression::SpreadOperation(expr);
+  }
 
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
   }
 };
 
@@ skipping 481 matching lines @@
 
 template <class Traits>
 ParserBase<Traits>::FunctionState::~FunctionState() {
   *scope_stack_ = outer_scope_;
   *function_state_stack_ = outer_function_state_;
 }
 
 
 template<class Traits>
 void ParserBase<Traits>::ReportUnexpectedToken(Token::Value token) {
-  Scanner::Location source_location = scanner()->location();
+  return ReportUnexpectedTokenAt(scanner()->location(), token);
+}
 
+
+template <class Traits>
+void ParserBase<Traits>::ReportUnexpectedTokenAt(Scanner::Location location,
+                                                 Token::Value token) {
   // Four of the tokens are treated specially
   switch (token) {
     case Token::EOS:
-      return ReportMessageAt(source_location, "unexpected_eos");
+      return ReportMessageAt(location, "unexpected_eos");
     case Token::SMI:
     case Token::NUMBER:
-      return ReportMessageAt(source_location, "unexpected_token_number");
+      return ReportMessageAt(location, "unexpected_token_number");
     case Token::STRING:
-      return ReportMessageAt(source_location, "unexpected_token_string");
+      return ReportMessageAt(location, "unexpected_token_string");
     case Token::IDENTIFIER:
-      return ReportMessageAt(source_location, "unexpected_token_identifier");
+      return ReportMessageAt(location, "unexpected_token_identifier");
     case Token::FUTURE_RESERVED_WORD:
-      return ReportMessageAt(source_location, "unexpected_reserved");
+      return ReportMessageAt(location, "unexpected_reserved");
     case Token::LET:
     case Token::STATIC:
     case Token::YIELD:
     case Token::FUTURE_STRICT_RESERVED_WORD:
-      return ReportMessageAt(source_location,
-                             is_strict(language_mode())
-                                 ? "unexpected_strict_reserved"
-                                 : "unexpected_token_identifier");
+      return ReportMessageAt(location, is_strict(language_mode())
+                                           ? "unexpected_strict_reserved"
+                                           : "unexpected_token_identifier");
     case Token::TEMPLATE_SPAN:
     case Token::TEMPLATE_TAIL:
-      return Traits::ReportMessageAt(source_location,
-          "unexpected_template_string");
+      return Traits::ReportMessageAt(location, "unexpected_template_string");
     default:
       const char* name = Token::String(token);
       DCHECK(name != NULL);
-      Traits::ReportMessageAt(source_location, "unexpected_token", name);
+      Traits::ReportMessageAt(location, "unexpected_token", name);
   }
 }
 
 
 template<class Traits>
 typename ParserBase<Traits>::IdentifierT ParserBase<Traits>::ParseIdentifier(
     AllowEvalOrArgumentsAsIdentifier allow_eval_or_arguments,
     bool* ok) {
   Token::Value next = Next();
   if (next == Token::IDENTIFIER) {
@@ skipping 126 matching lines @@
   //   'false'
   //   Identifier
   //   Number
   //   String
   //   ArrayLiteral
   //   ObjectLiteral
   //   RegExpLiteral
   //   ClassLiteral
   //   '(' Expression ')'
   //   TemplateLiteral
+  //   ... Identifier ')' '=>'

[arv (Not doing code reviews), 2015/03/10 13:44:02]

Why ')' '=>'?

[caitp (gmail), 2015/03/10 14:47:51]

So, you're right that we can just check for the `)`, but this means there are
potentially a lot more places where we have to look for problems. I liked doing
it this way because it meant there was only one place where a syntax error could
occur

 
   int beg_pos = scanner()->peek_location().beg_pos;
   int end_pos = scanner()->peek_location().end_pos;
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
       scope_->RecordThisUsage();
       result = this->ThisExpression(scope_, factory(), beg_pos);
@@ skipping 52 matching lines @@
         Consume(Token::RPAREN);
         result = this->ParseArrowFunctionLiteral(
             beg_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);
+        if (peek() == Token::ARROW) {
+          int x = 5;

[marja, 2015/03/10 09:11:19]

?

[arv (Not doing code reviews), 2015/03/10 13:44:02]

Looks like debug code... remove?

[caitp (gmail), 2015/03/10 14:47:51]

Hah, yeah --- I'll get rid of that =)

+          USE(x);
+        }
       }
       break;
 
     case Token::CLASS: {
       Consume(Token::CLASS);
       if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
         ReportMessage("sloppy_lexical", NULL);
         *ok = false;
         break;
       }
@@ skipping 19 matching lines @@
       break;
 
     case Token::MOD:
       if (allow_natives() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
+    case Token::ELLIPSIS:
+      // Not a valid primary expression, but valid in parenthesized arrow
+      // function.
+      //
+      // Fail if name, closing parenthesis and arrow token are not found.
+      if (allow_harmony_rest_params() && allow_harmony_arrow_functions()) {
+        Consume(Token::ELLIPSIS);
+        bool is_strict_reserved_name = false;
+        IdentifierT name = ParseIdentifierOrStrictReservedWord(
+            &is_strict_reserved_name, CHECK_OK);

[arv (Not doing code reviews), 2015/03/10 13:44:03]

I don't see where is_strict_reserved_name is being checked?
ArrowFormalParameters are always strict.

[caitp (gmail), 2015/03/10 14:47:51]

to match the function signature... pretty much just trying to match what's
happening in CheckAndDeclareArrowFunctionParameters or whatever it's called.

+        if (peek() == Token::COMMA) {
+          *ok = false;
+          ReportMessageAt(scanner_->peek_location(), "param_after_rest");
+          break;
+        } else if (peek() != Token::RPAREN) {
+          ReportUnexpectedTokenAt(scanner_->peek_location(), peek());
+          *ok = false;
+          break;
+        }
+
+        if (peek(1) != Token::ARROW) {
+          ReportUnexpectedTokenAt(scanner_->peek_location(1), peek(1));

[arv (Not doing code reviews), 2015/03/10 13:44:03]

Another option here is to report the invalid `...`

+          *ok = false;
+          break;
+        }
+
+        Scanner::Location name_pos = scanner_->location();
+        result = this->ExpressionFromIdentifier(
+            name, name_pos.beg_pos, name_pos.end_pos, scope_, factory());
+
+        return factory()->NewSpreadOperation(result, beg_pos);
+      }
+
     default: {
       Next();
       ReportUnexpectedToken(token);
       *ok = false;
     }
   }
 
   return result;
 }
 
@@ skipping 775 matching lines @@
         name, function_name_location, is_strict_reserved_name,
         is_generator ? FunctionKind::kGeneratorFunction
                      : FunctionKind::kNormalFunction,
         function_token_position, function_type, FunctionLiteral::NORMAL_ARITY,
         CHECK_OK);
   } else if (peek() == Token::SUPER) {
     const bool is_new = false;
     result = ParseSuperExpression(is_new, CHECK_OK);
   } else {
     result = ParsePrimaryExpression(CHECK_OK);
+    if (result->IsSpreadOperation()) {
+      // SpreadOperation is only parsed here as the last parameter of an
+      // arrow function. It's not a valid MemberExpression, and there is no
+      // continuation.
+      return result;
+    }
   }
 
   result = ParseMemberExpressionContinuation(result, CHECK_OK);
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseSuperExpression(bool is_new, bool* ok) {
@@ skipping 339 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H