Implement handling of arrow functions in the parser

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 "allocation.h"
@@ skipping 169 matching lines @@
   UnicodeCache* unicode_constants_;
   // Backing store used to store strings used as hashmap keys.
   SequenceCollector<unsigned char> backing_store_;
   HashMap map_;
   // Buffer used for string->number->canonical string conversions.
   char number_buffer_[kBufferSize];
 };
 
 
 // ----------------------------------------------------------------------------
+// ParamListFinder discovers sequences of tokens which form a valid function
+// parameter list.
+
+class ParamListFinder {
+ public:
+  ParamListFinder(): state_(Invalid), start_pos_(-1) { }
+
+  void Update(Token::Value token, int pos) {
+    switch (state_) {
+      case Valid:
+        state_ = Invalid;
+        start_pos_ = -1;
+        // Fall-through.
+      case Invalid:
+        if (token == Token::LPAREN) {
+          state_ = LeftParen;
+          start_pos_ = pos;
+        }
+        break;
+
+      case LeftParen:
+        switch (token) {
+          case Token::LPAREN:
+            start_pos_ = pos;
+            break;
+          case Token::RPAREN:
+            state_ = Valid;
+            break;
+          case Token::IDENTIFIER:
+            state_ = Identifier;
+            break;
+          default:
+            state_ = Invalid;
+        }
+        break;
+
+      case Identifier:
+        switch (token) {
+          case Token::RPAREN:
+            state_ = Valid;
+            break;
+          case Token::COMMA:
+            state_ = Comma;
+            break;
+          default:
+            state_ = Invalid;
+        }
+        break;
+
+      case Comma:
+        if (token == Token::IDENTIFIER) {
+          state_ = Identifier;
+        } else {
+          state_ = Invalid;
+        }
+        break;
+    }
+  }
+
+  bool IsValid(int pos) const {
+    return state_ == Valid && start_pos_ == pos;
+  }
+
+ private:
+  enum State {
+    Invalid,
+    Valid,
+    LeftParen,
+    Identifier,
+    Comma
+  };
+
+  State state_;
+  int start_pos_;
+};
+
+
+// ----------------------------------------------------------------------------
 // LiteralBuffer -  Collector of chars of literals.
 
 class LiteralBuffer {
  public:
   LiteralBuffer() : is_one_byte_(true), position_(0), backing_store_() { }
 
   ~LiteralBuffer() {
     if (backing_store_.length() > 0) {
       backing_store_.Dispose();
     }
@@ skipping 195 matching lines @@
     if (is_literal_one_byte() &&
         literal_length() == 3 &&
         !literal_contains_escapes()) {
       const char* token =
           reinterpret_cast<const char*>(literal_one_byte_string().start());
       *is_get = strncmp(token, "get", 3) == 0;
       *is_set = !*is_get && strncmp(token, "set", 3) == 0;
     }
   }
 
+  bool IsValidParameterList(int pos) const {
+      return param_list_finder_.IsValid(pos);
+  }
+
   int FindNumber(DuplicateFinder* finder, int value);
   int FindSymbol(DuplicateFinder* finder, int value);
 
   UnicodeCache* unicode_cache() { return unicode_cache_; }
 
   // Returns the location of the last seen octal literal.
   Location octal_position() const { return octal_pos_; }
   void clear_octal_position() { octal_pos_ = Location::invalid(); }
 
   // Seek forward to the given position.  This operation does not
@@ skipping 183 matching lines @@
   int source_pos() {
     return source_->pos() - kCharacterLookaheadBufferSize;
   }
 
   UnicodeCache* unicode_cache_;
 
   // Buffers collecting literal strings, numbers, etc.
   LiteralBuffer literal_buffer1_;
   LiteralBuffer literal_buffer2_;
 
+  ParamListFinder param_list_finder_;
+
   TokenDesc current_;  // desc for current token (as returned by Next())
   TokenDesc next_;     // desc for next token (one token look-ahead)
 
   // Input stream. Must be initialized to an Utf16CharacterStream.
   Utf16CharacterStream* source_;
 
 
   // Start position of the octal literal last scanned.
   Location octal_pos_;
 
@@ skipping 11 matching lines @@
   bool harmony_scoping_;
   // Whether we scan 'module', 'import', 'export' as keywords.
   bool harmony_modules_;
   // Whether we scan 0o777 and 0b111 as numbers.
   bool harmony_numeric_literals_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_