Convert OVERRIDE -> override and update virtual/final usage in tools/gn/.

tools/gn/parse_tree.h

 // Copyright 2014 The Chromium 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 TOOLS_GN_PARSE_TREE_H_
 #define TOOLS_GN_PARSE_TREE_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "tools/gn/err.h"
 #include "tools/gn/token.h"
 #include "tools/gn/value.h"
 
 class AccessorNode;
 class BinaryOpNode;
 class BlockCommentNode;
 class BlockNode;
 class ConditionNode;
@@ skipping 108 matching lines @@
 //
 // Additionally, the left-hand-side of the accessor must currently be an
 // identifier. So you can't do things like:
 //   function_call()[1]
 //   a = b.c.d
 // These are easier to implement if we needed them but given the very limited
 // use cases for this, it hasn't seemed worth the bother.
 class AccessorNode : public ParseNode {
  public:
   AccessorNode();
-  virtual ~AccessorNode();
+  ~AccessorNode() override;
 
-  virtual const AccessorNode* AsAccessor() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const AccessorNode* AsAccessor() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   // Base is the thing on the left of the [] or dot, currently always required
   // to be an identifier token.
   const Token& base() const { return base_; }
   void set_base(const Token& b) { base_ = b; }
 
   // Index is the expression inside the []. Will be null if member is set.
   const ParseNode* index() const { return index_.get(); }
   void set_index(scoped_ptr<ParseNode> i) { index_ = i.Pass(); }
 
@@ skipping 14 matching lines @@
   scoped_ptr<IdentifierNode> member_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessorNode);
 };
 
 // BinaryOpNode ----------------------------------------------------------------
 
 class BinaryOpNode : public ParseNode {
  public:
   BinaryOpNode();
-  virtual ~BinaryOpNode();
+  ~BinaryOpNode() override;
 
-  virtual const BinaryOpNode* AsBinaryOp() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const BinaryOpNode* AsBinaryOp() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& op() const { return op_; }
   void set_op(const Token& t) { op_ = t; }
 
   const ParseNode* left() const { return left_.get(); }
   void set_left(scoped_ptr<ParseNode> left) {
     left_ = left.Pass();
   }
 
   const ParseNode* right() const { return right_.get(); }
   void set_right(scoped_ptr<ParseNode> right) {
     right_ = right.Pass();
   }
 
  private:
   scoped_ptr<ParseNode> left_;
   Token op_;
   scoped_ptr<ParseNode> right_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryOpNode);
 };
 
 // BlockNode -------------------------------------------------------------------
 
 class BlockNode : public ParseNode {
  public:
   // Set has_scope if this block introduces a nested scope.
   explicit BlockNode(bool has_scope);
-  virtual ~BlockNode();
+  ~BlockNode() override;
 
-  virtual const BlockNode* AsBlock() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const BlockNode* AsBlock() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
   const EndNode* End() const { return end_.get(); }
 
   const std::vector<ParseNode*>& statements() const { return statements_; }
   void append_statement(scoped_ptr<ParseNode> s) {
     statements_.push_back(s.release());
   }
 
@@ skipping 12 matching lines @@
   std::vector<ParseNode*> statements_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockNode);
 };
 
 // ConditionNode ---------------------------------------------------------------
 
 class ConditionNode : public ParseNode {
  public:
   ConditionNode();
-  virtual ~ConditionNode();
+  ~ConditionNode() override;
 
-  virtual const ConditionNode* AsConditionNode() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const ConditionNode* AsConditionNode() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   void set_if_token(const Token& token) { if_token_ = token; }
 
   const ParseNode* condition() const { return condition_.get(); }
   void set_condition(scoped_ptr<ParseNode> c) {
     condition_ = c.Pass();
   }
 
   const BlockNode* if_true() const { return if_true_.get(); }
   void set_if_true(scoped_ptr<BlockNode> t) {
@@ skipping 16 matching lines @@
   scoped_ptr<ParseNode> if_false_;  // May be null.
 
   DISALLOW_COPY_AND_ASSIGN(ConditionNode);
 };
 
 // FunctionCallNode ------------------------------------------------------------
 
 class FunctionCallNode : public ParseNode {
  public:
   FunctionCallNode();
-  virtual ~FunctionCallNode();
+  ~FunctionCallNode() override;
 
-  virtual const FunctionCallNode* AsFunctionCall() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const FunctionCallNode* AsFunctionCall() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& function() const { return function_; }
   void set_function(Token t) { function_ = t; }
 
   const ListNode* args() const { return args_.get(); }
   void set_args(scoped_ptr<ListNode> a) { args_ = a.Pass(); }
 
   const BlockNode* block() const { return block_.get(); }
   void set_block(scoped_ptr<BlockNode> b) { block_ = b.Pass(); }
 
  private:
   Token function_;
   scoped_ptr<ListNode> args_;
   scoped_ptr<BlockNode> block_;  // May be null.
 
   DISALLOW_COPY_AND_ASSIGN(FunctionCallNode);
 };
 
 // IdentifierNode --------------------------------------------------------------
 
 class IdentifierNode : public ParseNode {
  public:
   IdentifierNode();
   IdentifierNode(const Token& token);
-  virtual ~IdentifierNode();
+  ~IdentifierNode() override;
 
-  virtual const IdentifierNode* AsIdentifier() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const IdentifierNode* AsIdentifier() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(IdentifierNode);
 };
 
 // ListNode --------------------------------------------------------------------
 
 class ListNode : public ParseNode {
  public:
   ListNode();
-  virtual ~ListNode();
+  ~ListNode() override;
 
-  virtual const ListNode* AsList() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const ListNode* AsList() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
   const EndNode* End() const { return end_.get(); }
 
   void append_item(scoped_ptr<ParseNode> s) {
     contents_.push_back(s.release());
   }
   const std::vector<const ParseNode*>& contents() const { return contents_; }
 
  private:
   // Tokens corresponding to the [ and ]. The end token is stored in inside an
   // custom parse node so that it can have comments hung off of it.
   Token begin_token_;
   scoped_ptr<EndNode> end_;
 
   // Owning pointers, use unique_ptr when we can use C++11.
   std::vector<const ParseNode*> contents_;
 
   DISALLOW_COPY_AND_ASSIGN(ListNode);
 };
 
 // LiteralNode -----------------------------------------------------------------
 
 class LiteralNode : public ParseNode {
  public:
   LiteralNode();
   LiteralNode(const Token& token);
-  virtual ~LiteralNode();
+  ~LiteralNode() override;
 
-  virtual const LiteralNode* AsLiteral() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const LiteralNode* AsLiteral() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(LiteralNode);
 };
 
 // UnaryOpNode -----------------------------------------------------------------
 
 class UnaryOpNode : public ParseNode {
  public:
   UnaryOpNode();
-  virtual ~UnaryOpNode();
+  ~UnaryOpNode() override;
 
-  virtual const UnaryOpNode* AsUnaryOp() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const UnaryOpNode* AsUnaryOp() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& op() const { return op_; }
   void set_op(const Token& t) { op_ = t; }
 
   const ParseNode* operand() const { return operand_.get(); }
   void set_operand(scoped_ptr<ParseNode> operand) {
     operand_ = operand.Pass();
   }
 
  private:
   Token op_;
   scoped_ptr<ParseNode> operand_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryOpNode);
 };
 
 // BlockCommentNode ------------------------------------------------------------
 
 // This node type is only used for standalone comments (that is, those not
 // specifically attached to another syntax element. The most common of these
 // is a standard header block. This node contains only the last line of such
 // a comment block as the anchor, and other lines of the block comment are
 // hung off of it as Before comments, similar to other syntax elements.
 class BlockCommentNode : public ParseNode {
  public:
   BlockCommentNode();
-  virtual ~BlockCommentNode();
+  ~BlockCommentNode() override;
 
-  virtual const BlockCommentNode* AsBlockComment() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const BlockCommentNode* AsBlockComment() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& comment() const { return comment_; }
   void set_comment(const Token& t) { comment_ = t; }
 
  private:
   Token comment_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockCommentNode);
 };
 
 // EndNode ---------------------------------------------------------------------
 
 // This node type is used as the end_ object for lists and blocks (rather than
 // just the end ']', '}', or ')' token). This is so that during formatting
 // traversal there is a node that appears at the end of the block to which
 // comments can be attached.
 class EndNode : public ParseNode {
  public:
   EndNode(const Token& token);
-  virtual ~EndNode();
+  ~EndNode() override;
 
-  virtual const EndNode* AsEnd() const override;
-  virtual Value Execute(Scope* scope, Err* err) const override;
-  virtual LocationRange GetRange() const override;
-  virtual Err MakeErrorDescribing(
+  const EndNode* AsEnd() const override;
+  Value Execute(Scope* scope, Err* err) const override;
+  LocationRange GetRange() const override;
+  Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
-  virtual void Print(std::ostream& out, int indent) const override;
+  void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(EndNode);
 };
 
 #endif  // TOOLS_GN_PARSE_TREE_H_