Take ast node id counting away from Isolate.

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 327 matching lines @@
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
 class ParserTraits::Checkpoint
     : public ParserBase<ParserTraits>::CheckpointBase {
  public:
   explicit Checkpoint(ParserBase<ParserTraits>* parser)
-      : CheckpointBase(parser) {
-    isolate_ = parser->zone()->isolate();
-    saved_ast_node_id_ = isolate_->ast_node_id();
+      : CheckpointBase(parser), parser_(parser) {
+    saved_ast_node_id_gen_ = *(parser_->ast_node_id_gen_);
   }
 
   void Restore() {
     CheckpointBase::Restore();
-    isolate_->set_ast_node_id(saved_ast_node_id_);
+    *(parser_->ast_node_id_gen_) = saved_ast_node_id_gen_;
   }
 
  private:
-  Isolate* isolate_;
-  int saved_ast_node_id_;
+  ParserBase<ParserTraits>* parser_;
+  AstNode::IdGen saved_ast_node_id_gen_;
 };
 
 
 bool ParserTraits::IsEvalOrArguments(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory_->eval_string() ||
          identifier == parser_->ast_value_factory_->arguments_string();
 }
 
 
 bool ParserTraits::IsThisProperty(Expression* expression) {
@@ skipping 354 matching lines @@
     FunctionLiteral::ArityRestriction arity_restriction,
     bool* ok) {
   return parser_->ParseFunctionLiteral(name, function_name_location,
                                        name_is_strict_reserved, is_generator,
                                        function_token_position, type,
                                        arity_restriction, ok);
 }
 
 
 Parser::Parser(CompilationInfo* info)
-    : ParserBase<ParserTraits>(&scanner_,
-                               info->isolate()->stack_guard()->real_climit(),
-                               info->extension(), NULL, info->zone(), this),
+    : ParserBase<ParserTraits>(
+          &scanner_, info->isolate()->stack_guard()->real_climit(),
+          info->extension(), NULL, info->zone(), info->ast_node_id_gen(), this),
       isolate_(info->isolate()),
       script_(info->script()),
       scanner_(isolate_->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       cached_parse_data_(NULL),
       ast_value_factory_(NULL),
       info_(info),
       has_pending_error_(false),
       pending_error_message_(NULL),
       pending_error_arg_(NULL),
       pending_error_char_arg_(NULL) {
   DCHECK(!script_.is_null());
-  isolate_->set_ast_node_id(0);
+  *(info->ast_node_id_gen()) = AstNode::IdGen(0);

[rossberg, 2014/08/21 13:43:35]

Isn't this default constructed in the CompilationInfo class? Are we reusing comp
infos in weird ways?

[marja, 2014/08/22 07:59:07]

This would only change things if we parse with the same CompilationInfo twice.
That shouldn't happen in the current state. I was trying to be overly defensive
(in case somebody wants to parse the same compilationinfo again in the future)
and not change the behavior in that case. Removed this line.

[rossberg, 2014/08/22 08:47:58]

Right, I don't think we should ever do such reuse. I'm pretty sure more things
would break anyway.

   set_allow_harmony_scoping(!info->is_native() && FLAG_harmony_scoping);
   set_allow_modules(!info->is_native() && FLAG_harmony_modules);
   set_allow_natives_syntax(FLAG_allow_natives_syntax || info->is_native());
   set_allow_lazy(false);  // Must be explicitly enabled.
   set_allow_generators(FLAG_harmony_generators);
   set_allow_arrow_functions(FLAG_harmony_arrow_functions);
   set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
   set_allow_classes(FLAG_harmony_classes);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
@@ skipping 91 matching lines @@
     Mode mode = (FLAG_lazy && allow_lazy()) ? PARSE_LAZILY : PARSE_EAGERLY;
     if (allow_natives_syntax() ||
         extension_ != NULL ||
         scope->is_eval_scope()) {
       mode = PARSE_EAGERLY;
     }
     ParsingModeScope parsing_mode(this, mode);
 
     // Enters 'scope'.
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
-                                 ast_value_factory_);
+                                 ast_value_factory_, info->ast_node_id_gen());
 
     scope_->SetStrictMode(info->strict_mode());
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     ParseSourceElements(body, Token::EOS, info->is_eval(), true, &ok);
 
     HandleSourceURLComments();
 
     if (ok && strict_mode() == STRICT) {
@@ skipping 97 matching lines @@
   {
     // Parse the function literal.
     Scope* scope = NewScope(scope_, GLOBAL_SCOPE);
     info()->SetGlobalScope(scope);
     if (!info()->closure().is_null()) {
       scope = Scope::DeserializeScopeChain(info()->closure()->context(), scope,
                                            zone());
     }
     original_scope_ = scope;
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
-                                 ast_value_factory_);
+                                 ast_value_factory_, info()->ast_node_id_gen());
     DCHECK(scope->strict_mode() == SLOPPY || info()->strict_mode() == STRICT);
     DCHECK(info()->strict_mode() == shared_info->strict_mode());
     scope->SetStrictMode(shared_info->strict_mode());
     FunctionLiteral::FunctionType function_type = shared_info->is_expression()
         ? (shared_info->is_anonymous()
               ? FunctionLiteral::ANONYMOUS_EXPRESSION
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
     bool is_generator = shared_info->is_generator();
     bool ok = true;
@@ skipping 2442 matching lines @@
   FunctionLiteral::ParameterFlag duplicate_parameters =
       FunctionLiteral::kNoDuplicateParameters;
   FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
       ? FunctionLiteral::kIsParenthesized
       : FunctionLiteral::kNotParenthesized;
   AstProperties ast_properties;
   BailoutReason dont_optimize_reason = kNoReason;
   // Parse function body.
   {
     FunctionState function_state(&function_state_, &scope_, scope, zone(),
-                                 ast_value_factory_);
+                                 ast_value_factory_, info()->ast_node_id_gen());
     scope_->SetScopeName(function_name);
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
@@ skipping 1374 matching lines @@
     info()->SetAstValueFactory(ast_value_factory_);
   }
   ast_value_factory_ = NULL;
 
   InternalizeUseCounts();
 
   return (result != NULL);
 }
 
 } }  // namespace v8::internal