[turbofan] Unify custom node matchers.

src/compiler/node.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_NODE_H_
 #define V8_COMPILER_NODE_H_
 
 #include <deque>
 #include <set>
 #include <vector>
@@ skipping 260 matching lines @@
   friend class Node::UseEdges::iterator;
   friend class Node::InputEdges::iterator;
 
   explicit Edge(Node::Input* input) : input_(input) {}
 
   Node::Input* input_;
 };
 
 
 // A forward iterator to visit the edges for the input dependencies of a node..
-class Node::InputEdges::iterator {
+class Node::InputEdges::iterator FINAL {
  public:
   typedef std::forward_iterator_tag iterator_category;
-  typedef int difference_type;
+  typedef ptrdiff_t difference_type;
   typedef Edge value_type;
   typedef Edge* pointer;
   typedef Edge& reference;
   iterator(const Node::InputEdges::iterator& other)  // NOLINT
       : input_(other.input_) {}
-  iterator() : input_(NULL) {}
+  iterator() : input_(nullptr) {}
 
   Edge operator*() const { return Edge(input_); }
   bool operator==(const iterator& other) const { return Equals(other); }
   bool operator!=(const iterator& other) const { return !Equals(other); }
+  iterator& operator+=(difference_type n) {
+    DCHECK_NOT_NULL(input_);
+    Edge const edge(input_);
+    SetInput(edge.from(), input_->use->input_index + n);
+    return *this;
+  }
   iterator& operator++() {
-    DCHECK(input_ != NULL);
-    Edge edge(input_);
-    Node* from = edge.from();
-    SetInput(from, input_->use->input_index + 1);
+    (*this) += 1;
     return *this;
   }
+  iterator operator+(difference_type n) const {
+    iterator result(*this);
+    result += n;
+    return result;
+  }
   iterator operator++(int) {
     iterator result(*this);
     ++(*this);
     return result;
   }
 
  private:
   friend class Node;
 
-  explicit iterator(Node* from, int index = 0) : input_(NULL) {
+  explicit iterator(Node* from, difference_type index = 0) {
     SetInput(from, index);
   }
 
   bool Equals(const iterator& other) const { return other.input_ == input_; }
-  void SetInput(Node* from, int index) {
+  void SetInput(Node* from, difference_type index) {
     DCHECK(index >= 0 && index <= from->InputCount());
     if (index < from->InputCount()) {
-      input_ = from->GetInputRecordPtr(index);
+      input_ = from->GetInputRecordPtr(static_cast<int>(index));
     } else {
-      input_ = NULL;
+      input_ = nullptr;
     }
   }
 
   Input* input_;
 };
 
 
 // A forward iterator to visit the inputs of a node.
-class Node::Inputs::iterator {
+class Node::Inputs::iterator FINAL {
  public:
   typedef std::forward_iterator_tag iterator_category;
-  typedef int difference_type;
+  typedef ptrdiff_t difference_type;
   typedef Node* value_type;
   typedef Node** pointer;
   typedef Node*& reference;
 
   iterator(const Node::Inputs::iterator& other)  // NOLINT
       : iter_(other.iter_) {}
 
   Node* operator*() const { return (*iter_).to(); }
   bool operator==(const iterator& other) const { return Equals(other); }
   bool operator!=(const iterator& other) const { return !Equals(other); }
+  iterator& operator+=(difference_type n) {
+    iter_ += n;
+    return *this;
+  }
   iterator& operator++() {
     ++iter_;
     return *this;
   }
+  iterator operator+(difference_type n) const {
+    iterator result(*this);
+    result += n;
+    return result;
+  }
   iterator operator++(int) {
     iterator result(*this);
     ++(*this);
     return result;
   }
 
 
  private:
   friend class Node::Inputs;
 
@@ skipping 294 matching lines @@
 inline bool Node::OwnedBy(Node* owner) const {
   return first_use_ != NULL && first_use_->from == owner &&
          first_use_->next == NULL;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_H_