Implement handling of arrow functions in the parser

src/scanner.cc

 // 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.
 
 #include <cmath>
 
 #include "src/scanner.h"
 
 #include "include/v8stdint.h"
 #include "src/ast-value-factory.h"
 #include "src/char-predicates-inl.h"
 #include "src/conversions-inl.h"
 #include "src/list-inl.h"
 #include "src/v8.h"
 #include "src/parser.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // Scanner
 
 Scanner::Scanner(UnicodeCache* unicode_cache)
     : unicode_cache_(unicode_cache),
+      param_list_finder_(unicode_cache_),
       octal_pos_(Location::invalid()),
       harmony_scoping_(false),
       harmony_modules_(false),
       harmony_numeric_literals_(false) { }
 
 
 void Scanner::Initialize(Utf16CharacterStream* source) {
   source_ = source;
   // Need to capture identifiers in order to recognize "get" and "set"
   // in object literals.
@@ skipping 166 matching lines @@
   Token::RBRACE,       // 0x7d
   Token::BIT_NOT,      // 0x7e
   Token::ILLEGAL
 };
 
 
 Token::Value Scanner::Next() {
   current_ = next_;
   has_line_terminator_before_next_ = false;
   has_multiline_comment_before_next_ = false;
+  param_list_finder_.Update(this);
   if (static_cast<unsigned>(c0_) <= 0x7f) {
     Token::Value token = static_cast<Token::Value>(one_char_tokens[c0_]);
     if (token != Token::ILLEGAL) {
       int pos = source_pos();
       next_.token = token;
       next_.location.beg_pos = pos;
       next_.location.end_pos = pos + 1;
       Advance();
       return current_.token;
     }
@@ skipping 165 matching lines @@
             token = Select('=', Token::ASSIGN_SHR, Token::SHR);
           } else {
             token = Token::SAR;
           }
         } else {
           token = Token::GT;
         }
         break;
 
       case '=':
-        // = == ===
+        // = == === =>
         Advance();
         if (c0_ == '=') {
           token = Select('=', Token::EQ_STRICT, Token::EQ);
+        } else if (c0_ == '>') {
+          token = Select(Token::ARROW);
         } else {
           token = Token::ASSIGN;
         }
         break;
 
       case '!':
         // ! != !==
         Advance();
         if (c0_ == '=') {
           token = Select('=', Token::NE_STRICT, Token::NE);
@@ skipping 509 matching lines @@
           (keyword_length <= 9 || input[9] == keyword[9])) {  \
         return token;                                         \
       }                                                       \
     }
     KEYWORDS(KEYWORD_GROUP_CASE, KEYWORD)
   }
   return Token::IDENTIFIER;
 }
 
 
+bool Scanner::IdentifierIsFutureStrictReserved(const AstString* string) const {

[marja, 2014/06/17 11:47:38]

This sounds wrong, since we have a separate token for FUTURE_RESERVED_WORD, so
here we have somehow lost that information and we're trying to get it back.. :/

+  if (string->is_one_byte()) {
+    return Token::FUTURE_STRICT_RESERVED_WORD == KeywordOrIdentifierToken(
+        string->raw_data(), string->length(),
+        harmony_scoping_, harmony_modules_);
+  }
+
+  // Language keywords are always ASCII-only, so we can just pick the
+  // lower bytes to have a one-byte representation of the keyword.
+  const unsigned len = string->length();
+  Vector<unsigned char> chars = Vector<unsigned char>::New(len);
+  const uint16_t* uchars = reinterpret_cast<const uint16_t*>(string->raw_data());
+
+  for (unsigned i = 0; i < len; i++)
+    (chars.start())[i] = 0xFF & uchars[i];
+
+  bool result = Token::FUTURE_STRICT_RESERVED_WORD == KeywordOrIdentifierToken(
+      chars.start(), len, harmony_scoping_, harmony_modules_);
+  chars.Dispose();
+  return result;
+}
+
+
 Token::Value Scanner::ScanIdentifierOrKeyword() {
   ASSERT(unicode_cache_->IsIdentifierStart(c0_));
   LiteralScope literal(this);
   // Scan identifier start character.
   if (c0_ == '\\') {
     uc32 c = ScanIdentifierUnicodeEscape();
     // Only allow legal identifier start characters.
     if (c < 0 ||
         c == '\\' ||  // No recursive escapes.
         !unicode_cache_->IsIdentifierStart(c)) {
@@ skipping 324 matching lines @@
     }
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 } }  // namespace v8::internal