44 #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H
45 #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H
82 #include "llvm/ADT/ArrayRef.h"
83 #include "llvm/ADT/SmallVector.h"
84 #include "llvm/ADT/StringRef.h"
85 #include "llvm/Support/Casting.h"
86 #include "llvm/Support/Compiler.h"
87 #include "llvm/Support/ErrorHandling.h"
88 #include "llvm/Support/Regex.h"
99 namespace ast_matchers {
114 template <
typename T>
116 return MyBoundNodes.getNodeAs<T>(
ID);
126 return MyBoundNodes.getMap();
133 BoundNodes(internal::BoundNodesMap &MyBoundNodes)
134 : MyBoundNodes(MyBoundNodes) {}
136 internal::BoundNodesMap MyBoundNodes;
170 inline internal::TrueMatcher
anything() {
return internal::TrueMatcher(); }
183 extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
195 extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl>
207 extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
219 extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl>
229 extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
248 auto &
SourceManager = Finder->getASTContext().getSourceManager();
269 auto &
SourceManager = Finder->getASTContext().getSourceManager();
271 if (ExpansionLoc.isInvalid()) {
296 auto &
SourceManager = Finder->getASTContext().getSourceManager();
298 if (ExpansionLoc.isInvalid()) {
320 auto& Context = Finder->getASTContext();
321 std::optional<SourceLocation> B =
323 if (!B)
return false;
324 std::optional<SourceLocation> E =
326 if (!E)
return false;
339 extern const internal::VariadicAllOfMatcher<Decl>
decl;
351 extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl>
361 extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl>
372 extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
386 extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl>
namedDecl;
397 extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl>
labelDecl;
408 extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl>
420 extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
432 extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl>
recordDecl;
441 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl>
450 extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
463 extern const internal::VariadicDynCastAllOfMatcher<
482 extern const internal::VariadicDynCastAllOfMatcher<
495 extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
506 extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl>
520 extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
530 extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier>
cxxBaseSpecifier;
541 extern const internal::VariadicAllOfMatcher<CXXCtorInitializer>
553 extern const internal::VariadicAllOfMatcher<TemplateArgument>
templateArgument;
564 extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc>
576 extern const internal::VariadicAllOfMatcher<TemplateName>
templateName;
586 extern const internal::VariadicDynCastAllOfMatcher<
Decl,
598 extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
609 extern const internal::VariadicDynCastAllOfMatcher<
Decl,
693 return Node.isBitField();
710 return Node.isBitField() &&
711 Node.getBitWidthValue(Finder->getASTContext()) == Width;
732 InnerMatcher.matches(*
Initializer, Finder, Builder));
738 return Node.isMain();
752 internal::Matcher<ClassTemplateDecl>, InnerMatcher) {
754 return (
Decl !=
nullptr &&
755 InnerMatcher.matches(*
Decl, Finder, Builder));
763 return Node.isImplicit();
788 hasAnyTemplateArgument,
792 internal::Matcher<TemplateArgument>, InnerMatcher) {
794 internal::getTemplateSpecializationArgs(
Node);
795 return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder,
796 Builder) != List.end();
815 template <
typename T>
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>();
824 template <
typename T>
825 internal::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>());
834 template <
typename... T>
835 internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>
837 const internal::VariadicOperatorMatcher<T...> &InnerMatcher) {
838 return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>(
842 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
843 typename T,
typename ToTypes>
844 internal::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);
853 template <
template <
typename T,
typename...
P>
class MatcherT, typename...
P,
854 typename ReturnTypesF>
855 internal::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,
865 template <
typename... T>
866 internal::Matcher<
typename internal::GetClade<T...>
::Type>
868 return traverse(TK, InnerMatcher.with());
894 return InnerMatcher.matches(*
Node.IgnoreImplicit(), Finder, Builder);
923 internal::Matcher<Expr>, InnerMatcher) {
924 return InnerMatcher.matches(*
Node.IgnoreImpCasts(), Finder, Builder);
945 return InnerMatcher.matches(*
Node.IgnoreParenCasts(), Finder, Builder);
970 internal::Matcher<Expr>, InnerMatcher) {
971 return InnerMatcher.matches(*
Node.IgnoreParenImpCasts(), Finder, Builder);
987 return InnerMatcher.matches(
Node.IgnoreParens(), Finder, Builder);
1003 const Expr *E =
Node.IgnoreParens();
1004 return InnerMatcher.matches(*E, Finder, Builder);
1021 return Node.isInstantiationDependent();
1068 hasTemplateArgument,
1072 unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher) {
1074 internal::getTemplateSpecializationArgs(
Node);
1075 if (List.size() <= N)
1077 return InnerMatcher.matches(List[N], Finder, Builder);
1090 templateArgumentCountIs,
1094 return internal::getTemplateSpecializationArgs(
Node).size() == N;
1109 internal::Matcher<QualType>, InnerMatcher) {
1112 return InnerMatcher.matches(
Node.getAsType(), Finder, Builder);
1127 internal::Matcher<TemplateName>, InnerMatcher) {
1130 return InnerMatcher.matches(
Node.getAsTemplate(), Finder, Builder);
1147 internal::Matcher<Decl>, InnerMatcher) {
1149 return InnerMatcher.matches(*
Node.getAsDecl(), Finder, Builder);
1167 return InnerMatcher.matches(*
Node.getAsExpr(), Finder, Builder);
1197 internal::Matcher<QualType>, InnerMatcher) {
1200 return InnerMatcher.matches(
Node.getIntegralType(), Finder, Builder);
1234 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1244 extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl>
valueDecl;
1257 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
1269 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
1280 extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl>
enumDecl;
1290 extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
1305 extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl>
tagDecl;
1313 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl>
1322 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
1333 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
1345 extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl>
varDecl;
1355 extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl>
fieldDecl;
1365 extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
1374 extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl>
1383 extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
1394 extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl>
friendDecl;
1404 extern const internal::VariadicAllOfMatcher<Stmt>
stmt;
1414 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt>
declStmt;
1427 extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr>
memberExpr;
1441 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
1453 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1465 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr>
callExpr;
1495 extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr>
lambdaExpr;
1504 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
1516 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
1525 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
1535 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
1545 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
1555 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
1565 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
1575 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
1590 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
1603 extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
1615 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl>
1626 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
1635 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
1645 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
1655 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
1665 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
1675 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
1688 extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
1694 internal::Matcher<Expr>, InnerMatcher) {
1695 const Expr *SyntForm =
Node.getSyntacticForm();
1696 return (SyntForm !=
nullptr &&
1697 InnerMatcher.matches(*SyntForm, Finder, Builder));
1711 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1723 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
1741 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
1754 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1767 extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl>
usingDecl;
1778 extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl>
1790 extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
1807 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
1821 extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1840 extern const internal::VariadicDynCastAllOfMatcher<
Decl,
1853 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
1863 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr>
parenExpr;
1875 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
1886 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1900 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
1911 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
1932 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
1944 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr>
cxxNewExpr;
1954 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
1970 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
1981 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
1993 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
2012 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
2032 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2042 extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr>
expr;
2051 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
2065 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
2074 extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr>
blockExpr;
2082 extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt>
ifStmt;
2091 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt>
forStmt;
2103 const Stmt *
const Increment =
Node.getInc();
2104 return (Increment !=
nullptr &&
2105 InnerMatcher.matches(*Increment, Finder, Builder));
2118 const Stmt *
const Init =
Node.getInit();
2119 return (Init !=
nullptr && InnerMatcher.matches(*Init, Finder, Builder));
2129 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
2142 const VarDecl *
const Var =
Node.getLoopVariable();
2143 return (Var !=
nullptr && InnerMatcher.matches(*Var, Finder, Builder));
2156 const Expr *
const Init =
Node.getRangeInit();
2157 return (Init !=
nullptr && InnerMatcher.matches(*Init, Finder, Builder));
2168 extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt>
whileStmt;
2178 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt>
doStmt;
2188 extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt>
breakStmt;
2198 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
2209 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt>
2220 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt>
returnStmt;
2231 extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt>
gotoStmt;
2242 extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt>
labelStmt;
2254 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
2265 extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt>
switchStmt;
2275 extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase>
switchCase;
2285 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt>
caseStmt;
2295 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
2304 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
2314 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
2324 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt>
cxxTryStmt;
2333 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
2343 extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt>
nullStmt;
2353 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt>
asmStmt;
2361 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
2371 extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
2384 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
2391 extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
2401 extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
2406 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
2410 extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
2416 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
2426 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
2437 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
2440 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
2450 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
2454 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
2458 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
2462 extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
2466 extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
2474 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr>
atomicExpr;
2482 extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr>
stmtExpr;
2491 extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
2500 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
2509 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
2518 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2530 extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
2546 extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
2559 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
2575 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
2590 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
2601 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
2610 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
2634 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
2641 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
2657 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr>
castExpr;
2667 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
2676 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
2685 extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
2694 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
2709 return Node.size() == N;
2713 extern const internal::VariadicAllOfMatcher<QualType>
qualType;
2716 extern const internal::VariadicAllOfMatcher<Type>
type;
2719 extern const internal::VariadicAllOfMatcher<TypeLoc>
typeLoc;
2740 extern const internal::VariadicOperatorMatcherFunc<
2747 extern const internal::VariadicOperatorMatcherFunc<
2754 extern const internal::VariadicOperatorMatcherFunc<
2782 extern const internal::VariadicOperatorMatcherFunc<1, 1>
optionally;
2793 extern const internal::VariadicDynCastAllOfMatcher<
Stmt,
2822 template <
typename T,
typename...
U>
2823 auto mapAnyOf(internal::VariadicDynCastAllOfMatcher<T, U>
const &...) {
2824 return internal::MapAnyOfHelper<
U...>();
2937 extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr>
invocation;
2948 internal::Matcher<QualType>, InnerMatcher) {
2949 const QualType ArgumentType =
Node.getTypeOfArgument();
2950 return InnerMatcher.matches(ArgumentType, Finder, Builder);
2972 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
2974 allOf(
anyOf(ofKind(UETT_AlignOf), ofKind(UETT_PreferredAlignOf)),
2981 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
2983 allOf(ofKind(UETT_SizeOf), InnerMatcher)));
3001 inline internal::Matcher<NamedDecl>
hasName(StringRef Name) {
3002 return internal::Matcher<NamedDecl>(
3003 new internal::HasNameMatcher({
std::string(Name)}));
3016 extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
3038 return RegExp->match(FullNameString);
3060 inline internal::PolymorphicMatcher<
3061 internal::HasOverloadedOperatorNameMatcher,
3063 std::vector<std::string>>
3065 return internal::PolymorphicMatcher<
3066 internal::HasOverloadedOperatorNameMatcher,
3079 extern const internal::VariadicFunction<
3080 internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher,
3083 std::vector<std::string>>,
3108 return Node.getMember().getAsString() == N;
3147 auto MemberName =
Node.getMember().getAsString();
3149 return Builder->removeBindings(
3150 [
this, MemberName](
const BoundNodesMap &
Nodes) {
3151 const auto &BN =
Nodes.getNode(this->BindingID);
3152 if (
const auto *ND = BN.get<
NamedDecl>()) {
3153 if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(ND))
3155 return ND->getName() != MemberName;
3194 internal::Matcher<NamedDecl>,
Base) {
3196 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3197 return Finder->classIsDerivedFrom(RD,
Base, Builder,
false);
3200 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3201 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3210 if (BaseName.empty())
3213 const auto M = isDerivedFrom(
hasName(BaseName));
3215 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3216 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3218 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3219 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3256 return Node.hasDefinition() &&
3258 return BaseSpecMatcher.matches(Base, Finder, Builder);
3265 isSameOrDerivedFrom,
3267 internal::Matcher<NamedDecl>,
Base, 0) {
3270 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3271 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3273 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3274 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3280 isSameOrDerivedFrom,
3283 if (BaseName.empty())
3286 const auto M = isSameOrDerivedFrom(
hasName(BaseName));
3288 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3289 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3291 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3292 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3317 isDirectlyDerivedFrom,
3319 internal::Matcher<NamedDecl>,
Base, 0) {
3321 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3322 return Finder->classIsDerivedFrom(RD,
Base, Builder,
true);
3325 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3326 return Finder->objcClassIsDerivedFrom(InterfaceDecl,
Base, Builder,
3332 isDirectlyDerivedFrom,
3335 if (BaseName.empty())
3337 const auto M = isDirectlyDerivedFrom(
hasName(BaseName));
3339 if (
const auto *RD = dyn_cast<CXXRecordDecl>(&
Node))
3340 return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder);
3342 const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&
Node);
3343 return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder);
3358 BoundNodesTreeBuilder Result(*Builder);
3359 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.method_begin(),
3360 Node.method_end(), Finder, &Result);
3361 if (MatchIt ==
Node.method_end())
3364 if (Finder->isTraversalIgnoringImplicitNodes() && (*MatchIt)->isImplicit())
3366 *Builder = std::move(Result);
3380 return Node.isLambda();
3401 extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher>
has;
3417 extern const internal::ArgumentAdaptingMatcherFunc<
3418 internal::HasDescendantMatcher>
3439 extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
3469 extern const internal::ArgumentAdaptingMatcherFunc<
3470 internal::ForEachDescendantMatcher>
3489 template <
typename T>
3490 internal::Matcher<T>
findAll(
const internal::Matcher<T> &Matcher) {
3504 extern const internal::ArgumentAdaptingMatcherFunc<
3505 internal::HasParentMatcher,
3506 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3507 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3521 extern const internal::ArgumentAdaptingMatcherFunc<
3522 internal::HasAncestorMatcher,
3523 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
3524 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
3536 extern const internal::VariadicOperatorMatcherFunc<1, 1>
unless;
3572 inline internal::PolymorphicMatcher<
3573 internal::HasDeclarationMatcher,
3574 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>
3576 return internal::PolymorphicMatcher<
3577 internal::HasDeclarationMatcher,
3578 void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>(
3597 return UnderlyingDecl !=
nullptr &&
3598 InnerMatcher.matches(*UnderlyingDecl, Finder, Builder);
3621 const Expr *ExprNode =
Node.getImplicitObjectArgument()
3622 ->IgnoreParenImpCasts();
3623 return (ExprNode !=
nullptr &&
3624 InnerMatcher.matches(*ExprNode, Finder, Builder));
3641 return InnerMatcher.matches(
TypeDecl, Finder, Builder);
3657 return Node.isClassMethod();
3673 return Node.isInstanceMethod();
3690 return Node.isClassMessage();
3707 return Node.isInstanceMessage();
3722 const Expr *ReceiverNode =
Node.getInstanceReceiver();
3723 return (ReceiverNode !=
nullptr &&
3750 extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
3765 return RegExp->match(SelectorString);
3773 return Node.getSelector().isNull();
3785 return Node.getSelector().isUnarySelector();
3801 return Node.getSelector().isKeywordSelector();
3816 return Node.getSelector().getNumArgs() == N;
3837 const Expr *ExprNode =
Node.getCallee();
3838 return (ExprNode !=
nullptr &&
3839 InnerMatcher.matches(*ExprNode, Finder, Builder));
3865 internal::Matcher<Decl>, InnerMatcher, 1) {
3866 if (
const auto *CallNode = dyn_cast<CallExpr>(&
Node))
3868 .matches(
Node, Finder, Builder);
3872 const auto *MsgNode = cast<ObjCMessageExpr>(&
Node);
3873 const Decl *DeclNode = MsgNode->getMethodDecl();
3874 return (DeclNode !=
nullptr &&
3875 InnerMatcher.matches(*DeclNode, Finder, Builder));
3899 internal::Matcher<QualType>, InnerMatcher, 0) {
3902 return InnerMatcher.matches(QT, Finder, Builder);
3940 internal::Matcher<Decl>, InnerMatcher, 1) {
3985 internal::Matcher<TypeLoc>, Inner) {
3987 if (source ==
nullptr) {
3991 return Inner.matches(source->
getTypeLoc(), Finder, Builder);
4004 return Name ==
Node.getAsString();
4018 QualType, pointsTo, internal::Matcher<QualType>,
4020 return (!
Node.isNull() &&
Node->isAnyPointerType() &&
4021 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4028 .matches(
Node, Finder, Builder);
4043 return InnerMatcher.matches(*
Node.getUnqualifiedDesugaredType(), Finder,
4062 return (!
Node.isNull() &&
Node->isReferenceType() &&
4063 InnerMatcher.matches(
Node->getPointeeType(), Finder, Builder));
4082 return InnerMatcher.matches(
Node.getCanonicalType(), Finder, Builder);
4089 .matches(
Node, Finder, Builder);
4110 internal::Matcher<Expr>, InnerMatcher) {
4111 const Expr *ExprNode =
Node.getImplicitObjectArgument();
4112 return (ExprNode !=
nullptr &&
4113 InnerMatcher.matches(*ExprNode, Finder, Builder));
4133 internal::Matcher<QualType>, InnerMatcher, 0) {
4134 return onImplicitObjectArgument(
4135 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4136 .matches(
Node, Finder, Builder);
4141 internal::Matcher<Decl>, InnerMatcher, 1) {
4142 return onImplicitObjectArgument(
4143 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
4144 .matches(
Node, Finder, Builder);
4158 const Decl *DeclNode =
Node.getDecl();
4159 return (DeclNode !=
nullptr &&
4160 InnerMatcher.matches(*DeclNode, Finder, Builder));
4187 internal::Matcher<UsingShadowDecl>, Inner) {
4190 return Inner.matches(*
UsingDecl, Finder, Builder);
4211 return matchesFirstInPointerRange(InnerMatcher,
Node.decls_begin(),
4212 Node.decls_end(), Finder,
4213 Builder) !=
Node.decls_end();
4226 if (
Node.isSingleDecl()) {
4227 const Decl *FoundDecl =
Node.getSingleDecl();
4228 return InnerMatcher.matches(*FoundDecl, Finder, Builder);
4242 VarDecl, hasInitializer, internal::Matcher<Expr>,
4246 InnerMatcher.matches(*
Initializer, Finder, Builder));
4272 internal::Matcher<LambdaCapture>, InnerMatcher) {
4273 BoundNodesTreeBuilder Result;
4274 bool Matched =
false;
4276 if (Finder->isTraversalIgnoringImplicitNodes() &&
Capture.isImplicit())
4278 BoundNodesTreeBuilder CaptureBuilder(*Builder);
4279 if (InnerMatcher.matches(
Capture, Finder, &CaptureBuilder)) {
4281 Result.addMatch(CaptureBuilder);
4284 *Builder = std::move(Result);
4299 return Node.isStaticLocal();
4314 return Node.hasLocalStorage();
4328 return Node.hasGlobalStorage();
4395 return Node.isExceptionVariable();
4411 unsigned NumArgs =
Node.getNumArgs();
4412 if (!Finder->isTraversalIgnoringImplicitNodes())
4413 return NumArgs == N;
4415 if (!isa<CXXDefaultArgExpr>(
Node.getArg(NumArgs - 1)))
4419 return NumArgs == N;
4434 unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
4435 if (N >=
Node.getNumArgs())
4438 if (Finder->isTraversalIgnoringImplicitNodes() && isa<CXXDefaultArgExpr>(Arg))
4451 ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
4452 return N <
Node.getNumInits() &&
4453 InnerMatcher.matches(*
Node.getInit(N), Finder, Builder);
4491 internal::Matcher<Decl>, InnerMatcher) {
4497 return InnerMatcher.matches(**Iterator, Finder, Builder);
4514 return Node.getExceptionDecl() ==
nullptr;
4531 internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
4532 auto MatchIt = matchesFirstInPointerRange(InnerMatcher,
Node.init_begin(),
4533 Node.init_end(), Finder, Builder);
4534 if (MatchIt ==
Node.init_end())
4536 return (*MatchIt)->isWritten() || !Finder->isTraversalIgnoringImplicitNodes();
4553 internal::Matcher<FieldDecl>, InnerMatcher) {
4555 return (NodeAsDecl !=
nullptr &&
4556 InnerMatcher.matches(*NodeAsDecl, Finder, Builder));
4573 internal::Matcher<Expr>, InnerMatcher) {
4574 const Expr* NodeAsExpr =
Node.getInit();
4575 return (NodeAsExpr !=
nullptr &&
4576 InnerMatcher.matches(*NodeAsExpr, Finder, Builder));
4593 return Node.isWritten();
4613 return Node.isBaseInitializer();
4633 return Node.isMemberInitializer();
4659 internal::Matcher<Expr>, InnerMatcher) {
4660 for (
const Expr *Arg :
Node.arguments()) {
4661 if (Finder->isTraversalIgnoringImplicitNodes() &&
4662 isa<CXXDefaultArgExpr>(Arg))
4664 BoundNodesTreeBuilder Result(*Builder);
4665 if (InnerMatcher.matches(*Arg, Finder, &Result)) {
4666 *Builder = std::move(Result);
4685 extern const internal::VariadicAllOfMatcher<LambdaCapture>
lambdaCapture;
4702 clang::ast_matchers::internal::BoundNodesTreeBuilder Result(*Builder);
4703 if (InnerMatcher.matches(
Capture, Finder, &Result)) {
4704 *Builder = std::move(Result);
4728 auto *capturedVar =
Node.getCapturedVar();
4729 return capturedVar && InnerMatcher.matches(*capturedVar, Finder, Builder);
4750 return Node.isListInitialization();
4766 return Node.requiresZeroInitialization();
4793 unsigned, N, internal::Matcher<ParmVarDecl>,
4795 return (N <
Node.parameters().size()
4796 && InnerMatcher.matches(*
Node.parameters()[N], Finder, Builder));
4820 internal::Matcher<Expr>, ArgMatcher,
4821 internal::Matcher<ParmVarDecl>, ParamMatcher) {
4822 BoundNodesTreeBuilder Result;
4826 BoundNodesTreeBuilder Matches;
4828 .matches(
Node, Finder, &Matches)
4832 bool Matched =
false;
4833 for (; ArgIndex <
Node.getNumArgs(); ++ArgIndex) {
4834 BoundNodesTreeBuilder ArgMatches(*Builder);
4835 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()),
4836 Finder, &ArgMatches)) {
4837 BoundNodesTreeBuilder ParamMatches(ArgMatches);
4839 hasParameter(ParamIndex, ParamMatcher)))),
4841 hasParameter(ParamIndex, ParamMatcher))))))
4843 Result.addMatch(ParamMatches);
4849 *Builder = std::move(Result);
4881 internal::Matcher<Expr>, ArgMatcher,
4882 internal::Matcher<QualType>, ParamMatcher) {
4883 BoundNodesTreeBuilder Result;
4887 BoundNodesTreeBuilder Matches;
4889 .matches(
Node, Finder, &Matches)
4895 if (
const auto *Call = dyn_cast<CallExpr>(&
Node)) {
4896 if (
const auto *
Value =
4897 dyn_cast_or_null<ValueDecl>(Call->getCalleeDecl())) {
4907 assert(MP &&
"Must be member-pointer if its a memberfunctionpointer");
4910 "The call must have happened through a member function "
4916 unsigned ParamIndex = 0;
4917 bool Matched =
false;
4918 unsigned NumArgs =
Node.getNumArgs();
4922 for (; ArgIndex < NumArgs; ++ArgIndex, ++ParamIndex) {
4923 BoundNodesTreeBuilder ArgMatches(*Builder);
4924 if (ArgMatcher.matches(*(
Node.getArg(ArgIndex)->IgnoreParenCasts()), Finder,
4926 BoundNodesTreeBuilder ParamMatches(ArgMatches);
4932 if (ParamMatcher.matches(ParamType, Finder, &ParamMatches)) {
4933 Result.addMatch(ParamMatches);
4939 hasParameter(ParamIndex, hasType(ParamMatcher))))),
4941 hasParameter(ParamIndex, hasType(ParamMatcher)))))))
4943 Result.addMatch(ParamMatches);
4949 *Builder = std::move(Result);
4971 if (
const auto *
Decl = dyn_cast_or_null<FunctionDecl>(Context))
4972 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
4973 if (
const auto *
Decl = dyn_cast_or_null<BlockDecl>(Context))
4974 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
4975 if (
const auto *
Decl = dyn_cast_or_null<ObjCMethodDecl>(Context))
4976 return N <
Decl->param_size() &&
Decl->getParamDecl(N) == &
Node;
5016 internal::Matcher<ParmVarDecl>,
5018 return matchesFirstInPointerRange(InnerMatcher,
Node.param_begin(),
5019 Node.param_end(), Finder,
5020 Builder) !=
Node.param_end();
5044 return Node.getNumParams() == N;
5071 forEachTemplateArgument,
5074 clang::ast_matchers::internal::Matcher<TemplateArgument>, InnerMatcher) {
5076 clang::ast_matchers::internal::getTemplateSpecializationArgs(
Node);
5077 clang::ast_matchers::internal::BoundNodesTreeBuilder Result;
5078 bool Matched =
false;
5079 for (
const auto &Arg : TemplateArgs) {
5080 clang::ast_matchers::internal::BoundNodesTreeBuilder ArgBuilder(*Builder);
5081 if (InnerMatcher.matches(Arg, Finder, &ArgBuilder)) {
5083 Result.addMatch(ArgBuilder);
5086 *Builder = std::move(Result);
5115 internal::Matcher<QualType>, InnerMatcher) {
5116 return InnerMatcher.matches(
Node.getReturnType(), Finder, Builder);
5136 return Node.isExternC();
5169 return Node.isDeleted();
5182 return Node.isDefaulted();
5215 return FnTy->hasDynamicExceptionSpec();
5265 return Node.isConsteval();
5287 return Node.isConstexpr();
5302 if (
const auto *CIA =
Node.getAttr<ConstInitAttr>())
5303 return CIA->isConstinit();
5331 internal::Matcher<Stmt>, InnerMatcher) {
5333 return Init !=
nullptr && InnerMatcher.matches(*Init, Finder, Builder);
5347 internal::Matcher<Expr>, InnerMatcher) {
5350 InnerMatcher.matches(*
Condition, Finder, Builder));
5361 const Stmt *
const Then =
Node.getThen();
5362 return (Then !=
nullptr && InnerMatcher.matches(*Then, Finder, Builder));
5373 const Stmt *
const Else =
Node.getElse();
5374 return (Else !=
nullptr && InnerMatcher.matches(*Else, Finder, Builder));
5408 internal::NotEqualsBoundNodePredicate Predicate;
5411 return Builder->removeBindings(Predicate);
5423 internal::Matcher<DeclStmt>, InnerMatcher) {
5424 const DeclStmt*
const DeclarationStatement =
5425 Node.getConditionVariableDeclStmt();
5426 return DeclarationStatement !=
nullptr &&
5427 InnerMatcher.matches(*DeclarationStatement, Finder, Builder);
5440 internal::Matcher<Expr>, InnerMatcher) {
5442 return InnerMatcher.matches(*
Expression, Finder, Builder);
5457 internal::Matcher<Expr>, InnerMatcher) {
5459 return InnerMatcher.matches(*
Expression, Finder, Builder);
5491 internal::Matcher<Stmt>, InnerMatcher) {
5492 if (Finder->isTraversalIgnoringImplicitNodes() && isDefaultedHelper(&
Node))
5494 const Stmt *
const Statement = internal::GetBodyMatcher<NodeType>::get(
Node);
5495 return (Statement !=
nullptr &&
5496 InnerMatcher.matches(*Statement, Finder, Builder));
5516 internal::Matcher<Stmt>, InnerMatcher) {
5517 const Stmt *
const Statement =
Node.getBody();
5518 return (Statement !=
nullptr &&
5519 InnerMatcher.matches(*Statement, Finder, Builder));
5537 internal::Matcher<Stmt>, InnerMatcher) {
5539 return CS && matchesFirstInPointerRange(InnerMatcher, CS->
body_begin(),
5555 return Node.size() == N;
5583 template <
typename ValueT>
5584 internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5585 void(internal::AllNodeBaseTypes), ValueT>
5587 return internal::PolymorphicMatcher<internal::ValueEqualsMatcher,
5588 void(internal::AllNodeBaseTypes), ValueT>(
5597 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5605 unsigned,
Value, 1) {
5606 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5616 return internal::ValueEqualsMatcher<NodeType, ParamT>(
Value)
5632 if (std::optional<StringRef> OpName = internal::getOpName(
Node))
5633 return *OpName == Name;
5643 extern const internal::VariadicFunction<
5644 internal::PolymorphicMatcher<internal::HasAnyOperatorNameMatcher,
5648 std::vector<std::string>>,
5667 isAssignmentOperator,
5670 return Node.isAssignmentOp();
5691 return Node.isComparisonOp();
5704 internal::Matcher<Expr>, InnerMatcher) {
5705 const Expr *LeftHandSide = internal::getLHS(
Node);
5706 return (LeftHandSide !=
nullptr &&
5707 InnerMatcher.matches(*LeftHandSide, Finder, Builder));
5720 internal::Matcher<Expr>, InnerMatcher) {
5721 const Expr *RightHandSide = internal::getRHS(
Node);
5722 return (RightHandSide !=
nullptr &&
5723 InnerMatcher.matches(*RightHandSide, Finder, Builder));
5732 internal::Matcher<Expr>, InnerMatcher) {
5733 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
5734 anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher)))
5752 internal::Matcher<Expr>, Matcher1, internal::Matcher<Expr>, Matcher2) {
5753 return internal::VariadicDynCastAllOfMatcher<Stmt, NodeType>()(
5754 anyOf(
allOf(hasLHS(Matcher1), hasRHS(Matcher2)),
5755 allOf(hasLHS(Matcher2), hasRHS(Matcher1))))
5769 internal::Matcher<Expr>, InnerMatcher) {
5770 const Expr *
const Operand = internal::getSubExpr(
Node);
5771 return (Operand !=
nullptr &&
5772 InnerMatcher.matches(*Operand, Finder, Builder));
5793 internal::Matcher<Expr>, InnerMatcher) {
5794 const Expr *
const SubExpression =
5795 internal::GetSourceExpressionMatcher<NodeType>::get(
Node);
5796 return (SubExpression !=
nullptr &&
5797 InnerMatcher.matches(*SubExpression, Finder, Builder));
5819 internal::Matcher<QualType>, InnerMatcher) {
5821 return InnerMatcher.matches(NodeType, Finder, Builder);
5827 internal::Matcher<QualType>, InnerMatcher) {
5828 return InnerMatcher.matches(
Node.getType(), Finder, Builder);
5841 return Node.isStruct();
5854 return Node.isUnion();
5867 return Node.isClass();
5880 return Node.isEnum();
5895 internal::Matcher<Expr>, InnerMatcher) {
5898 InnerMatcher.matches(*
Expression, Finder, Builder));
5910 internal::Matcher<Expr>, InnerMatcher) {
5913 InnerMatcher.matches(*
Expression, Finder, Builder));
5940 return Node.isThisDeclarationADefinition();
5954 return Node.isVariadic();
5975 internal::Matcher<CXXRecordDecl>, InnerMatcher) {
5977 ASTChildrenNotSpelledInSourceScope RAII(Finder,
false);
5980 return (
Parent !=
nullptr &&
5981 InnerMatcher.matches(*
Parent, Finder, Builder));
6009 internal::Matcher<CXXMethodDecl>, InnerMatcher) {
6010 BoundNodesTreeBuilder Result;
6011 bool Matched =
false;
6012 for (
const auto *Overridden :
Node.overridden_methods()) {
6013 BoundNodesTreeBuilder OverriddenBuilder(*Builder);
6014 const bool OverriddenMatched =
6015 InnerMatcher.matches(*Overridden, Finder, &OverriddenBuilder);
6016 if (OverriddenMatched) {
6018 Result.addMatch(OverriddenBuilder);
6021 *Builder = std::move(Result);
6047 return Node.isVirtual();
6065 return Node.isVirtualAsWritten();
6069 return Node.isInheritingConstructor();
6090 return Node.template hasAttr<FinalAttr>();
6104 return Node.isPure();
6119 return Node.isConst();
6136 return Node.isCopyAssignmentOperator();
6153 return Node.isMoveAssignmentOperator();
6171 return Node.size_overridden_methods() > 0 ||
Node.hasAttr<OverrideAttr>();
6186 return Node.isUserProvided();
6216 return Node.isArrow();
6230 return Node->isIntegerType();
6244 return Node->isUnsignedIntegerType();
6258 return Node->isSignedIntegerType();
6272 return Node->isAnyCharacterType();
6292 return Node->isAnyPointerType();
6311 return Node.isConstQualified();
6330 return Node.isVolatileQualified();