Rename the successor field of instruction to next.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 48 matching lines @@
 }
 
 FOR_EACH_COMPUTATION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
 #define DEFINE_ACCEPT(ShortName)                                               \
 Instruction* ShortName##Instr::Accept(FlowGraphVisitor* visitor) {             \
   visitor->Visit##ShortName(this);                                             \
-  return successor();                                                          \
+  return next();                                                               \
 }
 
 FOR_EACH_INSTRUCTION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
 // True iff. the v2 is above v1 on stack, or one of them is constant.
 static bool VerifyValues(Value* v1, Value* v2) {
   ASSERT(v1->IsUse() && v2->IsUse());
@@ skipping 358 matching lines @@
   BitVector* vars =
       (variable_count == 0) ? NULL : new BitVector(variable_count);
   assigned_vars->Add(vars);
   // The preorder, parent, and assigned_vars arrays are all indexed by
   // preorder block number, so they should stay in lockstep.
   ASSERT(preorder->length() == parent->length());
   ASSERT(preorder->length() == assigned_vars->length());
 
   // 5. Iterate straight-line successors until a branch instruction or
   // another basic block entry instruction, and visit that instruction.
-  ASSERT(successor() != NULL);
-  Instruction* next = successor();
-  if (next->IsBlockEntry()) {
+  ASSERT(next() != NULL);
+  Instruction* next_instr = next();
+  if (next_instr->IsBlockEntry()) {
     set_last_instruction(this);
   } else {
-    while ((next != NULL) && !next->IsBlockEntry() && !next->IsBranch()) {
-      if (vars != NULL) next->RecordAssignedVars(vars);
-      set_last_instruction(next);
-      next = next->successor();
+    while ((next_instr != NULL) &&
+           !next_instr->IsBlockEntry() &&
+           !next_instr->IsBranch()) {
+      if (vars != NULL) next_instr->RecordAssignedVars(vars);
+      set_last_instruction(next_instr);
+      next_instr = next_instr->next();
     }
   }
-  if (next != NULL) {
-    next->DiscoverBlocks(this, preorder, postorder,
-                         parent, assigned_vars, variable_count);
+  if (next_instr != NULL) {
+    next_instr->DiscoverBlocks(this, preorder, postorder,
+                               parent, assigned_vars, variable_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
 }
 
 
 void BranchInstr::DiscoverBlocks(
     BlockEntryInstr* current_block,
@@ skipping 28 matching lines @@
   }
   ASSERT((*phis_)[var_index] == NULL);
   (*phis_)[var_index] = new PhiInstr(PredecessorCount());
   phi_count_++;
 }
 
 
 intptr_t Instruction::SuccessorCount() const {
   ASSERT(!IsBranch());
   ASSERT(!IsGraphEntry());
-  ASSERT(successor() == NULL ||
-         successor()->IsBlockEntry());
-  return successor() != NULL ? 1 : 0;
+  ASSERT(next() == NULL || next()->IsBlockEntry());
+  return (next() != NULL) ? 1 : 0;
 }
 
 
 BlockEntryInstr* Instruction::SuccessorAt(intptr_t index) const {
-  return successor()->AsBlockEntry();
+  return next()->AsBlockEntry();
 }
 
 
 intptr_t GraphEntryInstr::SuccessorCount() const {
   return 1 + catch_entries_.length();
 }
 
 
 BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return normal_entry_;
@@ skipping 764 matching lines @@
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 #undef __
 
 }  // namespace dart