[es6] Remove Scanner and Parser flags for harmony_modules

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 <stdint.h>
 
 #include <cmath>
 
@@ skipping 23 matching lines @@
 void Utf16CharacterStream::ResetToBookmark() { UNREACHABLE(); }
 
 
 // ----------------------------------------------------------------------------
 // Scanner
 
 Scanner::Scanner(UnicodeCache* unicode_cache)
     : unicode_cache_(unicode_cache),
       bookmark_c0_(kNoBookmark),
       octal_pos_(Location::invalid()),
-      harmony_modules_(false),
       harmony_unicode_(false) {
   bookmark_current_.literal_chars = &bookmark_current_literal_;
   bookmark_current_.raw_literal_chars = &bookmark_current_raw_literal_;
   bookmark_next_.literal_chars = &bookmark_next_literal_;
   bookmark_next_.raw_literal_chars = &bookmark_next_raw_literal_;
 }
 
 
 void Scanner::Initialize(Utf16CharacterStream* source) {
   source_ = source;
@@ skipping 1036 matching lines @@
     Advance<capture_raw>();
     return cp;
   }
   return ScanHexNumber<capture_raw>(4);
 }
 
 
 // ----------------------------------------------------------------------------
 // Keyword Matcher
 
-#define KEYWORDS(KEYWORD_GROUP, KEYWORD)                                 \
-  KEYWORD_GROUP('b')                                                     \
-  KEYWORD("break", Token::BREAK)                                         \
-  KEYWORD_GROUP('c')                                                     \
-  KEYWORD("case", Token::CASE)                                           \
-  KEYWORD("catch", Token::CATCH)                                         \
-  KEYWORD("class", Token::CLASS)                                         \
-  KEYWORD("const", Token::CONST)                                         \
-  KEYWORD("continue", Token::CONTINUE)                                   \
-  KEYWORD_GROUP('d')                                                     \
-  KEYWORD("debugger", Token::DEBUGGER)                                   \
-  KEYWORD("default", Token::DEFAULT)                                     \
-  KEYWORD("delete", Token::DELETE)                                       \
-  KEYWORD("do", Token::DO)                                               \
-  KEYWORD_GROUP('e')                                                     \
-  KEYWORD("else", Token::ELSE)                                           \
-  KEYWORD("enum", Token::FUTURE_RESERVED_WORD)                           \
-  KEYWORD("export",                                                      \
-          harmony_modules ? Token::EXPORT : Token::FUTURE_RESERVED_WORD) \
-  KEYWORD("extends", Token::EXTENDS)                                     \
-  KEYWORD_GROUP('f')                                                     \
-  KEYWORD("false", Token::FALSE_LITERAL)                                 \
-  KEYWORD("finally", Token::FINALLY)                                     \
-  KEYWORD("for", Token::FOR)                                             \
-  KEYWORD("function", Token::FUNCTION)                                   \
-  KEYWORD_GROUP('i')                                                     \
-  KEYWORD("if", Token::IF)                                               \
-  KEYWORD("implements", Token::FUTURE_STRICT_RESERVED_WORD)              \
-  KEYWORD("import",                                                      \
-          harmony_modules ? Token::IMPORT : Token::FUTURE_RESERVED_WORD) \
-  KEYWORD("in", Token::IN)                                               \
-  KEYWORD("instanceof", Token::INSTANCEOF)                               \
-  KEYWORD("interface", Token::FUTURE_STRICT_RESERVED_WORD)               \
-  KEYWORD_GROUP('l')                                                     \
-  KEYWORD("let", Token::LET)                                             \
-  KEYWORD_GROUP('n')                                                     \
-  KEYWORD("new", Token::NEW)                                             \
-  KEYWORD("null", Token::NULL_LITERAL)                                   \
-  KEYWORD_GROUP('p')                                                     \
-  KEYWORD("package", Token::FUTURE_STRICT_RESERVED_WORD)                 \
-  KEYWORD("private", Token::FUTURE_STRICT_RESERVED_WORD)                 \
-  KEYWORD("protected", Token::FUTURE_STRICT_RESERVED_WORD)               \
-  KEYWORD("public", Token::FUTURE_STRICT_RESERVED_WORD)                  \
-  KEYWORD_GROUP('r')                                                     \
-  KEYWORD("return", Token::RETURN)                                       \
-  KEYWORD_GROUP('s')                                                     \
-  KEYWORD("static", Token::STATIC)                                       \
-  KEYWORD("super", Token::SUPER)                                         \
-  KEYWORD("switch", Token::SWITCH)                                       \
-  KEYWORD_GROUP('t')                                                     \
-  KEYWORD("this", Token::THIS)                                           \
-  KEYWORD("throw", Token::THROW)                                         \
-  KEYWORD("true", Token::TRUE_LITERAL)                                   \
-  KEYWORD("try", Token::TRY)                                             \
-  KEYWORD("typeof", Token::TYPEOF)                                       \
-  KEYWORD_GROUP('v')                                                     \
-  KEYWORD("var", Token::VAR)                                             \
-  KEYWORD("void", Token::VOID)                                           \
-  KEYWORD_GROUP('w')                                                     \
-  KEYWORD("while", Token::WHILE)                                         \
-  KEYWORD("with", Token::WITH)                                           \
-  KEYWORD_GROUP('y')                                                     \
+#define KEYWORDS(KEYWORD_GROUP, KEYWORD)                    \
+  KEYWORD_GROUP('b')                                        \
+  KEYWORD("break", Token::BREAK)                            \
+  KEYWORD_GROUP('c')                                        \
+  KEYWORD("case", Token::CASE)                              \
+  KEYWORD("catch", Token::CATCH)                            \
+  KEYWORD("class", Token::CLASS)                            \
+  KEYWORD("const", Token::CONST)                            \
+  KEYWORD("continue", Token::CONTINUE)                      \
+  KEYWORD_GROUP('d')                                        \
+  KEYWORD("debugger", Token::DEBUGGER)                      \
+  KEYWORD("default", Token::DEFAULT)                        \
+  KEYWORD("delete", Token::DELETE)                          \
+  KEYWORD("do", Token::DO)                                  \
+  KEYWORD_GROUP('e')                                        \
+  KEYWORD("else", Token::ELSE)                              \
+  KEYWORD("enum", Token::FUTURE_RESERVED_WORD)              \
+  KEYWORD("export", Token::EXPORT)                          \
+  KEYWORD("extends", Token::EXTENDS)                        \
+  KEYWORD_GROUP('f')                                        \
+  KEYWORD("false", Token::FALSE_LITERAL)                    \
+  KEYWORD("finally", Token::FINALLY)                        \
+  KEYWORD("for", Token::FOR)                                \
+  KEYWORD("function", Token::FUNCTION)                      \
+  KEYWORD_GROUP('i')                                        \
+  KEYWORD("if", Token::IF)                                  \
+  KEYWORD("implements", Token::FUTURE_STRICT_RESERVED_WORD) \
+  KEYWORD("import", Token::IMPORT)                          \
+  KEYWORD("in", Token::IN)                                  \
+  KEYWORD("instanceof", Token::INSTANCEOF)                  \
+  KEYWORD("interface", Token::FUTURE_STRICT_RESERVED_WORD)  \
+  KEYWORD_GROUP('l')                                        \
+  KEYWORD("let", Token::LET)                                \
+  KEYWORD_GROUP('n')                                        \
+  KEYWORD("new", Token::NEW)                                \
+  KEYWORD("null", Token::NULL_LITERAL)                      \
+  KEYWORD_GROUP('p')                                        \
+  KEYWORD("package", Token::FUTURE_STRICT_RESERVED_WORD)    \
+  KEYWORD("private", Token::FUTURE_STRICT_RESERVED_WORD)    \
+  KEYWORD("protected", Token::FUTURE_STRICT_RESERVED_WORD)  \
+  KEYWORD("public", Token::FUTURE_STRICT_RESERVED_WORD)     \
+  KEYWORD_GROUP('r')                                        \
+  KEYWORD("return", Token::RETURN)                          \
+  KEYWORD_GROUP('s')                                        \
+  KEYWORD("static", Token::STATIC)                          \
+  KEYWORD("super", Token::SUPER)                            \
+  KEYWORD("switch", Token::SWITCH)                          \
+  KEYWORD_GROUP('t')                                        \
+  KEYWORD("this", Token::THIS)                              \
+  KEYWORD("throw", Token::THROW)                            \
+  KEYWORD("true", Token::TRUE_LITERAL)                      \
+  KEYWORD("try", Token::TRY)                                \
+  KEYWORD("typeof", Token::TYPEOF)                          \
+  KEYWORD_GROUP('v')                                        \
+  KEYWORD("var", Token::VAR)                                \
+  KEYWORD("void", Token::VOID)                              \
+  KEYWORD_GROUP('w')                                        \
+  KEYWORD("while", Token::WHILE)                            \
+  KEYWORD("with", Token::WITH)                              \
+  KEYWORD_GROUP('y')                                        \
   KEYWORD("yield", Token::YIELD)
 
 
 static Token::Value KeywordOrIdentifierToken(const uint8_t* input,
-                                             int input_length,
-                                             bool harmony_modules) {
+                                             int input_length) {
   DCHECK(input_length >= 1);
   const int kMinLength = 2;
   const int kMaxLength = 10;
   if (input_length < kMinLength || input_length > kMaxLength) {
     return Token::IDENTIFIER;
   }
   switch (input[0]) {
     default:
 #define KEYWORD_GROUP_CASE(ch)                                \
       break;                                                  \
@@ skipping 26 matching lines @@
 
 bool Scanner::IdentifierIsFutureStrictReserved(
     const AstRawString* string) const {
   // Keywords are always 1-byte strings.
   if (!string->is_one_byte()) return false;
   if (string->IsOneByteEqualTo("let") || string->IsOneByteEqualTo("static") ||
       string->IsOneByteEqualTo("yield")) {
     return true;
   }
   return Token::FUTURE_STRICT_RESERVED_WORD ==
-         KeywordOrIdentifierToken(string->raw_data(), string->length(),
-                                  harmony_modules_);
+         KeywordOrIdentifierToken(string->raw_data(), string->length());
 }
 
 
 Token::Value Scanner::ScanIdentifierOrKeyword() {
   DCHECK(unicode_cache_->IsIdentifierStart(c0_));
   LiteralScope literal(this);
   if (IsInRange(c0_, 'a', 'z')) {
     do {
       uc32 first_char = c0_;
       Advance<false, false>();
@@ skipping 12 matching lines @@
         AddLiteralChar(first_char);
       }
       if (c0_ <= kMaxAscii && c0_ != '\\') {
         literal.Complete();
         return Token::IDENTIFIER;
       }
     } else if (c0_ <= kMaxAscii && c0_ != '\\') {
       // Only a-z+: could be a keyword or identifier.
       literal.Complete();
       Vector<const uint8_t> chars = next_.literal_chars->one_byte_literal();
-      return KeywordOrIdentifierToken(chars.start(), chars.length(),
-                                      harmony_modules_);
+      return KeywordOrIdentifierToken(chars.start(), chars.length());
     }
 
     HandleLeadSurrogate();
   } else if (IsInRange(c0_, 'A', 'Z') || c0_ == '_' || c0_ == '$') {
     do {
       uc32 first_char = c0_;
       Advance<false, false>();
       AddLiteralChar(first_char);
     } while (IsAsciiIdentifier(c0_));
 
@@ skipping 29 matching lines @@
       continue;
     }
     // Fallthrough if no longer able to complete keyword.
     return ScanIdentifierSuffix(&literal);
   }
 
   literal.Complete();
 
   if (next_.literal_chars->is_one_byte()) {
     Vector<const uint8_t> chars = next_.literal_chars->one_byte_literal();
-    return KeywordOrIdentifierToken(chars.start(), chars.length(),
-                                    harmony_modules_);
+    return KeywordOrIdentifierToken(chars.start(), chars.length());
   }
   return Token::IDENTIFIER;
 }
 
 
 Token::Value Scanner::ScanIdentifierSuffix(LiteralScope* literal) {
   // Scan the rest of the identifier characters.
   while (c0_ >= 0 && unicode_cache_->IsIdentifierPart(c0_)) {
     if (c0_ == '\\') {
       uc32 c = ScanIdentifierUnicodeEscape();
@@ skipping 312 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 internal
 }  // namespace v8