RFC: Switch to ast ids (instead of positions) for type feedback.

src/hydrogen.cc

 // Copyright 2010 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 103 matching lines @@
 
 HInstruction* HBasicBlock::GetLastInstruction() {
   if (end_ != NULL) return end_->previous();
   if (first_ == NULL) return NULL;
   if (last_ == NULL) last_ = first_;
   while (last_->next() != NULL) last_ = last_->next();
   return last_;
 }
 
 
-HSimulate* HBasicBlock::CreateSimulate(int id) {
+HSimulate* HBasicBlock::CreateSimulate(AstId id) {
   ASSERT(HasEnvironment());
   HEnvironment* environment = last_environment();
-  ASSERT(id == AstNode::kNoNumber ||
+  ASSERT(id == kNoAstId ||
          environment->closure()->shared()->VerifyBailoutId(id));
 
   int push_count = environment->push_count();
   int pop_count = environment->pop_count();
 
   int length = environment->values()->length();
   HSimulate* instr = new HSimulate(id, pop_count, length);
   for (int i = push_count - 1; i >= 0; --i) {
     instr->AddPushedValue(environment->ExpressionStackAt(i));
   }
@@ skipping 13 matching lines @@
   if (end->FirstSuccessor() != NULL) {
     end->FirstSuccessor()->RegisterPredecessor(this);
     if (end->SecondSuccessor() != NULL) {
       end->SecondSuccessor()->RegisterPredecessor(this);
     }
   }
 }
 
 
 void HBasicBlock::Goto(HBasicBlock* block, bool include_stack_check) {
-  AddSimulate(AstNode::kNoNumber);
+  AddSimulate(kNoAstId);
   HGoto* instr = new HGoto(block);
   instr->set_include_stack_check(include_stack_check);
   Finish(instr);
 }
 
 
 void HBasicBlock::SetInitialEnvironment(HEnvironment* env) {
   ASSERT(!HasEnvironment());
   ASSERT(first() == NULL);
   UpdateEnvironment(env);
@@ skipping 255 matching lines @@
 
     // Check that phis have correct arguments.
     for (int j = 0; j < block->phis()->length(); j++) {
       HPhi* phi = block->phis()->at(j);
       phi->Verify();
     }
 
     // Check that all join blocks have predecessors that end with an
     // unconditional goto and agree on their environment node id.
     if (block->predecessors()->length() >= 2) {
-      int id = block->predecessors()->first()->last_environment()->ast_id();
+      AstId id = block->predecessors()->first()->last_environment()->ast_id();
       for (int k = 0; k < block->predecessors()->length(); k++) {
         HBasicBlock* predecessor = block->predecessors()->at(k);
         ASSERT(predecessor->end()->IsGoto());
         ASSERT(predecessor->last_environment()->ast_id() == id);
       }
     }
   }
 
   // Check special property of first block to have no predecessors.
   ASSERT(blocks_.at(0)->predecessors()->is_empty());
@@ skipping 3498 matching lines @@
                                    invert_true, invert_false);
     function_return_ = NULL;
   } else {
     // Inlined body is treated as if it occurs in the original call context.
     function_return_ = graph()->CreateBasicBlock();
     function_return_->MarkAsInlineReturnTarget();
   }
   call_context_ = ast_context();
   TypeFeedbackOracle new_oracle(Handle<Code>(shared->code()));
   oracle_ = &new_oracle;
-  graph()->info()->SetOsrAstId(AstNode::kNoNumber);
+  graph()->info()->SetOsrAstId(kNoAstId);
 
   HSubgraph* body = CreateInlinedSubgraph(env, target, function);
   body->exit_block()->AddInstruction(new HEnterInlined(target, function));
   AddToSubgraph(body, function->body());
   if (HasStackOverflow()) {
     // Bail out if the inline function did, as we cannot residualize a call
     // instead.
     delete test_context;
     call_context_ = saved_call_context;
     function_return_ = saved_function_return;
@@ skipping 483 matching lines @@
   // occurs as a subexpression of CountOperation.
   UNREACHABLE();
 }
 
 
 HInstruction* HGraphBuilder::BuildIncrement(HValue* value, bool increment) {
   HConstant* delta = increment
       ? graph_->GetConstant1()
       : graph_->GetConstantMinus1();
   HInstruction* instr = new HAdd(value, delta);
-  AssumeRepresentation(instr,  Representation::Integer32());
+  AssumeRepresentation(instr, Representation::Integer32());
   return instr;
 }
 
 
 void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
   IncrementOperation* increment = expr->increment();
   Expression* target = increment->expression();
   VariableProxy* proxy = target->AsVariableProxy();
   Variable* var = proxy->AsVariable();
   Property* prop = target->AsProperty();
@@ skipping 653 matching lines @@
                            Scope* scope,
                            Handle<JSFunction> closure)
     : closure_(closure),
       values_(0),
       assigned_variables_(4),
       parameter_count_(0),
       local_count_(0),
       outer_(outer),
       pop_count_(0),
       push_count_(0),
-      ast_id_(AstNode::kNoNumber) {
+      ast_id_(kNoAstId) {
   Initialize(scope->num_parameters() + 1, scope->num_stack_slots(), 0);
 }
 
 
 HEnvironment::HEnvironment(const HEnvironment* other)
     : values_(0),
       assigned_variables_(0),
       parameter_count_(0),
       local_count_(0),
       outer_(NULL),
@@ skipping 432 matching lines @@
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (chunk_ != NULL) chunk_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal