Refactor Parser to make it usable on a background thread.

src/parser.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // For CachedDataMode
@@ skipping 579 matching lines @@
   V8_INLINE void CheckConflictingVarDeclarations(v8::internal::Scope* scope,
                                                  bool* ok);
 
  private:
   Parser* parser_;
 };
 
 
 class Parser : public ParserBase<ParserTraits> {
  public:
-  explicit Parser(CompilationInfo* info);
+  // Note that the passed hash seed must be the hash seed from the Isolate's
+  // heap, otherwise the heap will be in an inconsistent state once the strings
+  // created by the Parser are internalized.
+  Parser(CompilationInfo* info, uintptr_t stack_limit, uint32_t hash_seed,

[rossberg, 2014/09/02 08:47:40]

Would it be worth introducing a struct to collect these additional arguments?
E.g. ParseInfo or something?

[marja, 2014/09/02 09:48:40]

Ok. Ultimately, we'd want is separate structs for things which are inputs to the
parse phase and for things which are outputs from the parse phase. That would
clarify things. Currently CompilationInfo has both...

Anyhow, I added ParserInfo here, to store these three things. Parser doesn't
need to store, because it only passes the information forward.

(I moved the AstValueFactory creation to Parser ctor, so we don't need to store
the hash seed any more. That would've been the right place for the code anyway.)

ParserInfo is passed the same way as CompilationInfo, i.e., the caller creates
it on the stack and passes a pointer (ownership not transferred).

+         UnicodeCache* unicode_cache);
   ~Parser() {
     delete reusable_preparser_;
     reusable_preparser_ = NULL;
     delete cached_parse_data_;
     cached_parse_data_ = NULL;
   }
 
   // Parses the source code represented by the compilation info and sets its
   // function literal.  Returns false (and deallocates any allocated AST
   // nodes) if parsing failed.
   static bool Parse(CompilationInfo* info,
                     bool allow_lazy = false) {
-    Parser parser(info);
+    Parser parser(info, info->isolate()->stack_guard()->real_climit(),
+                  info->isolate()->heap()->HashSeed(),
+                  info->isolate()->unicode_cache());
     parser.set_allow_lazy(allow_lazy);
     return parser.Parse();
   }
   bool Parse();
 
  private:
   friend class ParserTraits;
 
   // Limit the allowed number of local variables in a function. The hard limit
   // is that offsets computed by FullCodeGenerator::StackOperand and similar
@@ skipping 166 matching lines @@
 
   // Consumes the ending }.
   ZoneList<Statement*>* ParseEagerFunctionBody(
       const AstRawString* function_name, int pos, Variable* fvar,
       Token::Value fvar_init_op, bool is_generator, bool* ok);
 
   void HandleSourceURLComments();
 
   void ThrowPendingError();
 
-  void InternalizeUseCounts();
+  // Handle errors detected during parsing, move statistics to Isolate,
+  // internalize strings (move them to the heap).
+  void Internalize();
 
   Isolate* isolate_;
 
   Handle<Script> script_;
   Scanner scanner_;
   PreParser* reusable_preparser_;
   Scope* original_scope_;  // for ES5 function declarations in sloppy eval
   Target* target_stack_;  // for break, continue statements
   ParseData* cached_parse_data_;
   AstValueFactory* ast_value_factory_;
 
   CompilationInfo* info_;
 
   // Pending errors.
   bool has_pending_error_;
   Scanner::Location pending_error_location_;
   const char* pending_error_message_;
   const AstRawString* pending_error_arg_;
   const char* pending_error_char_arg_;
   bool pending_error_is_reference_error_;
 
+  // Other information which will be stored in Parser and moved to Isolate after
+  // parsing.
   int use_counts_[v8::Isolate::kUseCounterFeatureCount];
+  int total_preparse_skipped_;
+  HistogramTimer* pre_parse_timer_;
+
+  // Hash seed of the heap where strings will eventually get internalized.
+  uint32_t hash_seed_;
 };
 
 
 bool ParserTraits::IsFutureStrictReserved(
     const AstRawString* identifier) const {
   return identifier->IsOneByteEqualTo("yield") ||
          parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
 }
 
 
@@ skipping 58 matching lines @@
  private:
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_