[es6] support rest parameters in arrow functions

src/scanner.h

 // Copyright 2011 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.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #ifndef V8_SCANNER_H_
 #define V8_SCANNER_H_
 
 #include "src/allocation.h"
@@ skipping 304 matching lines @@
   Vector<byte> backing_store_;
 
   DISALLOW_COPY_AND_ASSIGN(LiteralBuffer);
 };
 
 
 // ----------------------------------------------------------------------------
 // JavaScript Scanner.
 
 class Scanner {
+  struct TokenDesc;
+
  public:
+  static const int kMaxLookahead = 2;
+
   // Scoped helper for literal recording. Automatically drops the literal
   // if aborting the scanning before it's complete.
   class LiteralScope {
    public:
     explicit LiteralScope(Scanner* self) : scanner_(self), complete_(false) {
-      scanner_->StartLiteral();
+      next_ = scanner_->PeekTokenDesc();
+      scanner_->StartLiteral(next_);
     }
      ~LiteralScope() {
-       if (!complete_) scanner_->DropLiteral();
+       if (!complete_) scanner_->DropLiteral(next_);
      }
     void Complete() {
       complete_ = true;
     }
 
    private:
+    friend class Scanner;
     Scanner* scanner_;
+    TokenDesc* next_;
     bool complete_;
   };
 
   // Representation of an interval of source positions.
   struct Location {
     Location(int b, int e) : beg_pos(b), end_pos(e) { }
     Location() : beg_pos(0), end_pos(0) { }
 
     bool IsValid() const {
       return beg_pos >= 0 && end_pos >= beg_pos;
@@ skipping 16 matching lines @@
   Token::Value Next();
   // Returns the current token again.
   Token::Value current_token() { return current_.token; }
   // Returns the location information for the current token
   // (the token last returned by Next()).
   Location location() const { return current_.location; }
 
   // Similar functions for the upcoming token.
 
   // One token look-ahead (past the token returned by Next()).
-  Token::Value peek() const { return next_.token; }
+  Token::Value peek() const { return next_[0].token; }
+  Token::Value peek(int n);
 
-  Location peek_location() const { return next_.location; }
+  Location peek_location() const { return next_[0].location; }
+  Location peek_location(int n);
 
   bool literal_contains_escapes() const {
     Location location = current_.location;
     int source_length = (location.end_pos - location.beg_pos);
     if (current_.token == Token::STRING) {
       // Subtract delimiters.
       source_length -= 2;
     }
     return current_.literal_chars->length() != source_length;
   }
   bool is_literal_contextual_keyword(Vector<const char> keyword) {
     DCHECK_NOT_NULL(current_.literal_chars);
     return current_.literal_chars->is_contextual_keyword(keyword);
   }
   bool is_next_contextual_keyword(Vector<const char> keyword) {
-    DCHECK_NOT_NULL(next_.literal_chars);
-    return next_.literal_chars->is_contextual_keyword(keyword);
+    DCHECK_NOT_NULL(next_[0].literal_chars);
+    return next_[0].literal_chars->is_contextual_keyword(keyword);
   }
 
   const AstRawString* CurrentSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* NextSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* CurrentRawSymbol(AstValueFactory* ast_value_factory);
 
   double DoubleValue();
   bool LiteralMatches(const char* data, int length, bool allow_escapes = true) {
     if (is_literal_one_byte() &&
         literal_length() == length &&
@@ skipping 110 matching lines @@
   void Init() {
     // Set c0_ (one character ahead)
     STATIC_ASSERT(kCharacterLookaheadBufferSize == 1);
     Advance();
     // Initialize current_ to not refer to a literal.
     current_.literal_chars = NULL;
     current_.raw_literal_chars = NULL;
   }
 
   // Literal buffer support
-  inline void StartLiteral() {
+  inline void StartLiteral(TokenDesc* next) {
     LiteralBuffer* free_buffer = (current_.literal_chars == &literal_buffer1_) ?
             &literal_buffer2_ : &literal_buffer1_;
     free_buffer->Reset();
-    next_.literal_chars = free_buffer;
+    next->literal_chars = free_buffer;
   }
 
   inline void StartRawLiteral() {
+    TokenDesc* next = PeekTokenDesc();
     raw_literal_buffer_.Reset();
-    next_.raw_literal_chars = &raw_literal_buffer_;
+    next->raw_literal_chars = &raw_literal_buffer_;
   }
 
-  INLINE(void AddLiteralChar(uc32 c)) {
-    DCHECK_NOT_NULL(next_.literal_chars);
-    next_.literal_chars->AddChar(c);
+  INLINE(void AddLiteralChar(TokenDesc* next, uc32 c)) {
+    DCHECK_NOT_NULL(next->literal_chars);
+    next->literal_chars->AddChar(c);
   }
 
-  INLINE(void AddRawLiteralChar(uc32 c)) {
-    DCHECK_NOT_NULL(next_.raw_literal_chars);
-    next_.raw_literal_chars->AddChar(c);
+  INLINE(void AddRawLiteralChar(TokenDesc* next, uc32 c)) {
+    DCHECK_NOT_NULL(next->raw_literal_chars);
+    next->raw_literal_chars->AddChar(c);
   }
 
-  INLINE(void ReduceRawLiteralLength(int delta)) {
-    DCHECK_NOT_NULL(next_.raw_literal_chars);
-    next_.raw_literal_chars->ReduceLength(delta);
+  INLINE(void ReduceRawLiteralLength(TokenDesc* next, int delta)) {
+    DCHECK_NOT_NULL(next->raw_literal_chars);
+    next->raw_literal_chars->ReduceLength(delta);
   }
 
   // Stops scanning of a literal and drop the collected characters,
   // e.g., due to an encountered error.
-  inline void DropLiteral() {
-    next_.literal_chars = NULL;
-    next_.raw_literal_chars = NULL;
+  inline void DropLiteral(TokenDesc* next) {
+    next->literal_chars = NULL;
+    next->raw_literal_chars = NULL;
   }
 
-  inline void AddLiteralCharAdvance() {
-    AddLiteralChar(c0_);
+  inline void AddLiteralCharAdvance(TokenDesc* next) {
+    AddLiteralChar(next, c0_);
     Advance();
   }
 
   // Low-level scanning support.
   template <bool capture_raw = false, bool check_surrogate = true>
   void Advance() {
     if (capture_raw) {
-      AddRawLiteralChar(c0_);
+      AddRawLiteralChar(PeekTokenDesc(), c0_);
     }
     c0_ = source_->Advance();
     if (check_surrogate) HandleLeadSurrogate();
   }
 
   void HandleLeadSurrogate() {
     if (unibrow::Utf16::IsLeadSurrogate(c0_)) {
       uc32 c1 = source_->Advance();
       if (!unibrow::Utf16::IsTrailSurrogate(c1)) {
         source_->PushBack(c1);
@@ skipping 47 matching lines @@
     DCHECK_NOT_NULL(current_.literal_chars);
     return current_.literal_chars->is_one_byte();
   }
   int literal_length() const {
     DCHECK_NOT_NULL(current_.literal_chars);
     return current_.literal_chars->length();
   }
   // Returns the literal string for the next token (the token that
   // would be returned if Next() were called).
   Vector<const uint8_t> next_literal_one_byte_string() {
-    DCHECK_NOT_NULL(next_.literal_chars);
-    return next_.literal_chars->one_byte_literal();
+    DCHECK_NOT_NULL(next_[0].literal_chars);
+    return next_[0].literal_chars->one_byte_literal();
   }
   Vector<const uint16_t> next_literal_two_byte_string() {
-    DCHECK_NOT_NULL(next_.literal_chars);
-    return next_.literal_chars->two_byte_literal();
+    DCHECK_NOT_NULL(next_[0].literal_chars);
+    return next_[0].literal_chars->two_byte_literal();
   }
   bool is_next_literal_one_byte() {
-    DCHECK_NOT_NULL(next_.literal_chars);
-    return next_.literal_chars->is_one_byte();
+    DCHECK_NOT_NULL(next_[0].literal_chars);
+    return next_[0].literal_chars->is_one_byte();
   }
   Vector<const uint8_t> raw_literal_one_byte_string() {
     DCHECK_NOT_NULL(current_.raw_literal_chars);
     return current_.raw_literal_chars->one_byte_literal();
   }
   Vector<const uint16_t> raw_literal_two_byte_string() {
     DCHECK_NOT_NULL(current_.raw_literal_chars);
     return current_.raw_literal_chars->two_byte_literal();
   }
   bool is_raw_literal_one_byte() {
     DCHECK_NOT_NULL(current_.raw_literal_chars);
     return current_.raw_literal_chars->is_one_byte();
   }
 
   template <bool capture_raw>
   uc32 ScanHexNumber(int expected_length);
   // Scan a number of any length but not bigger than max_value. For example, the
   // number can be 000000001, so it's very long in characters but its value is
   // small.
   template <bool capture_raw>
   uc32 ScanUnlimitedLengthHexNumber(int max_value);
 
   // Scans a single JavaScript token.
-  void Scan();
+  void Scan(TokenDesc* next);
 
   bool SkipWhiteSpace();
   Token::Value SkipSingleLineComment();
   Token::Value SkipSourceURLComment();
   void TryToParseSourceURLComment();
   Token::Value SkipMultiLineComment();
   // Scans a possible HTML comment -- begins with '<!'.
   Token::Value ScanHtmlComment();
 
-  void ScanDecimalDigits();
+  void ScanDecimalDigits(TokenDesc* next);
   Token::Value ScanNumber(bool seen_period);
   Token::Value ScanIdentifierOrKeyword();
   Token::Value ScanIdentifierSuffix(LiteralScope* literal);
 
   Token::Value ScanString();
 
   // Scans an escape-sequence which is part of a string and adds the
   // decoded character to the current literal. Returns true if a pattern
   // is scanned.
   template <bool capture_raw, bool in_template_literal>
-  bool ScanEscape();
+  bool ScanEscape(TokenDesc* next);
 
   // Decodes a Unicode escape-sequence which is part of an identifier.
   // If the escape sequence cannot be decoded the result is kBadChar.
   uc32 ScanIdentifierUnicodeEscape();
   // Helper for the above functions.
   template <bool capture_raw>
   uc32 ScanUnicodeEscape();
 
   Token::Value ScanTemplateSpan();
 
   // Return the current source position.
   int source_pos() {
     return static_cast<int>(source_->pos()) - kCharacterLookaheadBufferSize;
   }
 
   UnicodeCache* unicode_cache_;
 
   // Buffers collecting literal strings, numbers, etc.
   LiteralBuffer literal_buffer1_;
   LiteralBuffer literal_buffer2_;
 
   // Values parsed from magic comments.
   LiteralBuffer source_url_;
   LiteralBuffer source_mapping_url_;
 
   // Buffer to store raw string values
   LiteralBuffer raw_literal_buffer_;
 
   TokenDesc current_;  // desc for current token (as returned by Next())
-  TokenDesc next_;     // desc for next token (one token look-ahead)
+  TokenDesc next_[kMaxLookahead];  // desc for next (look-ahead) tokens
+  int peek_count_;  // number of peek tokens available (normally 1)
+
+  INLINE(TokenDesc* PeekTokenDesc(int count)) {
+    DCHECK(count >= 0 && count < kMaxLookahead);
+    return &(next_[count]);
+  }
+
+  INLINE(TokenDesc* PeekTokenDesc()) { return PeekTokenDesc(peek_count_ - 1); }
+
+  // Scan multiple lookahead tokens
+  void PeekScan(int count);
 
   // Input stream. Must be initialized to an Utf16CharacterStream.
   Utf16CharacterStream* source_;
 
 
   // Start position of the octal literal last scanned.
   Location octal_pos_;
 
   // Value of the last smi that was scanned.
   int smi_value_;
@@ skipping 18 matching lines @@
   bool harmony_classes_;
   // Whether we scan TEMPLATE_SPAN and TEMPLATE_TAIL
   bool harmony_templates_;
   // Whether we allow \u{xxxxx}.
   bool harmony_unicode_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_