Introduce subclass wrappers for STL containers that make them a lot easier

src/compiler/structured-machine-assembler.cc

 // Copyright 2014 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/compiler/pipeline.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/structured-machine-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 288 matching lines @@
   if (environment->is_dead_) return;
   BasicBlock* true_block = TrampolineFor(true_val->block_);
   BasicBlock* false_block = TrampolineFor(false_val->block_);
   schedule()->AddBranch(environment->block_, branch, true_block, false_block);
 }
 
 
 StructuredMachineAssembler::Environment::Environment(Zone* zone,
                                                      BasicBlock* block,
                                                      bool is_dead)
-    : block_(block),
-      variables_(NodeVector::allocator_type(zone)),
-      is_dead_(is_dead) {}
+    : block_(block), variables_(zone), is_dead_(is_dead) {}
 
 
 StructuredMachineAssembler::IfBuilder::IfBuilder(
     StructuredMachineAssembler* smasm)
     : smasm_(smasm),
-      if_clauses_(IfClauses::allocator_type(smasm_->zone())),
-      pending_exit_merges_(EnvironmentVector::allocator_type(smasm_->zone())) {
+      if_clauses_(smasm_->zone()),
+      pending_exit_merges_(smasm_->zone()) {
   DCHECK(smasm_->current_environment_ != NULL);
   PushNewIfClause();
   DCHECK(!IsDone());
 }
 
 
 StructuredMachineAssembler::IfBuilder&
 StructuredMachineAssembler::IfBuilder::If() {
   DCHECK(smasm_->current_environment_ != NULL);
   IfClause* clause = CurrentClause();
@@ skipping 58 matching lines @@
       static_cast<int>(smasm_->current_environment_->variables_.size());
   IfClause* clause = new (smasm_->zone()) IfClause(smasm_->zone(), curr_size);
   if_clauses_.push_back(clause);
 }
 
 
 StructuredMachineAssembler::IfBuilder::IfClause::IfClause(
     Zone* zone, int initial_environment_size)
     : unresolved_list_tail_(NULL),
       initial_environment_size_(initial_environment_size),
-      expression_states_(ExpressionStates::allocator_type(zone)),
-      pending_then_merges_(PendingMergeStack::allocator_type(zone)),
-      pending_else_merges_(PendingMergeStack::allocator_type(zone)),
+      expression_states_(zone),
+      pending_then_merges_(zone),
+      pending_else_merges_(zone),
       then_environment_(NULL),
       else_environment_(NULL) {
   PushNewExpressionState();
 }
 
 
 StructuredMachineAssembler::IfBuilder::PendingMergeStackRange
 StructuredMachineAssembler::IfBuilder::IfClause::ComputeRelevantMerges(
     CombineType combine_type) {
   DCHECK(!expression_states_.empty());
@@ skipping 22 matching lines @@
   PendingMergeStackRange data = ComputeRelevantMerges(combine_type);
   DCHECK_EQ(data.merge_stack_->back(), unresolved_list_tail_);
   DCHECK(data.size_ > 0);
   // TODO(dcarney): assert no new variables created during expression building.
   int truncate_at = initial_environment_size_;
   if (data.size_ == 1) {
     // Just copy environment in common case.
     smasm->current_environment_ =
         smasm->Copy(unresolved_list_tail_->environment_, truncate_at);
   } else {
-    EnvironmentVector environments(
-        EnvironmentVector::allocator_type(smasm->zone()));
+    EnvironmentVector environments(smasm->zone());
     environments.reserve(data.size_);
     CopyEnvironments(data, &environments);
     DCHECK(static_cast<int>(environments.size()) == data.size_);
     smasm->Merge(&environments, truncate_at);
   }
   Environment* then_environment = then_environment_;
   Environment* else_environment = NULL;
   if (resolution_type == kExpressionDone) {
     DCHECK(expression_states_.size() == 1);
     // Set the current then_ or else_environment_ to the new merged environment.
@@ skipping 149 matching lines @@
   pending_exit_merges_.clear();
   if_clauses_.clear();
   DCHECK(IsDone());
 }
 
 
 StructuredMachineAssembler::LoopBuilder::LoopBuilder(
     StructuredMachineAssembler* smasm)
     : smasm_(smasm),
       header_environment_(NULL),
-      pending_header_merges_(EnvironmentVector::allocator_type(smasm_->zone())),
-      pending_exit_merges_(EnvironmentVector::allocator_type(smasm_->zone())) {
+      pending_header_merges_(smasm_->zone()),
+      pending_exit_merges_(smasm_->zone()) {
   DCHECK(smasm_->current_environment_ != NULL);
   // Create header environment.
   header_environment_ = smasm_->CopyForLoopHeader(smasm_->current_environment_);
   smasm_->AddGoto(smasm_->current_environment_, header_environment_);
   // Create body environment.
   Environment* body = smasm_->Copy(header_environment_);
   smasm_->AddGoto(header_environment_, body);
   smasm_->current_environment_ = body;
   DCHECK(!IsDone());
 }
@@ skipping 30 matching lines @@
   }
   pending_header_merges_.clear();
   pending_exit_merges_.clear();
   header_environment_ = NULL;
   DCHECK(IsDone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8