Replace OVERRIDE->override and FINAL->final since we now require C++11.

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 "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/types-inl.h"
@@ skipping 21 matching lines @@
 
 // A Node is the basic primitive of graphs. Nodes are chained together by
 // input/use chains but by default otherwise contain only an identifying number
 // which specific applications of graphs and nodes can use to index auxiliary
 // out-of-line data, especially transient data.
 //
 // In addition Nodes only contain a mutable Operator that may change during
 // compilation, e.g. during lowering passes. Other information that needs to be
 // associated with Nodes during compilation must be stored out-of-line indexed
 // by the Node's id.
-class Node FINAL {
+class Node final {
  public:
   static Node* New(Zone* zone, NodeId id, const Operator* op, int input_count,
                    Node** inputs, bool has_extensible_inputs);
 
   bool IsDead() const { return InputCount() > 0 && !InputAt(0); }
   void Kill();
 
   const Operator* op() const { return op_; }
   void set_op(const Operator* op) { op_ = op; }
 
   IrOpcode::Value opcode() const {
     DCHECK(op_->opcode() <= IrOpcode::kLast);
     return static_cast<IrOpcode::Value>(op_->opcode());
   }
 
   NodeId id() const { return id_; }
 
   int InputCount() const { return input_count(); }
   Node* InputAt(int index) const { return GetInputRecordPtr(index)->to; }
   inline void ReplaceInput(int index, Node* new_to);
   void AppendInput(Zone* zone, Node* new_to);
   void InsertInput(Zone* zone, int index, Node* new_to);
   void RemoveInput(int index);
   void NullAllInputs();
   void TrimInputCount(int new_input_count);
 
   int UseCount() const;
   void ReplaceUses(Node* replace_to);
 
-  class InputEdges FINAL {
+  class InputEdges final {
    public:
     typedef Edge value_type;
 
     class iterator;
     inline iterator begin() const;
     inline iterator end() const;
 
     bool empty() const;
 
     explicit InputEdges(Node* node) : node_(node) {}
 
    private:
     Node* node_;
   };
 
   InputEdges input_edges() { return InputEdges(this); }
 
-  class Inputs FINAL {
+  class Inputs final {
    public:
     typedef Node* value_type;
 
     class const_iterator;
     inline const_iterator begin() const;
     inline const_iterator end() const;
 
     bool empty() const;
 
     explicit Inputs(Node* node) : node_(node) {}
 
    private:
     Node* node_;
   };
 
   Inputs inputs() { return Inputs(this); }
 
-  class UseEdges FINAL {
+  class UseEdges final {
    public:
     typedef Edge value_type;
 
     class iterator;
     inline iterator begin() const;
     inline iterator end() const;
 
     bool empty() const;
 
     explicit UseEdges(Node* node) : node_(node) {}
 
    private:
     Node* node_;
   };
 
   UseEdges use_edges() { return UseEdges(this); }
 
-  class Uses FINAL {
+  class Uses final {
    public:
     typedef Node* value_type;
 
     class const_iterator;
     inline const_iterator begin() const;
     inline const_iterator end() const;
 
     bool empty() const;
 
     explicit Uses(Node* node) : node_(node) {}
 
    private:
     Node* node_;
   };
 
   Uses uses() { return Uses(this); }
 
   // Returns true if {owner} is the user of {this} node.
   bool OwnedBy(Node* owner) const {
     return first_use_ && first_use_->from == owner && !first_use_->next;
   }
 
  private:
-  struct Use FINAL : public ZoneObject {
+  struct Use final : public ZoneObject {
     Node* from;
     Use* next;
     Use* prev;
     int input_index;
   };
 
-  class Input FINAL {
+  class Input final {
    public:
     Node* to;
     Use* use;
 
     void Update(Node* new_to);
   };
 
   inline Node(NodeId id, const Operator* op, int input_count,
               int reserve_input_count);
 
@@ skipping 87 matching lines @@
 // Helper to extract parameters from Operator1<*> nodes.
 template <typename T>
 static inline const T& OpParameter(const Node* node) {
   return OpParameter<T>(node->op());
 }
 
 
 // An encapsulation for information associated with a single use of node as a
 // input from another node, allowing access to both the defining node and
 // the node having the input.
-class Edge FINAL {
+class Edge final {
  public:
   Node* from() const { return input_->use->from; }
   Node* to() const { return input_->to; }
   int index() const {
     int const index = input_->use->input_index;
     DCHECK_LT(index, input_->use->from->input_count());
     return index;
   }
 
   bool operator==(const Edge& other) { return input_ == other.input_; }
   bool operator!=(const Edge& other) { return !(*this == other); }
 
   void UpdateTo(Node* new_to) { input_->Update(new_to); }
 
  private:
   friend class Node::UseEdges::iterator;
   friend class Node::InputEdges::iterator;
 
   explicit Edge(Node::Input* input) : input_(input) { DCHECK_NOT_NULL(input); }
 
   Node::Input* input_;
 };
 
 
 // A forward iterator to visit the edges for the input dependencies of a node.
-class Node::InputEdges::iterator FINAL {
+class Node::InputEdges::iterator final {
  public:
   typedef std::forward_iterator_tag iterator_category;
   typedef int difference_type;
   typedef Edge value_type;
   typedef Edge* pointer;
   typedef Edge& reference;
 
   iterator() : input_(nullptr) {}
   iterator(const iterator& other) : input_(other.input_) {}
 
@@ skipping 32 matching lines @@
   return Node::InputEdges::iterator(this->node_, 0);
 }
 
 
 Node::InputEdges::iterator Node::InputEdges::end() const {
   return Node::InputEdges::iterator(this->node_, this->node_->InputCount());
 }
 
 
 // A forward iterator to visit the inputs of a node.
-class Node::Inputs::const_iterator FINAL {
+class Node::Inputs::const_iterator final {
  public:
   typedef std::forward_iterator_tag iterator_category;
   typedef int difference_type;
   typedef Node* value_type;
   typedef Node** pointer;
   typedef Node*& reference;
 
   const_iterator(const const_iterator& other) : iter_(other.iter_) {}
 
   Node* operator*() const { return (*iter_).to(); }
@@ skipping 24 matching lines @@
 
 
 Node::Inputs::const_iterator Node::Inputs::end() const {
   return const_iterator(this->node_, this->node_->InputCount());
 }
 
 
 // A forward iterator to visit the uses edges of a node. The edges are returned
 // in
 // the order in which they were added as inputs.
-class Node::UseEdges::iterator FINAL {
+class Node::UseEdges::iterator final {
  public:
   iterator(const iterator& other)
       : current_(other.current_), next_(other.next_) {}
 
   Edge operator*() const {
     return Edge(current_->from->GetInputRecordPtr(current_->input_index));
   }
 
   bool operator==(const iterator& other) const {
     return current_ == other.current_;
@@ skipping 25 matching lines @@
 }
 
 
 Node::UseEdges::iterator Node::UseEdges::end() const {
   return Node::UseEdges::iterator();
 }
 
 
 // A forward iterator to visit the uses of a node. The uses are returned in
 // the order in which they were added as inputs.
-class Node::Uses::const_iterator FINAL {
+class Node::Uses::const_iterator final {
  public:
   typedef std::forward_iterator_tag iterator_category;
   typedef int difference_type;
   typedef Node* value_type;
   typedef Node** pointer;
   typedef Node*& reference;
 
   const_iterator(const const_iterator& other) : current_(other.current_) {}
 
   Node* operator*() const { return current_->from; }
@@ skipping 30 matching lines @@
 
 void Node::ReplaceInput(int index, Node* new_to) {
   GetInputRecordPtr(index)->Update(new_to);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_H_