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/StringExtras.h"
85#include "llvm/ADT/StringRef.h"
86#include "llvm/Support/Casting.h"
87#include "llvm/Support/Compiler.h"
88#include "llvm/Support/ErrorHandling.h"
89#include "llvm/Support/Regex.h"
100namespace ast_matchers {
115 template <
typename T>
117 return MyBoundNodes.getNodeAs<T>(
ID);
127 return MyBoundNodes.getMap();
134 BoundNodes(internal::BoundNodesMap &MyBoundNodes)
135 : MyBoundNodes(MyBoundNodes) {}
137 internal::BoundNodesMap MyBoundNodes;
171inline internal::TrueMatcher
anything() {
return internal::TrueMatcher(); }
184extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
196extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl>
208extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
220extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl>
230extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
249 auto &
SourceManager = Finder->getASTContext().getSourceManager();
270 auto &
SourceManager = Finder->getASTContext().getSourceManager();
272 if (ExpansionLoc.isInvalid()) {
297 auto &
SourceManager = Finder->getASTContext().getSourceManager();
299 if (ExpansionLoc.isInvalid()) {
318 std::string, MacroName) {
321 auto& Context = Finder->getASTContext();
322 std::optional<SourceLocation> B =
324 if (!B)
return false;
325 std::optional<SourceLocation> E =
327 if (!E)
return false;
340extern const internal::VariadicAllOfMatcher<Decl>
decl;
352extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl>
362extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl>
373extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
387extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl>
namedDecl;
398extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl>
labelDecl;
409extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl>
421extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
433extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl>
recordDecl;
442extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl>
451extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
464extern const internal::VariadicDynCastAllOfMatcher<
483extern const internal::VariadicDynCastAllOfMatcher<
496extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
507extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl>
521extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
531extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier>
cxxBaseSpecifier;
542extern const internal::VariadicAllOfMatcher<CXXCtorInitializer>
554extern const internal::VariadicAllOfMatcher<TemplateArgument>
templateArgument;
565extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc>
577extern const internal::VariadicAllOfMatcher<TemplateName>
templateName;
587extern const internal::VariadicDynCastAllOfMatcher<
Decl,
599extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
610extern const internal::VariadicDynCastAllOfMatcher<
Decl,
694 return Node.isBitField();
711 return Node.isBitField() &&
712 Node.getBitWidthValue(Finder->getASTContext()) == Width;
733 InnerMatcher.matches(*
Initializer, Finder, Builder));
739 return Node.isMain();
753 internal::Matcher<ClassTemplateDecl>, InnerMatcher) {
755 return (
Decl !=
nullptr &&
756 InnerMatcher.matches(*
Decl, Finder, Builder));
764 return Node.isImplicit();
789 hasAnyTemplateArgument,
793 internal::Matcher<TemplateArgument>, InnerMatcher) {
795 internal::getTemplateSpecializationArgs(
Node);
796 return matchesFirstInRange(InnerMatcher,
List.begin(),
List.end(), Finder,
797 Builder) !=
List.end();
818 const internal::Matcher<T> &InnerMatcher) {
819 return internal::DynTypedMatcher::constructRestrictedWrapper(
820 new internal::TraversalMatcher<T>(TK, InnerMatcher),
821 InnerMatcher.getID().first)
822 .template unconditionalConvertTo<T>();
826internal::BindableMatcher<T>
828 return internal::BindableMatcher<T>(
829 internal::DynTypedMatcher::constructRestrictedWrapper(
830 new internal::TraversalMatcher<T>(TK, InnerMatcher),
831 InnerMatcher.getID().first)
832 .template unconditionalConvertTo<T>());
835template <
typename... T>
836internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>
838 const internal::VariadicOperatorMatcher<T...> &InnerMatcher) {
839 return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>(
843template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
844 typename T,
typename ToTypes>
845internal::TraversalWrapper<
846 internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>>
848 ArgumentAdapterT, T, ToTypes> &InnerMatcher) {
849 return internal::TraversalWrapper<
850 internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T,
851 ToTypes>>(TK, InnerMatcher);
854template <
template <
typename T,
typename...
P>
class MatcherT, typename...
P,
855 typename ReturnTypesF>
856internal::TraversalWrapper<
857 internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>>
859 const internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>
861 return internal::TraversalWrapper<
862 internal::PolymorphicMatcher<MatcherT, ReturnTypesF,
P...>>(TK,
866template <
typename... T>
867internal::Matcher<
typename internal::GetClade<T...>::Type>
869 return traverse(TK, InnerMatcher.with());
895 return InnerMatcher.matches(*
Node.IgnoreImplicit(), Finder, Builder);
924 internal::Matcher<Expr>, InnerMatcher) {
925 return InnerMatcher.matches(*
Node.IgnoreImpCasts(), Finder, Builder);
946 return InnerMatcher.matches(*
Node.IgnoreParenCasts(), Finder, Builder);
971 internal::Matcher<Expr>, InnerMatcher) {
972 return InnerMatcher.matches(*
Node.IgnoreParenImpCasts(), Finder, Builder);
988 return InnerMatcher.matches(
Node.IgnoreParens(), Finder, Builder);
1004 const Expr *E =
Node.IgnoreParens();
1005 return InnerMatcher.matches(*E, Finder, Builder);
1022 return Node.isInstantiationDependent();
1069 hasTemplateArgument,
1073 unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher) {
1075 internal::getTemplateSpecializationArgs(
Node);
1076 if (
List.size() <= N)
1078 return InnerMatcher.matches(
List[N], Finder, Builder);
1091 templateArgumentCountIs,
1095 return internal::getTemplateSpecializationArgs(
Node).size() == N;
1110 internal::Matcher<QualType>, InnerMatcher) {
1113 return InnerMatcher.matches(
Node.getAsType(), Finder, Builder);
1128 internal::Matcher<TemplateName>, InnerMatcher) {
1131 return InnerMatcher.matches(
Node.getAsTemplate(), Finder, Builder);
1148 internal::Matcher<Decl>, InnerMatcher) {
1150 return InnerMatcher.matches(*
Node.getAsDecl(), Finder, Builder);
1168 return InnerMatcher.matches(*
Node.getAsExpr(), Finder, Builder);
1198 internal::Matcher<QualType>, InnerMatcher) {
1201 return InnerMatcher.matches(
Node.getIntegralType(), Finder, Builder);
1219 std::string,
Value) {
1235extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1245extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl>
valueDecl;
1258extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
1270extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
1281extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl>
enumDecl;
1291extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
1306extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl>
tagDecl;
1314extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl>
1323extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
1334extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
1344extern const internal::VariadicDynCastAllOfMatcher<Decl, ConceptDecl>
1356extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl>
varDecl;
1366extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl>
fieldDecl;
1376extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
1385extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl>
1394extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
1405extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl>
friendDecl;
1415extern const internal::VariadicAllOfMatcher<Stmt>
stmt;
1425extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt>
declStmt;
1438extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr>
memberExpr;
1452extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
1464extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1476extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr>
callExpr;
1506extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr>
lambdaExpr;
1515extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
1527extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
1536extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
1546extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
1556extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
1566extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
1576extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
1586extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
1601extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
1614extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
1626extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl>
1637extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
1646extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
1656extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
1666extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
1676extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
1686extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
1699extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
1705 internal::Matcher<Expr>, InnerMatcher) {
1706 const Expr *SyntForm =
Node.getSyntacticForm();
1707 return (SyntForm !=
nullptr &&
1708 InnerMatcher.matches(*SyntForm, Finder, Builder));
1722extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1734extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
1752extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
1765extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1778extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl>
usingDecl;
1789extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl>
1801extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
1818extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
1832extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1851extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1864extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
1874extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr>
parenExpr;
1886extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
1897extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1911extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
1922extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
1943extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1955extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr>
cxxNewExpr;
1965extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
1981extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
2001extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitLoopExpr>
2020extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitIndexExpr>
2031extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
2043extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
2062extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
2082extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2092extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr>
expr;
2101extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
2115extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
2124extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr>
blockExpr;
2132extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt>
ifStmt;
2141extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt>
forStmt;
2153 const Stmt *
const Increment =
Node.getInc();
2154 return (Increment !=
nullptr &&
2155 InnerMatcher.matches(*Increment, Finder, Builder));
2169 return (
Init !=
nullptr && InnerMatcher.matches(*
Init, Finder, Builder));
2179extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
2192 const VarDecl *
const Var =
Node.getLoopVariable();
2193 return (Var !=
nullptr && InnerMatcher.matches(*Var, Finder, Builder));
2207 return (
Init !=
nullptr && InnerMatcher.matches(*
Init, Finder, Builder));
2218extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt>
whileStmt;
2228extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt>
doStmt;
2238extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt>
breakStmt;
2248extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
2259extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt>
2270extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt>
returnStmt;
2281extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt>
gotoStmt;
2292extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt>
labelStmt;
2304extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
2315extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt>
switchStmt;
2325extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase>
switchCase;
2335extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt>
caseStmt;
2345extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
2354extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
2364extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
2374extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt>
cxxTryStmt;
2383extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
2393extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt>
nullStmt;
2403extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt>
asmStmt;
2411extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
2421extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
2434extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
2441extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
2451extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
2456extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
2460extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
2466extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
2476extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
2487extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
2490extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
2500extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
2511extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
2515extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
2519extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
2523extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConvertVectorExpr>
2527extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
2531extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
2539extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr>
atomicExpr;
2547extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr>
stmtExpr;
2556extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
2565extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
2574extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
2583extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2595extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
2611extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
2624extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
2640extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
2655extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
2666extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
2675extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
2699extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
2706extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
2722extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr>
castExpr;
2732extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
2741extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
2750extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
2759extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
2774 return Node.size() == N;
2778extern const internal::VariadicAllOfMatcher<QualType>
qualType;
2781extern const internal::VariadicAllOfMatcher<Type>
type;
2784extern const internal::VariadicAllOfMatcher<TypeLoc>
typeLoc;
2805extern const internal::VariadicOperatorMatcherFunc<
2806 2, std::numeric_limits<unsigned>::max()>
2812extern const internal::VariadicOperatorMatcherFunc<
2813 2, std::numeric_limits<unsigned>::max()>
2819extern const internal::VariadicOperatorMatcherFunc<
2820 2, std::numeric_limits<unsigned>::max()>
2847extern const internal::VariadicOperatorMatcherFunc<1, 1>
optionally;
2858extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2887template <
typename T,
typename...
U>
2888auto mapAnyOf(internal::VariadicDynCastAllOfMatcher<T, U>
const &...) {
2889 return internal::MapAnyOfHelper<
U...>();
3002extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr>
invocation;
3013 internal::Matcher<QualType>, InnerMatcher) {
3014 const QualType ArgumentType =
Node.getTypeOfArgument();
3015 return InnerMatcher.matches(ArgumentType, Finder, Builder);
3031 return Node.getKind() == Kind;
3037 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
3039 allOf(
anyOf(ofKind(UETT_AlignOf), ofKind(UETT_PreferredAlignOf)),
3046 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
3048 allOf(ofKind(UETT_SizeOf), InnerMatcher)));
3066inline internal::Matcher<NamedDecl>
hasName(StringRef Name) {
3067 return internal::Matcher<NamedDecl>(
3068 new internal::HasNameMatcher({std::string(Name)}));
3081extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
3102 std::string FullNameString =
"::" +
Node.getQualifiedNameAsString();
3103 return RegExp->match(FullNameString);
3125inline internal::PolymorphicMatcher<
3126 internal::HasOverloadedOperatorNameMatcher,
3128 std::vector<std::string>>
3130 return internal::PolymorphicMatcher<
3131 internal::HasOverloadedOperatorNameMatcher,
3133 std::vector<std::string>>({std::string(Name)});
3144extern const internal::VariadicFunction<
3145 internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher,
3148 std::vector<std::string>>,
3173 return Node.getMember().getAsString() == N;
3211 std::string, BindingID) {
3212 auto MemberName =
Node.getMember().getAsString();
3214 return Builder->removeBindings(
3215 [
this, MemberName](
const BoundNodesMap &
Nodes) {
3216 const auto &BN =
Nodes.getNode(this->BindingID);
3217 if (
const auto *ND = BN.get<
NamedDecl>()) {
3218 if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(ND))
3220 return ND->getName() != MemberName;
3259 internal::Matcher<NamedDecl>,
Base) {
3261 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3262 return Finder->classIsDerivedFrom(RD,
Base, Builder,
false);
3265 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3266 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3274 std::string, BaseName, 1) {
3275 if (BaseName.empty())
3278 const auto M = isDerivedFrom(
hasName(BaseName));
3280 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3281 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3283 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3284 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3321 return Node.hasDefinition() &&
3323 return BaseSpecMatcher.matches(Base, Finder, Builder);
3330 isSameOrDerivedFrom,
3332 internal::Matcher<NamedDecl>,
Base, 0) {
3335 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3336 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3338 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3339 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3345 isSameOrDerivedFrom,
3347 std::string, BaseName, 1) {
3348 if (BaseName.empty())
3351 const auto M = isSameOrDerivedFrom(
hasName(BaseName));
3353 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3354 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3356 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3357 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3382 isDirectlyDerivedFrom,
3384 internal::Matcher<NamedDecl>,
Base, 0) {
3386 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3387 return Finder->classIsDerivedFrom(RD,
Base, Builder,
true);
3390 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3391 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3397 isDirectlyDerivedFrom,
3399 std::string, BaseName, 1) {
3400 if (BaseName.empty())
3402 const auto M = isDirectlyDerivedFrom(
hasName(BaseName));
3404 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3405 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3407 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3408 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3423 BoundNodesTreeBuilder
Result(*Builder);
3424 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.method_begin(),
3426 if (MatchIt ==
Node.method_end())
3429 if (Finder->isTraversalIgnoringImplicitNodes() && (*MatchIt)->isImplicit())
3431 *Builder = std::move(
Result);
3445 return Node.isLambda();
3466extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher>
has;
3482extern const internal::ArgumentAdaptingMatcherFunc<
3483 internal::HasDescendantMatcher>
3504extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
3534extern const internal::ArgumentAdaptingMatcherFunc<
3535 internal::ForEachDescendantMatcher>
3554template <
typename T>
3555internal::Matcher<T>
findAll(
const internal::Matcher<T> &Matcher) {
3569extern const internal::ArgumentAdaptingMatcherFunc<
3570 internal::HasParentMatcher,
3571 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3572 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3586extern const internal::ArgumentAdaptingMatcherFunc<
3587 internal::HasAncestorMatcher,
3588 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3589 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3601extern const internal::VariadicOperatorMatcherFunc<1, 1>
unless;
3637inline internal::PolymorphicMatcher<
3638 internal::HasDeclarationMatcher,
3639 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>
3641 return internal::PolymorphicMatcher<
3642 internal::HasDeclarationMatcher,
3643 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>(
3662 return UnderlyingDecl !=
nullptr &&
3663 InnerMatcher.matches(*UnderlyingDecl, Finder, Builder);
3686 const Expr *ExprNode =
Node.getImplicitObjectArgument()
3687 ->IgnoreParenImpCasts();
3688 return (ExprNode !=
nullptr &&
3689 InnerMatcher.matches(*ExprNode, Finder, Builder));
3706 return InnerMatcher.matches(
TypeDecl, Finder, Builder);
3722 return Node.isClassMethod();
3738 return Node.isInstanceMethod();
3755 return Node.isClassMessage();
3772 return Node.isInstanceMessage();
3787 const Expr *ReceiverNode =
Node.getInstanceReceiver();
3788 return (ReceiverNode !=
nullptr &&
3815extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
3829 std::string SelectorString =
Node.getSelector().getAsString();
3830 return RegExp->match(SelectorString);
3838 return Node.getSelector().isNull();
3850 return Node.getSelector().isUnarySelector();
3866 return Node.getSelector().isKeywordSelector();
3881 return Node.getSelector().getNumArgs() == N;
3902 const Expr *ExprNode =
Node.getCallee();
3903 return (ExprNode !=
nullptr &&
3904 InnerMatcher.matches(*ExprNode, Finder, Builder));
3930 internal::Matcher<Decl>, InnerMatcher, 1) {
3931 if (isa<CallExpr>(&
Node))
3933 .matches(
Node, Finder, Builder);
3937 const auto *MsgNode = cast<ObjCMessageExpr>(&
Node);
3938 const Decl *DeclNode = MsgNode->getMethodDecl();
3939 return (DeclNode !=
nullptr &&
3940 InnerMatcher.matches(*DeclNode, Finder, Builder));
3964 internal::Matcher<QualType>, InnerMatcher, 0) {
3967 return InnerMatcher.matches(QT, Finder, Builder);
4005 internal::Matcher<Decl>, InnerMatcher, 1) {
4050 internal::Matcher<TypeLoc>, Inner) {
4052 if (source ==
nullptr) {
4056 return Inner.matches(source->
getTypeLoc(), Finder, Builder);
4069 return Name ==
Node.getAsString();
4083 QualType, pointsTo, internal::Matcher<QualType>,
4085 return (!
Node.isNull() &&
Node->isAnyPointerType() &&
4086 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4093 .matches(
Node, Finder, Builder);
4108 return InnerMatcher.matches(*
Node.getUnqualifiedDesugaredType(), Finder,
4127 return (!
Node.isNull() &&
Node->isReferenceType() &&
4128 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4147 return InnerMatcher.matches(
Node.getCanonicalType(), Finder, Builder);
4154 .matches(
Node, Finder, Builder);
4175 internal::Matcher<Expr>, InnerMatcher) {
4176 const Expr *ExprNode =
Node.getImplicitObjectArgument();
4177 return (ExprNode !=
nullptr &&
4178 InnerMatcher.matches(*ExprNode, Finder, Builder));
4198 internal::Matcher<QualType>, InnerMatcher, 0) {
4199 return onImplicitObjectArgument(
4200 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4201 .matches(
Node, Finder, Builder);
4206 internal::Matcher<Decl>, InnerMatcher, 1) {
4207 return onImplicitObjectArgument(
4208 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4209 .matches(
Node, Finder, Builder);
4223 const Decl *DeclNode =
Node.getDecl();
4224 return (DeclNode !=
nullptr &&
4225 InnerMatcher.matches(*DeclNode, Finder, Builder));
4252 internal::Matcher<UsingShadowDecl>, Inner) {
4255 return Inner.matches(*
UsingDecl, Finder, Builder);
4276 return matchesFirstInPointerRange(InnerMatcher,
Node.decls_begin(),
4277 Node.decls_end(), Finder,
4278 Builder) !=
Node.decls_end();
4291 if (
Node.isSingleDecl()) {
4292 const Decl *FoundDecl =
Node.getSingleDecl();
4293 return InnerMatcher.matches(*FoundDecl, Finder, Builder);
4307 VarDecl, hasInitializer, internal::Matcher<Expr>,
4311 InnerMatcher.matches(*
Initializer, Finder, Builder));
4337 internal::Matcher<LambdaCapture>, InnerMatcher) {
4338 BoundNodesTreeBuilder
Result;
4339 bool Matched =
false;
4341 if (Finder->isTraversalIgnoringImplicitNodes() &&
Capture.isImplicit())
4343 BoundNodesTreeBuilder CaptureBuilder(*Builder);
4344 if (InnerMatcher.matches(
Capture, Finder, &CaptureBuilder)) {
4346 Result.addMatch(CaptureBuilder);
4349 *Builder = std::move(
Result);
4364 return Node.isStaticLocal();
4379 return Node.hasLocalStorage();
4393 return Node.hasGlobalStorage();
4460 return Node.isExceptionVariable();
4476 unsigned NumArgs =
Node.getNumArgs();
4477 if (!Finder->isTraversalIgnoringImplicitNodes())
4478 return NumArgs == N;
4480 if (!isa<CXXDefaultArgExpr>(
Node.getArg(NumArgs - 1)))
4484 return NumArgs == N;
4503 unsigned NumArgs =
Node.getNumArgs();
4504 if (!Finder->isTraversalIgnoringImplicitNodes())
4505 return NumArgs >= N;
4507 if (!isa<CXXDefaultArgExpr>(
Node.getArg(NumArgs - 1)))
4511 return NumArgs >= N;
4526 unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
4527 if (N >=
Node.getNumArgs())
4530 if (Finder->isTraversalIgnoringImplicitNodes() && isa<CXXDefaultArgExpr>(Arg))
4543 ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
4544 return N <
Node.getNumInits() &&
4545 InnerMatcher.matches(*
Node.getInit(N), Finder, Builder);
4583 internal::Matcher<Decl>, InnerMatcher) {
4584 const unsigned NumDecls = std::distance(
Node.decl_begin(),
Node.decl_end());
4588 std::advance(Iterator, N);
4589 return InnerMatcher.matches(**Iterator, Finder, Builder);
4606 return Node.getExceptionDecl() ==
nullptr;
4623 internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
4624 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.init_begin(),
4625 Node.init_end(), Finder, Builder);
4626 if (MatchIt ==
Node.init_end())
4628 return (*MatchIt)->isWritten() || !Finder->isTraversalIgnoringImplicitNodes();
4645 internal::Matcher<FieldDecl>, InnerMatcher) {
4647 return (NodeAsDecl !=
nullptr &&
4648 InnerMatcher.matches(*NodeAsDecl, Finder, Builder));
4665 internal::Matcher<Expr>, InnerMatcher) {
4666 const Expr* NodeAsExpr =
Node.getInit();
4667 return (NodeAsExpr !=
nullptr &&
4668 InnerMatcher.matches(*NodeAsExpr, Finder, Builder));
4685 return Node.isWritten();
4705 return Node.isBaseInitializer();
4725 return Node.isMemberInitializer();
4751 internal::Matcher<Expr>, InnerMatcher) {
4752 for (
const Expr *Arg :
Node.arguments()) {
4753 if (Finder->isTraversalIgnoringImplicitNodes() &&
4754 isa<CXXDefaultArgExpr>(Arg))
4756 BoundNodesTreeBuilder
Result(*Builder);
4757 if (InnerMatcher.matches(*Arg, Finder, &
Result)) {
4758 *Builder = std::move(
Result);
4777extern const internal::VariadicAllOfMatcher<LambdaCapture>
lambdaCapture;
4794 clang::ast_matchers::internal::BoundNodesTreeBuilder
Result(*Builder);
4796 *Builder = std::move(
Result);
4820 auto *capturedVar =
Node.getCapturedVar();
4821 return capturedVar && InnerMatcher.matches(*capturedVar, Finder, Builder);
4842 return Node.isListInitialization();
4858 return Node.requiresZeroInitialization();
4885 unsigned, N, internal::Matcher<ParmVarDecl>,
4887 return (N <
Node.parameters().size()
4888 && InnerMatcher.matches(*
Node.parameters()[N], Finder, Builder));
4912 internal::Matcher<Expr>, ArgMatcher,
4913 internal::Matcher<ParmVarDecl>, ParamMatcher) {
4914 BoundNodesTreeBuilder
Result;
4918 BoundNodesTreeBuilder Matches;
4920 .matches(
Node, Finder, &Matches)
4924 bool Matched =
false;
4925 for (; ArgIndex <
Node.getNumArgs(); ++ArgIndex) {
4926 BoundNodesTreeBuilder ArgMatches(*Builder);
4927 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()),
4928 Finder, &ArgMatches)) {
4929 BoundNodesTreeBuilder ParamMatches(ArgMatches);
4931 hasParameter(ParamIndex, ParamMatcher)))),
4933 hasParameter(ParamIndex, ParamMatcher))))))
4934 .matches(
Node, Finder, &ParamMatches)) {
4935 Result.addMatch(ParamMatches);
4941 *Builder = std::move(
Result);
4973 internal::Matcher<Expr>, ArgMatcher,
4974 internal::Matcher<QualType>, ParamMatcher) {
4975 BoundNodesTreeBuilder
Result;
4979 BoundNodesTreeBuilder Matches;
4981 .matches(
Node, Finder, &Matches)
4987 if (
const auto *
Call = dyn_cast<CallExpr>(&
Node)) {
4988 if (
const auto *
Value =
4989 dyn_cast_or_null<ValueDecl>(
Call->getCalleeDecl())) {
4999 assert(MP &&
"Must be member-pointer if its a memberfunctionpointer");
5002 "The call must have happened through a member function "
5008 unsigned ParamIndex = 0;
5009 bool Matched =
false;
5010 unsigned NumArgs =
Node.getNumArgs();
5014 for (; ArgIndex < NumArgs; ++ArgIndex, ++ParamIndex) {
5015 BoundNodesTreeBuilder ArgMatches(*Builder);
5016 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()), Finder,
5018 BoundNodesTreeBuilder ParamMatches(ArgMatches);
5024 if (ParamMatcher.matches(ParamType, Finder, &ParamMatches)) {
5025 Result.addMatch(ParamMatches);
5031 hasParameter(ParamIndex, hasType(ParamMatcher))))),
5033 hasParameter(ParamIndex, hasType(ParamMatcher)))))))
5034 .matches(
Node, Finder, &ParamMatches)) {
5035 Result.addMatch(ParamMatches);
5041 *Builder = std::move(
Result);
5063 if (
const auto *
Decl = dyn_cast_or_null<FunctionDecl>(Context))
5064 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5065 if (
const auto *
Decl = dyn_cast_or_null<BlockDecl>(Context))
5066 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5067 if (
const auto *
Decl = dyn_cast_or_null<ObjCMethodDecl>(Context))
5068 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5108 internal::Matcher<ParmVarDecl>,
5110 return matchesFirstInPointerRange(InnerMatcher,
Node.param_begin(),
5111 Node.param_end(), Finder,
5112 Builder) !=
Node.param_end();
5136 return Node.getNumParams() == N;
5163 forEachTemplateArgument,
5166 clang::ast_matchers::internal::Matcher<TemplateArgument>, InnerMatcher) {
5168 clang::ast_matchers::internal::getTemplateSpecializationArgs(
Node);
5169 clang::ast_matchers::internal::BoundNodesTreeBuilder
Result;
5170 bool Matched =
false;
5171 for (
const auto &Arg : TemplateArgs) {
5172 clang::ast_matchers::internal::BoundNodesTreeBuilder ArgBuilder(*Builder);
5173 if (InnerMatcher.matches(Arg, Finder, &ArgBuilder)) {
5175 Result.addMatch(ArgBuilder);
5178 *Builder = std::move(
Result);
5207 internal::Matcher<QualType>, InnerMatcher) {
5208 return InnerMatcher.matches(
Node.getReturnType(), Finder, Builder);
5228 return Node.isExternC();
5261 return Node.isDeleted();
5274 return Node.isDefaulted();
5307 return FnTy->hasDynamicExceptionSpec();
5357 return Node.isConsteval();
5379 return Node.isConstexpr();
5394 if (
const auto *CIA =
Node.getAttr<ConstInitAttr>())
5395 return CIA->isConstinit();
5423 internal::Matcher<Stmt>, InnerMatcher) {
5425 return Init !=
nullptr && InnerMatcher.matches(*
Init, Finder, Builder);
5439 internal::Matcher<Expr>, InnerMatcher) {
5442 InnerMatcher.matches(*
Condition, Finder, Builder));
5453 const Stmt *
const Then =
Node.getThen();
5454 return (Then !=
nullptr && InnerMatcher.matches(*Then, Finder, Builder));
5465 const Stmt *
const Else =
Node.getElse();
5466 return (Else !=
nullptr && InnerMatcher.matches(*Else, Finder, Builder));
5500 internal::NotEqualsBoundNodePredicate Predicate;
5503 return Builder->removeBindings(Predicate);
5515 internal::Matcher<DeclStmt>, InnerMatcher) {
5516 const DeclStmt*
const DeclarationStatement =
5517 Node.getConditionVariableDeclStmt();
5518 return DeclarationStatement !=
nullptr &&
5519 InnerMatcher.matches(*DeclarationStatement, Finder, Builder);
5532 internal::Matcher<Expr>, InnerMatcher) {
5534 return InnerMatcher.matches(*
Expression, Finder, Builder);
5549 internal::Matcher<Expr>, InnerMatcher) {
5551 return InnerMatcher.matches(*
Expression, Finder, Builder);
5583 internal::Matcher<Stmt>, InnerMatcher) {
5584 if (Finder->isTraversalIgnoringImplicitNodes() && isDefaultedHelper(&
Node))
5586 const Stmt *
const Statement = internal::GetBodyMatcher<NodeType>::get(
Node);
5587 return (Statement !=
nullptr &&
5588 InnerMatcher.matches(*Statement, Finder, Builder));
5608 internal::Matcher<Stmt>, InnerMatcher) {
5609 const Stmt *
const Statement =
Node.getBody();
5610 return (Statement !=
nullptr &&
5611 InnerMatcher.matches(*Statement, Finder, Builder));
5629 internal::Matcher<Stmt>, InnerMatcher) {
5631 return CS && matchesFirstInPointerRange(InnerMatcher, CS->
body_begin(),
5647 return Node.size() == N;
5675template <
typename ValueT>
5676internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5677 void(internal::AllNodeBaseTypes), ValueT>
5679 return internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5680 void(internal::AllNodeBaseTypes), ValueT>(
5689 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5697 unsigned,
Value, 1) {
5698 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5708 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5723 std::string, Name) {
5724 if (std::optional<StringRef> OpName = internal::getOpName(
Node))
5725 return *OpName == Name;
5735extern const internal::VariadicFunction<
5736 internal::PolymorphicMatcher<internal::HasAnyOperatorNameMatcher,
5740 std::vector<std::string>>,
5759 isAssignmentOperator,
5762 return Node.isAssignmentOp();
5780 isComparisonOperator,
5783 return Node.isComparisonOp();
5796 internal::Matcher<Expr>, InnerMatcher) {
5797 const Expr *LeftHandSide = internal::getLHS(
Node);
5798 return (LeftHandSide !=
nullptr &&
5799 InnerMatcher.matches(*LeftHandSide, Finder, Builder));
5812 internal::Matcher<Expr>, InnerMatcher) {
5813 const Expr *RightHandSide = internal::getRHS(
Node);
5814 return (RightHandSide !=
nullptr &&
5815 InnerMatcher.matches(*RightHandSide, Finder, Builder));
5824 internal::Matcher<Expr>, InnerMatcher) {
5825 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
5826 anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher)))
5827 .matches(
Node, Finder, Builder);
5844 internal::Matcher<Expr>, Matcher1, internal::Matcher<Expr>, Matcher2) {
5845 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
5846 anyOf(
allOf(hasLHS(Matcher1), hasRHS(Matcher2)),
5847 allOf(hasLHS(Matcher2), hasRHS(Matcher1))))
5848 .matches(
Node, Finder, Builder);
5861 internal::Matcher<Expr>, InnerMatcher) {
5862 const Expr *
const Operand = internal::getSubExpr(
Node);
5863 return (Operand !=
nullptr &&
5864 InnerMatcher.matches(*Operand, Finder, Builder));
5885 internal::Matcher<Expr>, InnerMatcher) {
5886 const Expr *
const SubExpression =
5887 internal::GetSourceExpressionMatcher<NodeType>::get(
Node);
5888 return (SubExpression !=
nullptr &&
5889 InnerMatcher.matches(*SubExpression, Finder, Builder));
5903 return Node.getCastKind() == Kind;
5911 internal::Matcher<QualType>, InnerMatcher) {
5913 return InnerMatcher.matches(NodeType, Finder, Builder);
5919 internal::Matcher<QualType>, InnerMatcher) {
5920 return InnerMatcher.matches(
Node.getType(), Finder, Builder);
5933 return Node.isStruct();
5946 return Node.isUnion();
5959 return Node.isClass();
5972 return Node.isEnum();
5987 internal::Matcher<Expr>, InnerMatcher) {
5990 InnerMatcher.matches(*
Expression, Finder, Builder));
6002 internal::Matcher<Expr>, InnerMatcher) {
6005 InnerMatcher.matches(*
Expression, Finder, Builder));