[es6] early error when Identifier is an escaped reserved word

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 355 matching lines @@
   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; }
 
   Location peek_location() const { return next_.location; }
 
   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;
+    return literal_contains_escapes(current_);
+  }
+  bool next_literal_contains_escapes() const {
+    return literal_contains_escapes(next_);
   }
   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);
   }
 
   const AstRawString* CurrentSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* NextSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* CurrentRawSymbol(AstValueFactory* ast_value_factory);
 
+  bool IsNextEscapedReservedWord(LanguageMode language_mode, bool is_generator,
+                                 bool allow_sloppy_let);
+
   double DoubleValue();
   bool ContainsDot();
   bool LiteralMatches(const char* data, int length, bool allow_escapes = true) {
     if (is_literal_one_byte() &&
         literal_length() == length &&
         (allow_escapes || !literal_contains_escapes())) {
       const char* token =
           reinterpret_cast<const char*>(literal_one_byte_string().start());
       return !strncmp(token, data, length);
     }
@@ skipping 275 matching lines @@
   template <bool capture_raw>
   uc32 ScanUnicodeEscape();
 
   Token::Value ScanTemplateSpan();
 
   // Return the current source position.
   int source_pos() {
     return static_cast<int>(source_->pos()) - kCharacterLookaheadBufferSize;
   }
 
+  bool literal_contains_escapes(const TokenDesc& token) const {

[adamk, 2015/11/03 23:00:57]

This could be static (and thus not const). And CamelCase would also make it
stand out from the members.

[caitp (gmail), 2015/11/04 04:49:24]

Done.

+    Location location = token.location;
+    int source_length = (location.end_pos - location.beg_pos);
+    if (token.token == Token::STRING) {
+      // Subtract delimiters.
+      source_length -= 2;
+    }
+    return token.literal_chars->length() != source_length;
+  }
+
   UnicodeCache* unicode_cache_;
 
   // Buffers collecting literal strings, numbers, etc.
   LiteralBuffer literal_buffer0_;
   LiteralBuffer literal_buffer1_;
   LiteralBuffer literal_buffer2_;
 
   // Values parsed from magic comments.
   LiteralBuffer source_url_;
   LiteralBuffer source_mapping_url_;
@@ skipping 54 matching lines @@
   bool has_line_terminator_before_next_;
   // Whether there is a multi-line comment that contains a
   // line-terminator after the current token, and before the next.
   bool has_multiline_comment_before_next_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SCANNER_H_