Make generic algorithm less generic.

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 14 matching lines @@
 
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class InlinerVisitor : public NullNodeVisitor {
  public:
   explicit InlinerVisitor(JSInliner* inliner) : inliner_(inliner) {}
 
-  GenericGraphVisit::Control Post(Node* node) {
+  void Post(Node* node) {
     switch (node->opcode()) {
       case IrOpcode::kJSCallFunction:
         inliner_->TryInlineJSCall(node);
         break;
       case IrOpcode::kJSCallRuntime:
         if (FLAG_turbo_inlining_intrinsics) {
           inliner_->TryInlineRuntimeCall(node);
         }
         break;
       default:
         break;
     }
-    return GenericGraphVisit::CONTINUE;
   }
 
  private:
   JSInliner* inliner_;
 };
 
 
 void JSInliner::Inline() {
   InlinerVisitor visitor(this);
   jsgraph_->graph()->VisitNodeInputsFromEnd(&visitor);
@@ skipping 101 matching lines @@
  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) {}
 
-  GenericGraphVisit::Control Post(Node* original) {
+  void Post(Node* original) {
     NodeVector inputs(temp_zone_);
     for (InputIter it = original->inputs().begin();
          it != original->inputs().end(); ++it) {
       inputs.push_back(GetCopy(*it));
     }
 
     // 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;
-    return GenericGraphVisit::CONTINUE;
   }
 
   Node* GetCopy(Node* original) {
     Node* copy = copies_[original->id()];
     if (copy == NULL) {
       copy = GetSentinel(original);
     }
     DCHECK_NE(NULL, copy);
     return copy;
   }
@@ skipping 294 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