https://github.com/Sirraide updated
https://github.com/llvm/llvm-project/pull/124821
>From d55c5afe4a485b6d0431386e6f45cb44c1fc8883 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalm...@gmail.com>
Date: Tue, 14 Jan 2025 22:01:04 +0100
Subject: [PATCH 1/4] [Clang] [NFC] Introduce ConstDynamicRecursiveASTVisitor
---
.../clang/AST/DynamicRecursiveASTVisitor.h | 113 +++++---
clang/lib/AST/DynamicRecursiveASTVisitor.cpp | 250 ++++++------------
2 files changed, 156 insertions(+), 207 deletions(-)
diff --git a/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
b/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
index 4382d209908292..31b588e3a60638 100644
--- a/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
+++ b/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
@@ -52,7 +52,11 @@ class ASTContext;
/// WalkUpFromX or post-order traversal).
///
/// \see RecursiveASTVisitor.
-class DynamicRecursiveASTVisitor {
+template <bool IsConst> class DynamicRecursiveASTVisitorBase {
+protected:
+ template <typename ASTNode>
+ using MaybeConst = std::conditional_t<IsConst, const ASTNode, ASTNode>;
+
public:
/// Whether this visitor should recurse into template instantiations.
bool ShouldVisitTemplateInstantiations = false;
@@ -68,28 +72,29 @@ class DynamicRecursiveASTVisitor {
bool ShouldVisitLambdaBody = true;
protected:
- DynamicRecursiveASTVisitor() = default;
- DynamicRecursiveASTVisitor(DynamicRecursiveASTVisitor &&) = default;
- DynamicRecursiveASTVisitor(const DynamicRecursiveASTVisitor &) = default;
- DynamicRecursiveASTVisitor &
- operator=(DynamicRecursiveASTVisitor &&) = default;
- DynamicRecursiveASTVisitor &
- operator=(const DynamicRecursiveASTVisitor &) = default;
+ DynamicRecursiveASTVisitorBase() = default;
+ DynamicRecursiveASTVisitorBase(DynamicRecursiveASTVisitorBase &&) = default;
+ DynamicRecursiveASTVisitorBase(const DynamicRecursiveASTVisitorBase &) =
+ default;
+ DynamicRecursiveASTVisitorBase &
+ operator=(DynamicRecursiveASTVisitorBase &&) = default;
+ DynamicRecursiveASTVisitorBase &
+ operator=(const DynamicRecursiveASTVisitorBase &) = default;
public:
virtual void anchor();
- virtual ~DynamicRecursiveASTVisitor() = default;
+ virtual ~DynamicRecursiveASTVisitorBase() = default;
/// Recursively visits an entire AST, starting from the TranslationUnitDecl.
/// \returns false if visitation was terminated early.
- virtual bool TraverseAST(ASTContext &AST);
+ virtual bool TraverseAST(MaybeConst<ASTContext> &AST);
/// Recursively visit an attribute, by dispatching to
/// Traverse*Attr() based on the argument's dynamic type.
///
/// \returns false if the visitation was terminated early, true
/// otherwise (including when the argument is a Null type location).
- virtual bool TraverseAttr(Attr *At);
+ virtual bool TraverseAttr(MaybeConst<Attr> *At);
/// Recursively visit a constructor initializer. This
/// automatically dispatches to another visitor for the initializer
@@ -97,7 +102,8 @@ class DynamicRecursiveASTVisitor {
/// be overridden for clients that need access to the name.
///
/// \returns false if the visitation was terminated early, true otherwise.
- virtual bool TraverseConstructorInitializer(CXXCtorInitializer *Init);
+ virtual bool
+ TraverseConstructorInitializer(MaybeConst<CXXCtorInitializer> *Init);
/// Recursively visit a base specifier. This can be overridden by a
/// subclass.
@@ -110,7 +116,7 @@ class DynamicRecursiveASTVisitor {
///
/// \returns false if the visitation was terminated early, true
/// otherwise (including when the argument is NULL).
- virtual bool TraverseDecl(Decl *D);
+ virtual bool TraverseDecl(MaybeConst<Decl> *D);
/// Recursively visit a name with its location information.
///
@@ -121,13 +127,14 @@ class DynamicRecursiveASTVisitor {
/// will be used to initialize the capture.
///
/// \returns false if the visitation was terminated early, true otherwise.
- virtual bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
- Expr *Init);
+ virtual bool TraverseLambdaCapture(MaybeConst<LambdaExpr> *LE,
+ const LambdaCapture *C,
+ MaybeConst<Expr> *Init);
/// Recursively visit a C++ nested-name-specifier.
///
/// \returns false if the visitation was terminated early, true otherwise.
- virtual bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
+ virtual bool TraverseNestedNameSpecifier(MaybeConst<NestedNameSpecifier>
*NNS);
/// Recursively visit a C++ nested-name-specifier with location
/// information.
@@ -140,7 +147,7 @@ class DynamicRecursiveASTVisitor {
///
/// \returns false if the visitation was terminated early, true
/// otherwise (including when the argument is nullptr).
- virtual bool TraverseStmt(Stmt *S);
+ virtual bool TraverseStmt(MaybeConst<Stmt> *S);
/// Recursively visit a template argument and dispatch to the
/// appropriate method for the argument type.
@@ -190,41 +197,51 @@ class DynamicRecursiveASTVisitor {
/// Traverse a concept (requirement).
virtual bool TraverseTypeConstraint(const TypeConstraint *C);
- virtual bool TraverseConceptRequirement(concepts::Requirement *R);
- virtual bool TraverseConceptTypeRequirement(concepts::TypeRequirement *R);
- virtual bool TraverseConceptExprRequirement(concepts::ExprRequirement *R);
- virtual bool TraverseConceptNestedRequirement(concepts::NestedRequirement
*R);
- virtual bool TraverseConceptReference(ConceptReference *CR);
- virtual bool VisitConceptReference(ConceptReference *CR) { return true; }
+ virtual bool TraverseConceptRequirement(MaybeConst<concepts::Requirement>
*R);
+
+ virtual bool
+ TraverseConceptTypeRequirement(MaybeConst<concepts::TypeRequirement> *R);
+
+ virtual bool
+ TraverseConceptExprRequirement(MaybeConst<concepts::ExprRequirement> *R);
+
+ virtual bool
+ TraverseConceptNestedRequirement(MaybeConst<concepts::NestedRequirement> *R);
+
+ virtual bool TraverseConceptReference(MaybeConst<ConceptReference> *CR);
+ virtual bool VisitConceptReference(MaybeConst<ConceptReference> *CR) {
+ return true;
+ }
/// Visit a node.
- virtual bool VisitAttr(Attr *A) { return true; }
- virtual bool VisitDecl(Decl *D) { return true; }
- virtual bool VisitStmt(Stmt *S) { return true; }
- virtual bool VisitType(Type *T) { return true; }
+ virtual bool VisitAttr(MaybeConst<Attr> *A) { return true; }
+ virtual bool VisitDecl(MaybeConst<Decl> *D) { return true; }
+ virtual bool VisitStmt(MaybeConst<Stmt> *S) { return true; }
+ virtual bool VisitType(MaybeConst<Type> *T) { return true; }
virtual bool VisitTypeLoc(TypeLoc TL) { return true; }
/// Walk up from a node.
- bool WalkUpFromDecl(Decl *D) { return VisitDecl(D); }
- bool WalkUpFromStmt(Stmt *S) { return VisitStmt(S); }
- bool WalkUpFromType(Type *T) { return VisitType(T); }
+ bool WalkUpFromDecl(MaybeConst<Decl> *D) { return VisitDecl(D); }
+ bool WalkUpFromStmt(MaybeConst<Stmt> *S) { return VisitStmt(S); }
+ bool WalkUpFromType(MaybeConst<Type> *T) { return VisitType(T); }
bool WalkUpFromTypeLoc(TypeLoc TL) { return VisitTypeLoc(TL); }
/// Invoked before visiting a statement or expression via data recursion.
///
/// \returns false to skip visiting the node, true otherwise.
- virtual bool dataTraverseStmtPre(Stmt *S) { return true; }
+ virtual bool dataTraverseStmtPre(MaybeConst<Stmt> *S) { return true; }
/// Invoked after visiting a statement or expression via data recursion.
/// This is not invoked if the previously invoked \c dataTraverseStmtPre
/// returned false.
///
/// \returns false if the visitation was terminated early, true otherwise.
- virtual bool dataTraverseStmtPost(Stmt *S) { return true; }
- virtual bool dataTraverseNode(Stmt *S);
+ virtual bool dataTraverseStmtPost(MaybeConst<Stmt> *S) { return true; }
+ virtual bool dataTraverseNode(MaybeConst<Stmt> *S);
#define DEF_TRAVERSE_TMPL_INST(kind)
\
- virtual bool TraverseTemplateInstantiations(kind##TemplateDecl *D);
+ virtual bool TraverseTemplateInstantiations(
\
+ MaybeConst<kind##TemplateDecl> *D);
DEF_TRAVERSE_TMPL_INST(Class)
DEF_TRAVERSE_TMPL_INST(Var)
DEF_TRAVERSE_TMPL_INST(Function)
@@ -232,32 +249,34 @@ class DynamicRecursiveASTVisitor {
// Decls.
#define ABSTRACT_DECL(DECL)
-#define DECL(CLASS, BASE) virtual bool Traverse##CLASS##Decl(CLASS##Decl *D);
+#define DECL(CLASS, BASE)
\
+ virtual bool Traverse##CLASS##Decl(MaybeConst<CLASS##Decl> *D);
#include "clang/AST/DeclNodes.inc"
#define DECL(CLASS, BASE)
\
- bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D);
\
- virtual bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }
+ bool WalkUpFrom##CLASS##Decl(MaybeConst<CLASS##Decl> *D);
\
+ virtual bool Visit##CLASS##Decl(MaybeConst<CLASS##Decl> *D) { return true; }
#include "clang/AST/DeclNodes.inc"
// Stmts.
#define ABSTRACT_STMT(STMT)
-#define STMT(CLASS, PARENT) virtual bool Traverse##CLASS(CLASS *S);
+#define STMT(CLASS, PARENT) virtual bool Traverse##CLASS(MaybeConst<CLASS> *S);
#include "clang/AST/StmtNodes.inc"
#define STMT(CLASS, PARENT)
\
- bool WalkUpFrom##CLASS(CLASS *S);
\
- virtual bool Visit##CLASS(CLASS *S) { return true; }
+ bool WalkUpFrom##CLASS(MaybeConst<CLASS> *S);
\
+ virtual bool Visit##CLASS(MaybeConst<CLASS> *S) { return true; }
#include "clang/AST/StmtNodes.inc"
// Types.
#define ABSTRACT_TYPE(CLASS, BASE)
-#define TYPE(CLASS, BASE) virtual bool Traverse##CLASS##Type(CLASS##Type *T);
+#define TYPE(CLASS, BASE)
\
+ virtual bool Traverse##CLASS##Type(MaybeConst<CLASS##Type> *T);
#include "clang/AST/TypeNodes.inc"
#define TYPE(CLASS, BASE)
\
- bool WalkUpFrom##CLASS##Type(CLASS##Type *T);
\
- virtual bool Visit##CLASS##Type(CLASS##Type *T) { return true; }
+ bool WalkUpFrom##CLASS##Type(MaybeConst<CLASS##Type> *T);
\
+ virtual bool Visit##CLASS##Type(MaybeConst<CLASS##Type> *T) { return true; }
#include "clang/AST/TypeNodes.inc"
// TypeLocs.
@@ -271,6 +290,14 @@ class DynamicRecursiveASTVisitor {
virtual bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }
#include "clang/AST/TypeLocNodes.def"
};
+
+extern template class DynamicRecursiveASTVisitorBase<false>;
+extern template class DynamicRecursiveASTVisitorBase<true>;
+
+using DynamicRecursiveASTVisitor =
+ DynamicRecursiveASTVisitorBase</*Const=*/false>;
+using ConstDynamicRecursiveASTVisitor =
+ DynamicRecursiveASTVisitorBase</*Const=*/true>;
} // namespace clang
#endif // LLVM_CLANG_AST_DYNAMIC_RECURSIVE_AST_VISITOR_H
diff --git a/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
b/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
index 8cfabd9f3e93fe..194a7358423f73 100644
--- a/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
+++ b/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
@@ -89,9 +89,9 @@ using namespace clang;
//
// End result: RAV::TraverseCallExpr() is executed,
namespace {
-struct Impl : RecursiveASTVisitor<Impl> {
- DynamicRecursiveASTVisitor &Visitor;
- Impl(DynamicRecursiveASTVisitor &Visitor) : Visitor(Visitor) {}
+template <bool Const> struct Impl : RecursiveASTVisitor<Impl<Const>> {
+ DynamicRecursiveASTVisitorBase<Const> &Visitor;
+ Impl(DynamicRecursiveASTVisitorBase<Const> &Visitor) : Visitor(Visitor) {}
bool shouldVisitTemplateInstantiations() const {
return Visitor.ShouldVisitTemplateInstantiations;
@@ -189,8 +189,10 @@ struct Impl : RecursiveASTVisitor<Impl> {
// TraverseStmt() always passes in a queue, so we have no choice but to
// accept it as a parameter here.
- bool dataTraverseNode(Stmt *S, DataRecursionQueue * = nullptr) {
- // But since don't support postorder traversal, we don't need it, so
+ bool dataTraverseNode(
+ Stmt *S,
+ typename RecursiveASTVisitor<Impl>::DataRecursionQueue * = nullptr) {
+ // But since we don't support postorder traversal, we don't need it, so
// simply discard it here. This way, derived classes don't need to worry
// about including it as a parameter that they never use.
return Visitor.dataTraverseNode(S);
@@ -266,187 +268,107 @@ struct Impl : RecursiveASTVisitor<Impl> {
};
} // namespace
-void DynamicRecursiveASTVisitor::anchor() {}
-
-bool DynamicRecursiveASTVisitor::TraverseAST(ASTContext &AST) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseAST(AST);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseAttr(Attr *At) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseAttr(At);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseConstructorInitializer(
- CXXCtorInitializer *Init) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseConstructorInitializer(
- Init);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseDecl(Decl *D) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseDecl(D);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseLambdaCapture(LambdaExpr *LE,
- const LambdaCapture *C,
- Expr *Init) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseLambdaCapture(LE, C,
- Init);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseStmt(Stmt *S) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseStmt(S);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseTemplateArgument(
- const TemplateArgument &Arg) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseTemplateArgument(Arg);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseTemplateArguments(
- ArrayRef<TemplateArgument> Args) {
- return
Impl(*this).RecursiveASTVisitor<Impl>::TraverseTemplateArguments(Args);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseTemplateArgumentLoc(
- const TemplateArgumentLoc &ArgLoc) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseTemplateArgumentLoc(
- ArgLoc);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseTemplateName(TemplateName Template) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseTemplateName(Template);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseType(QualType T) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseType(T);
+template <bool Const> void DynamicRecursiveASTVisitorBase<Const>::anchor() {}
+
+// Helper macros to forward a call to the base implementation since that
+// ends up getting very verbose otherwise.
+
+// This calls the RecursiveASTVisitor implementation of the same function,
+// stripping any 'const' that the DRAV implementation may have added since
+// the RAV implementation largely doesn't use 'const'.
+#define FORWARD_TO_BASE(Function, Type, RefOrPointer)
\
+ template <bool Const>
\
+ bool DynamicRecursiveASTVisitorBase<Const>::Function(
\
+ MaybeConst<Type> RefOrPointer Param) {
\
+ return Impl<Const>(*this)
\
+ .template RecursiveASTVisitor<Impl<Const>>::Function(
\
+ const_cast<Type RefOrPointer>(Param));
\
+ }
+
+// Same as 'FORWARD_TO_BASE', but doesn't change the parameter type in any way.
+#define FORWARD_TO_BASE_EXACT(Function, Type)
\
+ template <bool Const>
\
+ bool DynamicRecursiveASTVisitorBase<Const>::Function(Type Param) {
\
+ return Impl<Const>(*this)
\
+ .template RecursiveASTVisitor<Impl<Const>>::Function(Param);
\
+ }
+
+FORWARD_TO_BASE(TraverseAST, ASTContext, &)
+FORWARD_TO_BASE(TraverseAttr, Attr, *)
+FORWARD_TO_BASE(TraverseConstructorInitializer, CXXCtorInitializer, *)
+FORWARD_TO_BASE(TraverseDecl, Decl, *)
+FORWARD_TO_BASE(TraverseStmt, Stmt, *)
+FORWARD_TO_BASE(TraverseNestedNameSpecifier, NestedNameSpecifier, *)
+FORWARD_TO_BASE(TraverseTemplateInstantiations, ClassTemplateDecl, *)
+FORWARD_TO_BASE(TraverseTemplateInstantiations, VarTemplateDecl, *)
+FORWARD_TO_BASE(TraverseTemplateInstantiations, FunctionTemplateDecl, *)
+FORWARD_TO_BASE(TraverseConceptRequirement, concepts::Requirement, *)
+FORWARD_TO_BASE(TraverseConceptTypeRequirement, concepts::TypeRequirement, *)
+FORWARD_TO_BASE(TraverseConceptExprRequirement, concepts::ExprRequirement, *)
+FORWARD_TO_BASE(TraverseConceptReference, ConceptReference, *)
+FORWARD_TO_BASE(TraverseConceptNestedRequirement,
+ concepts::NestedRequirement, *)
+
+FORWARD_TO_BASE_EXACT(TraverseCXXBaseSpecifier, const CXXBaseSpecifier &)
+FORWARD_TO_BASE_EXACT(TraverseDeclarationNameInfo, DeclarationNameInfo)
+FORWARD_TO_BASE_EXACT(TraverseTemplateArgument, const TemplateArgument &)
+FORWARD_TO_BASE_EXACT(TraverseTemplateArguments, ArrayRef<TemplateArgument>)
+FORWARD_TO_BASE_EXACT(TraverseTemplateArgumentLoc, const TemplateArgumentLoc &)
+FORWARD_TO_BASE_EXACT(TraverseTemplateName, TemplateName)
+FORWARD_TO_BASE_EXACT(TraverseType, QualType)
+FORWARD_TO_BASE_EXACT(TraverseTypeLoc, TypeLoc)
+FORWARD_TO_BASE_EXACT(TraverseTypeConstraint, const TypeConstraint *)
+FORWARD_TO_BASE_EXACT(TraverseObjCProtocolLoc, ObjCProtocolLoc)
+FORWARD_TO_BASE_EXACT(TraverseNestedNameSpecifierLoc, NestedNameSpecifierLoc)
+
+template <bool Const>
+bool DynamicRecursiveASTVisitorBase<Const>::TraverseLambdaCapture(
+ MaybeConst<LambdaExpr> *LE, const LambdaCapture *C,
+ MaybeConst<Expr> *Init) {
+ return Impl<Const>(*this)
+ .template RecursiveASTVisitor<Impl<Const>>::TraverseLambdaCapture(
+ const_cast<LambdaExpr *>(LE), C, const_cast<Expr *>(Init));
}
-bool DynamicRecursiveASTVisitor::TraverseTypeLoc(TypeLoc TL) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseTypeLoc(TL);
+template <bool Const>
+bool DynamicRecursiveASTVisitorBase<Const>::dataTraverseNode(MaybeConst<Stmt>
*S) {
+ return Impl<Const>(*this)
+ .template RecursiveASTVisitor<Impl<Const>>::dataTraverseNode(
+ const_cast<Stmt *>(S), nullptr);
}
-bool DynamicRecursiveASTVisitor::TraverseTypeConstraint(
- const TypeConstraint *C) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseTypeConstraint(C);
-}
-bool DynamicRecursiveASTVisitor::TraverseObjCProtocolLoc(
- ObjCProtocolLoc ProtocolLoc) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseObjCProtocolLoc(
- ProtocolLoc);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseConceptRequirement(
- concepts::Requirement *R) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseConceptRequirement(R);
-}
-bool DynamicRecursiveASTVisitor::TraverseConceptTypeRequirement(
- concepts::TypeRequirement *R) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseConceptTypeRequirement(
- R);
-}
-bool DynamicRecursiveASTVisitor::TraverseConceptExprRequirement(
- concepts::ExprRequirement *R) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseConceptExprRequirement(
- R);
-}
-bool DynamicRecursiveASTVisitor::TraverseConceptNestedRequirement(
- concepts::NestedRequirement *R) {
- return Impl(*this)
- .RecursiveASTVisitor<Impl>::TraverseConceptNestedRequirement(R);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseConceptReference(
- ConceptReference *CR) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseConceptReference(CR);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseCXXBaseSpecifier(
- const CXXBaseSpecifier &Base) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseCXXBaseSpecifier(Base);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseDeclarationNameInfo(
- DeclarationNameInfo NameInfo) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseDeclarationNameInfo(
- NameInfo);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseNestedNameSpecifier(
- NestedNameSpecifier *NNS) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseNestedNameSpecifier(
- NNS);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseNestedNameSpecifierLoc(
- NestedNameSpecifierLoc NNS) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseNestedNameSpecifierLoc(
- NNS);
-}
-
-bool DynamicRecursiveASTVisitor::dataTraverseNode(Stmt *S) {
- return Impl(*this).RecursiveASTVisitor<Impl>::dataTraverseNode(S, nullptr);
-}
-
-#define DEF_TRAVERSE_TMPL_INST(kind)
\
- bool DynamicRecursiveASTVisitor::TraverseTemplateInstantiations(
\
- kind##TemplateDecl *D) {
\
- return Impl(*this)
\
- .RecursiveASTVisitor<Impl>::TraverseTemplateInstantiations(D);
\
- }
-DEF_TRAVERSE_TMPL_INST(Class)
-DEF_TRAVERSE_TMPL_INST(Var)
-DEF_TRAVERSE_TMPL_INST(Function)
-#undef DEF_TRAVERSE_TMPL_INST
-
// Declare Traverse*() for and friends all concrete Decl classes.
#define ABSTRACT_DECL(DECL)
#define DECL(CLASS, BASE)
\
- bool DynamicRecursiveASTVisitor::Traverse##CLASS##Decl(CLASS##Decl *D) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::Traverse##CLASS##Decl(D);
\
- }
\
- bool DynamicRecursiveASTVisitor::WalkUpFrom##CLASS##Decl(CLASS##Decl *D) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::WalkUpFrom##CLASS##Decl(D);
\
- }
+ FORWARD_TO_BASE(Traverse##CLASS##Decl, CLASS##Decl, *)
\
+ FORWARD_TO_BASE(WalkUpFrom##CLASS##Decl, CLASS##Decl, *)
#include "clang/AST/DeclNodes.inc"
// Declare Traverse*() and friends for all concrete Stmt classes.
#define ABSTRACT_STMT(STMT)
-#define STMT(CLASS, PARENT)
\
- bool DynamicRecursiveASTVisitor::Traverse##CLASS(CLASS *S) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::Traverse##CLASS(S);
\
- }
+#define STMT(CLASS, PARENT) FORWARD_TO_BASE(Traverse##CLASS, CLASS, *)
#include "clang/AST/StmtNodes.inc"
-#define STMT(CLASS, PARENT)
\
- bool DynamicRecursiveASTVisitor::WalkUpFrom##CLASS(CLASS *S) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::WalkUpFrom##CLASS(S);
\
- }
+#define STMT(CLASS, PARENT) FORWARD_TO_BASE(WalkUpFrom##CLASS, CLASS, *)
#include "clang/AST/StmtNodes.inc"
-// Declare Traverse*() and friends for all concrete Typeclasses.
+// Declare Traverse*() and friends for all concrete Type classes.
#define ABSTRACT_TYPE(CLASS, BASE)
#define TYPE(CLASS, BASE)
\
- bool DynamicRecursiveASTVisitor::Traverse##CLASS##Type(CLASS##Type *T) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::Traverse##CLASS##Type(T);
\
- }
\
- bool DynamicRecursiveASTVisitor::WalkUpFrom##CLASS##Type(CLASS##Type *T) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::WalkUpFrom##CLASS##Type(T);
\
- }
+ FORWARD_TO_BASE(Traverse##CLASS##Type, CLASS##Type, *)
\
+ FORWARD_TO_BASE(WalkUpFrom##CLASS##Type, CLASS##Type, *)
#include "clang/AST/TypeNodes.inc"
#define ABSTRACT_TYPELOC(CLASS, BASE)
#define TYPELOC(CLASS, BASE)
\
- bool DynamicRecursiveASTVisitor::Traverse##CLASS##TypeLoc(
\
- CLASS##TypeLoc TL) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::Traverse##CLASS##TypeLoc(
\
- TL);
\
- }
+ FORWARD_TO_BASE_EXACT(Traverse##CLASS##TypeLoc, CLASS##TypeLoc)
#include "clang/AST/TypeLocNodes.def"
#define TYPELOC(CLASS, BASE)
\
- bool DynamicRecursiveASTVisitor::WalkUpFrom##CLASS##TypeLoc(
\
- CLASS##TypeLoc TL) {
\
- return Impl(*this).RecursiveASTVisitor<Impl>::WalkUpFrom##CLASS##TypeLoc(
\
- TL);
\
- }
+ FORWARD_TO_BASE_EXACT(WalkUpFrom##CLASS##TypeLoc, CLASS##TypeLoc)
#include "clang/AST/TypeLocNodes.def"
+
+namespace clang {
+template class DynamicRecursiveASTVisitorBase<false>;
+template class DynamicRecursiveASTVisitorBase<true>;
+}
>From e3f434c45f0b35b4b8307e0b7339a65d49743a46 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalm...@gmail.com>
Date: Tue, 14 Jan 2025 22:02:20 +0100
Subject: [PATCH 2/4] clang-format
---
clang/include/clang/AST/DynamicRecursiveASTVisitor.h | 3 ++-
clang/lib/AST/DynamicRecursiveASTVisitor.cpp | 5 +++--
2 files changed, 5 insertions(+), 3 deletions(-)
diff --git a/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
b/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
index 31b588e3a60638..4e0ba568263bf3 100644
--- a/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
+++ b/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
@@ -134,7 +134,8 @@ template <bool IsConst> class
DynamicRecursiveASTVisitorBase {
/// Recursively visit a C++ nested-name-specifier.
///
/// \returns false if the visitation was terminated early, true otherwise.
- virtual bool TraverseNestedNameSpecifier(MaybeConst<NestedNameSpecifier>
*NNS);
+ virtual bool
+ TraverseNestedNameSpecifier(MaybeConst<NestedNameSpecifier> *NNS);
/// Recursively visit a C++ nested-name-specifier with location
/// information.
diff --git a/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
b/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
index 194a7358423f73..9cc0ee60c05f60 100644
--- a/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
+++ b/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
@@ -331,7 +331,8 @@ bool
DynamicRecursiveASTVisitorBase<Const>::TraverseLambdaCapture(
}
template <bool Const>
-bool DynamicRecursiveASTVisitorBase<Const>::dataTraverseNode(MaybeConst<Stmt>
*S) {
+bool DynamicRecursiveASTVisitorBase<Const>::dataTraverseNode(
+ MaybeConst<Stmt> *S) {
return Impl<Const>(*this)
.template RecursiveASTVisitor<Impl<Const>>::dataTraverseNode(
const_cast<Stmt *>(S), nullptr);
@@ -371,4 +372,4 @@ bool
DynamicRecursiveASTVisitorBase<Const>::dataTraverseNode(MaybeConst<Stmt> *S
namespace clang {
template class DynamicRecursiveASTVisitorBase<false>;
template class DynamicRecursiveASTVisitorBase<true>;
-}
+} // namespace clang
>From 56cc1163b6a15474537cff656a6525e9698ef7fc Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalm...@gmail.com>
Date: Wed, 15 Jan 2025 01:34:59 +0100
Subject: [PATCH 3/4] Migrate a visitor to use the const DRAV
---
.../Checkers/WebKit/RawPtrRefMemberChecker.cpp | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git
a/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp
b/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp
index d7e5ebee9a9b4f..79f88553feb958 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp
@@ -48,7 +48,7 @@ class RawPtrRefMemberChecker
// The calls to checkAST* from AnalysisConsumer don't
// visit template instantiations or lambda classes. We
// want to visit those, so we make our own RecursiveASTVisitor.
- struct LocalVisitor : DynamicRecursiveASTVisitor {
+ struct LocalVisitor : ConstDynamicRecursiveASTVisitor {
const RawPtrRefMemberChecker *Checker;
explicit LocalVisitor(const RawPtrRefMemberChecker *Checker)
: Checker(Checker) {
@@ -57,14 +57,14 @@ class RawPtrRefMemberChecker
ShouldVisitImplicitCode = false;
}
- bool VisitRecordDecl(RecordDecl *RD) override {
+ bool VisitRecordDecl(const RecordDecl *RD) override {
Checker->visitRecordDecl(RD);
return true;
}
};
LocalVisitor visitor(this);
- visitor.TraverseDecl(const_cast<TranslationUnitDecl *>(TUD));
+ visitor.TraverseDecl(TUD);
}
void visitRecordDecl(const RecordDecl *RD) const {
>From 60f24aabc1080e786afb731cde92bac172a15f00 Mon Sep 17 00:00:00 2001
From: Sirraide <aeternalm...@gmail.com>
Date: Tue, 28 Jan 2025 20:31:07 +0100
Subject: [PATCH 4/4] `template` is apparently not needed here
---
clang/lib/AST/DynamicRecursiveASTVisitor.cpp | 16 +++++++---------
1 file changed, 7 insertions(+), 9 deletions(-)
diff --git a/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
b/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
index 9cc0ee60c05f60..b478e7a39ea186 100644
--- a/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
+++ b/clang/lib/AST/DynamicRecursiveASTVisitor.cpp
@@ -280,17 +280,16 @@ template <bool Const> void
DynamicRecursiveASTVisitorBase<Const>::anchor() {}
template <bool Const>
\
bool DynamicRecursiveASTVisitorBase<Const>::Function(
\
MaybeConst<Type> RefOrPointer Param) {
\
- return Impl<Const>(*this)
\
- .template RecursiveASTVisitor<Impl<Const>>::Function(
\
- const_cast<Type RefOrPointer>(Param));
\
+ return Impl<Const>(*this).RecursiveASTVisitor<Impl<Const>>::Function(
\
+ const_cast<Type RefOrPointer>(Param));
\
}
// Same as 'FORWARD_TO_BASE', but doesn't change the parameter type in any way.
#define FORWARD_TO_BASE_EXACT(Function, Type)
\
template <bool Const>
\
bool DynamicRecursiveASTVisitorBase<Const>::Function(Type Param) {
\
- return Impl<Const>(*this)
\
- .template RecursiveASTVisitor<Impl<Const>>::Function(Param);
\
+ return Impl<Const>(*this).RecursiveASTVisitor<Impl<Const>>::Function(
\
+ Param);
\
}
FORWARD_TO_BASE(TraverseAST, ASTContext, &)
@@ -326,16 +325,15 @@ bool
DynamicRecursiveASTVisitorBase<Const>::TraverseLambdaCapture(
MaybeConst<LambdaExpr> *LE, const LambdaCapture *C,
MaybeConst<Expr> *Init) {
return Impl<Const>(*this)
- .template RecursiveASTVisitor<Impl<Const>>::TraverseLambdaCapture(
+ .RecursiveASTVisitor<Impl<Const>>::TraverseLambdaCapture(
const_cast<LambdaExpr *>(LE), C, const_cast<Expr *>(Init));
}
template <bool Const>
bool DynamicRecursiveASTVisitorBase<Const>::dataTraverseNode(
MaybeConst<Stmt> *S) {
- return Impl<Const>(*this)
- .template RecursiveASTVisitor<Impl<Const>>::dataTraverseNode(
- const_cast<Stmt *>(S), nullptr);
+ return Impl<Const>(*this).RecursiveASTVisitor<Impl<Const>>::dataTraverseNode(
+ const_cast<Stmt *>(S), nullptr);
}
// Declare Traverse*() for and friends all concrete Decl classes.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
