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() &&
Node.getBitWidthValue() == 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);
1004 return InnerMatcher.matches(*
E, Finder, Builder);
1021 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,
1247extern const internal::VariadicDynCastAllOfMatcher<Decl, ExportDecl>
exportDecl;
1256extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl>
valueDecl;
1269extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
1281extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
1292extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl>
enumDecl;
1302extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
1317extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl>
tagDecl;
1325extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl>
1334extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
1345extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
1355extern const internal::VariadicDynCastAllOfMatcher<Decl, ConceptDecl>
1367extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl>
varDecl;
1377extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl>
fieldDecl;
1387extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
1396extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl>
1405extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
1416extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl>
friendDecl;
1426extern const internal::VariadicAllOfMatcher<Stmt>
stmt;
1436extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt>
declStmt;
1449extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr>
memberExpr;
1463extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
1475extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1487extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr>
callExpr;
1517extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr>
lambdaExpr;
1526extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
1538extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
1547extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
1557extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
1567extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
1577extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
1587extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
1597extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
1612extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
1625extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
1637extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl>
1648extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
1657extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
1667extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
1677extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
1687extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
1697extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
1710extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
1716 internal::Matcher<Expr>, InnerMatcher) {
1717 const Expr *SyntForm =
Node.getSyntacticForm();
1718 return (SyntForm !=
nullptr &&
1719 InnerMatcher.matches(*SyntForm, Finder, Builder));
1733extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1745extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
1763extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
1776extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1789extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl>
usingDecl;
1800extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl>
1812extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
1829extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
1843extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1862extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1875extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
1885extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr>
parenExpr;
1897extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
1908extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1922extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
1933extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
1954extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1966extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr>
cxxNewExpr;
1976extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
1992extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
2012extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitLoopExpr>
2031extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitIndexExpr>
2042extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
2054extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
2073extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
2085extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFoldExpr>
2105extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2115extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr>
expr;
2124extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
2133extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2148extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
2157extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr>
blockExpr;
2165extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt>
ifStmt;
2174extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt>
forStmt;
2186 const Stmt *
const Increment =
Node.getInc();
2187 return (Increment !=
nullptr &&
2188 InnerMatcher.matches(*Increment, Finder, Builder));
2202 return (
Init !=
nullptr && InnerMatcher.matches(*
Init, Finder, Builder));
2212extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
2225 const VarDecl *
const Var =
Node.getLoopVariable();
2226 return (Var !=
nullptr && InnerMatcher.matches(*Var, Finder, Builder));
2240 return (
Init !=
nullptr && InnerMatcher.matches(*
Init, Finder, Builder));
2251extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt>
whileStmt;
2261extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt>
doStmt;
2271extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt>
breakStmt;
2281extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
2292extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt>
2303extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt>
returnStmt;
2314extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt>
gotoStmt;
2325extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt>
labelStmt;
2337extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
2348extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt>
switchStmt;
2358extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase>
switchCase;
2368extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt>
caseStmt;
2378extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
2387extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
2397extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
2407extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt>
cxxTryStmt;
2416extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
2426extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt>
nullStmt;
2436extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt>
asmStmt;
2444extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
2454extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
2467extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
2474extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
2484extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
2489extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
2493extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
2499extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
2509extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
2520extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
2523extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
2533extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
2544extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
2548extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
2552extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
2556extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConvertVectorExpr>
2560extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
2564extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
2572extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr>
atomicExpr;
2580extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr>
stmtExpr;
2589extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
2598extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
2607extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
2616extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2628extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
2644extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
2657extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
2673extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
2688extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
2699extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
2708extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
2732extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
2739extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
2755extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr>
castExpr;
2765extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
2774extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
2783extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
2792extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
2807 return Node.size() == N;
2811extern const internal::VariadicAllOfMatcher<QualType>
qualType;
2814extern const internal::VariadicAllOfMatcher<Type>
type;
2817extern const internal::VariadicAllOfMatcher<TypeLoc>
typeLoc;
2838extern const internal::VariadicOperatorMatcherFunc<
2839 2, std::numeric_limits<unsigned>::max()>
2845extern const internal::VariadicOperatorMatcherFunc<
2846 2, std::numeric_limits<unsigned>::max()>
2852extern const internal::VariadicOperatorMatcherFunc<
2853 2, std::numeric_limits<unsigned>::max()>
2880extern const internal::VariadicOperatorMatcherFunc<1, 1>
optionally;
2891extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2920template <
typename T,
typename...
U>
2921auto mapAnyOf(internal::VariadicDynCastAllOfMatcher<T, U>
const &...) {
2922 return internal::MapAnyOfHelper<
U...>();
3035extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr>
invocation;
3046 internal::Matcher<QualType>, InnerMatcher) {
3047 const QualType ArgumentType =
Node.getTypeOfArgument();
3048 return InnerMatcher.matches(ArgumentType, Finder, Builder);
3070 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
3072 allOf(
anyOf(ofKind(UETT_AlignOf), ofKind(UETT_PreferredAlignOf)),
3079 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
3081 allOf(ofKind(UETT_SizeOf), InnerMatcher)));
3099inline internal::Matcher<NamedDecl>
hasName(StringRef Name) {
3100 return internal::Matcher<NamedDecl>(
3101 new internal::HasNameMatcher({std::string(Name)}));
3114extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
3135 std::string FullNameString =
"::" +
Node.getQualifiedNameAsString();
3136 return RegExp->match(FullNameString);
3158inline internal::PolymorphicMatcher<
3159 internal::HasOverloadedOperatorNameMatcher,
3161 std::vector<std::string>>
3163 return internal::PolymorphicMatcher<
3164 internal::HasOverloadedOperatorNameMatcher,
3166 std::vector<std::string>>({std::string(Name)});
3177extern const internal::VariadicFunction<
3178 internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher,
3181 std::vector<std::string>>,
3206 return Node.getMember().getAsString() == N;
3244 std::string, BindingID) {
3245 auto MemberName =
Node.getMember().getAsString();
3247 return Builder->removeBindings(
3248 [
this, MemberName](
const BoundNodesMap &
Nodes) {
3251 if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(ND))
3253 return ND->getName() != MemberName;
3279 return internal::getDependentName(
Node) == N;
3315 internal::Matcher<NamedDecl>,
Base) {
3317 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3318 return Finder->classIsDerivedFrom(RD,
Base, Builder,
false);
3321 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3322 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3330 std::string, BaseName, 1) {
3331 if (BaseName.empty())
3334 const auto M = isDerivedFrom(
hasName(BaseName));
3336 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3337 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3339 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3340 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3377 return Node.hasDefinition() &&
3379 return BaseSpecMatcher.matches(Base, Finder, Builder);
3386 isSameOrDerivedFrom,
3388 internal::Matcher<NamedDecl>,
Base, 0) {
3391 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3392 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3394 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3395 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3401 isSameOrDerivedFrom,
3403 std::string, BaseName, 1) {
3404 if (BaseName.empty())
3407 const auto M = isSameOrDerivedFrom(
hasName(BaseName));
3409 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3410 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3412 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3413 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3438 isDirectlyDerivedFrom,
3440 internal::Matcher<NamedDecl>,
Base, 0) {
3442 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3443 return Finder->classIsDerivedFrom(RD,
Base, Builder,
true);
3446 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3447 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3453 isDirectlyDerivedFrom,
3455 std::string, BaseName, 1) {
3456 if (BaseName.empty())
3458 const auto M = isDirectlyDerivedFrom(
hasName(BaseName));
3460 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3461 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3463 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3464 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3479 BoundNodesTreeBuilder
Result(*Builder);
3480 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.method_begin(),
3482 if (MatchIt ==
Node.method_end())
3485 if (Finder->isTraversalIgnoringImplicitNodes() && (*MatchIt)->isImplicit())
3487 *Builder = std::move(
Result);
3501 return Node.isLambda();
3522extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher>
has;
3538extern const internal::ArgumentAdaptingMatcherFunc<
3539 internal::HasDescendantMatcher>
3560extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
3590extern const internal::ArgumentAdaptingMatcherFunc<
3591 internal::ForEachDescendantMatcher>
3610template <
typename T>
3611internal::Matcher<T>
findAll(
const internal::Matcher<T> &Matcher) {
3625extern const internal::ArgumentAdaptingMatcherFunc<
3626 internal::HasParentMatcher,
3627 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3628 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3642extern const internal::ArgumentAdaptingMatcherFunc<
3643 internal::HasAncestorMatcher,
3644 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3645 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3657extern const internal::VariadicOperatorMatcherFunc<1, 1>
unless;
3693inline internal::PolymorphicMatcher<
3694 internal::HasDeclarationMatcher,
3695 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>
3697 return internal::PolymorphicMatcher<
3698 internal::HasDeclarationMatcher,
3699 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>(
3718 return UnderlyingDecl !=
nullptr &&
3719 InnerMatcher.matches(*UnderlyingDecl, Finder, Builder);
3742 const Expr *ExprNode =
Node.getImplicitObjectArgument()
3743 ->IgnoreParenImpCasts();
3744 return (ExprNode !=
nullptr &&
3745 InnerMatcher.matches(*ExprNode, Finder, Builder));
3762 return InnerMatcher.matches(
TypeDecl, Finder, Builder);
3778 return Node.isClassMethod();
3794 return Node.isInstanceMethod();
3811 return Node.isClassMessage();
3828 return Node.isInstanceMessage();
3843 const Expr *ReceiverNode =
Node.getInstanceReceiver();
3844 return (ReceiverNode !=
nullptr &&
3871extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
3885 std::string SelectorString =
Node.getSelector().getAsString();
3886 return RegExp->match(SelectorString);
3894 return Node.getSelector().isNull();
3906 return Node.getSelector().isUnarySelector();
3922 return Node.getSelector().isKeywordSelector();
3937 return Node.getSelector().getNumArgs() == N;
3976 internal::Matcher<Stmt>, InnerMatcher, 0) {
3977 const auto *ExprNode =
Node.getCallee();
3978 return (ExprNode !=
nullptr &&
3979 InnerMatcher.matches(*ExprNode, Finder, Builder));
4005 internal::Matcher<Decl>, InnerMatcher, 1) {
4006 if (isa<CallExpr>(&
Node))
4008 .matches(
Node, Finder, Builder);
4012 const auto *MsgNode = cast<ObjCMessageExpr>(&
Node);
4013 const Decl *DeclNode = MsgNode->getMethodDecl();
4014 return (DeclNode !=
nullptr &&
4015 InnerMatcher.matches(*DeclNode, Finder, Builder));
4039 internal::Matcher<QualType>, InnerMatcher, 0) {
4042 return InnerMatcher.matches(QT, Finder, Builder);
4080 internal::Matcher<Decl>, InnerMatcher, 1) {
4124 internal::Matcher<TypeLoc>, Inner) {
4126 if (source ==
nullptr) {
4130 return Inner.matches(source->
getTypeLoc(), Finder, Builder);
4143 return Name ==
Node.getAsString();
4157 QualType, pointsTo, internal::Matcher<QualType>,
4159 return (!
Node.isNull() &&
Node->isAnyPointerType() &&
4160 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4167 .matches(
Node, Finder, Builder);
4182 return InnerMatcher.matches(*
Node.getUnqualifiedDesugaredType(), Finder,
4201 return (!
Node.isNull() &&
Node->isReferenceType() &&
4202 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4221 return InnerMatcher.matches(
Node.getCanonicalType(), Finder, Builder);
4228 .matches(
Node, Finder, Builder);
4249 internal::Matcher<Expr>, InnerMatcher) {
4250 const Expr *ExprNode =
Node.getImplicitObjectArgument();
4251 return (ExprNode !=
nullptr &&
4252 InnerMatcher.matches(*ExprNode, Finder, Builder));
4272 internal::Matcher<QualType>, InnerMatcher, 0) {
4273 return onImplicitObjectArgument(
4274 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4275 .matches(
Node, Finder, Builder);
4280 internal::Matcher<Decl>, InnerMatcher, 1) {
4281 return onImplicitObjectArgument(
4282 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4283 .matches(
Node, Finder, Builder);
4297 const Decl *DeclNode =
Node.getDecl();
4298 return (DeclNode !=
nullptr &&
4299 InnerMatcher.matches(*DeclNode, Finder, Builder));
4326 internal::Matcher<UsingShadowDecl>, Inner) {
4329 return Inner.matches(*
UsingDecl, Finder, Builder);
4350 return matchesFirstInPointerRange(InnerMatcher,
Node.decls_begin(),
4351 Node.decls_end(), Finder,
4352 Builder) !=
Node.decls_end();
4365 if (
Node.isSingleDecl()) {
4366 const Decl *FoundDecl =
Node.getSingleDecl();
4367 return InnerMatcher.matches(*FoundDecl, Finder, Builder);
4381 VarDecl, hasInitializer, internal::Matcher<Expr>,
4385 InnerMatcher.matches(*
Initializer, Finder, Builder));
4411 internal::Matcher<LambdaCapture>, InnerMatcher) {
4412 BoundNodesTreeBuilder
Result;
4413 bool Matched =
false;
4415 if (Finder->isTraversalIgnoringImplicitNodes() &&
Capture.isImplicit())
4417 BoundNodesTreeBuilder CaptureBuilder(*Builder);
4418 if (InnerMatcher.matches(
Capture, Finder, &CaptureBuilder)) {
4420 Result.addMatch(CaptureBuilder);
4423 *Builder = std::move(
Result);
4438 return Node.isStaticLocal();
4453 return Node.hasLocalStorage();
4467 return Node.hasGlobalStorage();
4534 return Node.isExceptionVariable();
4550 unsigned NumArgs =
Node.getNumArgs();
4551 if (!Finder->isTraversalIgnoringImplicitNodes())
4552 return NumArgs == N;
4554 if (!isa<CXXDefaultArgExpr>(
Node.getArg(NumArgs - 1)))
4558 return NumArgs == N;
4577 unsigned NumArgs =
Node.getNumArgs();
4578 if (!Finder->isTraversalIgnoringImplicitNodes())
4579 return NumArgs >= N;
4581 if (!isa<CXXDefaultArgExpr>(
Node.getArg(NumArgs - 1)))
4585 return NumArgs >= N;
4600 unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
4601 if (N >=
Node.getNumArgs())
4604 if (Finder->isTraversalIgnoringImplicitNodes() && isa<CXXDefaultArgExpr>(Arg))
4627 const auto *
const Init =
Node.getInit();
4628 return Init && InnerMacher.matches(*
Init, Finder, Builder);
4649 const Expr *
const Pattern =
Node.getPattern();
4650 return Pattern && InnerMacher.matches(*Pattern, Finder, Builder);
4731 return N <
Node.getNumInits() &&
4732 InnerMatcher.matches(*
Node.getInit(N), Finder, Builder);
4770 internal::Matcher<Decl>, InnerMatcher) {
4771 const unsigned NumDecls = std::distance(
Node.decl_begin(),
Node.decl_end());
4775 std::advance(Iterator, N);
4776 return InnerMatcher.matches(**Iterator, Finder, Builder);
4793 return Node.getExceptionDecl() ==
nullptr;
4810 internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
4811 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.init_begin(),
4812 Node.init_end(), Finder, Builder);
4813 if (MatchIt ==
Node.init_end())
4815 return (*MatchIt)->isWritten() || !Finder->isTraversalIgnoringImplicitNodes();
4832 internal::Matcher<FieldDecl>, InnerMatcher) {
4834 return (NodeAsDecl !=
nullptr &&
4835 InnerMatcher.matches(*NodeAsDecl, Finder, Builder));
4852 internal::Matcher<Expr>, InnerMatcher) {
4853 const Expr* NodeAsExpr =
Node.getInit();
4854 return (NodeAsExpr !=
nullptr &&
4855 InnerMatcher.matches(*NodeAsExpr, Finder, Builder));
4872 return Node.isWritten();
4892 return Node.isBaseInitializer();
4912 return Node.isMemberInitializer();
4938 internal::Matcher<Expr>, InnerMatcher) {
4939 for (
const Expr *Arg :
Node.arguments()) {
4940 if (Finder->isTraversalIgnoringImplicitNodes() &&
4941 isa<CXXDefaultArgExpr>(Arg))
4943 BoundNodesTreeBuilder
Result(*Builder);
4944 if (InnerMatcher.matches(*Arg, Finder, &
Result)) {
4945 *Builder = std::move(
Result);
4964extern const internal::VariadicAllOfMatcher<LambdaCapture>
lambdaCapture;
4981 clang::ast_matchers::internal::BoundNodesTreeBuilder
Result(*Builder);
4983 *Builder = std::move(
Result);
5007 if (!
Node.capturesVariable())
5009 auto *capturedVar =
Node.getCapturedVar();
5010 return capturedVar && InnerMatcher.matches(*capturedVar, Finder, Builder);
5031 return Node.isListInitialization();
5047 return Node.requiresZeroInitialization();
5074 unsigned, N, internal::Matcher<ParmVarDecl>,
5076 return (N <
Node.parameters().size()
5077 && InnerMatcher.matches(*
Node.parameters()[N], Finder, Builder));
5096 return Node.isExplicitObjectMemberFunction();
5120 internal::Matcher<Expr>, ArgMatcher,
5121 internal::Matcher<ParmVarDecl>, ParamMatcher) {
5122 BoundNodesTreeBuilder
Result;
5126 BoundNodesTreeBuilder Matches;
5130 .matches(
Node, Finder, &Matches)
5134 bool Matched =
false;
5135 for (; ArgIndex <
Node.getNumArgs(); ++ArgIndex) {
5136 BoundNodesTreeBuilder ArgMatches(*Builder);
5137 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()),
5138 Finder, &ArgMatches)) {
5139 BoundNodesTreeBuilder ParamMatches(ArgMatches);
5141 hasParameter(ParamIndex, ParamMatcher)))),
5143 hasParameter(ParamIndex, ParamMatcher))))))
5144 .matches(
Node, Finder, &ParamMatches)) {
5145 Result.addMatch(ParamMatches);
5151 *Builder = std::move(
Result);
5183 internal::Matcher<Expr>, ArgMatcher,
5184 internal::Matcher<QualType>, ParamMatcher) {
5185 BoundNodesTreeBuilder
Result;
5189 BoundNodesTreeBuilder Matches;
5193 .matches(
Node, Finder, &Matches)
5198 if (
const auto *
Call = dyn_cast<CallExpr>(&
Node)) {
5199 if (
const auto *
Value =
5200 dyn_cast_or_null<ValueDecl>(
Call->getCalleeDecl())) {
5210 assert(MP &&
"Must be member-pointer if its a memberfunctionpointer");
5213 "The call must have happened through a member function "
5219 unsigned ParamIndex = 0;
5220 bool Matched =
false;
5221 unsigned NumArgs =
Node.getNumArgs();
5225 for (; ArgIndex < NumArgs; ++ArgIndex, ++ParamIndex) {
5226 BoundNodesTreeBuilder ArgMatches(*Builder);
5227 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()), Finder,
5229 BoundNodesTreeBuilder ParamMatches(ArgMatches);
5235 if (ParamMatcher.matches(ParamType, Finder, &ParamMatches)) {
5236 Result.addMatch(ParamMatches);
5242 hasParameter(ParamIndex, hasType(ParamMatcher))))),
5244 hasParameter(ParamIndex, hasType(ParamMatcher)))))))
5245 .matches(
Node, Finder, &ParamMatches)) {
5246 Result.addMatch(ParamMatches);
5252 *Builder = std::move(
Result);
5274 if (
const auto *
Decl = dyn_cast_or_null<FunctionDecl>(Context))
5275 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5276 if (
const auto *
Decl = dyn_cast_or_null<BlockDecl>(Context))
5277 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5278 if (
const auto *
Decl = dyn_cast_or_null<ObjCMethodDecl>(Context))
5279 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5319 internal::Matcher<ParmVarDecl>,
5321 return matchesFirstInPointerRange(InnerMatcher,
Node.param_begin(),
5322 Node.param_end(), Finder,
5323 Builder) !=
Node.param_end();
5347 return Node.getNumParams() == N;
5375 forEachTemplateArgument,
5379 internal::Matcher<TemplateArgument>, InnerMatcher) {
5381 clang::ast_matchers::internal::getTemplateSpecializationArgs(
Node);
5382 clang::ast_matchers::internal::BoundNodesTreeBuilder
Result;
5383 bool Matched =
false;
5384 for (
const auto &Arg : TemplateArgs) {
5385 clang::ast_matchers::internal::BoundNodesTreeBuilder ArgBuilder(*Builder);
5386 if (InnerMatcher.matches(Arg, Finder, &ArgBuilder)) {
5388 Result.addMatch(ArgBuilder);
5391 *Builder = std::move(
Result);
5420 internal::Matcher<QualType>, InnerMatcher) {
5421 return InnerMatcher.matches(
Node.getReturnType(), Finder, Builder);
5441 return Node.isExternC();
5474 return Node.isDeleted();
5487 return Node.isDefaulted();
5520 return FnTy->hasDynamicExceptionSpec();
5570 return Node.isConsteval();
5592 return Node.isConstexpr();
5607 if (
const auto *CIA =
Node.getAttr<ConstInitAttr>())
5608 return CIA->isConstinit();
5636 internal::Matcher<Stmt>, InnerMatcher) {
5638 return Init !=
nullptr && InnerMatcher.matches(*
Init, Finder, Builder);
5652 internal::Matcher<Expr>, InnerMatcher) {
5655 InnerMatcher.matches(*
Condition, Finder, Builder));
5666 const Stmt *
const Then =
Node.getThen();
5667 return (Then !=
nullptr && InnerMatcher.matches(*Then, Finder, Builder));
5678 const Stmt *
const Else =
Node.getElse();
5679 return (Else !=
nullptr && InnerMatcher.matches(*Else, Finder, Builder));
5713 internal::NotEqualsBoundNodePredicate Predicate;
5716 return Builder->removeBindings(Predicate);
5728 internal::Matcher<DeclStmt>, InnerMatcher) {
5729 const DeclStmt*
const DeclarationStatement =
5730 Node.getConditionVariableDeclStmt();
5731 return DeclarationStatement !=
nullptr &&
5732 InnerMatcher.matches(*DeclarationStatement, Finder, Builder);
5745 internal::Matcher<Expr>, InnerMatcher) {
5747 return InnerMatcher.matches(*
Expression, Finder, Builder);
5762 internal::Matcher<Expr>, InnerMatcher) {
5764 return InnerMatcher.matches(*
Expression, Finder, Builder);
5796 internal::Matcher<Stmt>, InnerMatcher) {
5797 if (Finder->isTraversalIgnoringImplicitNodes() && isDefaultedHelper(&
Node))
5799 const Stmt *
const Statement = internal::GetBodyMatcher<NodeType>::get(
Node);
5800 return (Statement !=
nullptr &&
5801 InnerMatcher.matches(*Statement, Finder, Builder));
5821 internal::Matcher<Stmt>, InnerMatcher) {
5822 const Stmt *
const Statement =
Node.getBody();
5823 return (Statement !=
nullptr &&
5824 InnerMatcher.matches(*Statement, Finder, Builder));
5842 internal::Matcher<Stmt>, InnerMatcher) {
5844 return CS && matchesFirstInPointerRange(InnerMatcher, CS->
body_begin(),
5860 return Node.size() == N;
5888template <
typename ValueT>
5889internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5890 void(internal::AllNodeBaseTypes), ValueT>
5892 return internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5893 void(internal::AllNodeBaseTypes), ValueT>(
5902 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5910 unsigned,
Value, 1) {
5911 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5921 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5946 std::string, Name) {
5947 if (std::optional<StringRef> OpName = internal::getOpName(
Node))
5948 return *OpName == Name;
5958extern const internal::VariadicFunction<
5959 internal::PolymorphicMatcher<internal::HasAnyOperatorNameMatcher,
5963 std::vector<std::string>>,
5982 isAssignmentOperator,
5985 return Node.isAssignmentOp();
6003 isComparisonOperator,
6006 return Node.isComparisonOp();
6020 internal::Matcher<Expr>, InnerMatcher) {
6021 const Expr *LeftHandSide = internal::getLHS(
Node);
6022 return (LeftHandSide !=
nullptr &&
6023 InnerMatcher.matches(*LeftHandSide, Finder, Builder));
6037 internal::Matcher<Expr>, InnerMatcher) {
6038 const Expr *RightHandSide = internal::getRHS(
Node);
6039 return (RightHandSide !=
nullptr &&
6040 InnerMatcher.matches(*RightHandSide, Finder, Builder));
6049 internal::Matcher<Expr>, InnerMatcher) {
6050 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
6051 anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher)))
6052 .matches(
Node, Finder, Builder);
6070 internal::Matcher<Expr>, Matcher1, internal::Matcher<Expr>, Matcher2) {
6071 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
6072 anyOf(
allOf(hasLHS(Matcher1), hasRHS(Matcher2)),
6073 allOf(hasRHS(Matcher1), hasLHS(Matcher2))))
6074 .matches(
Node, Finder, Builder);
6087 internal::Matcher<Expr>, InnerMatcher) {
6088 const Expr *
const Operand = internal::getSubExpr(
Node);
6089 return (Operand !=
nullptr &&
6090 InnerMatcher.matches(*Operand, Finder, Builder));
6111 internal::Matcher<Expr>, InnerMatcher) {
6112 const Expr *
const SubExpression =
6113 internal::GetSourceExpressionMatcher<NodeType>::get(
Node);
6114 return (SubExpression !=
nullptr &&
6115 InnerMatcher.matches(*SubExpression, Finder, Builder));
6137 internal::Matcher<QualType>, InnerMatcher) {
6139 return InnerMatcher.matches(NodeType, Finder, Builder);
6145 internal::Matcher<QualType>, InnerMatcher) {
6146 return InnerMatcher.matches(
Node.getType(), Finder, Builder);
6159 return Node.isStruct();
6172 return Node.isUnion();
6185 return Node.isClass();
6198 return Node.isEnum();
6213 internal::Matcher<Expr>, InnerMatcher) {
6216 InnerMatcher.matches(*
Expression, Finder, Builder));
6228 internal::Matcher<Expr>, InnerMatcher) {
6231 InnerMatcher.matches(*
Expression, Finder, Builder));
6258 return Node.isThisDeclarationADefinition();
6272 return Node.isVariadic();
6293 internal::Matcher<CXXRecordDecl>, InnerMatcher) {
6295 ASTChildrenNotSpelledInSourceScope RAII(Finder,
false);
6298 return (
Parent !=
nullptr &&
6299 InnerMatcher.matches(*
Parent, Finder, Builder));
6327 internal::Matcher<CXXMethodDecl>, InnerMatcher) {
6328 BoundNodesTreeBuilder
Result;
6329 bool Matched =
false;
6330 for (
const auto *Overridden :
Node.overridden_methods()) {
6331 BoundNodesTreeBuilder OverriddenBuilder(*Builder);
6332 const bool OverriddenMatched =
6333 InnerMatcher.matches(*Overridden, Finder, &OverriddenBuilder);
6334 if (OverriddenMatched) {
6336 Result.addMatch(OverriddenBuilder);
6339 *Builder = std::move(
Result);
6365 return Node.isVirtual();
6383 return Node.isVirtualAsWritten();
6387 return Node.isInheritingConstructor();
6408 return Node.template hasAttr<FinalAttr>();
6435 return Node.isConst();
6452 return Node.isCopyAssignmentOperator();
6469 return Node.isMoveAssignmentOperator();
6487 return Node.size_overridden_methods() > 0 ||
Node.hasAttr<OverrideAttr>();
6502 return Node.isUserProvided();
6532 return Node.isArrow();
6546 return Node->isIntegerType();
6560 return Node->isUnsignedIntegerType();
6574 return Node->isSignedIntegerType();
6588 return Node->isAnyCharacterType();
6608 return Node->isAnyPointerType();
6627 return Node.isConstQualified();
6646 return Node.isVolatileQualified();
6663 return Node.hasLocalQualifiers();
6679 internal::Matcher<ValueDecl>, InnerMatcher) {
6680 return InnerMatcher.matches(*
Node.getMemberDecl(), Finder, Builder);
6700 hasObjectExpression,
6703 internal::Matcher<Expr>, InnerMatcher) {
6704 if (
const auto *
E = dyn_cast<UnresolvedMemberExpr>(&
Node))
6705 if (
E->isImplicitAccess())
6707 if (
const auto *
E = dyn_cast<CXXDependentScopeMemberExpr>(&
Node))
6708 if (
E->isImplicitAccess())
6710 return InnerMatcher.matches(*
Node.getBase(), Finder, Builder);
6723 internal::Matcher<UsingShadowDecl>, InnerMatcher) {
6724 return matchesFirstInPointerRange(InnerMatcher,
Node.shadow_begin(),
6725 Node.shadow_end(), Finder,
6726 Builder) !=
Node.shadow_end();
6742 internal::Matcher<NamedDecl>, InnerMatcher) {
6743 return InnerMatcher.matches(*
Node.getTargetDecl(), Finder, Builder);
6777 Node.getTemplateSpecializationKind() ==
6779 Node.getTemplateSpecializationKind() ==
6842 internal::Matcher<QualType>, InnerMatcher, 0) {
6843 return internal::BindableMatcher<TypeLoc>(
6844 new internal::TypeLocTypeMatcher(InnerMatcher));
6855extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, QualifiedTypeLoc>
6870 return InnerMatcher.matches(
Node.getUnqualifiedLoc(), Finder, Builder);
6884 auto Loc =
Node.getFunctionTypeLoc();
6885 return Loc && ReturnMatcher.matches(
Loc.getReturnLoc(), Finder, Builder);
6896extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, PointerTypeLoc>
6910 return PointeeMatcher.matches(
Node.getPointeeLoc(), Finder, Builder);
6923extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, ReferenceTypeLoc>
6938 return ReferentMatcher.matches(
Node.getPointeeLoc(), Finder, Builder);
6950extern const internal::VariadicDynCastAllOfMatcher<
6968 hasAnyTemplateArgumentLoc,
6972 internal::Matcher<TemplateArgumentLoc>, InnerMatcher) {
6973 auto Args = internal::getTemplateArgsWritten(
Node);
6974 return matchesFirstInRange(InnerMatcher, Args.begin(), Args.end(), Finder,
6975 Builder) != Args.end();
6993 hasTemplateArgumentLoc,
6997 unsigned, Index, internal::Matcher<TemplateArgumentLoc>, InnerMatcher) {
6998 auto Args = internal::getTemplateArgsWritten(
Node);
6999 return Index < Args.size() &&
7000 InnerMatcher.matches(Args[Index], Finder, Builder);
7012extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, ElaboratedTypeLoc>
7031 return InnerMatcher.matches(
Node.getNamedTypeLoc(), Finder, Builder);
7043 return Node.isBooleanType();
7055 return Node.isVoidType();
7058template <
typename NodeType>
7107 return Node.isRealFloatingType();
7160 return internal::HasSizeMatcher<NodeType>::hasSize(
Node, N);
7231 internal::Matcher<Expr>, InnerMatcher) {
7232 return InnerMatcher.matches(*
Node.getSizeExpr(), Finder, Builder);
7478 pointee, getPointee,
7627 internal::Matcher<NestedNameSpecifier>, InnerMatcher) {
7629 return InnerMatcher.matches(*Qualifier, Finder, Builder);
7651 return InnerMatcher.matches(
Node.getNamedType(), Finder, Builder);
7694 hasReplacementType, getReplacementType,
7733 return InnerType.matches(
Node.getDecayedType(), Finder, Builder);
7774 if (!DC)
return false;
7791extern const internal::VariadicAllOfMatcher<NestedNameSpecifier>
7795extern const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
7801 internal::BindableMatcher<NestedNameSpecifierLoc>, loc,
7802 internal::Matcher<NestedNameSpecifier>, InnerMatcher, 1) {
7803 return internal::BindableMatcher<NestedNameSpecifierLoc>(
7804 new internal::LocMatcher<NestedNameSpecifierLoc, NestedNameSpecifier>(
7821 internal::Matcher<QualType>, InnerMatcher) {
7822 if (!
Node.getAsType())
7824 return InnerMatcher.matches(
QualType(
Node.getAsType(), 0), Finder, Builder);
7839 internal::Matcher<TypeLoc>, InnerMatcher) {
7840 return Node &&
Node.getNestedNameSpecifier()->getAsType() &&
7841 InnerMatcher.matches(
Node.getTypeLoc(), Finder, Builder);
7854 internal::Matcher<NestedNameSpecifier>, InnerMatcher,
7859 return InnerMatcher.matches(*NextNode, Finder, Builder);
7872 internal::Matcher<NestedNameSpecifierLoc>, InnerMatcher,
7877 return InnerMatcher.matches(NextNode, Finder, Builder);
7891 internal::Matcher<NamespaceDecl>, InnerMatcher) {
7892 if (!
Node.getAsNamespace())
7894 return InnerMatcher.matches(*
Node.getAsNamespace(), Finder, Builder);
7913extern const internal::VariadicAllOfMatcher<Attr>
attr;
7953 BoundNodesTreeBuilder
Result;
7958 bool Matched =
false;
7960 SC = SC->getNextSwitchCase()) {
7961 BoundNodesTreeBuilder CaseBuilder(*Builder);
7962 bool CaseMatched = InnerMatcher.matches(*SC, Finder, &CaseBuilder);
7965 Result.addMatch(CaseBuilder);
7968 *Builder = std::move(
Result);
7983 internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
7984 BoundNodesTreeBuilder
Result;
7985 bool Matched =
false;
7986 for (
const auto *I :
Node.inits()) {
7987 if (Finder->isTraversalIgnoringImplicitNodes() && !I->isWritten())
7989 BoundNodesTreeBuilder InitBuilder(*Builder);
7990 if (InnerMatcher.matches(*I, Finder, &InitBuilder)) {
7992 Result.addMatch(InitBuilder);
7995 *Builder = std::move(
Result);
8011 return Node.isCopyConstructor();
8026 return Node.isMoveConstructor();
8041 return Node.isDefaultConstructor();
8058 return Node.isDelegatingConstructor();
8086 return Node.isExplicit();
8116 ASTChildrenNotSpelledInSourceScope RAII(Finder,
false);
8118 return InnerMatcher.matches(*ES.
getExpr(), Finder, Builder);
8141 if (
const auto *FD = dyn_cast<FunctionDecl>(&
Node))
8142 return FD->isInlineSpecified();
8143 if (
const auto *NSD = dyn_cast<NamespaceDecl>(&
Node))
8144 return NSD->isInline();
8145 if (
const auto *VD = dyn_cast<VarDecl>(&
Node))
8146 return VD->isInline();
8147 llvm_unreachable(
"Not a valid polymorphic type");
8160 return Node.isAnonymousNamespace();
8207 return Node.isInAnonymousNamespace();
8224 return InnerMatcher.matches(*
Node.getLHS(), Finder, Builder);
8237 for (
const auto *
Attr :
Node.attrs()) {
8257 return InnerMatcher.matches(*
RetValue, Finder, Builder);
8267extern const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
8312 return InnerMatcher.matches(*VD, Finder, Builder);
8335 internal::Matcher<BindingDecl>, InnerMatcher) {
8336 if (
Node.bindings().size() <= N)
8338 return InnerMatcher.matches(*
Node.bindings()[N], Finder, Builder);
8360 return llvm::any_of(
Node.bindings(), [&](
const auto *Binding) {
8361 return InnerMatcher.matches(*Binding, Finder, Builder);
8384 const auto &Parents = Finder->getASTContext().getParents(
Node);
8387 while (!Stack.empty()) {
8388 const auto &CurNode = Stack.back();
8390 if (
const auto *FuncDeclNode = CurNode.get<
FunctionDecl>()) {
8391 if (InnerMatcher.matches(*FuncDeclNode, Finder, Builder)) {
8394 }
else if (
const auto *LambdaExprNode = CurNode.get<
LambdaExpr>()) {
8395 if (InnerMatcher.matches(*LambdaExprNode->getCallOperator(), Finder,
8400 llvm::append_range(Stack, Finder->getASTContext().getParents(CurNode));
8434 const auto &Parents = Finder->getASTContext().getParents(
Node);
8437 while (!Stack.empty()) {
8438 const auto &CurNode = Stack.back();
8440 if (
const auto *FuncDeclNode = CurNode.get<
FunctionDecl>()) {
8441 BoundNodesTreeBuilder B = *Builder;
8442 if (InnerMatcher.matches(*FuncDeclNode, Finder, &B)) {
8443 *Builder = std::move(B);
8446 }
else if (
const auto *LambdaExprNode = CurNode.get<
LambdaExpr>()) {
8447 BoundNodesTreeBuilder B = *Builder;
8448 if (InnerMatcher.matches(*LambdaExprNode->getCallOperator(), Finder,
8450 *Builder = std::move(B);
8453 }
else if (
const auto *ObjCMethodDeclNode = CurNode.get<
ObjCMethodDecl>()) {
8454 BoundNodesTreeBuilder B = *Builder;
8455 if (InnerMatcher.matches(*ObjCMethodDeclNode, Finder, &B)) {
8456 *Builder = std::move(B);
8459 }
else if (
const auto *BlockDeclNode = CurNode.get<
BlockDecl>()) {
8460 BoundNodesTreeBuilder B = *Builder;
8461 if (InnerMatcher.matches(*BlockDeclNode, Finder, &B)) {
8462 *Builder = std::move(B);
8466 llvm::append_range(Stack, Finder->getASTContext().getParents(CurNode));
8493 return Node.hasExternalFormalLinkage();
8518 return Node.hasDefaultArg();
8530 return Node.isArray();
8542 internal::Matcher<Expr>, InnerMatcher) {
8543 return Node.getNumPlacementArgs() > Index &&
8544 InnerMatcher.matches(*
Node.getPlacementArg(Index), Finder, Builder);
8557 return llvm::any_of(
Node.placement_arguments(), [&](
const Expr *Arg) {
8558 return InnerMatcher.matches(*Arg, Finder, Builder);
8571 return Node.isArray() && *
Node.getArraySize() &&
8572 InnerMatcher.matches(**
Node.getArraySize(), Finder, Builder);
8583 return Node.hasDefinition();
8594 return Node.isScoped();
8606 return F->hasTrailingReturn();
8642 if (
const auto *CleanupsExpr = dyn_cast<ExprWithCleanups>(&
Node))
8643 E = CleanupsExpr->getSubExpr();
8644 if (
const auto *CtorExpr = dyn_cast<CXXConstructExpr>(
E)) {
8645 if (CtorExpr->isElidable()) {
8646 if (
const auto *MaterializeTemp =
8647 dyn_cast<MaterializeTemporaryExpr>(CtorExpr->getArg(0))) {
8648 return InnerMatcher.matches(*MaterializeTemp->getSubExpr(), Finder,
8653 return InnerMatcher.matches(
Node, Finder, Builder);
8672extern const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
8689 return Node.isStandaloneDirective();
8708 internal::Matcher<Stmt>, InnerMatcher) {
8709 if (
Node.isStandaloneDirective())
8711 return InnerMatcher.matches(*
Node.getStructuredBlock(), Finder, Builder);
8726 internal::Matcher<OMPClause>, InnerMatcher) {
8728 return matchesFirstInPointerRange(InnerMatcher, Clauses.begin(),
8729 Clauses.end(), Finder,
8730 Builder) != Clauses.end();
8747extern const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause>
8764 return Node.getDefaultKind() == llvm::omp::OMP_DEFAULT_none;
8781 return Node.getDefaultKind() == llvm::omp::OMP_DEFAULT_shared;
8800 return Node.getDefaultKind() == llvm::omp::OMP_DEFAULT_private;
8819 return Node.getDefaultKind() == llvm::omp::OMP_DEFAULT_firstprivate;
8841 return llvm::omp::isAllowedClauseForDirective(
8842 Node.getDirectiveKind(), CKind,
8843 Finder->getASTContext().getLangOpts().OpenMP);
Defines the clang::ASTContext interface.
BoundNodesTreeBuilder BoundNodes
BoundNodesTreeBuilder Nodes
#define AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ReturnTypesF, ParamType, Param)
AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ParamType, Param) { ... } defines a single-parameter functio...
#define AST_POLYMORPHIC_MATCHER_P2(DefineMatcher, ReturnTypesF, ParamType1, Param1, ParamType2, Param2)
AST_POLYMORPHIC_MATCHER_P2( DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ....
#define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF)
AST_POLYMORPHIC_MATCHER(DefineMatcher) { ... } defines a single-parameter function named DefineMatche...
#define AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, Param, OverloadId)
#define AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType, Param, OverloadId)
#define AST_POLYMORPHIC_SUPPORTED_TYPES(...)
Construct a type-list to be passed to the AST_POLYMORPHIC_MATCHER* macros.
#define AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, OverloadId)
#define AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF)
AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName) defines the matcher MatcherName that can be used...
#define AST_POLYMORPHIC_MATCHER_REGEX(DefineMatcher, ReturnTypesF, Param)
AST_POLYMORPHIC_MATCHER_REGEX(DefineMatcher, ReturnTypesF, Param) { ... } defines a function named De...
#define AST_MATCHER(Type, DefineMatcher)
AST_MATCHER(Type, DefineMatcher) { ... } defines a zero parameter function named DefineMatcher() that...
#define AST_TYPELOC_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName, ReturnTypesF)
#define AST_MATCHER_P2(Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2)
AST_MATCHER_P2( Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ....
#define AST_MATCHER_REGEX(Type, DefineMatcher, Param)
AST_MATCHER_REGEX(Type, DefineMatcher, Param) { ... } defines a function named DefineMatcher() that t...
#define AST_MATCHER_FUNCTION(ReturnType, DefineMatcher)
AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) { ... } defines a zero parameter function named Defin...
#define AST_MATCHER_P(Type, DefineMatcher, ParamType, Param)
AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... } defines a single-parameter function name...
Defines the clang::attr::Kind enum.
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::FileManager interface and associated types.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
static bool RetValue(InterpState &S, CodePtr &Pt)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
static bool isExternC(const NamedDecl *ND)
This file defines OpenMP AST classes for clauses.
static QualType getUnderlyingType(const SubRegion *R)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the Objective-C statement AST node classes.
This file defines OpenMP AST classes for executable directives and clauses.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
__PTRDIFF_TYPE__ ptrdiff_t
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Attr - This represents one attribute.
attr::Kind getKind() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Represents a C++ declaration that introduces decls from somewhere else.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
A binding in a decomposition declaration.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Represents a base class of a C++ class.
A boolean literal, per ([C++ lex.bool] Boolean literals).
CXXCatchStmt - This represents a C++ catch block.
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
Represents a C++ base or member initializer.
Represents a C++ deduction guide declaration.
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Represents a folding of a pack over an operator.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
A rewritten comparison expression that was originally written using operator syntax.
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Represents a C++ functional cast expression that builds a temporary object.
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CaseStmt - Represent a case statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
Complex values, per C99 6.2.5p11.
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
body_iterator body_begin()
Represents the canonical version of C arrays with a specified constant size.
Represents the body of a coroutine.
Represents a pointer type decayed from an array or function type.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
A reference to a declared variable, function, enum, etc.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
DeclGroupRef::const_iterator const_decl_iterator
Decl - This represents one declaration (or definition), e.g.
static Decl * castFromDeclContext(const DeclContext *)
Represents a ValueDecl that came out of a declarator.
Represents the type decltype(expr) (C++11).
A decomposition declaration.
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
Represents a C99 designated initializer expression.
DoStmt - This represents a 'do/while' stmt.
A dynamically typed AST node container.
const T * get() const
Retrieve the stored node as type T.
static DynTypedNode create(const T &Node)
Creates a DynTypedNode from Node.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
ExplicitCastExpr - An explicit cast written in the source code.
Store information needed for an explicit specifier.
const Expr * getExpr() const
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
This represents one expression.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Represents a member of a struct/union/class.
Cached information about one file (either on disk or in the virtual file system).
ForStmt - This represents a 'for (init;cond;inc)' stmt.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Represents a function declaration or definition.
Represents a prototype with parameter type info, e.g.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
IfStmt - This represents an if/then/else.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Describes an C or C++ initializer list.
Describes the capture of a variable or of this, or of a C++1y init-capture.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
A pointer to member type per C++ 8.3.3 - Pointers to members.
This represents a decl that may have a name.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
This represents 'default' clause in the '#pragma omp ...' directive.
This is a basic class for representing single OpenMP executable directive.
Represents Objective-C's @autoreleasepool Statement.
Represents an ObjC class declaration.
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
Represents a pointer to an Objective C object.
Represents one property declaration in an Objective-C interface.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
Wrapper for source info for pointers.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
QualType getCanonicalType() const
Wrapper of type source information for a type with non-trivial direct qualifiers.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Smart pointer class that efficiently represents Objective-C method names.
std::string getAsString() const
Derive the full selector name (e.g.
This class handles loading and caching of source files into memory.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Stmt - This represents one statement.
StringLiteral - This represents a string literal expression, e.g.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Represents the result of substituting a type for a template type parameter.
SwitchStmt - This represents a 'switch' stmt.
Represents the declaration of a struct/union/class/enum.
Location wrapper for a TemplateArgument.
Represents a template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ Type
The template argument is a type.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Represents a declaration of a type.
Base wrapper for a particular "section" of type source info.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
The base class of the type hierarchy.
bool isFunctionPointerType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isMemberFunctionPointerType() const
const T * getAs() const
Member-template getAs<specific type>'.
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
Represents a dependent using declaration which was marked with typename.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
Represents a variable template specialization, which refers to a variable template with a given set o...
Represents a C array with a specified size that is not an integer-constant-expression.
WhileStmt - This represents a 'while' stmt.
Maps string IDs to AST nodes matched by parts of a matcher.
internal::BoundNodesMap::IDToNodeMap IDToNodeMap
Type of mapping from binding identifiers to bound nodes.
const IDToNodeMap & getMap() const
Retrieve mapping from binding identifiers to bound nodes.
friend class internal::BoundNodesTreeBuilder
const T * getNodeAs(StringRef ID) const
Returns the AST node bound to ID.
HasOverloadOpNameMatcher hasAnyOverloadedOperatorNameFunc(ArrayRef< const StringRef * > NameRefs)
Matcher< ObjCMessageExpr > hasAnySelectorFunc(ArrayRef< const StringRef * > NameRefs)
Matcher< NamedDecl > hasAnyNameFunc(ArrayRef< const StringRef * > NameRefs)
HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef< const StringRef * > NameRefs)
std::optional< SourceLocation > getExpansionLocOfMacro(StringRef MacroName, SourceLocation Loc, const ASTContext &Context)
bool matchesAnyBase(const CXXRecordDecl &Node, const Matcher< CXXBaseSpecifier > &BaseSpecMatcher, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder)
const internal::VariadicDynCastAllOfMatcher< Stmt, FixedPointLiteral > fixedPointLiteral
Matches fixed point literals.
const internal::VariadicDynCastAllOfMatcher< Stmt, CStyleCastExpr > cStyleCastExpr
Matches a C-style cast expression.
const internal::VariadicDynCastAllOfMatcher< Decl, TagDecl > tagDecl
Matches tag declarations.
internal::Matcher< QualType > TypeMatcher
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXReinterpretCastExpr > cxxReinterpretCastExpr
Matches a reinterpret_cast expression.
const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl
Matches variable declarations.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, ElaboratedTypeLoc > elaboratedTypeLoc
Matches C or C++ elaborated TypeLocs.
const internal::VariadicDynCastAllOfMatcher< Stmt, StmtExpr > stmtExpr
Matches statement expression (GNU extension).
const internal::VariadicDynCastAllOfMatcher< Stmt, ExprWithCleanups > exprWithCleanups
Matches expressions that introduce cleanups to be run at the end of the sub-expression's evaluation.
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclRefExpr > declRefExpr
Matches expressions that refer to declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefNameDecl > typedefNameDecl
Matches typedef name declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCIvarDecl > objcIvarDecl
Matches Objective-C instance variable declarations.
const AstTypeMatcher< EnumType > enumType
Matches enum types.
const AstTypeMatcher< FunctionProtoType > functionProtoType
Matches FunctionProtoType nodes.
const AstTypeMatcher< ElaboratedType > elaboratedType
Matches types specified with an elaborated type keyword or with a qualified name.
const internal::VariadicDynCastAllOfMatcher< Decl, TypeAliasDecl > typeAliasDecl
Matches type alias declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, UsingEnumDecl > usingEnumDecl
Matches using-enum declarations.
const AstTypeMatcher< ObjCObjectPointerType > objcObjectPointerType
Matches an Objective-C object pointer type, which is different from a pointer type,...
const internal::VariadicDynCastAllOfMatcher< Stmt, ConstantExpr > constantExpr
Matches a constant expression wrapper.
const internal::VariadicDynCastAllOfMatcher< Stmt, ArrayInitLoopExpr > arrayInitLoopExpr
Matches a loop initializing the elements of an array in a number of contexts:
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCIvarRefExpr > objcIvarRefExpr
Matches a reference to an ObjCIvar.
const AstTypeMatcher< BuiltinType > builtinType
Matches builtin Types.
const internal::VariadicOperatorMatcherFunc< 1, 1 > unless
Matches if the provided matcher does not match.
const internal::VariadicDynCastAllOfMatcher< Decl, ConceptDecl > conceptDecl
Matches concept declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoyieldExpr > coyieldExpr
Matches co_yield expressions.
const AstTypeMatcher< DependentSizedExtVectorType > dependentSizedExtVectorType
Matches C++ extended vector type where either the type or size is dependent.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDeleteExpr > cxxDeleteExpr
Matches delete expressions.
const internal::VariadicAllOfMatcher< TemplateName > templateName
Matches template name.
internal::Matcher< Decl > DeclarationMatcher
Types of matchers for the top-level classes in the AST class hierarchy.
internal::Matcher< NestedNameSpecifier > NestedNameSpecifierMatcher
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCProtocolDecl > objcProtocolDecl
Matches Objective-C protocol declarations.
const AstTypeMatcher< DependentTemplateSpecializationType > dependentTemplateSpecializationType
Matches a dependent template specialization type.
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitCastExpr > implicitCastExpr
Matches the implicit cast nodes of Clang's AST.
const internal::VariadicOperatorMatcherFunc< 1, 1 > optionally
Matches any node regardless of the submatcher.
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDecl > usingDecl
Matches using declarations.
const internal::ArgumentAdaptingMatcherFunc< internal::HasDescendantMatcher > hasDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCPropertyDecl > objcPropertyDecl
Matches Objective-C property declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, StringLiteral > stringLiteral
Matches string literals (also matches wide string literals).
const internal::VariadicAllOfMatcher< CXXCtorInitializer > cxxCtorInitializer
Matches constructor initializers.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtFinallyStmt > objcFinallyStmt
Matches Objective-C @finally statements.
const AstTypeMatcher< DependentSizedArrayType > dependentSizedArrayType
Matches C++ arrays whose size is a value-dependent expression.
const AstTypeMatcher< TemplateSpecializationType > templateSpecializationType
Matches template specialization types.
const internal::VariadicDynCastAllOfMatcher< Stmt, AtomicExpr > atomicExpr
Matches atomic builtins.
const AstTypeMatcher< DeducedTemplateSpecializationType > deducedTemplateSpecializationType
Matches C++17 deduced template specialization types, e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoawaitExpr > coawaitExpr
Matches co_await expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, EnumDecl > enumDecl
Matches enum declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, ConvertVectorExpr > convertVectorExpr
Matches builtin function __builtin_convertvector.
const internal::VariadicDynCastAllOfMatcher< Stmt, AddrLabelExpr > addrLabelExpr
Matches address of label statements (GNU extension).
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDependentScopeMemberExpr > cxxDependentScopeMemberExpr
Matches member expressions where the actual member referenced could not be resolved because the base ...
const internal::VariadicDynCastAllOfMatcher< Stmt, PredefinedExpr > predefinedExpr
Matches predefined identifier expressions [C99 6.4.2.2].
const internal::VariadicAllOfMatcher< NestedNameSpecifier > nestedNameSpecifier
Matches nested name specifiers.
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
const internal::VariadicDynCastAllOfMatcher< Stmt, DependentCoawaitExpr > dependentCoawaitExpr
Matches co_await expressions where the type of the promise is dependent.
const internal::VariadicDynCastAllOfMatcher< Stmt, BreakStmt > breakStmt
Matches break statements.
const internal::VariadicDynCastAllOfMatcher< Decl, BindingDecl > bindingDecl
Matches binding declarations Example matches foo and bar (matcher = bindingDecl()
const internal::VariadicDynCastAllOfMatcher< Stmt, UnresolvedLookupExpr > unresolvedLookupExpr
Matches reference to a name that can be looked up during parsing but could not be resolved to a speci...
const internal::VariadicDynCastAllOfMatcher< Stmt, OMPExecutableDirective > ompExecutableDirective
Matches any #pragma omp executable directive.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCStringLiteral > objcStringLiteral
Matches ObjectiveC String literal expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCMethodDecl > objcMethodDecl
Matches Objective-C method declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, ParmVarDecl > parmVarDecl
Matches parameter variable declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXRewrittenBinaryOperator > cxxRewrittenBinaryOperator
Matches rewritten binary operators.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, GenericSelectionExpr > genericSelectionExpr
Matches C11 _Generic expression.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDeductionGuideDecl > cxxDeductionGuideDecl
Matches user-defined and implicitly generated deduction guide.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBoolLiteralExpr > cxxBoolLiteral
Matches bool literals.
const AstTypeMatcher< DependentNameType > dependentNameType
Matches a dependent name type.
const internal::VariadicDynCastAllOfMatcher< Stmt, ReturnStmt > returnStmt
Matches return statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, AsmStmt > asmStmt
Matches asm statements.
internal::Matcher< NamedDecl > hasName(StringRef Name)
Matches NamedDecl nodes that have the specified name.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDynamicCastExpr > cxxDynamicCastExpr
Matches a dynamic_cast expression.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoreturnStmt > coreturnStmt
Matches co_return statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr
Matches call expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, LambdaExpr > lambdaExpr
Matches lambda expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundStmt > compoundStmt
Matches compound statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, FloatingLiteral > floatLiteral
Matches float literals of all sizes / encodings, e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAutoreleasePoolStmt > autoreleasePoolStmt
Matches an Objective-C autorelease pool statement.
const internal::VariadicFunction< internal::PolymorphicMatcher< internal::HasOverloadedOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), std::vector< std::string > >, StringRef, internal::hasAnyOverloadedOperatorNameFunc > hasAnyOverloadedOperatorName
Matches overloaded operator names.
const internal::VariadicDynCastAllOfMatcher< Decl, NonTypeTemplateParmDecl > nonTypeTemplateParmDecl
Matches non-type template parameter declarations.
const AstTypeMatcher< VariableArrayType > variableArrayType
Matches C arrays with a specified size that is not an integer-constant-expression.
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryExprOrTypeTraitExpr > unaryExprOrTypeTraitExpr
Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
const internal::VariadicDynCastAllOfMatcher< Stmt, NullStmt > nullStmt
Matches null statements.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, TemplateSpecializationTypeLoc > templateSpecializationTypeLoc
Matches template specialization TypeLocs.
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachDescendantMatcher > forEachDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
const internal::VariadicAllOfMatcher< CXXBaseSpecifier > cxxBaseSpecifier
Matches class bases.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDefaultArgExpr > cxxDefaultArgExpr
Matches the value of a default argument at the call site.
const internal::VariadicAllOfMatcher< TemplateArgument > templateArgument
Matches template arguments.
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachMatcher > forEach
Matches AST nodes that have child AST nodes that match the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Stmt, CaseStmt > caseStmt
Matches case statements inside switch statements.
const internal::VariadicAllOfMatcher< NestedNameSpecifierLoc > nestedNameSpecifierLoc
Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
const internal::VariadicDynCastAllOfMatcher< Decl, NamedDecl > namedDecl
Matches a declaration of anything that could have a name.
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingTypenameDecl > unresolvedUsingTypenameDecl
Matches unresolved using value declarations that involve the typename.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< DecltypeType > decltypeType
Matches types nodes representing C++11 decltype(<expr>) types.
const internal::VariadicAllOfMatcher< TypeLoc > typeLoc
Matches TypeLocs in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, ParenListExpr > parenListExpr
Matches paren list expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplatePartialSpecializationDecl > classTemplatePartialSpecializationDecl
Matches C++ class template partial specializations.
const internal::VariadicDynCastAllOfMatcher< Stmt, WhileStmt > whileStmt
Matches while statements.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCCategoryDecl > objcCategoryDecl
Matches Objective-C category declarations.
internal::TrueMatcher anything()
Matches any node.
const internal::VariadicFunction< internal::Matcher< ObjCMessageExpr >, StringRef, internal::hasAnySelectorFunc > hasAnySelector
Matches when at least one of the supplied string equals to the Selector.getAsString()
const AstTypeMatcher< AutoType > autoType
Matches types nodes representing C++11 auto types.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConversionDecl > cxxConversionDecl
Matches conversion operator declarations.
const AstTypeMatcher< ParenType > parenType
Matches ParenType nodes.
const internal::VariadicDynCastAllOfMatcher< Decl, LabelDecl > labelDecl
Matches a declaration of label.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFunctionalCastExpr > cxxFunctionalCastExpr
Matches functional cast expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstCastExpr > cxxConstCastExpr
Matches a const_cast expression.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTemporaryObjectExpr > cxxTemporaryObjectExpr
Matches functional cast expressions having N != 1 arguments.
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryOperator > unaryOperator
Matches unary operator expressions.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, ReferenceTypeLoc > referenceTypeLoc
Matches reference TypeLocs.
const internal::VariadicFunction< internal::Matcher< NamedDecl >, StringRef, internal::hasAnyNameFunc > hasAnyName
Matches NamedDecl nodes that have any of the specified names.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCMessageExpr > objcMessageExpr
Matches ObjectiveC Message invocation expressions.
const internal::MapAnyOfMatcher< BinaryOperator, CXXOperatorCallExpr, CXXRewrittenBinaryOperator > binaryOperation
Matches nodes which can be used with binary operators.
const internal::VariadicDynCastAllOfMatcher< Stmt, ArraySubscriptExpr > arraySubscriptExpr
Matches array subscript expressions.
const internal::VariadicDynCastAllOfMatcher< OMPClause, OMPDefaultClause > ompDefaultClause
Matches OpenMP default clause.
const internal::VariadicDynCastAllOfMatcher< Decl, AccessSpecDecl > accessSpecDecl
Matches C++ access specifier declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, LinkageSpecDecl > linkageSpecDecl
Matches a declaration of a linkage specification.
const AstTypeMatcher< InjectedClassNameType > injectedClassNameType
Matches injected class name types.
const internal::VariadicDynCastAllOfMatcher< Stmt, GNUNullExpr > gnuNullExpr
Matches GNU __null expression.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, PointerTypeLoc > pointerTypeLoc
Matches pointer TypeLocs.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXForRangeStmt > cxxForRangeStmt
Matches range-based for statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXMemberCallExpr > cxxMemberCallExpr
Matches member call expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConstructorDecl > cxxConstructorDecl
Matches C++ constructor declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, DependentScopeDeclRefExpr > dependentScopeDeclRefExpr
Matches expressions that refer to dependent scope declarations.
const AstTypeMatcher< BlockPointerType > blockPointerType
Matches block pointer types, i.e.
internal::BindableMatcher< Stmt > sizeOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching sizeof.
const internal::VariadicDynCastAllOfMatcher< Stmt, InitListExpr > initListExpr
Matches init list expressions.
internal::Matcher< CXXCtorInitializer > CXXCtorInitializerMatcher
const AstTypeMatcher< AtomicType > atomicType
Matches atomic types.
const internal::VariadicDynCastAllOfMatcher< Decl, TypeAliasTemplateDecl > typeAliasTemplateDecl
Matches type alias template declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNoexceptExpr > cxxNoexceptExpr
Matches noexcept expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ArrayInitIndexExpr > arrayInitIndexExpr
The arrayInitIndexExpr consists of two subexpressions: a common expression (the source array) that is...
internal::VariadicDynCastAllOfMatcher< Type, NodeType > AstTypeMatcher
const AstTypeMatcher< UsingType > usingType
Matches types specified through a using declaration.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNewExpr > cxxNewExpr
Matches new expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, EnumConstantDecl > enumConstantDecl
Matches enum constants.
const internal::VariadicDynCastAllOfMatcher< Stmt, ForStmt > forStmt
Matches for statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, GotoStmt > gotoStmt
Matches goto statements.
internal::Matcher< CXXBaseSpecifier > CXXBaseSpecifierMatcher
auto mapAnyOf(internal::VariadicDynCastAllOfMatcher< T, U > const &...)
Matches any of the NodeMatchers with InnerMatchers nested within.
const internal::VariadicDynCastAllOfMatcher< Decl, DeclaratorDecl > declaratorDecl
Matches declarator declarations (field, variable, function and non-type template parameter declaratio...
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtCatchStmt > objcCatchStmt
Matches Objective-C @catch statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryOperator > binaryOperator
Matches binary operator expressions.
const internal::VariadicDynCastAllOfMatcher< TypeLoc, QualifiedTypeLoc > qualifiedTypeLoc
Matches QualifiedTypeLocs in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Decl, TemplateTypeParmDecl > templateTypeParmDecl
Matches template type parameter declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, BlockExpr > blockExpr
Matches a reference to a block.
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionTemplateDecl > functionTemplateDecl
Matches C++ function template declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, ParenExpr > parenExpr
Matches parentheses used in expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, StaticAssertDecl > staticAssertDecl
Matches a C++ static_assert declaration.
const internal::ArgumentAdaptingMatcherFunc< internal::HasMatcher > has
Matches AST nodes that have child AST nodes that match the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Stmt, CoroutineBodyStmt > coroutineBodyStmt
Matches coroutine body statements.
const AstTypeMatcher< MacroQualifiedType > macroQualifiedType
Matches qualified types when the qualifier is applied via a macro.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCCategoryImplDecl > objcCategoryImplDecl
Matches Objective-C category definitions.
const AstTypeMatcher< TypedefType > typedefType
Matches typedef types.
const internal::VariadicDynCastAllOfMatcher< Stmt, MaterializeTemporaryExpr > materializeTemporaryExpr
Matches nodes where temporaries are materialized.
const AstTypeMatcher< TagType > tagType
Matches tag types (record and enum types).
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryConditionalOperator > binaryConditionalOperator
Matches binary conditional operator expressions (GNU extension).
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtTryStmt > objcTryStmt
Matches Objective-C @try statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, ExplicitCastExpr > explicitCastExpr
Matches explicit cast expressions.
internal::PolymorphicMatcher< internal::ValueEqualsMatcher, void(internal::AllNodeBaseTypes), ValueT > equals(const ValueT &Value)
Matches literals that are equal to the given value of type ValueT.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStaticCastExpr > cxxStaticCastExpr
Matches a C++ static_cast expression.
const internal::VariadicDynCastAllOfMatcher< Decl, ValueDecl > valueDecl
Matches any value declaration.
const internal::VariadicDynCastAllOfMatcher< Decl, TranslationUnitDecl > translationUnitDecl
Matches the top declaration context.
const AstTypeMatcher< TemplateTypeParmType > templateTypeParmType
Matches template type parameter types.
const AstTypeMatcher< ConstantArrayType > constantArrayType
Matches C arrays with a specified constant size.
internal::Matcher< Stmt > StatementMatcher
internal::Matcher< TypeLoc > TypeLocMatcher
const internal::VariadicAllOfMatcher< LambdaCapture > lambdaCapture
Matches lambda captures.
internal::Matcher< TemplateArgumentLoc > TemplateArgumentLocMatcher
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> eachOf
Matches if any of the given matchers matches.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstructExpr > cxxConstructExpr
Matches constructor call expressions (including implicit ones).
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCInterfaceDecl > objcInterfaceDecl
Matches Objective-C interface declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, TemplateTemplateParmDecl > templateTemplateParmDecl
Matches template template parameter declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, FieldDecl > fieldDecl
Matches field declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, UserDefinedLiteral > userDefinedLiteral
Matches user defined literal operator call.
const internal::VariadicDynCastAllOfMatcher< Stmt, ChooseExpr > chooseExpr
Matches GNU __builtin_choose_expr.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXOperatorCallExpr > cxxOperatorCallExpr
Matches overloaded operator calls.
internal::PolymorphicMatcher< internal::HasOverloadedOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), std::vector< std::string > > hasOverloadedOperatorName(StringRef Name)
Matches overloaded operator names.
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceAliasDecl > namespaceAliasDecl
Matches a declaration of a namespace alias.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBindTemporaryExpr > cxxBindTemporaryExpr
Matches nodes where temporaries are created.
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchCase > switchCase
Matches case and default statements inside switch statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, DefaultStmt > defaultStmt
Matches default statements inside switch statements.
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> allOf
Matches if all given matchers match.
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateSpecializationDecl > classTemplateSpecializationDecl
Matches C++ class template specializations.
const internal::VariadicDynCastAllOfMatcher< Decl, DecompositionDecl > decompositionDecl
Matches decomposition-declarations.
const AstTypeMatcher< SubstTemplateTypeParmType > substTemplateTypeParmType
Matches types that represent the result of substituting a type for a template type parameter.
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionDecl > functionDecl
Matches function declarations.
const AstTypeMatcher< UnaryTransformType > unaryTransformType
Matches types nodes representing unary type transformations.
const internal::VariadicDynCastAllOfMatcher< Stmt, UnresolvedMemberExpr > unresolvedMemberExpr
Matches unresolved member expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCAtThrowStmt > objcThrowStmt
Matches Objective-C @throw statements.
const internal::MapAnyOfMatcher< CallExpr, CXXConstructExpr > invocation
Matches function calls and constructor calls.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThrowExpr > cxxThrowExpr
Matches throw expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchStmt > switchStmt
Matches switch statements.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, MemberExpr > memberExpr
Matches member expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXRecordDecl > cxxRecordDecl
Matches C++ class declarations.
const internal::VariadicAllOfMatcher< TemplateArgumentLoc > templateArgumentLoc
Matches template arguments (with location info).
internal::Matcher< T > traverse(TraversalKind TK, const internal::Matcher< T > &InnerMatcher)
Causes all nested matchers to be matched with the specified traversal kind.
const AstTypeMatcher< ReferenceType > referenceType
Matches both lvalue and rvalue reference types.
const internal::VariadicDynCastAllOfMatcher< Stmt, DesignatedInitExpr > designatedInitExpr
Matches C99 designated initializer expressions [C99 6.7.8].
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDestructorDecl > cxxDestructorDecl
Matches explicit C++ destructor declarations.
internal::BindableMatcher< Stmt > alignOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching alignof.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXUnresolvedConstructExpr > cxxUnresolvedConstructExpr
Matches unresolved constructor call expressions.
const internal::VariadicDynCastAllOfMatcher< Decl, ObjCImplementationDecl > objcImplementationDecl
Matches Objective-C implementation declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, IntegerLiteral > integerLiteral
Matches integer literals of all sizes / encodings, e.g.
const internal::VariadicDynCastAllOfMatcher< Decl, ExportDecl > exportDecl
Matches any export declaration.
internal::Matcher< T > findAll(const internal::Matcher< T > &Matcher)
Matches if the node or any descendant matches.
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitValueInitExpr > implicitValueInitExpr
Matches implicit initializers of init list expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, DoStmt > doStmt
Matches do statements.
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceDecl > namespaceDecl
Matches a declaration of a namespace.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNullPtrLiteralExpr > cxxNullPtrLiteralExpr
Matches nullptr literal.
internal::PolymorphicMatcher< internal::HasDeclarationMatcher, void(internal::HasDeclarationSupportedTypes), internal::Matcher< Decl > > hasDeclaration(const internal::Matcher< Decl > &InnerMatcher)
Matches a node if the declaration associated with that node matches the given matcher.
const AstTypeMatcher< DecayedType > decayedType
Matches decayed type Example matches i[] in declaration of f.
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclStmt > declStmt
Matches declaration statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundLiteralExpr > compoundLiteralExpr
Matches compound (i.e.
const AstTypeMatcher< MemberPointerType > memberPointerType
Matches member pointer types.
const internal::VariadicDynCastAllOfMatcher< Stmt, LabelStmt > labelStmt
Matches label statements.
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
const internal::VariadicDynCastAllOfMatcher< Decl, FriendDecl > friendDecl
Matches friend declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
internal::Matcher< TemplateArgument > TemplateArgumentMatcher
const AstTypeMatcher< IncompleteArrayType > incompleteArrayType
Matches C arrays with unspecified size.
const internal::VariadicDynCastAllOfMatcher< Stmt, CharacterLiteral > characterLiteral
Matches character literals (also matches wchar_t).
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFoldExpr > cxxFoldExpr
Matches C++17 fold expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ConditionalOperator > conditionalOperator
Matches conditional operator expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStdInitializerListExpr > cxxStdInitializerListExpr
Matches C++ initializer list expressions.
const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> anyOf
Matches if any of the given matchers matches.
internal::Matcher< Attr > AttrMatcher
const internal::VariadicFunction< internal::PolymorphicMatcher< internal::HasAnyOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr, CXXRewrittenBinaryOperator, UnaryOperator), std::vector< std::string > >, StringRef, internal::hasAnyOperatorNameFunc > hasAnyOperatorName
Matches operator expressions (binary or unary) that have any of the specified names.
const internal::VariadicDynCastAllOfMatcher< Stmt, OpaqueValueExpr > opaqueValueExpr
Matches opaque value expressions.
const AstTypeMatcher< ComplexType > complexType
Matches C99 complex types.
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > cudaKernelCallExpr
Matches CUDA kernel call expression.
const internal::VariadicDynCastAllOfMatcher< Decl, IndirectFieldDecl > indirectFieldDecl
Matches indirect field declarations.
const AstTypeMatcher< FunctionType > functionType
Matches FunctionType nodes.
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXMethodDecl > cxxMethodDecl
Matches method declarations.
internal::Matcher< LambdaCapture > LambdaCaptureMatcher
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXCatchStmt > cxxCatchStmt
Matches catch statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
internal::Matcher< NestedNameSpecifierLoc > NestedNameSpecifierLocMatcher
const internal::VariadicAllOfMatcher< QualType > qualType
Matches QualTypes in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTryStmt > cxxTryStmt
Matches try statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, SubstNonTypeTemplateParmExpr > substNonTypeTemplateParmExpr
Matches substitutions of non-type template parameters.
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDirectiveDecl > usingDirectiveDecl
Matches using namespace declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingValueDecl > unresolvedUsingValueDecl
Matches unresolved using value declarations.
const internal::ArgumentAdaptingMatcherFunc< internal::HasAncestorMatcher, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr >, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr > > hasAncestor
Matches AST nodes that have an ancestor that matches the provided matcher.
const internal::ArgumentAdaptingMatcherFunc< internal::HasParentMatcher, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr >, internal::TypeList< Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr > > hasParent
Matches AST nodes that have a parent that matches the provided matcher.
const internal::VariadicDynCastAllOfMatcher< Stmt, IfStmt > ifStmt
Matches if statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThisExpr > cxxThisExpr
Matches implicit and explicit this expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, ImaginaryLiteral > imaginaryLiteral
Matches imaginary literals, which are based on integer and floating point literals e....
const AstTypeMatcher< RValueReferenceType > rValueReferenceType
Matches rvalue reference types.
const internal::VariadicDynCastAllOfMatcher< Stmt, ContinueStmt > continueStmt
Matches continue statements.
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateDecl > classTemplateDecl
Matches C++ class template declarations.
const AstTypeMatcher< LValueReferenceType > lValueReferenceType
Matches lvalue reference types.
The JSON file list parser is used to communicate input to InstallAPI.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
bool isInstanceMethod(const Decl *D)
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
TraversalKind
Defines how we descend a level in the AST when we pass through expressions.
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
@ SD_Automatic
Automatic storage duration (most local variables).
@ Result
The result type of a method or function.
CastKind
CastKind - The kind of operation required for a conversion.
const FunctionProtoType * T
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ Other
Other implicit parameter.