DO NOT COMMIT: Trying to use ExperimentalScanner instead of Scanner; doesn't work.

src/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 21 matching lines @@
 #include "lexer/experimental-scanner.h"
 #include "token.h"
 #include "scanner.h"
 
 namespace v8 {
 namespace internal {
 
 // Common base class shared between parser and pre-parser.
 class ParserBase {
  public:
-  ParserBase(Scanner* scanner, uintptr_t stack_limit)
+  ParserBase(ScannerBase* scanner, uintptr_t stack_limit)
       : scanner_(scanner),
         stack_limit_(stack_limit),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_syntax_(false),
         allow_generators_(false),
         allow_for_of_(false) { }
   // TODO(mstarzinger): Only virtual until message reporting has been unified.
   virtual ~ParserBase() { }
 
@@ skipping 17 matching lines @@
   void set_allow_for_of(bool allow) { allow_for_of_ = allow; }
   void set_allow_modules(bool allow) { scanner()->SetHarmonyModules(allow); }
   void set_allow_harmony_scoping(bool allow) {
     scanner()->SetHarmonyScoping(allow);
   }
   void set_allow_harmony_numeric_literals(bool allow) {
     scanner()->SetHarmonyNumericLiterals(allow);
   }
 
  protected:
-  Scanner* scanner() const { return scanner_; }
+  ScannerBase* scanner() const { return scanner_; }
   int position() { return scanner_->location().beg_pos; }
   int peek_position() { return scanner_->peek_location().beg_pos; }
   bool stack_overflow() const { return stack_overflow_; }
   void set_stack_overflow() { stack_overflow_ = true; }
 
   INLINE(Token::Value peek()) {
     if (stack_overflow_) return Token::ILLEGAL;
     return scanner()->peek();
   }
 
@@ skipping 41 matching lines @@
   void ExpectContextualKeyword(Vector<const char> keyword, bool* ok);
 
   // Strict mode octal literal validation.
   void CheckOctalLiteral(int beg_pos, int end_pos, bool* ok);
 
   // Determine precedence of given token.
   static int Precedence(Token::Value token, bool accept_IN);
 
   // Report syntax errors.
   virtual void ReportUnexpectedToken(Token::Value token) = 0;
-  virtual void ReportMessageAt(Scanner::Location loc, const char* type) = 0;
+  virtual void ReportMessageAt(ScannerBase::Location loc, const char* type) = 0;
 
   // Used to detect duplicates in object literals. Each of the values
   // kGetterProperty, kSetterProperty and kValueProperty represents
   // a type of object literal property. When parsing a property, its
   // type value is stored in the DuplicateFinder for the property name.
   // Values are chosen so that having intersection bits means the there is
   // an incompatibility.
   // I.e., you can add a getter to a property that already has a setter, since
   // kGetterProperty and kSetterProperty doesn't intersect, but not if it
   // already has a getter or a value. Adding the getter to an existing
@@ skipping 14 matching lines @@
    public:
     ObjectLiteralChecker(ParserBase* parser, LanguageMode mode)
         : parser_(parser),
           finder_(scanner()->unicode_cache()),
           language_mode_(mode) { }
 
     void CheckProperty(Token::Value property, PropertyKind type, bool* ok);
 
    private:
     ParserBase* parser() const { return parser_; }
-    Scanner* scanner() const { return parser_->scanner(); }
+    ScannerBase* scanner() const { return parser_->scanner(); }
 
     // Checks the type of conflict based on values coming from PropertyType.
     bool HasConflict(PropertyKind type1, PropertyKind type2) {
       return (type1 & type2) != 0;
     }
     bool IsDataDataConflict(PropertyKind type1, PropertyKind type2) {
       return ((type1 & type2) & kValueFlag) != 0;
     }
     bool IsDataAccessorConflict(PropertyKind type1, PropertyKind type2) {
       return ((type1 ^ type2) & kValueFlag) != 0;
     }
     bool IsAccessorAccessorConflict(PropertyKind type1, PropertyKind type2) {
       return ((type1 | type2) & kValueFlag) == 0;
     }
 
     ParserBase* parser_;
     DuplicateFinder finder_;
     LanguageMode language_mode_;
   };
 
+  ScannerBase* scanner_;
+
  private:
-  Scanner* scanner_;
   uintptr_t stack_limit_;
   bool stack_overflow_;
 
   bool allow_lazy_;
   bool allow_natives_syntax_;
   bool allow_generators_;
   bool allow_for_of_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
 // The PreParser checks that the syntax follows the grammar for JavaScript,
 // and collects some information about the program along the way.
 // The grammar check is only performed in order to understand the program
 // sufficiently to deduce some information about it, that can be used
 // to speed up later parsing. Finding errors is not the goal of pre-parsing,
 // rather it is to speed up properly written and correct programs.
 // That means that contextual checks (like a label being declared where
 // it is used) are generally omitted.
 class PreParser : public ParserBase {
  public:
   enum PreParseResult {
     kPreParseStackOverflow,
     kPreParseSuccess
   };
 
-  PreParser(Scanner* scanner,
+  PreParser(ScannerBase* scanner,
             ParserRecorder* log,
             uintptr_t stack_limit)
       : ParserBase(scanner, stack_limit),
         log_(log),
         scope_(NULL),
-        strict_mode_violation_location_(Scanner::Location::invalid()),
+        strict_mode_violation_location_(ScannerBase::Location::invalid()),
         strict_mode_violation_type_(NULL),
         parenthesized_function_(false) { }
 
   ~PreParser() {}
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
   PreParseResult PreParseProgram() {
@@ skipping 323 matching lines @@
     const ScopeType type_;
     int materialized_literal_count_;
     int expected_properties_;
     int with_nesting_count_;
     LanguageMode language_mode_;
     bool is_generator_;
   };
 
   // Report syntax error
   void ReportUnexpectedToken(Token::Value token);
-  void ReportMessageAt(Scanner::Location location, const char* type) {
+  void ReportMessageAt(ScannerBase::Location location, const char* type) {
     ReportMessageAt(location, type, NULL);
   }
-  void ReportMessageAt(Scanner::Location location,
+  void ReportMessageAt(ScannerBase::Location location,
                        const char* type,
                        const char* name_opt) {
     log_->LogMessage(location.beg_pos, location.end_pos, type, name_opt);
   }
   void ReportMessageAt(int start_pos,
                        int end_pos,
                        const char* type,
                        const char* name_opt) {
     log_->LogMessage(start_pos, end_pos, type, name_opt);
   }
@@ skipping 70 matching lines @@
   }
 
   bool is_extended_mode() {
     return scope_->language_mode() == EXTENDED_MODE;
   }
 
   LanguageMode language_mode() { return scope_->language_mode(); }
 
   bool CheckInOrOf(bool accept_OF);
 
-  void SetStrictModeViolation(Scanner::Location,
+  void SetStrictModeViolation(ScannerBase::Location,
                               const char* type,
                               bool* ok);
 
   void CheckDelayedStrictModeViolation(int beg_pos, int end_pos, bool* ok);
 
-  void StrictModeIdentifierViolation(Scanner::Location,
+  void StrictModeIdentifierViolation(ScannerBase::Location,
                                      const char* eval_args_type,
                                      Identifier identifier,
                                      bool* ok);
 
   ParserRecorder* log_;
   Scope* scope_;
-  Scanner::Location strict_mode_violation_location_;
+  ScannerBase::Location strict_mode_violation_location_;
   const char* strict_mode_violation_type_;
   bool parenthesized_function_;
 };
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H