Clang-Tidy: Fix src/antlr/BaseAST.*.

Author: jkohnert

src/antlr/BaseAST.cpp

@@ -25,21 +25,19 @@ BaseAST::BaseAST() : AST()
 {
 }
 
-BaseAST::~BaseAST()
-{
-}
+BaseAST::~BaseAST() = default;
 
 BaseAST::BaseAST(const BaseAST& other)
 : AST(other) // RK: don't copy links! , down(other.down), right(other.right)
 {
 }
 
-const char* BaseAST::typeName( void ) const
+const char* BaseAST::typeName() const
 {
 	return BaseAST::TYPE_NAME;
 }
 
-RefAST BaseAST::clone( void ) const
+RefAST BaseAST::clone() const
 {
 	ANTLR_USE_NAMESPACE(std)cerr << "BaseAST::clone()" << ANTLR_USE_NAMESPACE(std)endl;
 	return nullAST;
@@ -81,7 +79,8 @@ size_t BaseAST::getNumberOfChildren() const
 
 void BaseAST::doWorkForFindAll(
 		ANTLR_USE_NAMESPACE(std)vector<RefAST>& v,
-		RefAST target,bool partialMatch)
+		const RefAST& target,
+        bool partialMatch)
 {
 	// Start walking sibling lists, looking for matches.
 	for (RefAST sibling=this;
@@ -248,7 +247,7 @@ ANTLR_USE_NAMESPACE(std)string BaseAST::toString() const
 
 ANTLR_USE_NAMESPACE(std)string BaseAST::toStringList() const
 {
-	ANTLR_USE_NAMESPACE(std)string ts="";
+	ANTLR_USE_NAMESPACE(std)string ts;
 
 	if (getFirstChild())
 	{
@@ -271,7 +270,7 @@ ANTLR_USE_NAMESPACE(std)string BaseAST::toStringList() const
 
 ANTLR_USE_NAMESPACE(std)string BaseAST::toStringTree() const
 {
-	ANTLR_USE_NAMESPACE(std)string ts = "";
+	ANTLR_USE_NAMESPACE(std)string ts;
 
 	if (getFirstChild())
 	{
@@ -331,7 +330,7 @@ ANTLR_API RefAST nullAST;
 #if defined(_MSC_VER) && !defined(__ICL) // Microsoft Visual C++
 extern ANTLR_API AST* const nullASTptr = 0;
 #else
-ANTLR_API AST* const nullASTptr = 0;
+ANTLR_API AST* const nullASTptr = nullptr;
 #endif
 
 #ifdef ANTLR_CXX_SUPPORTS_NAMESPACE

src/antlr/BaseAST.hpp

@@ -1,5 +1,5 @@
-#ifndef INC_BaseAST_hpp__
-#define INC_BaseAST_hpp__
+#ifndef INC_BaseAST_hpp_
+#define INC_BaseAST_hpp_
 
 /* ANTLR Translator Generator
  * Project led by Terence Parr at http://www.jGuru.com
@@ -23,100 +23,100 @@ class ANTLR_API BaseAST : public AST {
 	BaseAST();
 	BaseAST(const BaseAST& other);
 
-	virtual ~BaseAST();
+	~BaseAST() override;
 
 	/// Return the class name
-	virtual const char* typeName( void ) const;
+	const char* typeName() const override;
 
 	/// Clone this AST node.
-	virtual RefAST clone( void ) const;
+	RefAST clone() const override;
 
    /// Is node t equal to this in terms of token type and text?
-	virtual bool equals(RefAST t) const;
+	bool equals(RefAST t) const override;
 
    /** Is t an exact structural and equals() match of this tree. The
 	 * 'this' reference is considered the start of a sibling list.
 	 */
-	virtual bool equalsList(RefAST t) const;
+	bool equalsList(RefAST t) const override;
 
    /** Is 't' a subtree of this list? The siblings of the root are NOT ignored.
     */
-	virtual bool equalsListPartial(RefAST t) const;
+	bool equalsListPartial(RefAST t) const override;
 
 	/** Is tree rooted at 'this' equal to 't'?  The siblings of 'this' are
 	 * ignored.
 	 */
-	virtual bool equalsTree(RefAST t) const;
+	bool equalsTree(RefAST t) const override;
 
 	/** Is 't' a subtree of the tree rooted at 'this'? The siblings of
 	 * 'this' are ignored.
 	 */
-	virtual bool equalsTreePartial(RefAST t) const;
+	bool equalsTreePartial(RefAST t) const override;
 
 	/** Walk the tree looking for all exact subtree matches.  Return
 	 *  an ASTEnumerator that lets the caller walk the list
 	 *  of subtree roots found herein.
 	 */
-	virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAll(RefAST t);
+	ANTLR_USE_NAMESPACE(std)vector<RefAST> findAll(RefAST t) override;
 
    /** Walk the tree looking for all subtrees.  Return
     *  an ASTEnumerator that lets the caller walk the list
     *  of subtree roots found herein.
     */
-	virtual ANTLR_USE_NAMESPACE(std)vector<RefAST> findAllPartial(RefAST t);
+	ANTLR_USE_NAMESPACE(std)vector<RefAST> findAllPartial(RefAST t) override;
 
    /// Add a node to the end of the child list for this node
-	virtual void addChild(RefAST c);
+	void addChild(RefAST c) override;
 	/** Get the number of child nodes of this node (shallow e.g. not of the
 	 * whole tree it spans).
 	 */
-	virtual size_t getNumberOfChildren() const;
+	size_t getNumberOfChildren() const override;
 
 	/// Get the first child of this node; null if no children
-	virtual RefAST getFirstChild() const
+	RefAST getFirstChild() const override
 	{
-		return RefAST(down);
+		return {down};
 	}
 	/// Get  the next sibling in line after this one
-	virtual RefAST getNextSibling() const
+	RefAST getNextSibling() const override
 	{
-		return RefAST(right);
+		return {right};
 	}
 
 	/// Get the token text for this node
-	virtual ANTLR_USE_NAMESPACE(std)string getText() const
+	ANTLR_USE_NAMESPACE(std)string getText() const override
 	{
 		return "";
 	}
 	/// Get the token type for this node
-	virtual int getType() const
+	int getType() const override
 	{
 		return 0;
 	}
 
 	/// Remove all children
 	virtual void removeChildren()
 	{
-		down = static_cast<BaseAST*>(static_cast<AST*>(nullAST));
+		down = dynamic_cast<BaseAST*>(static_cast<AST*>(nullAST));
 	}
 
 	/// Set the first child of a node.
-	virtual void setFirstChild(RefAST c)
+	void setFirstChild(RefAST c) override
 	{
-		down = static_cast<BaseAST*>(static_cast<AST*>(c));
+		down = dynamic_cast<BaseAST*>(static_cast<AST*>(c));
 	}
 
 	/// Set the next sibling after this one.
-	void setNextSibling(RefAST n)
+	void setNextSibling(RefAST n) override
 	{
-		right = static_cast<BaseAST*>(static_cast<AST*>(n));
+		right = dynamic_cast<BaseAST*>(static_cast<AST*>(n));
 	}
 
 	/// Set the token text for this node
-	virtual void setText(const ANTLR_USE_NAMESPACE(std)string& txt);
+	void setText(const ANTLR_USE_NAMESPACE(std)string& txt) override;
 
 	/// Set the token type for this node
-	virtual void setType(int type);
+	void setType(int type) override;
 
 #ifdef ANTLR_SUPPORT_XML
 	/** print attributes of this node to 'out'. Override to customize XML
@@ -132,19 +132,19 @@ class ANTLR_API BaseAST : public AST {
 #endif
 
 	/// Return string representation for the AST
-	virtual ANTLR_USE_NAMESPACE(std)string toString() const;
+	ANTLR_USE_NAMESPACE(std)string toString() const override;
 
 	/// Print out a child sibling tree in LISP notation
-	virtual ANTLR_USE_NAMESPACE(std)string toStringList() const;
-	virtual ANTLR_USE_NAMESPACE(std)string toStringTree() const;
+	ANTLR_USE_NAMESPACE(std)string toStringList() const override;
+	ANTLR_USE_NAMESPACE(std)string toStringTree() const override;
 
 	static const char* const TYPE_NAME;
 protected:
 	RefBaseAST down;
 	RefBaseAST right;
 private:
 	void doWorkForFindAll(ANTLR_USE_NAMESPACE(std)vector<RefAST>& v,
-								 RefAST target,
+								 const RefAST& target,
 								 bool partialMatch);
 };
 
@@ -161,4 +161,4 @@ inline bool BaseAST::equals(RefAST t) const
 }
 #endif
 
-#endif //INC_BaseAST_hpp__
+#endif //INC_BaseAST_hpp_