Reland "Hook up compiler dispatcher jobs to lazy parser."

src/parsing/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_PARSING_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 94 matching lines @@
   }
 
   Scope* script_scope() { return script_scope_; }
   void set_script_scope(Scope* script_scope) { script_scope_ = script_scope; }
 
   AstValueFactory* ast_value_factory() { return ast_value_factory_; }
   void set_ast_value_factory(AstValueFactory* ast_value_factory) {
     ast_value_factory_ = ast_value_factory;
   }
 
+  const AstRawString* function_name() const { return function_name_; }
+  void set_function_name(const AstRawString* function_name) {
+    function_name_ = function_name;
+  }
+
   FunctionLiteral* literal() { return literal_; }
   void set_literal(FunctionLiteral* literal) { literal_ = literal; }
 
   Scope* scope() { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
   UnicodeCache* unicode_cache() { return unicode_cache_; }
   void set_unicode_cache(UnicodeCache* unicode_cache) {
     unicode_cache_ = unicode_cache;
   }
@@ skipping 93 matching lines @@
 
   // TODO(titzer): Move handles and isolate out of ParseInfo.
   Isolate* isolate_;
   Handle<SharedFunctionInfo> shared_;
   Handle<Script> script_;
   Handle<Context> context_;
 
   //----------- Inputs+Outputs of parsing and scope analysis -----------------
   ScriptData** cached_data_;  // used if available, populated if requested.
   AstValueFactory* ast_value_factory_;  // used if available, otherwise new.
+  const AstRawString* function_name_;
 
   //----------- Outputs of parsing and scope analysis ------------------------
   FunctionLiteral* literal_;  // produced by full parser.
   Scope* scope_;              // produced by scope analysis.
 
   void SetFlag(Flag f) { flags_ |= f; }
   void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
   bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
 };
 
@@ skipping 531 matching lines @@
   // local variables creates user-controlled constants in the generated code,
   // and we don't want too much user-controlled memory inside the code (this was
   // the reason why this limit was introduced in the first place; see
   // https://codereview.chromium.org/7003030/ ).
   static const int kMaxNumFunctionLocals = 4194303;  // 2^22-1
 
   // Returns NULL if parsing failed.
   FunctionLiteral* ParseProgram(Isolate* isolate, ParseInfo* info);
 
   FunctionLiteral* ParseLazy(Isolate* isolate, ParseInfo* info);
-  FunctionLiteral* DoParseLazy(Isolate* isolate, ParseInfo* info,
-                               const AstRawString* raw_name,
+  FunctionLiteral* DoParseLazy(ParseInfo* info, const AstRawString* raw_name,
                                Utf16CharacterStream* source);
 
   // Called by ParseProgram after setting up the scanner.
   FunctionLiteral* DoParseProgram(ParseInfo* info);
 
   void SetCachedData(ParseInfo* info);
 
   ScriptCompiler::CompileOptions compile_options() const {
     return compile_options_;
   }
@@ skipping 563 matching lines @@
 
 DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
   return parser_->ParseDoExpression(ok);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_