Clean up node iteration

src/compiler/js-inlining.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/ast.h"
 #include "src/ast-numbering.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
@@ skipping 109 matching lines @@
 
   int predecessors = final_merge->op()->ControlInputCount();
 
   const Operator* op_phi = jsgraph->common()->Phi(kMachAnyTagged, predecessors);
   const Operator* op_ephi = jsgraph->common()->EffectPhi(predecessors);
 
   NodeVector values(jsgraph->zone());
   NodeVector effects(jsgraph->zone());
   // Iterate over all control flow predecessors,
   // which must be return statements.
-  InputIter iter = final_merge->inputs().begin();
-  while (iter != final_merge->inputs().end()) {
-    Node* input = *iter;
+  for (auto edge : final_merge->input_edges()) {
+    Node* input = edge.to();
     switch (input->opcode()) {
       case IrOpcode::kReturn:
         values.push_back(NodeProperties::GetValueInput(input, 0));
         effects.push_back(NodeProperties::GetEffectInput(input));
-        iter.UpdateToAndIncrement(NodeProperties::GetControlInput(input));
+        edge.UpdateTo(NodeProperties::GetControlInput(input));
         input->RemoveAllInputs();
         break;
       default:
         UNREACHABLE();
-        ++iter;
         break;
     }
   }
   values.push_back(final_merge);
   effects.push_back(final_merge);
   Node* phi =
       graph->NewNode(op_phi, static_cast<int>(values.size()), &values.front());
   Node* ephi = graph->NewNode(op_ephi, static_cast<int>(effects.size()),
                               &effects.front());
   Node* new_return =
       graph->NewNode(jsgraph->common()->Return(), phi, ephi, final_merge);
   graph->end()->ReplaceInput(0, new_return);
 }
 
 
 class CopyVisitor : public NullNodeVisitor {
  public:
   CopyVisitor(Graph* source_graph, Graph* target_graph, Zone* temp_zone)
       : copies_(source_graph->NodeCount(), NULL, temp_zone),
         sentinels_(source_graph->NodeCount(), NULL, temp_zone),
         source_graph_(source_graph),
         target_graph_(target_graph),
         temp_zone_(temp_zone),
         sentinel_op_(IrOpcode::kDead, Operator::kNoProperties, "sentinel", 0, 0,
                      0, 0, 0, 0) {}
 
   void Post(Node* original) {
     NodeVector inputs(temp_zone_);
-    for (InputIter it = original->inputs().begin();
-         it != original->inputs().end(); ++it) {
-      inputs.push_back(GetCopy(*it));
+    for (auto const node : original->inputs()) {
+      inputs.push_back(GetCopy(node));
     }
 
     // Reuse the operator in the copy. This assumes that op lives in a zone
     // that lives longer than graph()'s zone.
     Node* copy =
         target_graph_->NewNode(original->op(), static_cast<int>(inputs.size()),
                                (inputs.empty() ? NULL : &inputs.front()));
     copies_[original->id()] = copy;
   }
 
@@ skipping 52 matching lines @@
       simplified.LoadField(AccessBuilder::ForJSFunctionContext()),
       NodeProperties::GetValueInput(call, 0),
       NodeProperties::GetEffectInput(call), control);
 
   // Context is last argument.
   int inlinee_context_index = static_cast<int>(total_parameters()) - 1;
   // {inliner_inputs} counts JSFunction, Receiver, arguments, but not
   // context, effect, control.
   int inliner_inputs = call->op()->ValueInputCount();
   // Iterate over all uses of the start node.
-  UseIter iter = start_->uses().begin();
-  while (iter != start_->uses().end()) {
-    Node* use = *iter;
+  for (auto edge : start_->use_edges()) {
+    Node* use = edge.from();
     switch (use->opcode()) {
       case IrOpcode::kParameter: {
         int index = 1 + OpParameter<int>(use->op());
         if (index < inliner_inputs && index < inlinee_context_index) {
           // There is an input from the call, and the index is a value
           // projection but not the context, so rewire the input.
-          NodeProperties::ReplaceWithValue(*iter, call->InputAt(index));
+          NodeProperties::ReplaceWithValue(use, call->InputAt(index));
         } else if (index == inlinee_context_index) {
           // This is the context projection, rewire it to the context from the
           // JSFunction object.
-          NodeProperties::ReplaceWithValue(*iter, context);
+          NodeProperties::ReplaceWithValue(use, context);
         } else if (index < inlinee_context_index) {
           // Call has fewer arguments than required, fill with undefined.
-          NodeProperties::ReplaceWithValue(*iter, jsgraph->UndefinedConstant());
+          NodeProperties::ReplaceWithValue(use, jsgraph->UndefinedConstant());
         } else {
           // We got too many arguments, discard for now.
           // TODO(sigurds): Fix to treat arguments array correctly.
         }
-        ++iter;
         break;
       }
       default:
-        if (NodeProperties::IsEffectEdge(iter.edge())) {
-          iter.UpdateToAndIncrement(context);
-        } else if (NodeProperties::IsControlEdge(iter.edge())) {
-          iter.UpdateToAndIncrement(control);
+        if (NodeProperties::IsEffectEdge(edge)) {
+          edge.UpdateTo(context);
+        } else if (NodeProperties::IsControlEdge(edge)) {
+          edge.UpdateTo(control);
         } else {
           UNREACHABLE();
         }
         break;
     }
   }
 
   NodeProperties::ReplaceWithValue(call, value_output(), effect_output());
   call->RemoveAllInputs();
   DCHECK_EQ(0, call->UseCount());
@@ skipping 164 matching lines @@
   Node* context() const { return NodeProperties::GetContextInput(call_); }
   Node* control() const { return NodeProperties::GetControlInput(call_); }
   Node* effect() const { return NodeProperties::GetEffectInput(call_); }
 
   const Runtime::Function* function() const {
     return Runtime::FunctionForId(CallRuntimeParametersOf(call_->op()).id());
   }
 
   NodeVector inputs(Zone* zone) const {
     NodeVector inputs(zone);
-    for (InputIter it = call_->inputs().begin(); it != call_->inputs().end();
-         ++it) {
-      inputs.push_back(*it);
+    for (auto const node : call_->inputs()) {
+      inputs.push_back(node);
     }
     return inputs;
   }
 
  private:
   Node* call_;
 };
 
 
 void JSInliner::TryInlineRuntimeCall(Node* call_node) {
@@ skipping 15 matching lines @@
              info_->shared_info()->DebugName()->ToCString().get());
     }
     NodeProperties::ReplaceWithValue(call_node, r.first, r.second);
     call_node->RemoveAllInputs();
     DCHECK_EQ(0, call_node->UseCount());
   }
 }
 }
 }
 }  // namespace v8::internal::compiler