De-generify the GenericNode.

src/compiler/generic-algorithm.h

 // Copyright 2013 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.
 
 #ifndef V8_COMPILER_GENERIC_ALGORITHM_H_
 #define V8_COMPILER_GENERIC_ALGORITHM_H_
 
 #include <stack>
 
-#include "src/compiler/generic-node.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+class Graph;
+class Node;
+
 // GenericGraphVisit allows visitation of graphs of nodes and edges in pre- and
 // post-order. Visitation uses an explicitly allocated stack rather than the
 // execution stack to avoid stack overflow. Although GenericGraphVisit is
 // primarily intended to traverse networks of nodes through their
 // dependencies and uses, it also can be used to visit any graph-like network
 // by specifying custom traits.
 class GenericGraphVisit {
  public:
   // struct Visitor {
   //   void Pre(Traits::Node* current);
@@ skipping 54 matching lines @@
     }
   }
 
   template <class Visitor, class Traits>
   static void Visit(Graph* graph, Zone* zone, typename Traits::Node* current,
                     Visitor* visitor) {
     typename Traits::Node* array[] = {current};
     Visit<Visitor, Traits>(graph, zone, &array[0], &array[1], visitor);
   }
 
-  template <class B, class S>
   struct NullNodeVisitor {
-    void Pre(GenericNode<B, S>* node) {}
-    void Post(GenericNode<B, S>* node) {}
-    void PreEdge(GenericNode<B, S>* from, int index, GenericNode<B, S>* to) {}
-    void PostEdge(GenericNode<B, S>* from, int index, GenericNode<B, S>* to) {}
+    void Pre(Node* node) {}
+    void Post(Node* node) {}
+    void PreEdge(Node* from, int index, Node* to) {}
+    void PostEdge(Node* from, int index, Node* to) {}
   };
 
  private:
   static void SetVisited(BoolVector* visited, int id) {
     if (id >= static_cast<int>(visited->size())) {
       // Resize and set all values to unvisited.
       visited->resize((3 * id) / 2, false);
     }
     visited->at(id) = true;
   }
 
   static bool GetVisited(BoolVector* visited, int id) {
     if (id >= static_cast<int>(visited->size())) return false;
     return visited->at(id);
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_GENERIC_ALGORITHM_H_