[Clang] [NFC] Introduce ConstDynamicRecursiveASTVisitor
#122991
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
clang:frontend
|
@llvm/pr-subscribers-clang-static-analyzer-1 @llvm/pr-subscribers-clang Author: None (Sirraide) ChangesAfter some discussion around #116823, it was decided that it would be nice to have a Since that made the implementation of a bunch of DRAV functions quite a bit more verbose, I’ve moved most of them to be stamped out by a macro, which imo makes it easier to understand what’s actually going on there. For functions which already accepted As a sanity check, I’ve also migrated some random visitor in the static analyser to the The performance impact of this change seems to be negligible. Clang’s binary size went up by 0.5%, but that’s expected considering that this effectively adds an extra instantiation of Patch is 25.45 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/122991.diff 3 Files Affected:
diff --git a/clang/include/clang/AST/DynamicRecursiveASTVisitor.h b/clang/include/clang/AST/DynamicRecursiveASTVisitor.h
index 4382d209908292..4e0ba568263bf3 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,15 @@ 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 +148,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 +198,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 +250,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 +291,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..9cc0ee60c05f60 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,108 @@ 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);
-}
-
-bool DynamicRecursiveASTVisitor::TraverseTypeLoc(TypeLoc TL) {
- return Impl(*this).RecursiveASTVisitor<Impl>::TraverseTypeLoc(TL);
-}
-
-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);
+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::dataTraverseNode(Stmt *S) {
- return Impl(*this).RecursiveASTVisitor<Impl>::dataTraverseNode(S, nullptr);
+template <bool Const>
+bool DynamicRecursiveASTVisitorBase<Const>::dataTraverseNode(
+ MaybeConst<Stmt> *S) {
+ return Impl<Const>(*this)
+ .template RecursiveASTVisitor<Impl<Const>>::dataTraverseNode(
+ const_cast<S...
[truncated]
|
|
Generally looks great. can you explain why the 2 or 3 |
As in e.g. |
|
And in the case of |
|
ping |
AaronBallman
approved these changes
Jan 27, 2025
cor3ntin
approved these changes
Jan 27, 2025
|
Seems like that caused one of the bots to error; I’ll have to investigate why. |
|
Reverted for now; I’ll investigate this later today |
github-actions bot
pushed a commit
to arm/arm-toolchain
that referenced
this pull request
Jan 28, 2025
…isitor`" (#124667) Reverts llvm/llvm-project#122991 One of the bots is breaking; I’ll have to investigate what the issue is; this might be because I haven’t updated the branch in a while.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
After some discussion around #116823, it was decided that it would be nice to have a
constvariant ofDynamicRecursiveASTVisitor, so this pr does exactly that by making the main DRAV implementation a template with a singlebooltemplate parameter that turns several function parameters from aT*orT&to aconst T*orconst T&.Since that made the implementation of a bunch of DRAV functions quite a bit more verbose, I’ve moved most of them to be stamped out by a macro, which imo makes it easier to understand what’s actually going on there.
For functions which already accepted
constparameters in the original RAV implementation, the parameter isconstin both versions (e.g.TraverseTemplateArgument()always takes aconst TemplateArgument&); conversely, parameters that are passed by value (e.g. inTraverseType(), which takes aQualTypeby value) are notconstin either variant (i.e. theQualTypeargument is always just aQualType, never aconst QualType).As a sanity check, I’ve also migrated some random visitor in the static analyser to the
constversion (and indeed, it ends up simplifying the code around that particular visitor actually). It would make sense to do a pass over all visitors and change all which can beconstuse theconstversion, but that can be done in a follow-up pr.The performance impact of this change seems to be negligible. Clang’s binary size went up by 0.5%, but that’s expected considering that this effectively adds an extra instantiation of
RecursiveASTVisitor. Fortunately, this is of course a one-time cost.