PreParser fix: propagate reference erros properly.

src/preparse-data.h

 // Copyright 2011 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 37 matching lines @@
                            int literals,
                            int properties,
                            StrictMode strict_mode) = 0;
 
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
   virtual void LogMessage(int start,
                           int end,
                           const char* message,
-                          const char* argument_opt) = 0;
+                          const char* argument_opt,
+                          bool is_reference_error) = 0;
 
   // Logs a symbol creation of a literal or identifier.
   bool ShouldLogSymbols() { return should_log_symbols_; }
   // The following functions are only callable on CompleteParserRecorder
   // and are guarded by calls to ShouldLogSymbols.
   virtual void LogOneByteSymbol(int start, Vector<const uint8_t> literal) {
     UNREACHABLE();
   }
   virtual void LogTwoByteSymbol(int start, Vector<const uint16_t> literal) {
     UNREACHABLE();
   }
   virtual void PauseRecording() { UNREACHABLE(); }
   virtual void ResumeRecording() { UNREACHABLE(); }
 
  protected:
   bool should_log_symbols_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ParserRecorder);
 };
 
 
 class SingletonLogger : public ParserRecorder {
  public:
-  SingletonLogger() : has_error_(false), start_(-1), end_(-1) { }
-  virtual ~SingletonLogger() { }
+  SingletonLogger()
+      : has_error_(false), start_(-1), end_(-1), is_reference_error_(false) {}
+  virtual ~SingletonLogger() {}
 
   void Reset() { has_error_ = false; }
 
   virtual void LogFunction(int start,
                            int end,
                            int literals,
                            int properties,
                            StrictMode strict_mode) {
     ASSERT(!has_error_);
     start_ = start;
     end_ = end;
     literals_ = literals;
     properties_ = properties;
     strict_mode_ = strict_mode;
   };
 
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
   virtual void LogMessage(int start,
                           int end,
                           const char* message,
-                          const char* argument_opt) {
+                          const char* argument_opt,
+                          bool is_reference_error) {
     if (has_error_) return;
     has_error_ = true;
     start_ = start;
     end_ = end;
     message_ = message;
     argument_opt_ = argument_opt;
+    is_reference_error_ = is_reference_error;
   }
 
-  bool has_error() { return has_error_; }
+  bool has_error() const { return has_error_; }
 
-  int start() { return start_; }
-  int end() { return end_; }
-  int literals() {
+  int start() const { return start_; }
+  int end() const { return end_; }
+  int literals() const {
     ASSERT(!has_error_);
     return literals_;
   }
-  int properties() {
+  int properties() const {
     ASSERT(!has_error_);
     return properties_;
   }
-  StrictMode strict_mode() {
+  StrictMode strict_mode() const {
     ASSERT(!has_error_);
     return strict_mode_;
   }
+  int is_reference_error() const { return is_reference_error_; }
   const char* message() {
     ASSERT(has_error_);
     return message_;
   }
-  const char* argument_opt() {
+  const char* argument_opt() const {
     ASSERT(has_error_);
     return argument_opt_;
   }
 
  private:
   bool has_error_;
   int start_;
   int end_;
   // For function entries.
   int literals_;
   int properties_;
   StrictMode strict_mode_;
   // For error messages.
   const char* message_;
   const char* argument_opt_;
+  bool is_reference_error_;
 };
 
 
 class CompleteParserRecorder : public ParserRecorder {
  public:
   struct Key {
     bool is_one_byte;
     Vector<const byte> literal_bytes;
   };
 
@@ skipping 11 matching lines @@
     function_store_.Add(properties);
     function_store_.Add(strict_mode);
   }
 
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
   virtual void LogMessage(int start,
                           int end,
                           const char* message,
-                          const char* argument_opt);
+                          const char* argument_opt,
+                          bool is_reference_error_);
 
   virtual void PauseRecording() {
     ASSERT(should_log_symbols_);
     should_log_symbols_ = false;
   }
 
   virtual void ResumeRecording() {
     ASSERT(!should_log_symbols_);
     should_log_symbols_ = !has_error();
   }
@@ skipping 31 matching lines @@
   Collector<byte> symbol_store_;
   Collector<Key> symbol_keys_;
   HashMap string_table_;
   int symbol_id_;
 };
 
 
 } }  // namespace v8::internal.
 
 #endif  // V8_PREPARSE_DATA_H_