Revert "[turbofan] Merge GenericNode with Node."

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-graph.h"
+#include "src/compiler/generic-node.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // 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
@@ skipping 70 matching lines @@
     }
   }
 
   template <class Visitor, class Traits>
   static void Visit(GenericGraphBase* 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 Node>
+  template <class B, class S>
   struct NullNodeVisitor {
-    Control Pre(Node* node) { return CONTINUE; }
-    Control Post(Node* node) { return CONTINUE; }
-    void PreEdge(Node* from, int index, Node* to) {}
-    void PostEdge(Node* from, int index, Node* to) {}
+    Control Pre(GenericNode<B, S>* node) { return CONTINUE; }
+    Control Post(GenericNode<B, S>* node) { return CONTINUE; }
+    void PreEdge(GenericNode<B, S>* from, int index, GenericNode<B, S>* to) {}
+    void PostEdge(GenericNode<B, S>* from, int index, GenericNode<B, S>* to) {}
   };
 
  private:
   static bool IsSkip(Control c) { return c & SKIP; }
   static bool IsReenter(Control c) { return c & REENTER; }
 
   // TODO(turbofan): resizing could be optionally templatized away.
   static void SetVisited(BoolVector* visited, int id, bool value) {
     if (id >= static_cast<int>(visited->size())) {
       // Resize and set all values to unvisited.
       visited->resize((3 * id) / 2, false);
     }
     visited->at(id) = value;
   }
 
   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_