44#ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H
45#define LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H
82#include "llvm/ADT/ArrayRef.h"
83#include "llvm/ADT/SmallVector.h"
84#include "llvm/ADT/StringRef.h"
85#include "llvm/Support/Casting.h"
86#include "llvm/Support/Compiler.h"
87#include "llvm/Support/ErrorHandling.h"
88#include "llvm/Support/Regex.h"
99namespace ast_matchers {
114 template <
typename T>
116 return MyBoundNodes.getNodeAs<T>(ID);
126 return MyBoundNodes.getMap();
133 BoundNodes(internal::BoundNodesMap &MyBoundNodes)
134 : MyBoundNodes(MyBoundNodes) {}
136 internal::BoundNodesMap MyBoundNodes;
170inline internal::TrueMatcher
anything() {
return internal::TrueMatcher(); }
183extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
195extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl>
207extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
219extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl>
229extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
248 auto &
SourceManager = Finder->getASTContext().getSourceManager();
269 auto &
SourceManager = Finder->getASTContext().getSourceManager();
271 if (ExpansionLoc.isInvalid()) {
296 auto &
SourceManager = Finder->getASTContext().getSourceManager();
298 if (ExpansionLoc.isInvalid()) {
317 std::string, MacroName) {
320 auto& Context = Finder->getASTContext();
321 std::optional<SourceLocation> B =
323 if (!B)
return false;
324 std::optional<SourceLocation> E =
326 if (!E)
return false;
339extern const internal::VariadicAllOfMatcher<Decl>
decl;
351extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl>
361extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl>
372extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
386extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl>
namedDecl;
397extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl>
labelDecl;
408extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl>
420extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
432extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl>
recordDecl;
441extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl>
450extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
463extern const internal::VariadicDynCastAllOfMatcher<
482extern const internal::VariadicDynCastAllOfMatcher<
495extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
506extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl>
520extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
530extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier>
cxxBaseSpecifier;
541extern const internal::VariadicAllOfMatcher<CXXCtorInitializer>
553extern const internal::VariadicAllOfMatcher<TemplateArgument>
templateArgument;
564extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc>
576extern const internal::VariadicAllOfMatcher<TemplateName>
templateName;
586extern const internal::VariadicDynCastAllOfMatcher<
Decl,
598extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
609extern const internal::VariadicDynCastAllOfMatcher<
Decl,
693 return Node.isBitField();
710 return Node.isBitField() &&
711 Node.getBitWidthValue(Finder->getASTContext()) == Width;
732 InnerMatcher.matches(*
Initializer, Finder, Builder));
738 return Node.isMain();
752 internal::Matcher<ClassTemplateDecl>, InnerMatcher) {
754 return (
Decl !=
nullptr &&
755 InnerMatcher.matches(*
Decl, Finder, Builder));
763 return Node.isImplicit();
788 hasAnyTemplateArgument,
792 internal::Matcher<TemplateArgument>, InnerMatcher) {
794 internal::getTemplateSpecializationArgs(
Node);
795 return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder,
796 Builder) != List.end();
817 const internal::Matcher<T> &InnerMatcher) {
818 return internal::DynTypedMatcher::constructRestrictedWrapper(
819 new internal::TraversalMatcher<T>(TK, InnerMatcher),
820 InnerMatcher.getID().first)
821 .template unconditionalConvertTo<T>();
825internal::BindableMatcher<T>
827 return internal::BindableMatcher<T>(
828 internal::DynTypedMatcher::constructRestrictedWrapper(
829 new internal::TraversalMatcher<T>(TK, InnerMatcher),
830 InnerMatcher.getID().first)
831 .template unconditionalConvertTo<T>());
834template <
typename... T>
835internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>
837 const internal::VariadicOperatorMatcher<T...> &InnerMatcher) {
838 return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>(
842template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
843 typename T,
typename ToTypes>
844internal::TraversalWrapper<
845 internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>>
847 ArgumentAdapterT, T, ToTypes> &InnerMatcher) {
848 return internal::TraversalWrapper<
849 internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T,
850 ToTypes>>(TK, InnerMatcher);
853template <
template <
typename T,
typename...
P>
class MatcherT, typename...
P,
854 typename ReturnTypesF>
855internal::TraversalWrapper<
856 internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>>
858 const internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>
860 return internal::TraversalWrapper<
861 internal::PolymorphicMatcher<MatcherT, ReturnTypesF,
P...>>(TK,
865template <
typename... T>
866internal::Matcher<
typename internal::GetClade<T...>::Type>
868 return traverse(TK, InnerMatcher.with());
894 return InnerMatcher.matches(*
Node.IgnoreImplicit(), Finder, Builder);
923 internal::Matcher<Expr>, InnerMatcher) {
924 return InnerMatcher.matches(*
Node.IgnoreImpCasts(), Finder, Builder);
945 return InnerMatcher.matches(*
Node.IgnoreParenCasts(), Finder, Builder);
970 internal::Matcher<Expr>, InnerMatcher) {
971 return InnerMatcher.matches(*
Node.IgnoreParenImpCasts(), Finder, Builder);
987 return InnerMatcher.matches(
Node.IgnoreParens(), Finder, Builder);
1003 const Expr *E =
Node.IgnoreParens();
1004 return InnerMatcher.matches(*E, Finder, Builder);
1021 return Node.isInstantiationDependent();
1068 hasTemplateArgument,
1072 unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher) {
1074 internal::getTemplateSpecializationArgs(
Node);
1075 if (List.size() <= N)
1077 return InnerMatcher.matches(List[N], Finder, Builder);
1090 templateArgumentCountIs,
1094 return internal::getTemplateSpecializationArgs(
Node).size() == N;
1109 internal::Matcher<QualType>, InnerMatcher) {
1112 return InnerMatcher.matches(
Node.getAsType(), Finder, Builder);
1127 internal::Matcher<TemplateName>, InnerMatcher) {
1130 return InnerMatcher.matches(
Node.getAsTemplate(), Finder, Builder);
1147 internal::Matcher<Decl>, InnerMatcher) {
1149 return InnerMatcher.matches(*
Node.getAsDecl(), Finder, Builder);
1167 return InnerMatcher.matches(*
Node.getAsExpr(), Finder, Builder);
1197 internal::Matcher<QualType>, InnerMatcher) {
1200 return InnerMatcher.matches(
Node.getIntegralType(), Finder, Builder);
1218 std::string,
Value) {
1234extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1244extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl>
valueDecl;
1257extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
1269extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
1280extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl>
enumDecl;
1290extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
1305extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl>
tagDecl;
1313extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl>
1322extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
1333extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
1345extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl>
varDecl;
1355extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl>
fieldDecl;
1365extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
1374extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl>
1383extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
1394extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl>
friendDecl;
1404extern const internal::VariadicAllOfMatcher<Stmt>
stmt;
1414extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt>
declStmt;
1427extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr>
memberExpr;
1441extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
1453extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1465extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr>
callExpr;
1495extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr>
lambdaExpr;
1504extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
1516extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
1525extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
1535extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
1545extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
1555extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
1565extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
1575extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
1590extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
1603extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
1615extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl>
1626extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
1635extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
1645extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
1655extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
1665extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
1675extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
1688extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
1694 internal::Matcher<Expr>, InnerMatcher) {
1695 const Expr *SyntForm =
Node.getSyntacticForm();
1696 return (SyntForm !=
nullptr &&
1697 InnerMatcher.matches(*SyntForm, Finder, Builder));
1711extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1723extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
1741extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
1754extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1767extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl>
usingDecl;
1778extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl>
1790extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
1807extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
1821extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1840extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1853extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
1863extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr>
parenExpr;
1875extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
1886extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1900extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
1911extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
1932extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1944extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr>
cxxNewExpr;
1954extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
1970extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
1981extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
1993extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
2012extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
2032extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2042extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr>
expr;
2051extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
2065extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
2074extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr>
blockExpr;
2082extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt>
ifStmt;
2091extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt>
forStmt;
2103 const Stmt *
const Increment =
Node.getInc();
2104 return (Increment !=
nullptr &&
2105 InnerMatcher.matches(*Increment, Finder, Builder));
2118 const Stmt *
const Init =
Node.getInit();
2119 return (Init !=
nullptr && InnerMatcher.matches(*Init, Finder, Builder));
2129extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
2142 const VarDecl *
const Var =
Node.getLoopVariable();
2143 return (Var !=
nullptr && InnerMatcher.matches(*Var, Finder, Builder));
2156 const Expr *
const Init =
Node.getRangeInit();
2157 return (Init !=
nullptr && InnerMatcher.matches(*Init, Finder, Builder));
2168extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt>
whileStmt;
2178extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt>
doStmt;
2188extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt>
breakStmt;
2198extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
2209extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt>
2220extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt>
returnStmt;
2231extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt>
gotoStmt;
2242extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt>
labelStmt;
2254extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
2265extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt>
switchStmt;
2275extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase>
switchCase;
2285extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt>
caseStmt;
2295extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
2304extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
2314extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
2324extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt>
cxxTryStmt;
2333extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
2343extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt>
nullStmt;
2353extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt>
asmStmt;
2361extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
2371extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
2384extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
2391extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
2401extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
2406extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
2410extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
2416extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
2426extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
2437extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
2440extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
2450extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
2461extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
2465extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
2469extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
2473extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
2477extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
2485extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr>
atomicExpr;
2493extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr>
stmtExpr;
2502extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
2511extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
2520extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
2529extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2541extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
2557extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
2570extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
2586extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
2601extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
2612extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
2621extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
2645extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
2652extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
2668extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr>
castExpr;
2678extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
2687extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
2696extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
2705extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
2720 return Node.size() == N;
2724extern const internal::VariadicAllOfMatcher<QualType>
qualType;
2727extern const internal::VariadicAllOfMatcher<Type>
type;
2730extern const internal::VariadicAllOfMatcher<TypeLoc>
typeLoc;
2751extern const internal::VariadicOperatorMatcherFunc<
2752 2, std::numeric_limits<unsigned>::max()>
2758extern const internal::VariadicOperatorMatcherFunc<
2759 2, std::numeric_limits<unsigned>::max()>
2765extern const internal::VariadicOperatorMatcherFunc<
2766 2, std::numeric_limits<unsigned>::max()>
2793extern const internal::VariadicOperatorMatcherFunc<1, 1>
optionally;
2804extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2833template <
typename T,
typename...
U>
2834auto mapAnyOf(internal::VariadicDynCastAllOfMatcher<T, U>
const &...) {
2835 return internal::MapAnyOfHelper<
U...>();
2948extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr>
invocation;
2959 internal::Matcher<QualType>, InnerMatcher) {
2960 const QualType ArgumentType =
Node.getTypeOfArgument();
2961 return InnerMatcher.matches(ArgumentType, Finder, Builder);
2977 return Node.getKind() == Kind;
2983 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
2985 allOf(
anyOf(ofKind(UETT_AlignOf), ofKind(UETT_PreferredAlignOf)),
2992 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
2994 allOf(ofKind(UETT_SizeOf), InnerMatcher)));
3012inline internal::Matcher<NamedDecl>
hasName(StringRef Name) {
3013 return internal::Matcher<NamedDecl>(
3014 new internal::HasNameMatcher({std::string(Name)}));
3027extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
3048 std::string FullNameString =
"::" +
Node.getQualifiedNameAsString();
3049 return RegExp->match(FullNameString);
3071inline internal::PolymorphicMatcher<
3072 internal::HasOverloadedOperatorNameMatcher,
3074 std::vector<std::string>>
3076 return internal::PolymorphicMatcher<
3077 internal::HasOverloadedOperatorNameMatcher,
3079 std::vector<std::string>>({std::string(Name)});
3090extern const internal::VariadicFunction<
3091 internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher,
3094 std::vector<std::string>>,
3119 return Node.getMember().getAsString() == N;
3157 std::string, BindingID) {
3158 auto MemberName =
Node.getMember().getAsString();
3160 return Builder->removeBindings(
3161 [
this, MemberName](
const BoundNodesMap &
Nodes) {
3162 const auto &BN =
Nodes.getNode(this->BindingID);
3163 if (
const auto *ND = BN.get<
NamedDecl>()) {
3164 if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(ND))
3166 return ND->getName() != MemberName;
3205 internal::Matcher<NamedDecl>,
Base) {
3207 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3208 return Finder->classIsDerivedFrom(RD,
Base, Builder,
false);
3211 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3212 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3220 std::string, BaseName, 1) {
3221 if (BaseName.empty())
3224 const auto M = isDerivedFrom(
hasName(BaseName));
3226 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3227 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3229 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3230 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3267 return Node.hasDefinition() &&
3269 return BaseSpecMatcher.matches(Base, Finder, Builder);
3276 isSameOrDerivedFrom,
3278 internal::Matcher<NamedDecl>,
Base, 0) {
3281 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3282 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3284 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3285 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3291 isSameOrDerivedFrom,
3293 std::string, BaseName, 1) {
3294 if (BaseName.empty())
3297 const auto M = isSameOrDerivedFrom(
hasName(BaseName));
3299 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3300 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3302 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3303 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3328 isDirectlyDerivedFrom,
3330 internal::Matcher<NamedDecl>,
Base, 0) {
3332 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3333 return Finder->classIsDerivedFrom(RD,
Base, Builder,
true);
3336 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3337 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3343 isDirectlyDerivedFrom,
3345 std::string, BaseName, 1) {
3346 if (BaseName.empty())
3348 const auto M = isDirectlyDerivedFrom(
hasName(BaseName));
3350 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3351 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3353 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3354 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3369 BoundNodesTreeBuilder
Result(*Builder);
3370 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.method_begin(),
3372 if (MatchIt ==
Node.method_end())
3375 if (Finder->isTraversalIgnoringImplicitNodes() && (*MatchIt)->isImplicit())
3377 *Builder = std::move(
Result);
3391 return Node.isLambda();
3412extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher>
has;
3428extern const internal::ArgumentAdaptingMatcherFunc<
3429 internal::HasDescendantMatcher>
3450extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
3480extern const internal::ArgumentAdaptingMatcherFunc<
3481 internal::ForEachDescendantMatcher>
3500template <
typename T>
3501internal::Matcher<T>
findAll(
const internal::Matcher<T> &Matcher) {
3515extern const internal::ArgumentAdaptingMatcherFunc<
3516 internal::HasParentMatcher,
3517 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3518 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3532extern const internal::ArgumentAdaptingMatcherFunc<
3533 internal::HasAncestorMatcher,
3534 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3535 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3547extern const internal::VariadicOperatorMatcherFunc<1, 1>
unless;
3583inline internal::PolymorphicMatcher<
3584 internal::HasDeclarationMatcher,
3585 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>
3587 return internal::PolymorphicMatcher<
3588 internal::HasDeclarationMatcher,
3589 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>(
3608 return UnderlyingDecl !=
nullptr &&
3609 InnerMatcher.matches(*UnderlyingDecl, Finder, Builder);
3632 const Expr *ExprNode =
Node.getImplicitObjectArgument()
3633 ->IgnoreParenImpCasts();
3634 return (ExprNode !=
nullptr &&
3635 InnerMatcher.matches(*ExprNode, Finder, Builder));
3652 return InnerMatcher.matches(
TypeDecl, Finder, Builder);
3668 return Node.isClassMethod();
3684 return Node.isInstanceMethod();
3701 return Node.isClassMessage();
3718 return Node.isInstanceMessage();
3733 const Expr *ReceiverNode =
Node.getInstanceReceiver();
3734 return (ReceiverNode !=
nullptr &&
3761extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
3775 std::string SelectorString =
Node.getSelector().getAsString();
3776 return RegExp->match(SelectorString);
3784 return Node.getSelector().isNull();
3796 return Node.getSelector().isUnarySelector();
3812 return Node.getSelector().isKeywordSelector();
3827 return Node.getSelector().getNumArgs() == N;
3848 const Expr *ExprNode =
Node.getCallee();
3849 return (ExprNode !=
nullptr &&
3850 InnerMatcher.matches(*ExprNode, Finder, Builder));
3876 internal::Matcher<Decl>, InnerMatcher, 1) {
3877 if (
const auto *CallNode = dyn_cast<CallExpr>(&
Node))
3879 .matches(
Node, Finder, Builder);
3883 const auto *MsgNode = cast<ObjCMessageExpr>(&
Node);
3884 const Decl *DeclNode = MsgNode->getMethodDecl();
3885 return (DeclNode !=
nullptr &&
3886 InnerMatcher.matches(*DeclNode, Finder, Builder));
3910 internal::Matcher<QualType>, InnerMatcher, 0) {
3913 return InnerMatcher.matches(QT, Finder, Builder);
3951 internal::Matcher<Decl>, InnerMatcher, 1) {
3996 internal::Matcher<TypeLoc>, Inner) {
3998 if (source ==
nullptr) {
4002 return Inner.matches(source->
getTypeLoc(), Finder, Builder);
4015 return Name ==
Node.getAsString();
4029 QualType, pointsTo, internal::Matcher<QualType>,
4031 return (!
Node.isNull() &&
Node->isAnyPointerType() &&
4032 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4039 .matches(
Node, Finder, Builder);
4054 return InnerMatcher.matches(*
Node.getUnqualifiedDesugaredType(), Finder,
4073 return (!
Node.isNull() &&
Node->isReferenceType() &&
4074 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4093 return InnerMatcher.matches(
Node.getCanonicalType(), Finder, Builder);
4100 .matches(
Node, Finder, Builder);
4121 internal::Matcher<Expr>, InnerMatcher) {
4122 const Expr *ExprNode =
Node.getImplicitObjectArgument();
4123 return (ExprNode !=
nullptr &&
4124 InnerMatcher.matches(*ExprNode, Finder, Builder));
4144 internal::Matcher<QualType>, InnerMatcher, 0) {
4145 return onImplicitObjectArgument(
4146 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4147 .matches(
Node, Finder, Builder);
4152 internal::Matcher<Decl>, InnerMatcher, 1) {
4153 return onImplicitObjectArgument(
4154 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4155 .matches(
Node, Finder, Builder);
4169 const Decl *DeclNode =
Node.getDecl();
4170 return (DeclNode !=
nullptr &&
4171 InnerMatcher.matches(*DeclNode, Finder, Builder));
4198 internal::Matcher<UsingShadowDecl>, Inner) {
4201 return Inner.matches(*
UsingDecl, Finder, Builder);
4222 return matchesFirstInPointerRange(InnerMatcher,
Node.decls_begin(),
4223 Node.decls_end(), Finder,
4224 Builder) !=
Node.decls_end();
4237 if (
Node.isSingleDecl()) {
4238 const Decl *FoundDecl =
Node.getSingleDecl();
4239 return InnerMatcher.matches(*FoundDecl, Finder, Builder);
4253 VarDecl, hasInitializer, internal::Matcher<Expr>,
4257 InnerMatcher.matches(*
Initializer, Finder, Builder));
4283 internal::Matcher<LambdaCapture>, InnerMatcher) {
4284 BoundNodesTreeBuilder
Result;
4285 bool Matched =
false;
4287 if (Finder->isTraversalIgnoringImplicitNodes() &&
Capture.isImplicit())
4289 BoundNodesTreeBuilder CaptureBuilder(*Builder);
4290 if (InnerMatcher.matches(
Capture, Finder, &CaptureBuilder)) {
4292 Result.addMatch(CaptureBuilder);
4295 *Builder = std::move(
Result);
4310 return Node.isStaticLocal();
4325 return Node.hasLocalStorage();
4339 return Node.hasGlobalStorage();
4406 return Node.isExceptionVariable();
4422 unsigned NumArgs =
Node.getNumArgs();
4423 if (!Finder->isTraversalIgnoringImplicitNodes())
4424 return NumArgs == N;
4426 if (!isa<CXXDefaultArgExpr>(
Node.getArg(NumArgs - 1)))
4430 return NumArgs == N;
4445 unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
4446 if (N >=
Node.getNumArgs())
4449 if (Finder->isTraversalIgnoringImplicitNodes() && isa<CXXDefaultArgExpr>(Arg))
4462 ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
4463 return N <
Node.getNumInits() &&
4464 InnerMatcher.matches(*
Node.getInit(N), Finder, Builder);
4502 internal::Matcher<Decl>, InnerMatcher) {
4503 const unsigned NumDecls = std::distance(
Node.decl_begin(),
Node.decl_end());
4507 std::advance(Iterator, N);
4508 return InnerMatcher.matches(**Iterator, Finder, Builder);
4525 return Node.getExceptionDecl() ==
nullptr;
4542 internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
4543 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.init_begin(),
4544 Node.init_end(), Finder, Builder);
4545 if (MatchIt ==
Node.init_end())
4547 return (*MatchIt)->isWritten() || !Finder->isTraversalIgnoringImplicitNodes();
4564 internal::Matcher<FieldDecl>, InnerMatcher) {
4566 return (NodeAsDecl !=
nullptr &&
4567 InnerMatcher.matches(*NodeAsDecl, Finder, Builder));
4584 internal::Matcher<Expr>, InnerMatcher) {
4585 const Expr* NodeAsExpr =
Node.getInit();
4586 return (NodeAsExpr !=
nullptr &&
4587 InnerMatcher.matches(*NodeAsExpr, Finder, Builder));
4604 return Node.isWritten();
4624 return Node.isBaseInitializer();
4644 return Node.isMemberInitializer();
4670 internal::Matcher<Expr>, InnerMatcher) {
4671 for (
const Expr *Arg :
Node.arguments()) {
4672 if (Finder->isTraversalIgnoringImplicitNodes() &&
4673 isa<CXXDefaultArgExpr>(Arg))
4675 BoundNodesTreeBuilder
Result(*Builder);
4676 if (InnerMatcher.matches(*Arg, Finder, &
Result)) {
4677 *Builder = std::move(
Result);
4696extern const internal::VariadicAllOfMatcher<LambdaCapture>
lambdaCapture;
4713 clang::ast_matchers::internal::BoundNodesTreeBuilder
Result(*Builder);
4715 *Builder = std::move(
Result);
4739 auto *capturedVar =
Node.getCapturedVar();
4740 return capturedVar && InnerMatcher.matches(*capturedVar, Finder, Builder);
4761 return Node.isListInitialization();
4777 return Node.requiresZeroInitialization();
4804 unsigned, N, internal::Matcher<ParmVarDecl>,
4806 return (N <
Node.parameters().size()
4807 && InnerMatcher.matches(*
Node.parameters()[N], Finder, Builder));
4831 internal::Matcher<Expr>, ArgMatcher,
4832 internal::Matcher<ParmVarDecl>, ParamMatcher) {
4833 BoundNodesTreeBuilder
Result;
4837 BoundNodesTreeBuilder Matches;
4839 .matches(
Node, Finder, &Matches)
4843 bool Matched =
false;
4844 for (; ArgIndex <
Node.getNumArgs(); ++ArgIndex) {
4845 BoundNodesTreeBuilder ArgMatches(*Builder);
4846 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()),
4847 Finder, &ArgMatches)) {
4848 BoundNodesTreeBuilder ParamMatches(ArgMatches);
4850 hasParameter(ParamIndex, ParamMatcher)))),
4852 hasParameter(ParamIndex, ParamMatcher))))))
4853 .matches(
Node, Finder, &ParamMatches)) {
4854 Result.addMatch(ParamMatches);
4860 *Builder = std::move(
Result);
4892 internal::Matcher<Expr>, ArgMatcher,
4893 internal::Matcher<QualType>, ParamMatcher) {
4894 BoundNodesTreeBuilder
Result;
4898 BoundNodesTreeBuilder Matches;
4900 .matches(
Node, Finder, &Matches)
4906 if (
const auto *Call = dyn_cast<CallExpr>(&
Node)) {
4907 if (
const auto *
Value =
4908 dyn_cast_or_null<ValueDecl>(Call->getCalleeDecl())) {
4918 assert(MP &&
"Must be member-pointer if its a memberfunctionpointer");
4921 "The call must have happened through a member function "
4927 unsigned ParamIndex = 0;
4928 bool Matched =
false;
4929 unsigned NumArgs =
Node.getNumArgs();
4933 for (; ArgIndex < NumArgs; ++ArgIndex, ++ParamIndex) {
4934 BoundNodesTreeBuilder ArgMatches(*Builder);
4935 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()), Finder,
4937 BoundNodesTreeBuilder ParamMatches(ArgMatches);
4943 if (ParamMatcher.matches(ParamType, Finder, &ParamMatches)) {
4944 Result.addMatch(ParamMatches);
4950 hasParameter(ParamIndex, hasType(ParamMatcher))))),
4952 hasParameter(ParamIndex, hasType(ParamMatcher)))))))
4953 .matches(
Node, Finder, &ParamMatches)) {
4954 Result.addMatch(ParamMatches);
4960 *Builder = std::move(
Result);
4982 if (
const auto *
Decl = dyn_cast_or_null<FunctionDecl>(Context))
4983 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
4984 if (
const auto *
Decl = dyn_cast_or_null<BlockDecl>(Context))
4985 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
4986 if (
const auto *
Decl = dyn_cast_or_null<ObjCMethodDecl>(Context))
4987 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5027 internal::Matcher<ParmVarDecl>,
5029 return matchesFirstInPointerRange(InnerMatcher,
Node.param_begin(),
5030 Node.param_end(), Finder,
5031 Builder) !=
Node.param_end();
5055 return Node.getNumParams() == N;
5082 forEachTemplateArgument,
5085 clang::ast_matchers::internal::Matcher<TemplateArgument>, InnerMatcher) {
5087 clang::ast_matchers::internal::getTemplateSpecializationArgs(
Node);
5088 clang::ast_matchers::internal::BoundNodesTreeBuilder
Result;
5089 bool Matched =
false;
5090 for (
const auto &Arg : TemplateArgs) {
5091 clang::ast_matchers::internal::BoundNodesTreeBuilder ArgBuilder(*Builder);
5092 if (InnerMatcher.matches(Arg, Finder, &ArgBuilder)) {
5094 Result.addMatch(ArgBuilder);
5097 *Builder = std::move(
Result);
5126 internal::Matcher<QualType>, InnerMatcher) {
5127 return InnerMatcher.matches(
Node.getReturnType(), Finder, Builder);
5147 return Node.isExternC();
5180 return Node.isDeleted();
5193 return Node.isDefaulted();
5226 return FnTy->hasDynamicExceptionSpec();
5276 return Node.isConsteval();
5298 return Node.isConstexpr();
5313 if (
const auto *CIA =
Node.getAttr<ConstInitAttr>())
5314 return CIA->isConstinit();
5342 internal::Matcher<Stmt>, InnerMatcher) {
5344 return Init !=
nullptr && InnerMatcher.matches(*Init, Finder, Builder);
5358 internal::Matcher<Expr>, InnerMatcher) {
5361 InnerMatcher.matches(*
Condition, Finder, Builder));
5372 const Stmt *
const Then =
Node.getThen();
5373 return (Then !=
nullptr && InnerMatcher.matches(*Then, Finder, Builder));
5384 const Stmt *
const Else =
Node.getElse();
5385 return (Else !=
nullptr && InnerMatcher.matches(*Else, Finder, Builder));
5419 internal::NotEqualsBoundNodePredicate Predicate;
5422 return Builder->removeBindings(Predicate);
5434 internal::Matcher<DeclStmt>, InnerMatcher) {
5435 const DeclStmt*
const DeclarationStatement =
5436 Node.getConditionVariableDeclStmt();
5437 return DeclarationStatement !=
nullptr &&
5438 InnerMatcher.matches(*DeclarationStatement, Finder, Builder);
5451 internal::Matcher<Expr>, InnerMatcher) {
5453 return InnerMatcher.matches(*
Expression, Finder, Builder);
5468 internal::Matcher<Expr>, InnerMatcher) {
5470 return InnerMatcher.matches(*
Expression, Finder, Builder);
5502 internal::Matcher<Stmt>, InnerMatcher) {
5503 if (Finder->isTraversalIgnoringImplicitNodes() && isDefaultedHelper(&
Node))
5505 const Stmt *
const Statement = internal::GetBodyMatcher<NodeType>::get(
Node);
5506 return (Statement !=
nullptr &&
5507 InnerMatcher.matches(*Statement, Finder, Builder));
5527 internal::Matcher<Stmt>, InnerMatcher) {
5528 const Stmt *
const Statement =
Node.getBody();
5529 return (Statement !=
nullptr &&
5530 InnerMatcher.matches(*Statement, Finder, Builder));
5548 internal::Matcher<Stmt>, InnerMatcher) {
5550 return CS && matchesFirstInPointerRange(InnerMatcher, CS->
body_begin(),
5566 return Node.size() == N;
5594template <
typename ValueT>
5595internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5596 void(internal::AllNodeBaseTypes), ValueT>
5598 return internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5599 void(internal::AllNodeBaseTypes), ValueT>(
5608 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5616 unsigned,
Value, 1) {
5617 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5627 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5642 std::string, Name) {
5643 if (std::optional<StringRef> OpName = internal::getOpName(
Node))
5644 return *OpName == Name;
5654extern const internal::VariadicFunction<
5655 internal::PolymorphicMatcher<internal::HasAnyOperatorNameMatcher,
5659 std::vector<std::string>>,
5678 isAssignmentOperator,
5681 return Node.isAssignmentOp();
5699 isComparisonOperator,
5702 return Node.isComparisonOp();
5715 internal::Matcher<Expr>, InnerMatcher) {
5716 const Expr *LeftHandSide = internal::getLHS(
Node);
5717 return (LeftHandSide !=
nullptr &&
5718 InnerMatcher.matches(*LeftHandSide, Finder, Builder));
5731 internal::Matcher<Expr>, InnerMatcher) {
5732 const Expr *RightHandSide = internal::getRHS(
Node);
5733 return (RightHandSide !=
nullptr &&
5734 InnerMatcher.matches(*RightHandSide, Finder, Builder));
5743 internal::Matcher<Expr>, InnerMatcher) {
5744 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
5745 anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher)))
5746 .matches(
Node, Finder, Builder);
5763 internal::Matcher<Expr>, Matcher1, internal::Matcher<Expr>, Matcher2) {
5764 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
5765 anyOf(
allOf(hasLHS(Matcher1), hasRHS(Matcher2)),
5766 allOf(hasLHS(Matcher2), hasRHS(Matcher1))))
5767 .matches(
Node, Finder, Builder);
5780 internal::Matcher<Expr>, InnerMatcher) {
5781 const Expr *
const Operand = internal::getSubExpr(
Node);
5782 return (Operand !=
nullptr &&
5783 InnerMatcher.matches(*Operand, Finder, Builder));
5804 internal::Matcher<Expr>, InnerMatcher) {
5805 const Expr *
const SubExpression =
5806 internal::GetSourceExpressionMatcher<NodeType>::get(
Node);
5807 return (SubExpression !=
nullptr &&
5808 InnerMatcher.matches(*SubExpression, Finder, Builder));
5822 return Node.getCastKind() == Kind;
5830 internal::Matcher<QualType>, InnerMatcher) {
5832 return InnerMatcher.matches(NodeType, Finder, Builder);
5838 internal::Matcher<QualType>, InnerMatcher) {
5839 return InnerMatcher.matches(
Node.getType(), Finder, Builder);
5852 return Node.isStruct();
5865 return Node.isUnion();
5878 return Node.isClass();
5891 return Node.isEnum();
5906 internal::Matcher<Expr>, InnerMatcher) {
5909 InnerMatcher.matches(*
Expression, Finder, Builder));
5921 internal::Matcher<Expr>, InnerMatcher) {
5924 InnerMatcher.matches(*
Expression, Finder, Builder));
5951 return Node.isThisDeclarationADefinition();
5965 return Node.isVariadic();
5986 internal::Matcher<CXXRecordDecl>, InnerMatcher) {
5988 ASTChildrenNotSpelledInSourceScope RAII(Finder,
false);
5991 return (
Parent !=
nullptr &&
5992 InnerMatcher.matches(*
Parent, Finder, Builder));
6020 internal::Matcher<CXXMethodDecl>, InnerMatcher) {
6021 BoundNodesTreeBuilder
Result;
6022 bool Matched =
false;
6023 for (
const auto *Overridden :
Node.overridden_methods()) {
6024 BoundNodesTreeBuilder OverriddenBuilder(*Builder);
6025 const bool OverriddenMatched =
6026 InnerMatcher.matches(*Overridden, Finder, &OverriddenBuilder);
6027 if (OverriddenMatched) {
6029 Result.addMatch(OverriddenBuilder);
6032 *Builder = std::move(
Result);