1//===--- ASTMatchers.h - Structural query framework -------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements matchers to be used together with the MatchFinder to 11// match AST nodes. 12// 13// Matchers are created by generator functions, which can be combined in 14// a functional in-language DSL to express queries over the C++ AST. 15// 16// For example, to match a class with a certain name, one would call: 17// cxxRecordDecl(hasName("MyClass")) 18// which returns a matcher that can be used to find all AST nodes that declare 19// a class named 'MyClass'. 20// 21// For more complicated match expressions we're often interested in accessing 22// multiple parts of the matched AST nodes once a match is found. In that case, 23// use the id(...) matcher around the match expressions that match the nodes 24// you want to access. 25// 26// For example, when we're interested in child classes of a certain class, we 27// would write: 28// cxxRecordDecl(hasName("MyClass"), has(id("child", recordDecl()))) 29// When the match is found via the MatchFinder, a user provided callback will 30// be called with a BoundNodes instance that contains a mapping from the 31// strings that we provided for the id(...) calls to the nodes that were 32// matched. 33// In the given example, each time our matcher finds a match we get a callback 34// where "child" is bound to the RecordDecl node of the matching child 35// class declaration. 36// 37// See ASTMatchersInternal.h for a more in-depth explanation of the 38// implementation details of the matcher framework. 39// 40// See ASTMatchFinder.h for how to use the generated matchers to run over 41// an AST. 42// 43//===----------------------------------------------------------------------===// 44 45#ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H 46#define LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H 47 48#include "clang/AST/ASTContext.h" 49#include "clang/AST/DeclFriend.h" 50#include "clang/AST/DeclObjC.h" 51#include "clang/AST/DeclTemplate.h" 52#include "clang/ASTMatchers/ASTMatchersInternal.h" 53#include "clang/ASTMatchers/ASTMatchersMacros.h" 54#include "llvm/Support/Regex.h" 55#include <iterator> 56 57namespace clang { 58namespace ast_matchers { 59 60/// \brief Maps string IDs to AST nodes matched by parts of a matcher. 61/// 62/// The bound nodes are generated by calling \c bind("id") on the node matchers 63/// of the nodes we want to access later. 64/// 65/// The instances of BoundNodes are created by \c MatchFinder when the user's 66/// callbacks are executed every time a match is found. 67class BoundNodes { 68public: 69 /// \brief Returns the AST node bound to \c ID. 70 /// 71 /// Returns NULL if there was no node bound to \c ID or if there is a node but 72 /// it cannot be converted to the specified type. 73 template <typename T> 74 const T *getNodeAs(StringRef ID) const { 75 return MyBoundNodes.getNodeAs<T>(ID); 76 } 77 78 /// \brief Type of mapping from binding identifiers to bound nodes. This type 79 /// is an associative container with a key type of \c std::string and a value 80 /// type of \c clang::ast_type_traits::DynTypedNode 81 typedef internal::BoundNodesMap::IDToNodeMap IDToNodeMap; 82 83 /// \brief Retrieve mapping from binding identifiers to bound nodes. 84 const IDToNodeMap &getMap() const { 85 return MyBoundNodes.getMap(); 86 } 87 88private: 89 /// \brief Create BoundNodes from a pre-filled map of bindings. 90 BoundNodes(internal::BoundNodesMap &MyBoundNodes) 91 : MyBoundNodes(MyBoundNodes) {} 92 93 internal::BoundNodesMap MyBoundNodes; 94 95 friend class internal::BoundNodesTreeBuilder; 96}; 97 98/// \brief If the provided matcher matches a node, binds the node to \c ID. 99/// 100/// FIXME: Do we want to support this now that we have bind()? 101template <typename T> 102internal::Matcher<T> id(StringRef ID, 103 const internal::BindableMatcher<T> &InnerMatcher) { 104 return InnerMatcher.bind(ID); 105} 106 107/// \brief Types of matchers for the top-level classes in the AST class 108/// hierarchy. 109/// @{ 110typedef internal::Matcher<Decl> DeclarationMatcher; 111typedef internal::Matcher<Stmt> StatementMatcher; 112typedef internal::Matcher<QualType> TypeMatcher; 113typedef internal::Matcher<TypeLoc> TypeLocMatcher; 114typedef internal::Matcher<NestedNameSpecifier> NestedNameSpecifierMatcher; 115typedef internal::Matcher<NestedNameSpecifierLoc> NestedNameSpecifierLocMatcher; 116typedef internal::Matcher<CXXCtorInitializer> CXXCtorInitializerMatcher; 117/// @} 118 119/// \brief Matches any node. 120/// 121/// Useful when another matcher requires a child matcher, but there's no 122/// additional constraint. This will often be used with an explicit conversion 123/// to an \c internal::Matcher<> type such as \c TypeMatcher. 124/// 125/// Example: \c DeclarationMatcher(anything()) matches all declarations, e.g., 126/// \code 127/// "int* p" and "void f()" in 128/// int* p; 129/// void f(); 130/// \endcode 131/// 132/// Usable as: Any Matcher 133inline internal::TrueMatcher anything() { return internal::TrueMatcher(); } 134 135/// \brief Matches the top declaration context. 136/// 137/// Given 138/// \code 139/// int X; 140/// namespace NS { 141/// int Y; 142/// } // namespace NS 143/// \endcode 144/// decl(hasDeclContext(translationUnitDecl())) 145/// matches "int X", but not "int Y". 146const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl> 147 translationUnitDecl; 148 149/// \brief Matches typedef declarations. 150/// 151/// Given 152/// \code 153/// typedef int X; 154/// using Y = int; 155/// \endcode 156/// typedefDecl() 157/// matches "typedef int X", but not "using Y = int" 158const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> typedefDecl; 159 160/// \brief Matches typedef name declarations. 161/// 162/// Given 163/// \code 164/// typedef int X; 165/// using Y = int; 166/// \endcode 167/// typedefNameDecl() 168/// matches "typedef int X" and "using Y = int" 169const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl> 170 typedefNameDecl; 171 172/// \brief Matches type alias declarations. 173/// 174/// Given 175/// \code 176/// typedef int X; 177/// using Y = int; 178/// \endcode 179/// typeAliasDecl() 180/// matches "using Y = int", but not "typedef int X" 181const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> typeAliasDecl; 182 183/// \brief Matches type alias template declarations. 184/// 185/// typeAliasTemplateDecl() matches 186/// \code 187/// template <typename T> 188/// using Y = X<T>; 189/// \endcode 190const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl> 191 typeAliasTemplateDecl; 192 193/// \brief Matches AST nodes that were expanded within the main-file. 194/// 195/// Example matches X but not Y 196/// (matcher = cxxRecordDecl(isExpansionInMainFile()) 197/// \code 198/// #include <Y.h> 199/// class X {}; 200/// \endcode 201/// Y.h: 202/// \code 203/// class Y {}; 204/// \endcode 205/// 206/// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> 207AST_POLYMORPHIC_MATCHER(isExpansionInMainFile, 208 AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc)) { 209 auto &SourceManager = Finder->getASTContext().getSourceManager(); 210 return SourceManager.isInMainFile( 211 SourceManager.getExpansionLoc(Node.getLocStart())); 212} 213 214/// \brief Matches AST nodes that were expanded within system-header-files. 215/// 216/// Example matches Y but not X 217/// (matcher = cxxRecordDecl(isExpansionInSystemHeader()) 218/// \code 219/// #include <SystemHeader.h> 220/// class X {}; 221/// \endcode 222/// SystemHeader.h: 223/// \code 224/// class Y {}; 225/// \endcode 226/// 227/// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> 228AST_POLYMORPHIC_MATCHER(isExpansionInSystemHeader, 229 AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc)) { 230 auto &SourceManager = Finder->getASTContext().getSourceManager(); 231 auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getLocStart()); 232 if (ExpansionLoc.isInvalid()) { 233 return false; 234 } 235 return SourceManager.isInSystemHeader(ExpansionLoc); 236} 237 238/// \brief Matches AST nodes that were expanded within files whose name is 239/// partially matching a given regex. 240/// 241/// Example matches Y but not X 242/// (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*")) 243/// \code 244/// #include "ASTMatcher.h" 245/// class X {}; 246/// \endcode 247/// ASTMatcher.h: 248/// \code 249/// class Y {}; 250/// \endcode 251/// 252/// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> 253AST_POLYMORPHIC_MATCHER_P(isExpansionInFileMatching, 254 AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc), 255 std::string, RegExp) { 256 auto &SourceManager = Finder->getASTContext().getSourceManager(); 257 auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getLocStart()); 258 if (ExpansionLoc.isInvalid()) { 259 return false; 260 } 261 auto FileEntry = 262 SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc)); 263 if (!FileEntry) { 264 return false; 265 } 266 267 auto Filename = FileEntry->getName(); 268 llvm::Regex RE(RegExp); 269 return RE.match(Filename); 270} 271 272/// \brief Matches declarations. 273/// 274/// Examples matches \c X, \c C, and the friend declaration inside \c C; 275/// \code 276/// void X(); 277/// class C { 278/// friend X; 279/// }; 280/// \endcode 281const internal::VariadicAllOfMatcher<Decl> decl; 282 283/// \brief Matches a declaration of a linkage specification. 284/// 285/// Given 286/// \code 287/// extern "C" {} 288/// \endcode 289/// linkageSpecDecl() 290/// matches "extern "C" {}" 291const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl> 292 linkageSpecDecl; 293 294/// \brief Matches a declaration of anything that could have a name. 295/// 296/// Example matches \c X, \c S, the anonymous union type, \c i, and \c U; 297/// \code 298/// typedef int X; 299/// struct S { 300/// union { 301/// int i; 302/// } U; 303/// }; 304/// \endcode 305const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl; 306 307/// \brief Matches a declaration of label. 308/// 309/// Given 310/// \code 311/// goto FOO; 312/// FOO: bar(); 313/// \endcode 314/// labelDecl() 315/// matches 'FOO:' 316const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl; 317 318/// \brief Matches a declaration of a namespace. 319/// 320/// Given 321/// \code 322/// namespace {} 323/// namespace test {} 324/// \endcode 325/// namespaceDecl() 326/// matches "namespace {}" and "namespace test {}" 327const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> namespaceDecl; 328 329/// \brief Matches a declaration of a namespace alias. 330/// 331/// Given 332/// \code 333/// namespace test {} 334/// namespace alias = ::test; 335/// \endcode 336/// namespaceAliasDecl() 337/// matches "namespace alias" but not "namespace test" 338const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl> 339 namespaceAliasDecl; 340 341/// \brief Matches class, struct, and union declarations. 342/// 343/// Example matches \c X, \c Z, \c U, and \c S 344/// \code 345/// class X; 346/// template<class T> class Z {}; 347/// struct S {}; 348/// union U {}; 349/// \endcode 350const internal::VariadicDynCastAllOfMatcher< 351 Decl, 352 RecordDecl> recordDecl; 353 354/// \brief Matches C++ class declarations. 355/// 356/// Example matches \c X, \c Z 357/// \code 358/// class X; 359/// template<class T> class Z {}; 360/// \endcode 361const internal::VariadicDynCastAllOfMatcher< 362 Decl, 363 CXXRecordDecl> cxxRecordDecl; 364 365/// \brief Matches C++ class template declarations. 366/// 367/// Example matches \c Z 368/// \code 369/// template<class T> class Z {}; 370/// \endcode 371const internal::VariadicDynCastAllOfMatcher< 372 Decl, 373 ClassTemplateDecl> classTemplateDecl; 374 375/// \brief Matches C++ class template specializations. 376/// 377/// Given 378/// \code 379/// template<typename T> class A {}; 380/// template<> class A<double> {}; 381/// A<int> a; 382/// \endcode 383/// classTemplateSpecializationDecl() 384/// matches the specializations \c A<int> and \c A<double> 385const internal::VariadicDynCastAllOfMatcher< 386 Decl, 387 ClassTemplateSpecializationDecl> classTemplateSpecializationDecl; 388 389/// \brief Matches declarator declarations (field, variable, function 390/// and non-type template parameter declarations). 391/// 392/// Given 393/// \code 394/// class X { int y; }; 395/// \endcode 396/// declaratorDecl() 397/// matches \c int y. 398const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl> 399 declaratorDecl; 400 401/// \brief Matches parameter variable declarations. 402/// 403/// Given 404/// \code 405/// void f(int x); 406/// \endcode 407/// parmVarDecl() 408/// matches \c int x. 409const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> parmVarDecl; 410 411/// \brief Matches C++ access specifier declarations. 412/// 413/// Given 414/// \code 415/// class C { 416/// public: 417/// int a; 418/// }; 419/// \endcode 420/// accessSpecDecl() 421/// matches 'public:' 422const internal::VariadicDynCastAllOfMatcher< 423 Decl, 424 AccessSpecDecl> accessSpecDecl; 425 426/// \brief Matches constructor initializers. 427/// 428/// Examples matches \c i(42). 429/// \code 430/// class C { 431/// C() : i(42) {} 432/// int i; 433/// }; 434/// \endcode 435const internal::VariadicAllOfMatcher<CXXCtorInitializer> cxxCtorInitializer; 436 437/// \brief Matches template arguments. 438/// 439/// Given 440/// \code 441/// template <typename T> struct C {}; 442/// C<int> c; 443/// \endcode 444/// templateArgument() 445/// matches 'int' in C<int>. 446const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument; 447 448/// \brief Matches template name. 449/// 450/// Given 451/// \code 452/// template <typename T> class X { }; 453/// X<int> xi; 454/// \endcode 455/// templateName() 456/// matches 'X' in X<int>. 457const internal::VariadicAllOfMatcher<TemplateName> templateName; 458 459/// \brief Matches non-type template parameter declarations. 460/// 461/// Given 462/// \code 463/// template <typename T, int N> struct C {}; 464/// \endcode 465/// nonTypeTemplateParmDecl() 466/// matches 'N', but not 'T'. 467const internal::VariadicDynCastAllOfMatcher< 468 Decl, 469 NonTypeTemplateParmDecl> nonTypeTemplateParmDecl; 470 471/// \brief Matches template type parameter declarations. 472/// 473/// Given 474/// \code 475/// template <typename T, int N> struct C {}; 476/// \endcode 477/// templateTypeParmDecl() 478/// matches 'T', but not 'N'. 479const internal::VariadicDynCastAllOfMatcher< 480 Decl, 481 TemplateTypeParmDecl> templateTypeParmDecl; 482 483/// \brief Matches public C++ declarations. 484/// 485/// Given 486/// \code 487/// class C { 488/// public: int a; 489/// protected: int b; 490/// private: int c; 491/// }; 492/// \endcode 493/// fieldDecl(isPublic()) 494/// matches 'int a;' 495AST_MATCHER(Decl, isPublic) { 496 return Node.getAccess() == AS_public; 497} 498 499/// \brief Matches protected C++ declarations. 500/// 501/// Given 502/// \code 503/// class C { 504/// public: int a; 505/// protected: int b; 506/// private: int c; 507/// }; 508/// \endcode 509/// fieldDecl(isProtected()) 510/// matches 'int b;' 511AST_MATCHER(Decl, isProtected) { 512 return Node.getAccess() == AS_protected; 513} 514 515/// \brief Matches private C++ declarations. 516/// 517/// Given 518/// \code 519/// class C { 520/// public: int a; 521/// protected: int b; 522/// private: int c; 523/// }; 524/// \endcode 525/// fieldDecl(isPrivate()) 526/// matches 'int c;' 527AST_MATCHER(Decl, isPrivate) { 528 return Node.getAccess() == AS_private; 529} 530 531/// \brief Matches non-static data members that are bit-fields. 532/// 533/// Given 534/// \code 535/// class C { 536/// int a : 2; 537/// int b; 538/// }; 539/// \endcode 540/// fieldDecl(isBitField()) 541/// matches 'int a;' but not 'int b;'. 542AST_MATCHER(FieldDecl, isBitField) { 543 return Node.isBitField(); 544} 545 546/// \brief Matches non-static data members that are bit-fields of the specified 547/// bit width. 548/// 549/// Given 550/// \code 551/// class C { 552/// int a : 2; 553/// int b : 4; 554/// int c : 2; 555/// }; 556/// \endcode 557/// fieldDecl(hasBitWidth(2)) 558/// matches 'int a;' and 'int c;' but not 'int b;'. 559AST_MATCHER_P(FieldDecl, hasBitWidth, unsigned, Width) { 560 return Node.isBitField() && 561 Node.getBitWidthValue(Finder->getASTContext()) == Width; 562} 563 564/// \brief Matches non-static data members that have an in-class initializer. 565/// 566/// Given 567/// \code 568/// class C { 569/// int a = 2; 570/// int b = 3; 571/// int c; 572/// }; 573/// \endcode 574/// fieldDecl(hasInClassInitializer(integerLiteral(equals(2)))) 575/// matches 'int a;' but not 'int b;'. 576/// fieldDecl(hasInClassInitializer(anything())) 577/// matches 'int a;' and 'int b;' but not 'int c;'. 578AST_MATCHER_P(FieldDecl, hasInClassInitializer, internal::Matcher<Expr>, 579 InnerMatcher) { 580 const Expr *Initializer = Node.getInClassInitializer(); 581 return (Initializer != nullptr && 582 InnerMatcher.matches(*Initializer, Finder, Builder)); 583} 584 585/// \brief Matches the specialized template of a specialization declaration. 586/// 587/// Given 588/// \code 589/// tempalate<typename T> class A {}; 590/// typedef A<int> B; 591/// \endcode 592/// classTemplateSpecializationDecl(hasSpecializedTemplate(classTemplateDecl())) 593/// matches 'B' with classTemplateDecl() matching the class template 594/// declaration of 'A'. 595AST_MATCHER_P(ClassTemplateSpecializationDecl, hasSpecializedTemplate, 596 internal::Matcher<ClassTemplateDecl>, InnerMatcher) { 597 const ClassTemplateDecl* Decl = Node.getSpecializedTemplate(); 598 return (Decl != nullptr && 599 InnerMatcher.matches(*Decl, Finder, Builder)); 600} 601 602/// \brief Matches a declaration that has been implicitly added 603/// by the compiler (eg. implicit default/copy constructors). 604AST_MATCHER(Decl, isImplicit) { 605 return Node.isImplicit(); 606} 607 608/// \brief Matches classTemplateSpecializations, templateSpecializationType and 609/// functionDecl that have at least one TemplateArgument matching the given 610/// InnerMatcher. 611/// 612/// Given 613/// \code 614/// template<typename T> class A {}; 615/// template<> class A<double> {}; 616/// A<int> a; 617/// 618/// template<typename T> f() {}; 619/// void func() { f<int>(); }; 620/// \endcode 621/// 622/// \endcode 623/// classTemplateSpecializationDecl(hasAnyTemplateArgument( 624/// refersToType(asString("int")))) 625/// matches the specialization \c A<int> 626/// 627/// functionDecl(hasAnyTemplateArgument(refersToType(asString("int")))) 628/// matches the specialization \c f<int> 629AST_POLYMORPHIC_MATCHER_P( 630 hasAnyTemplateArgument, 631 AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl, 632 TemplateSpecializationType, 633 FunctionDecl), 634 internal::Matcher<TemplateArgument>, InnerMatcher) { 635 ArrayRef<TemplateArgument> List = 636 internal::getTemplateSpecializationArgs(Node); 637 return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder, 638 Builder); 639} 640 641/// \brief Matches expressions that match InnerMatcher after any implicit AST 642/// nodes are stripped off. 643/// 644/// Parentheses and explicit casts are not discarded. 645/// Given 646/// \code 647/// class C {}; 648/// C a = C(); 649/// C b; 650/// C c = b; 651/// \endcode 652/// The matchers 653/// \code 654/// varDecl(hasInitializer(ignoringImplicit(cxxConstructExpr()))) 655/// \endcode 656/// would match the declarations for a, b, and c. 657/// While 658/// \code 659/// varDecl(hasInitializer(cxxConstructExpr())) 660/// \endcode 661/// only match the declarations for b and c. 662AST_MATCHER_P(Expr, ignoringImplicit, ast_matchers::internal::Matcher<Expr>, 663 InnerMatcher) { 664 return InnerMatcher.matches(*Node.IgnoreImplicit(), Finder, Builder); 665} 666 667/// \brief Matches expressions that match InnerMatcher after any implicit casts 668/// are stripped off. 669/// 670/// Parentheses and explicit casts are not discarded. 671/// Given 672/// \code 673/// int arr[5]; 674/// int a = 0; 675/// char b = 0; 676/// const int c = a; 677/// int *d = arr; 678/// long e = (long) 0l; 679/// \endcode 680/// The matchers 681/// \code 682/// varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))) 683/// varDecl(hasInitializer(ignoringImpCasts(declRefExpr()))) 684/// \endcode 685/// would match the declarations for a, b, c, and d, but not e. 686/// While 687/// \code 688/// varDecl(hasInitializer(integerLiteral())) 689/// varDecl(hasInitializer(declRefExpr())) 690/// \endcode 691/// only match the declarations for b, c, and d. 692AST_MATCHER_P(Expr, ignoringImpCasts, 693 internal::Matcher<Expr>, InnerMatcher) { 694 return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder); 695} 696 697/// \brief Matches expressions that match InnerMatcher after parentheses and 698/// casts are stripped off. 699/// 700/// Implicit and non-C Style casts are also discarded. 701/// Given 702/// \code 703/// int a = 0; 704/// char b = (0); 705/// void* c = reinterpret_cast<char*>(0); 706/// char d = char(0); 707/// \endcode 708/// The matcher 709/// varDecl(hasInitializer(ignoringParenCasts(integerLiteral()))) 710/// would match the declarations for a, b, c, and d. 711/// while 712/// varDecl(hasInitializer(integerLiteral())) 713/// only match the declaration for a. 714AST_MATCHER_P(Expr, ignoringParenCasts, internal::Matcher<Expr>, InnerMatcher) { 715 return InnerMatcher.matches(*Node.IgnoreParenCasts(), Finder, Builder); 716} 717 718/// \brief Matches expressions that match InnerMatcher after implicit casts and 719/// parentheses are stripped off. 720/// 721/// Explicit casts are not discarded. 722/// Given 723/// \code 724/// int arr[5]; 725/// int a = 0; 726/// char b = (0); 727/// const int c = a; 728/// int *d = (arr); 729/// long e = ((long) 0l); 730/// \endcode 731/// The matchers 732/// varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral()))) 733/// varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr()))) 734/// would match the declarations for a, b, c, and d, but not e. 735/// while 736/// varDecl(hasInitializer(integerLiteral())) 737/// varDecl(hasInitializer(declRefExpr())) 738/// would only match the declaration for a. 739AST_MATCHER_P(Expr, ignoringParenImpCasts, 740 internal::Matcher<Expr>, InnerMatcher) { 741 return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder); 742} 743 744/// \brief Matches types that match InnerMatcher after any parens are stripped. 745/// 746/// Given 747/// \code 748/// void (*fp)(void); 749/// \endcode 750/// The matcher 751/// \code 752/// varDecl(hasType(pointerType(pointee(ignoringParens(functionType()))))) 753/// \endcode 754/// would match the declaration for fp. 755AST_MATCHER_P(QualType, ignoringParens, 756 internal::Matcher<QualType>, InnerMatcher) { 757 return InnerMatcher.matches(Node.IgnoreParens(), Finder, Builder); 758} 759 760/// \brief Matches classTemplateSpecializations, templateSpecializationType and 761/// functionDecl where the n'th TemplateArgument matches the given InnerMatcher. 762/// 763/// Given 764/// \code 765/// template<typename T, typename U> class A {}; 766/// A<bool, int> b; 767/// A<int, bool> c; 768/// 769/// template<typename T> f() {}; 770/// void func() { f<int>(); }; 771/// \endcode 772/// classTemplateSpecializationDecl(hasTemplateArgument( 773/// 1, refersToType(asString("int")))) 774/// matches the specialization \c A<bool, int> 775/// 776/// functionDecl(hasTemplateArgument(0, refersToType(asString("int")))) 777/// matches the specialization \c f<int> 778AST_POLYMORPHIC_MATCHER_P2( 779 hasTemplateArgument, 780 AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl, 781 TemplateSpecializationType, 782 FunctionDecl), 783 unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher) { 784 ArrayRef<TemplateArgument> List = 785 internal::getTemplateSpecializationArgs(Node); 786 if (List.size() <= N) 787 return false; 788 return InnerMatcher.matches(List[N], Finder, Builder); 789} 790 791/// \brief Matches if the number of template arguments equals \p N. 792/// 793/// Given 794/// \code 795/// template<typename T> struct C {}; 796/// C<int> c; 797/// \endcode 798/// classTemplateSpecializationDecl(templateArgumentCountIs(1)) 799/// matches C<int>. 800AST_POLYMORPHIC_MATCHER_P( 801 templateArgumentCountIs, 802 AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl, 803 TemplateSpecializationType), 804 unsigned, N) { 805 return internal::getTemplateSpecializationArgs(Node).size() == N; 806} 807 808/// \brief Matches a TemplateArgument that refers to a certain type. 809/// 810/// Given 811/// \code 812/// struct X {}; 813/// template<typename T> struct A {}; 814/// A<X> a; 815/// \endcode 816/// classTemplateSpecializationDecl(hasAnyTemplateArgument( 817/// refersToType(class(hasName("X"))))) 818/// matches the specialization \c A<X> 819AST_MATCHER_P(TemplateArgument, refersToType, 820 internal::Matcher<QualType>, InnerMatcher) { 821 if (Node.getKind() != TemplateArgument::Type) 822 return false; 823 return InnerMatcher.matches(Node.getAsType(), Finder, Builder); 824} 825 826/// \brief Matches a TemplateArgument that refers to a certain template. 827/// 828/// Given 829/// \code 830/// template<template <typename> class S> class X {}; 831/// template<typename T> class Y {};" 832/// X<Y> xi; 833/// \endcode 834/// classTemplateSpecializationDecl(hasAnyTemplateArgument( 835/// refersToTemplate(templateName()))) 836/// matches the specialization \c X<Y> 837AST_MATCHER_P(TemplateArgument, refersToTemplate, 838 internal::Matcher<TemplateName>, InnerMatcher) { 839 if (Node.getKind() != TemplateArgument::Template) 840 return false; 841 return InnerMatcher.matches(Node.getAsTemplate(), Finder, Builder); 842} 843 844/// \brief Matches a canonical TemplateArgument that refers to a certain 845/// declaration. 846/// 847/// Given 848/// \code 849/// template<typename T> struct A {}; 850/// struct B { B* next; }; 851/// A<&B::next> a; 852/// \endcode 853/// classTemplateSpecializationDecl(hasAnyTemplateArgument( 854/// refersToDeclaration(fieldDecl(hasName("next")))) 855/// matches the specialization \c A<&B::next> with \c fieldDecl(...) matching 856/// \c B::next 857AST_MATCHER_P(TemplateArgument, refersToDeclaration, 858 internal::Matcher<Decl>, InnerMatcher) { 859 if (Node.getKind() == TemplateArgument::Declaration) 860 return InnerMatcher.matches(*Node.getAsDecl(), Finder, Builder); 861 return false; 862} 863 864/// \brief Matches a sugar TemplateArgument that refers to a certain expression. 865/// 866/// Given 867/// \code 868/// template<typename T> struct A {}; 869/// struct B { B* next; }; 870/// A<&B::next> a; 871/// \endcode 872/// templateSpecializationType(hasAnyTemplateArgument( 873/// isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next")))))))) 874/// matches the specialization \c A<&B::next> with \c fieldDecl(...) matching 875/// \c B::next 876AST_MATCHER_P(TemplateArgument, isExpr, internal::Matcher<Expr>, InnerMatcher) { 877 if (Node.getKind() == TemplateArgument::Expression) 878 return InnerMatcher.matches(*Node.getAsExpr(), Finder, Builder); 879 return false; 880} 881 882/// \brief Matches a TemplateArgument that is an integral value. 883/// 884/// Given 885/// \code 886/// template<int T> struct A {}; 887/// C<42> c; 888/// \endcode 889/// classTemplateSpecializationDecl( 890/// hasAnyTemplateArgument(isIntegral())) 891/// matches the implicit instantiation of C in C<42> 892/// with isIntegral() matching 42. 893AST_MATCHER(TemplateArgument, isIntegral) { 894 return Node.getKind() == TemplateArgument::Integral; 895} 896 897/// \brief Matches a TemplateArgument that referes to an integral type. 898/// 899/// Given 900/// \code 901/// template<int T> struct A {}; 902/// C<42> c; 903/// \endcode 904/// classTemplateSpecializationDecl( 905/// hasAnyTemplateArgument(refersToIntegralType(asString("int")))) 906/// matches the implicit instantiation of C in C<42>. 907AST_MATCHER_P(TemplateArgument, refersToIntegralType, 908 internal::Matcher<QualType>, InnerMatcher) { 909 if (Node.getKind() != TemplateArgument::Integral) 910 return false; 911 return InnerMatcher.matches(Node.getIntegralType(), Finder, Builder); 912} 913 914/// \brief Matches a TemplateArgument of integral type with a given value. 915/// 916/// Note that 'Value' is a string as the template argument's value is 917/// an arbitrary precision integer. 'Value' must be euqal to the canonical 918/// representation of that integral value in base 10. 919/// 920/// Given 921/// \code 922/// template<int T> struct A {}; 923/// C<42> c; 924/// \endcode 925/// classTemplateSpecializationDecl( 926/// hasAnyTemplateArgument(equalsIntegralValue("42"))) 927/// matches the implicit instantiation of C in C<42>. 928AST_MATCHER_P(TemplateArgument, equalsIntegralValue, 929 std::string, Value) { 930 if (Node.getKind() != TemplateArgument::Integral) 931 return false; 932 return Node.getAsIntegral().toString(10) == Value; 933} 934 935/// \brief Matches any value declaration. 936/// 937/// Example matches A, B, C and F 938/// \code 939/// enum X { A, B, C }; 940/// void F(); 941/// \endcode 942const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl; 943 944/// \brief Matches C++ constructor declarations. 945/// 946/// Example matches Foo::Foo() and Foo::Foo(int) 947/// \code 948/// class Foo { 949/// public: 950/// Foo(); 951/// Foo(int); 952/// int DoSomething(); 953/// }; 954/// \endcode 955const internal::VariadicDynCastAllOfMatcher< 956 Decl, 957 CXXConstructorDecl> cxxConstructorDecl; 958 959/// \brief Matches explicit C++ destructor declarations. 960/// 961/// Example matches Foo::~Foo() 962/// \code 963/// class Foo { 964/// public: 965/// virtual ~Foo(); 966/// }; 967/// \endcode 968const internal::VariadicDynCastAllOfMatcher< 969 Decl, 970 CXXDestructorDecl> cxxDestructorDecl; 971 972/// \brief Matches enum declarations. 973/// 974/// Example matches X 975/// \code 976/// enum X { 977/// A, B, C 978/// }; 979/// \endcode 980const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl; 981 982/// \brief Matches enum constants. 983/// 984/// Example matches A, B, C 985/// \code 986/// enum X { 987/// A, B, C 988/// }; 989/// \endcode 990const internal::VariadicDynCastAllOfMatcher< 991 Decl, 992 EnumConstantDecl> enumConstantDecl; 993 994/// \brief Matches method declarations. 995/// 996/// Example matches y 997/// \code 998/// class X { void y(); }; 999/// \endcode 1000const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> cxxMethodDecl; 1001 1002/// \brief Matches conversion operator declarations. 1003/// 1004/// Example matches the operator. 1005/// \code 1006/// class X { operator int() const; }; 1007/// \endcode 1008const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl> 1009 cxxConversionDecl; 1010 1011/// \brief Matches variable declarations. 1012/// 1013/// Note: this does not match declarations of member variables, which are 1014/// "field" declarations in Clang parlance. 1015/// 1016/// Example matches a 1017/// \code 1018/// int a; 1019/// \endcode 1020const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl; 1021 1022/// \brief Matches field declarations. 1023/// 1024/// Given 1025/// \code 1026/// class X { int m; }; 1027/// \endcode 1028/// fieldDecl() 1029/// matches 'm'. 1030const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl; 1031 1032/// \brief Matches function declarations. 1033/// 1034/// Example matches f 1035/// \code 1036/// void f(); 1037/// \endcode 1038const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl; 1039 1040/// \brief Matches C++ function template declarations. 1041/// 1042/// Example matches f 1043/// \code 1044/// template<class T> void f(T t) {} 1045/// \endcode 1046const internal::VariadicDynCastAllOfMatcher< 1047 Decl, 1048 FunctionTemplateDecl> functionTemplateDecl; 1049 1050/// \brief Matches friend declarations. 1051/// 1052/// Given 1053/// \code 1054/// class X { friend void foo(); }; 1055/// \endcode 1056/// friendDecl() 1057/// matches 'friend void foo()'. 1058const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl; 1059 1060/// \brief Matches statements. 1061/// 1062/// Given 1063/// \code 1064/// { ++a; } 1065/// \endcode 1066/// stmt() 1067/// matches both the compound statement '{ ++a; }' and '++a'. 1068const internal::VariadicAllOfMatcher<Stmt> stmt; 1069 1070/// \brief Matches declaration statements. 1071/// 1072/// Given 1073/// \code 1074/// int a; 1075/// \endcode 1076/// declStmt() 1077/// matches 'int a'. 1078const internal::VariadicDynCastAllOfMatcher< 1079 Stmt, 1080 DeclStmt> declStmt; 1081 1082/// \brief Matches member expressions. 1083/// 1084/// Given 1085/// \code 1086/// class Y { 1087/// void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; } 1088/// int a; static int b; 1089/// }; 1090/// \endcode 1091/// memberExpr() 1092/// matches this->x, x, y.x, a, this->b 1093const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr; 1094 1095/// \brief Matches call expressions. 1096/// 1097/// Example matches x.y() and y() 1098/// \code 1099/// X x; 1100/// x.y(); 1101/// y(); 1102/// \endcode 1103const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr; 1104 1105/// \brief Matches lambda expressions. 1106/// 1107/// Example matches [&](){return 5;} 1108/// \code 1109/// [&](){return 5;} 1110/// \endcode 1111const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr; 1112 1113/// \brief Matches member call expressions. 1114/// 1115/// Example matches x.y() 1116/// \code 1117/// X x; 1118/// x.y(); 1119/// \endcode 1120const internal::VariadicDynCastAllOfMatcher< 1121 Stmt, 1122 CXXMemberCallExpr> cxxMemberCallExpr; 1123 1124/// \brief Matches ObjectiveC Message invocation expressions. 1125/// 1126/// The innermost message send invokes the "alloc" class method on the 1127/// NSString class, while the outermost message send invokes the 1128/// "initWithString" instance method on the object returned from 1129/// NSString's "alloc". This matcher should match both message sends. 1130/// \code 1131/// [[NSString alloc] initWithString:@"Hello"] 1132/// \endcode 1133const internal::VariadicDynCastAllOfMatcher< 1134 Stmt, 1135 ObjCMessageExpr> objcMessageExpr; 1136 1137/// \brief Matches Objective-C interface declarations. 1138/// 1139/// Example matches Foo 1140/// \code 1141/// @interface Foo 1142/// @end 1143/// \endcode 1144const internal::VariadicDynCastAllOfMatcher< 1145 Decl, 1146 ObjCInterfaceDecl> objcInterfaceDecl; 1147 1148/// \brief Matches Objective-C implementation declarations. 1149/// 1150/// Example matches Foo 1151/// \code 1152/// @implementation Foo 1153/// @end 1154/// \endcode 1155const internal::VariadicDynCastAllOfMatcher< 1156 Decl, 1157 ObjCImplementationDecl> objcImplementationDecl; 1158 1159/// \brief Matches Objective-C protocol declarations. 1160/// 1161/// Example matches FooDelegate 1162/// \code 1163/// @protocol FooDelegate 1164/// @end 1165/// \endcode 1166const internal::VariadicDynCastAllOfMatcher< 1167 Decl, 1168 ObjCProtocolDecl> objcProtocolDecl; 1169 1170/// \brief Matches Objective-C category declarations. 1171/// 1172/// Example matches Foo (Additions) 1173/// \code 1174/// @interface Foo (Additions) 1175/// @end 1176/// \endcode 1177const internal::VariadicDynCastAllOfMatcher< 1178 Decl, 1179 ObjCCategoryDecl> objcCategoryDecl; 1180 1181/// \brief Matches Objective-C method declarations. 1182/// 1183/// Example matches both declaration and definition of -[Foo method] 1184/// \code 1185/// @interface Foo 1186/// - (void)method; 1187/// @end 1188/// 1189/// @implementation Foo 1190/// - (void)method {} 1191/// @end 1192/// \endcode 1193const internal::VariadicDynCastAllOfMatcher< 1194 Decl, 1195 ObjCMethodDecl> objcMethodDecl; 1196 1197/// \brief Matches Objective-C instance variable declarations. 1198/// 1199/// Example matches _enabled 1200/// \code 1201/// @implementation Foo { 1202/// BOOL _enabled; 1203/// } 1204/// @end 1205/// \endcode 1206const internal::VariadicDynCastAllOfMatcher< 1207 Decl, 1208 ObjCIvarDecl> objcIvarDecl; 1209 1210/// \brief Matches Objective-C property declarations. 1211/// 1212/// Example matches enabled 1213/// \code 1214/// @interface Foo 1215/// @property BOOL enabled; 1216/// @end 1217/// \endcode 1218const internal::VariadicDynCastAllOfMatcher< 1219 Decl, 1220 ObjCPropertyDecl> objcPropertyDecl; 1221 1222/// \brief Matches expressions that introduce cleanups to be run at the end 1223/// of the sub-expression's evaluation. 1224/// 1225/// Example matches std::string() 1226/// \code 1227/// const std::string str = std::string(); 1228/// \endcode 1229const internal::VariadicDynCastAllOfMatcher< 1230 Stmt, 1231 ExprWithCleanups> exprWithCleanups; 1232 1233/// \brief Matches init list expressions. 1234/// 1235/// Given 1236/// \code 1237/// int a[] = { 1, 2 }; 1238/// struct B { int x, y; }; 1239/// B b = { 5, 6 }; 1240/// \endcode 1241/// initListExpr() 1242/// matches "{ 1, 2 }" and "{ 5, 6 }" 1243const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr; 1244 1245/// \brief Matches the syntactic form of init list expressions 1246/// (if expression have it). 1247AST_MATCHER_P(InitListExpr, hasSyntacticForm, 1248 internal::Matcher<Expr>, InnerMatcher) { 1249 const Expr *SyntForm = Node.getSyntacticForm(); 1250 return (SyntForm != nullptr && 1251 InnerMatcher.matches(*SyntForm, Finder, Builder)); 1252} 1253 1254/// \brief Matches C++ initializer list expressions. 1255/// 1256/// Given 1257/// \code 1258/// std::vector<int> a({ 1, 2, 3 }); 1259/// std::vector<int> b = { 4, 5 }; 1260/// int c[] = { 6, 7 }; 1261/// std::pair<int, int> d = { 8, 9 }; 1262/// \endcode 1263/// cxxStdInitializerListExpr() 1264/// matches "{ 1, 2, 3 }" and "{ 4, 5 }" 1265const internal::VariadicDynCastAllOfMatcher<Stmt, 1266 CXXStdInitializerListExpr> cxxStdInitializerListExpr; 1267 1268/// \brief Matches implicit initializers of init list expressions. 1269/// 1270/// Given 1271/// \code 1272/// point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; 1273/// \endcode 1274/// implicitValueInitExpr() 1275/// matches "[0].y" (implicitly) 1276const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr> 1277implicitValueInitExpr; 1278 1279/// \brief Matches paren list expressions. 1280/// ParenListExprs don't have a predefined type and are used for late parsing. 1281/// In the final AST, they can be met in template declarations. 1282/// 1283/// Given 1284/// \code 1285/// template<typename T> class X { 1286/// void f() { 1287/// X x(*this); 1288/// int a = 0, b = 1; int i = (a, b); 1289/// } 1290/// }; 1291/// \endcode 1292/// parenListExpr() matches "*this" but NOT matches (a, b) because (a, b) 1293/// has a predefined type and is a ParenExpr, not a ParenListExpr. 1294const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> parenListExpr; 1295 1296/// \brief Matches substitutions of non-type template parameters. 1297/// 1298/// Given 1299/// \code 1300/// template <int N> 1301/// struct A { static const int n = N; }; 1302/// struct B : public A<42> {}; 1303/// \endcode 1304/// substNonTypeTemplateParmExpr() 1305/// matches "N" in the right-hand side of "static const int n = N;" 1306const internal::VariadicDynCastAllOfMatcher< 1307 Stmt, 1308 SubstNonTypeTemplateParmExpr> substNonTypeTemplateParmExpr; 1309 1310/// \brief Matches using declarations. 1311/// 1312/// Given 1313/// \code 1314/// namespace X { int x; } 1315/// using X::x; 1316/// \endcode 1317/// usingDecl() 1318/// matches \code using X::x \endcode 1319const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl; 1320 1321/// \brief Matches using namespace declarations. 1322/// 1323/// Given 1324/// \code 1325/// namespace X { int x; } 1326/// using namespace X; 1327/// \endcode 1328/// usingDirectiveDecl() 1329/// matches \code using namespace X \endcode 1330const internal::VariadicDynCastAllOfMatcher< 1331 Decl, 1332 UsingDirectiveDecl> usingDirectiveDecl; 1333 1334/// \brief Matches reference to a name that can be looked up during parsing 1335/// but could not be resolved to a specific declaration. 1336/// 1337/// Given 1338/// \code 1339/// template<typename T> 1340/// T foo() { T a; return a; } 1341/// template<typename T> 1342/// void bar() { 1343/// foo<T>(); 1344/// } 1345/// \endcode 1346/// unresolvedLookupExpr() 1347/// matches \code foo<T>() \endcode 1348const internal::VariadicDynCastAllOfMatcher< 1349 Stmt, 1350 UnresolvedLookupExpr> unresolvedLookupExpr; 1351 1352/// \brief Matches unresolved using value declarations. 1353/// 1354/// Given 1355/// \code 1356/// template<typename X> 1357/// class C : private X { 1358/// using X::x; 1359/// }; 1360/// \endcode 1361/// unresolvedUsingValueDecl() 1362/// matches \code using X::x \endcode 1363const internal::VariadicDynCastAllOfMatcher< 1364 Decl, 1365 UnresolvedUsingValueDecl> unresolvedUsingValueDecl; 1366 1367/// \brief Matches unresolved using value declarations that involve the 1368/// typename. 1369/// 1370/// Given 1371/// \code 1372/// template <typename T> 1373/// struct Base { typedef T Foo; }; 1374/// 1375/// template<typename T> 1376/// struct S : private Base<T> { 1377/// using typename Base<T>::Foo; 1378/// }; 1379/// \endcode 1380/// unresolvedUsingTypenameDecl() 1381/// matches \code using Base<T>::Foo \endcode 1382const internal::VariadicDynCastAllOfMatcher< 1383 Decl, 1384 UnresolvedUsingTypenameDecl> unresolvedUsingTypenameDecl; 1385 1386/// \brief Matches parentheses used in expressions. 1387/// 1388/// Example matches (foo() + 1) 1389/// \code 1390/// int foo() { return 1; } 1391/// int a = (foo() + 1); 1392/// \endcode 1393const internal::VariadicDynCastAllOfMatcher< 1394 Stmt, 1395 ParenExpr> parenExpr; 1396 1397/// \brief Matches constructor call expressions (including implicit ones). 1398/// 1399/// Example matches string(ptr, n) and ptr within arguments of f 1400/// (matcher = cxxConstructExpr()) 1401/// \code 1402/// void f(const string &a, const string &b); 1403/// char *ptr; 1404/// int n; 1405/// f(string(ptr, n), ptr); 1406/// \endcode 1407const internal::VariadicDynCastAllOfMatcher< 1408 Stmt, 1409 CXXConstructExpr> cxxConstructExpr; 1410 1411/// \brief Matches unresolved constructor call expressions. 1412/// 1413/// Example matches T(t) in return statement of f 1414/// (matcher = cxxUnresolvedConstructExpr()) 1415/// \code 1416/// template <typename T> 1417/// void f(const T& t) { return T(t); } 1418/// \endcode 1419const internal::VariadicDynCastAllOfMatcher< 1420 Stmt, 1421 CXXUnresolvedConstructExpr> cxxUnresolvedConstructExpr; 1422 1423/// \brief Matches implicit and explicit this expressions. 1424/// 1425/// Example matches the implicit this expression in "return i". 1426/// (matcher = cxxThisExpr()) 1427/// \code 1428/// struct foo { 1429/// int i; 1430/// int f() { return i; } 1431/// }; 1432/// \endcode 1433const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> cxxThisExpr; 1434 1435/// \brief Matches nodes where temporaries are created. 1436/// 1437/// Example matches FunctionTakesString(GetStringByValue()) 1438/// (matcher = cxxBindTemporaryExpr()) 1439/// \code 1440/// FunctionTakesString(GetStringByValue()); 1441/// FunctionTakesStringByPointer(GetStringPointer()); 1442/// \endcode 1443const internal::VariadicDynCastAllOfMatcher< 1444 Stmt, 1445 CXXBindTemporaryExpr> cxxBindTemporaryExpr; 1446 1447/// \brief Matches nodes where temporaries are materialized. 1448/// 1449/// Example: Given 1450/// \code 1451/// struct T {void func();}; 1452/// T f(); 1453/// void g(T); 1454/// \endcode 1455/// materializeTemporaryExpr() matches 'f()' in these statements 1456/// \code 1457/// T u(f()); 1458/// g(f()); 1459/// \endcode 1460/// but does not match 1461/// \code 1462/// f(); 1463/// f().func(); 1464/// \endcode 1465const internal::VariadicDynCastAllOfMatcher< 1466 Stmt, 1467 MaterializeTemporaryExpr> materializeTemporaryExpr; 1468 1469/// \brief Matches new expressions. 1470/// 1471/// Given 1472/// \code 1473/// new X; 1474/// \endcode 1475/// cxxNewExpr() 1476/// matches 'new X'. 1477const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr; 1478 1479/// \brief Matches delete expressions. 1480/// 1481/// Given 1482/// \code 1483/// delete X; 1484/// \endcode 1485/// cxxDeleteExpr() 1486/// matches 'delete X'. 1487const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> cxxDeleteExpr; 1488 1489/// \brief Matches array subscript expressions. 1490/// 1491/// Given 1492/// \code 1493/// int i = a[1]; 1494/// \endcode 1495/// arraySubscriptExpr() 1496/// matches "a[1]" 1497const internal::VariadicDynCastAllOfMatcher< 1498 Stmt, 1499 ArraySubscriptExpr> arraySubscriptExpr; 1500 1501/// \brief Matches the value of a default argument at the call site. 1502/// 1503/// Example matches the CXXDefaultArgExpr placeholder inserted for the 1504/// default value of the second parameter in the call expression f(42) 1505/// (matcher = cxxDefaultArgExpr()) 1506/// \code 1507/// void f(int x, int y = 0); 1508/// f(42); 1509/// \endcode 1510const internal::VariadicDynCastAllOfMatcher< 1511 Stmt, 1512 CXXDefaultArgExpr> cxxDefaultArgExpr; 1513 1514/// \brief Matches overloaded operator calls. 1515/// 1516/// Note that if an operator isn't overloaded, it won't match. Instead, use 1517/// binaryOperator matcher. 1518/// Currently it does not match operators such as new delete. 1519/// FIXME: figure out why these do not match? 1520/// 1521/// Example matches both operator<<((o << b), c) and operator<<(o, b) 1522/// (matcher = cxxOperatorCallExpr()) 1523/// \code 1524/// ostream &operator<< (ostream &out, int i) { }; 1525/// ostream &o; int b = 1, c = 1; 1526/// o << b << c; 1527/// \endcode 1528const internal::VariadicDynCastAllOfMatcher< 1529 Stmt, 1530 CXXOperatorCallExpr> cxxOperatorCallExpr; 1531 1532/// \brief Matches expressions. 1533/// 1534/// Example matches x() 1535/// \code 1536/// void f() { x(); } 1537/// \endcode 1538const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr; 1539 1540/// \brief Matches expressions that refer to declarations. 1541/// 1542/// Example matches x in if (x) 1543/// \code 1544/// bool x; 1545/// if (x) {} 1546/// \endcode 1547const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr; 1548 1549/// \brief Matches if statements. 1550/// 1551/// Example matches 'if (x) {}' 1552/// \code 1553/// if (x) {} 1554/// \endcode 1555const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt; 1556 1557/// \brief Matches for statements. 1558/// 1559/// Example matches 'for (;;) {}' 1560/// \code 1561/// for (;;) {} 1562/// int i[] = {1, 2, 3}; for (auto a : i); 1563/// \endcode 1564const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt; 1565 1566/// \brief Matches the increment statement of a for loop. 1567/// 1568/// Example: 1569/// forStmt(hasIncrement(unaryOperator(hasOperatorName("++")))) 1570/// matches '++x' in 1571/// \code 1572/// for (x; x < N; ++x) { } 1573/// \endcode 1574AST_MATCHER_P(ForStmt, hasIncrement, internal::Matcher<Stmt>, 1575 InnerMatcher) { 1576 const Stmt *const Increment = Node.getInc(); 1577 return (Increment != nullptr && 1578 InnerMatcher.matches(*Increment, Finder, Builder)); 1579} 1580 1581/// \brief Matches the initialization statement of a for loop. 1582/// 1583/// Example: 1584/// forStmt(hasLoopInit(declStmt())) 1585/// matches 'int x = 0' in 1586/// \code 1587/// for (int x = 0; x < N; ++x) { } 1588/// \endcode 1589AST_MATCHER_P(ForStmt, hasLoopInit, internal::Matcher<Stmt>, 1590 InnerMatcher) { 1591 const Stmt *const Init = Node.getInit(); 1592 return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder)); 1593} 1594 1595/// \brief Matches range-based for statements. 1596/// 1597/// cxxForRangeStmt() matches 'for (auto a : i)' 1598/// \code 1599/// int i[] = {1, 2, 3}; for (auto a : i); 1600/// for(int j = 0; j < 5; ++j); 1601/// \endcode 1602const internal::VariadicDynCastAllOfMatcher< 1603 Stmt, 1604 CXXForRangeStmt> cxxForRangeStmt; 1605 1606/// \brief Matches the initialization statement of a for loop. 1607/// 1608/// Example: 1609/// forStmt(hasLoopVariable(anything())) 1610/// matches 'int x' in 1611/// \code 1612/// for (int x : a) { } 1613/// \endcode 1614AST_MATCHER_P(CXXForRangeStmt, hasLoopVariable, internal::Matcher<VarDecl>, 1615 InnerMatcher) { 1616 const VarDecl *const Var = Node.getLoopVariable(); 1617 return (Var != nullptr && InnerMatcher.matches(*Var, Finder, Builder)); 1618} 1619 1620/// \brief Matches the range initialization statement of a for loop. 1621/// 1622/// Example: 1623/// forStmt(hasRangeInit(anything())) 1624/// matches 'a' in 1625/// \code 1626/// for (int x : a) { } 1627/// \endcode 1628AST_MATCHER_P(CXXForRangeStmt, hasRangeInit, internal::Matcher<Expr>, 1629 InnerMatcher) { 1630 const Expr *const Init = Node.getRangeInit(); 1631 return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder)); 1632} 1633 1634/// \brief Matches while statements. 1635/// 1636/// Given 1637/// \code 1638/// while (true) {} 1639/// \endcode 1640/// whileStmt() 1641/// matches 'while (true) {}'. 1642const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt; 1643 1644/// \brief Matches do statements. 1645/// 1646/// Given 1647/// \code 1648/// do {} while (true); 1649/// \endcode 1650/// doStmt() 1651/// matches 'do {} while(true)' 1652const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt; 1653 1654/// \brief Matches break statements. 1655/// 1656/// Given 1657/// \code 1658/// while (true) { break; } 1659/// \endcode 1660/// breakStmt() 1661/// matches 'break' 1662const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt; 1663 1664/// \brief Matches continue statements. 1665/// 1666/// Given 1667/// \code 1668/// while (true) { continue; } 1669/// \endcode 1670/// continueStmt() 1671/// matches 'continue' 1672const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt; 1673 1674/// \brief Matches return statements. 1675/// 1676/// Given 1677/// \code 1678/// return 1; 1679/// \endcode 1680/// returnStmt() 1681/// matches 'return 1' 1682const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt; 1683 1684/// \brief Matches goto statements. 1685/// 1686/// Given 1687/// \code 1688/// goto FOO; 1689/// FOO: bar(); 1690/// \endcode 1691/// gotoStmt() 1692/// matches 'goto FOO' 1693const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt; 1694 1695/// \brief Matches label statements. 1696/// 1697/// Given 1698/// \code 1699/// goto FOO; 1700/// FOO: bar(); 1701/// \endcode 1702/// labelStmt() 1703/// matches 'FOO:' 1704const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt; 1705 1706/// \brief Matches address of label statements (GNU extension). 1707/// 1708/// Given 1709/// \code 1710/// FOO: bar(); 1711/// void *ptr = &&FOO; 1712/// goto *bar; 1713/// \endcode 1714/// addrLabelExpr() 1715/// matches '&&FOO' 1716const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> addrLabelExpr; 1717 1718/// \brief Matches switch statements. 1719/// 1720/// Given 1721/// \code 1722/// switch(a) { case 42: break; default: break; } 1723/// \endcode 1724/// switchStmt() 1725/// matches 'switch(a)'. 1726const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt; 1727 1728/// \brief Matches case and default statements inside switch statements. 1729/// 1730/// Given 1731/// \code 1732/// switch(a) { case 42: break; default: break; } 1733/// \endcode 1734/// switchCase() 1735/// matches 'case 42: break;' and 'default: break;'. 1736const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase; 1737 1738/// \brief Matches case statements inside switch statements. 1739/// 1740/// Given 1741/// \code 1742/// switch(a) { case 42: break; default: break; } 1743/// \endcode 1744/// caseStmt() 1745/// matches 'case 42: break;'. 1746const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt; 1747 1748/// \brief Matches default statements inside switch statements. 1749/// 1750/// Given 1751/// \code 1752/// switch(a) { case 42: break; default: break; } 1753/// \endcode 1754/// defaultStmt() 1755/// matches 'default: break;'. 1756const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt; 1757 1758/// \brief Matches compound statements. 1759/// 1760/// Example matches '{}' and '{{}}'in 'for (;;) {{}}' 1761/// \code 1762/// for (;;) {{}} 1763/// \endcode 1764const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt; 1765 1766/// \brief Matches catch statements. 1767/// 1768/// \code 1769/// try {} catch(int i) {} 1770/// \endcode 1771/// cxxCatchStmt() 1772/// matches 'catch(int i)' 1773const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt; 1774 1775/// \brief Matches try statements. 1776/// 1777/// \code 1778/// try {} catch(int i) {} 1779/// \endcode 1780/// cxxTryStmt() 1781/// matches 'try {}' 1782const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt; 1783 1784/// \brief Matches throw expressions. 1785/// 1786/// \code 1787/// try { throw 5; } catch(int i) {} 1788/// \endcode 1789/// cxxThrowExpr() 1790/// matches 'throw 5' 1791const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr; 1792 1793/// \brief Matches null statements. 1794/// 1795/// \code 1796/// foo();; 1797/// \endcode 1798/// nullStmt() 1799/// matches the second ';' 1800const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt; 1801 1802/// \brief Matches asm statements. 1803/// 1804/// \code 1805/// int i = 100; 1806/// __asm("mov al, 2"); 1807/// \endcode 1808/// asmStmt() 1809/// matches '__asm("mov al, 2")' 1810const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt; 1811 1812/// \brief Matches bool literals. 1813/// 1814/// Example matches true 1815/// \code 1816/// true 1817/// \endcode 1818const internal::VariadicDynCastAllOfMatcher< 1819 Stmt, 1820 CXXBoolLiteralExpr> cxxBoolLiteral; 1821 1822/// \brief Matches string literals (also matches wide string literals). 1823/// 1824/// Example matches "abcd", L"abcd" 1825/// \code 1826/// char *s = "abcd"; 1827/// wchar_t *ws = L"abcd"; 1828/// \endcode 1829const internal::VariadicDynCastAllOfMatcher< 1830 Stmt, 1831 StringLiteral> stringLiteral; 1832 1833/// \brief Matches character literals (also matches wchar_t). 1834/// 1835/// Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral), 1836/// though. 1837/// 1838/// Example matches 'a', L'a' 1839/// \code 1840/// char ch = 'a'; 1841/// wchar_t chw = L'a'; 1842/// \endcode 1843const internal::VariadicDynCastAllOfMatcher< 1844 Stmt, 1845 CharacterLiteral> characterLiteral; 1846 1847/// \brief Matches integer literals of all sizes / encodings, e.g. 1848/// 1, 1L, 0x1 and 1U. 1849/// 1850/// Does not match character-encoded integers such as L'a'. 1851const internal::VariadicDynCastAllOfMatcher< 1852 Stmt, 1853 IntegerLiteral> integerLiteral; 1854 1855/// \brief Matches float literals of all sizes / encodings, e.g. 1856/// 1.0, 1.0f, 1.0L and 1e10. 1857/// 1858/// Does not match implicit conversions such as 1859/// \code 1860/// float a = 10; 1861/// \endcode 1862const internal::VariadicDynCastAllOfMatcher< 1863 Stmt, 1864 FloatingLiteral> floatLiteral; 1865 1866/// \brief Matches user defined literal operator call. 1867/// 1868/// Example match: "foo"_suffix 1869const internal::VariadicDynCastAllOfMatcher< 1870 Stmt, 1871 UserDefinedLiteral> userDefinedLiteral; 1872 1873/// \brief Matches compound (i.e. non-scalar) literals 1874/// 1875/// Example match: {1}, (1, 2) 1876/// \code 1877/// int array[4] = {1}; 1878/// vector int myvec = (vector int)(1, 2); 1879/// \endcode 1880const internal::VariadicDynCastAllOfMatcher< 1881 Stmt, 1882 CompoundLiteralExpr> compoundLiteralExpr; 1883 1884/// \brief Matches nullptr literal. 1885const internal::VariadicDynCastAllOfMatcher< 1886 Stmt, 1887 CXXNullPtrLiteralExpr> cxxNullPtrLiteralExpr; 1888 1889/// \brief Matches GNU __null expression. 1890const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr; 1891 1892/// \brief Matches atomic builtins. 1893/// Example matches __atomic_load_n(ptr, 1) 1894/// \code 1895/// void foo() { int *ptr; __atomic_load_n(ptr, 1); } 1896/// \endcode 1897const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr; 1898 1899/// \brief Matches statement expression (GNU extension). 1900/// 1901/// Example match: ({ int X = 4; X; }) 1902/// \code 1903/// int C = ({ int X = 4; X; }); 1904/// \endcode 1905const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr; 1906 1907/// \brief Matches binary operator expressions. 1908/// 1909/// Example matches a || b 1910/// \code 1911/// !(a || b) 1912/// \endcode 1913const internal::VariadicDynCastAllOfMatcher< 1914 Stmt, 1915 BinaryOperator> binaryOperator; 1916 1917/// \brief Matches unary operator expressions. 1918/// 1919/// Example matches !a 1920/// \code 1921/// !a || b 1922/// \endcode 1923const internal::VariadicDynCastAllOfMatcher< 1924 Stmt, 1925 UnaryOperator> unaryOperator; 1926 1927/// \brief Matches conditional operator expressions. 1928/// 1929/// Example matches a ? b : c 1930/// \code 1931/// (a ? b : c) + 42 1932/// \endcode 1933const internal::VariadicDynCastAllOfMatcher< 1934 Stmt, 1935 ConditionalOperator> conditionalOperator; 1936 1937/// \brief Matches binary conditional operator expressions (GNU extension). 1938/// 1939/// Example matches a ?: b 1940/// \code 1941/// (a ?: b) + 42; 1942/// \endcode 1943const internal::VariadicDynCastAllOfMatcher< 1944 Stmt, 1945 BinaryConditionalOperator> binaryConditionalOperator; 1946 1947/// \brief Matches opaque value expressions. They are used as helpers 1948/// to reference another expressions and can be met 1949/// in BinaryConditionalOperators, for example. 1950/// 1951/// Example matches 'a' 1952/// \code 1953/// (a ?: c) + 42; 1954/// \endcode 1955const internal::VariadicDynCastAllOfMatcher< 1956 Stmt, 1957 OpaqueValueExpr> opaqueValueExpr; 1958 1959/// \brief Matches a C++ static_assert declaration. 1960/// 1961/// Example: 1962/// staticAssertExpr() 1963/// matches 1964/// static_assert(sizeof(S) == sizeof(int)) 1965/// in 1966/// \code 1967/// struct S { 1968/// int x; 1969/// }; 1970/// static_assert(sizeof(S) == sizeof(int)); 1971/// \endcode 1972const internal::VariadicDynCastAllOfMatcher< 1973 Decl, 1974 StaticAssertDecl> staticAssertDecl; 1975 1976/// \brief Matches a reinterpret_cast expression. 1977/// 1978/// Either the source expression or the destination type can be matched 1979/// using has(), but hasDestinationType() is more specific and can be 1980/// more readable. 1981/// 1982/// Example matches reinterpret_cast<char*>(&p) in 1983/// \code 1984/// void* p = reinterpret_cast<char*>(&p); 1985/// \endcode 1986const internal::VariadicDynCastAllOfMatcher< 1987 Stmt, 1988 CXXReinterpretCastExpr> cxxReinterpretCastExpr; 1989 1990/// \brief Matches a C++ static_cast expression. 1991/// 1992/// \see hasDestinationType 1993/// \see reinterpretCast 1994/// 1995/// Example: 1996/// cxxStaticCastExpr() 1997/// matches 1998/// static_cast<long>(8) 1999/// in 2000/// \code 2001/// long eight(static_cast<long>(8)); 2002/// \endcode 2003const internal::VariadicDynCastAllOfMatcher< 2004 Stmt, 2005 CXXStaticCastExpr> cxxStaticCastExpr; 2006 2007/// \brief Matches a dynamic_cast expression. 2008/// 2009/// Example: 2010/// cxxDynamicCastExpr() 2011/// matches 2012/// dynamic_cast<D*>(&b); 2013/// in 2014/// \code 2015/// struct B { virtual ~B() {} }; struct D : B {}; 2016/// B b; 2017/// D* p = dynamic_cast<D*>(&b); 2018/// \endcode 2019const internal::VariadicDynCastAllOfMatcher< 2020 Stmt, 2021 CXXDynamicCastExpr> cxxDynamicCastExpr; 2022 2023/// \brief Matches a const_cast expression. 2024/// 2025/// Example: Matches const_cast<int*>(&r) in 2026/// \code 2027/// int n = 42; 2028/// const int &r(n); 2029/// int* p = const_cast<int*>(&r); 2030/// \endcode 2031const internal::VariadicDynCastAllOfMatcher< 2032 Stmt, 2033 CXXConstCastExpr> cxxConstCastExpr; 2034 2035/// \brief Matches a C-style cast expression. 2036/// 2037/// Example: Matches (int) 2.2f in 2038/// \code 2039/// int i = (int) 2.2f; 2040/// \endcode 2041const internal::VariadicDynCastAllOfMatcher< 2042 Stmt, 2043 CStyleCastExpr> cStyleCastExpr; 2044 2045/// \brief Matches explicit cast expressions. 2046/// 2047/// Matches any cast expression written in user code, whether it be a 2048/// C-style cast, a functional-style cast, or a keyword cast. 2049/// 2050/// Does not match implicit conversions. 2051/// 2052/// Note: the name "explicitCast" is chosen to match Clang's terminology, as 2053/// Clang uses the term "cast" to apply to implicit conversions as well as to 2054/// actual cast expressions. 2055/// 2056/// \see hasDestinationType. 2057/// 2058/// Example: matches all five of the casts in 2059/// \code 2060/// int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42))))) 2061/// \endcode 2062/// but does not match the implicit conversion in 2063/// \code 2064/// long ell = 42; 2065/// \endcode 2066const internal::VariadicDynCastAllOfMatcher< 2067 Stmt, 2068 ExplicitCastExpr> explicitCastExpr; 2069 2070/// \brief Matches the implicit cast nodes of Clang's AST. 2071/// 2072/// This matches many different places, including function call return value 2073/// eliding, as well as any type conversions. 2074const internal::VariadicDynCastAllOfMatcher< 2075 Stmt, 2076 ImplicitCastExpr> implicitCastExpr; 2077 2078/// \brief Matches any cast nodes of Clang's AST. 2079/// 2080/// Example: castExpr() matches each of the following: 2081/// \code 2082/// (int) 3; 2083/// const_cast<Expr *>(SubExpr); 2084/// char c = 0; 2085/// \endcode 2086/// but does not match 2087/// \code 2088/// int i = (0); 2089/// int k = 0; 2090/// \endcode 2091const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr; 2092 2093/// \brief Matches functional cast expressions 2094/// 2095/// Example: Matches Foo(bar); 2096/// \code 2097/// Foo f = bar; 2098/// Foo g = (Foo) bar; 2099/// Foo h = Foo(bar); 2100/// \endcode 2101const internal::VariadicDynCastAllOfMatcher< 2102 Stmt, 2103 CXXFunctionalCastExpr> cxxFunctionalCastExpr; 2104 2105/// \brief Matches functional cast expressions having N != 1 arguments 2106/// 2107/// Example: Matches Foo(bar, bar) 2108/// \code 2109/// Foo h = Foo(bar, bar); 2110/// \endcode 2111const internal::VariadicDynCastAllOfMatcher< 2112 Stmt, 2113 CXXTemporaryObjectExpr> cxxTemporaryObjectExpr; 2114 2115/// \brief Matches predefined identifier expressions [C99 6.4.2.2]. 2116/// 2117/// Example: Matches __func__ 2118/// \code 2119/// printf("%s", __func__); 2120/// \endcode 2121const internal::VariadicDynCastAllOfMatcher< 2122 Stmt, 2123 PredefinedExpr> predefinedExpr; 2124 2125/// \brief Matches C99 designated initializer expressions [C99 6.7.8]. 2126/// 2127/// Example: Matches { [2].y = 1.0, [0].x = 1.0 } 2128/// \code 2129/// point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 }; 2130/// \endcode 2131const internal::VariadicDynCastAllOfMatcher< 2132 Stmt, 2133 DesignatedInitExpr> designatedInitExpr; 2134 2135/// \brief Matches designated initializer expressions that contain 2136/// a specific number of designators. 2137/// 2138/// Example: Given 2139/// \code 2140/// point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 }; 2141/// point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }; 2142/// \endcode 2143/// designatorCountIs(2) 2144/// matches '{ [2].y = 1.0, [0].x = 1.0 }', 2145/// but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'. 2146AST_MATCHER_P(DesignatedInitExpr, designatorCountIs, unsigned, N) { 2147 return Node.size() == N; 2148} 2149 2150/// \brief Matches \c QualTypes in the clang AST. 2151const internal::VariadicAllOfMatcher<QualType> qualType; 2152 2153/// \brief Matches \c Types in the clang AST. 2154const internal::VariadicAllOfMatcher<Type> type; 2155 2156/// \brief Matches \c TypeLocs in the clang AST. 2157const internal::VariadicAllOfMatcher<TypeLoc> typeLoc; 2158 2159/// \brief Matches if any of the given matchers matches. 2160/// 2161/// Unlike \c anyOf, \c eachOf will generate a match result for each 2162/// matching submatcher. 2163/// 2164/// For example, in: 2165/// \code 2166/// class A { int a; int b; }; 2167/// \endcode 2168/// The matcher: 2169/// \code 2170/// cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")), 2171/// has(fieldDecl(hasName("b")).bind("v")))) 2172/// \endcode 2173/// will generate two results binding "v", the first of which binds 2174/// the field declaration of \c a, the second the field declaration of 2175/// \c b. 2176/// 2177/// Usable as: Any Matcher 2178const internal::VariadicOperatorMatcherFunc<2, UINT_MAX> eachOf = { 2179 internal::DynTypedMatcher::VO_EachOf 2180}; 2181 2182/// \brief Matches if any of the given matchers matches. 2183/// 2184/// Usable as: Any Matcher 2185const internal::VariadicOperatorMatcherFunc<2, UINT_MAX> anyOf = { 2186 internal::DynTypedMatcher::VO_AnyOf 2187}; 2188 2189/// \brief Matches if all given matchers match. 2190/// 2191/// Usable as: Any Matcher 2192const internal::VariadicOperatorMatcherFunc<2, UINT_MAX> allOf = { 2193 internal::DynTypedMatcher::VO_AllOf 2194}; 2195 2196/// \brief Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL) 2197/// 2198/// Given 2199/// \code 2200/// Foo x = bar; 2201/// int y = sizeof(x) + alignof(x); 2202/// \endcode 2203/// unaryExprOrTypeTraitExpr() 2204/// matches \c sizeof(x) and \c alignof(x) 2205const internal::VariadicDynCastAllOfMatcher< 2206 Stmt, 2207 UnaryExprOrTypeTraitExpr> unaryExprOrTypeTraitExpr; 2208 2209/// \brief Matches unary expressions that have a specific type of argument. 2210/// 2211/// Given 2212/// \code 2213/// int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c); 2214/// \endcode 2215/// unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int")) 2216/// matches \c sizeof(a) and \c alignof(c) 2217AST_MATCHER_P(UnaryExprOrTypeTraitExpr, hasArgumentOfType, 2218 internal::Matcher<QualType>, InnerMatcher) { 2219 const QualType ArgumentType = Node.getTypeOfArgument(); 2220 return InnerMatcher.matches(ArgumentType, Finder, Builder); 2221} 2222 2223/// \brief Matches unary expressions of a certain kind. 2224/// 2225/// Given 2226/// \code 2227/// int x; 2228/// int s = sizeof(x) + alignof(x) 2229/// \endcode 2230/// unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf)) 2231/// matches \c sizeof(x) 2232AST_MATCHER_P(UnaryExprOrTypeTraitExpr, ofKind, UnaryExprOrTypeTrait, Kind) { 2233 return Node.getKind() == Kind; 2234} 2235 2236/// \brief Same as unaryExprOrTypeTraitExpr, but only matching 2237/// alignof. 2238inline internal::Matcher<Stmt> alignOfExpr( 2239 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) { 2240 return stmt(unaryExprOrTypeTraitExpr(allOf( 2241 ofKind(UETT_AlignOf), InnerMatcher))); 2242} 2243 2244/// \brief Same as unaryExprOrTypeTraitExpr, but only matching 2245/// sizeof. 2246inline internal::Matcher<Stmt> sizeOfExpr( 2247 const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) { 2248 return stmt(unaryExprOrTypeTraitExpr( 2249 allOf(ofKind(UETT_SizeOf), InnerMatcher))); 2250} 2251 2252/// \brief Matches NamedDecl nodes that have the specified name. 2253/// 2254/// Supports specifying enclosing namespaces or classes by prefixing the name 2255/// with '<enclosing>::'. 2256/// Does not match typedefs of an underlying type with the given name. 2257/// 2258/// Example matches X (Name == "X") 2259/// \code 2260/// class X; 2261/// \endcode 2262/// 2263/// Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X") 2264/// \code 2265/// namespace a { namespace b { class X; } } 2266/// \endcode 2267inline internal::Matcher<NamedDecl> hasName(const std::string &Name) { 2268 std::vector<std::string> Names; 2269 Names.push_back(Name); 2270 return internal::Matcher<NamedDecl>(new internal::HasNameMatcher(Names)); 2271} 2272 2273/// \brief Matches NamedDecl nodes that have any of the specified names. 2274/// 2275/// This matcher is only provided as a performance optimization of hasName. 2276/// \code 2277/// hasAnyName(a, b, c) 2278/// \endcode 2279/// is equivalent to, but faster than 2280/// \code 2281/// anyOf(hasName(a), hasName(b), hasName(c)) 2282/// \endcode 2283const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef, 2284 internal::hasAnyNameFunc> 2285 hasAnyName = {}; 2286 2287/// \brief Matches NamedDecl nodes whose fully qualified names contain 2288/// a substring matched by the given RegExp. 2289/// 2290/// Supports specifying enclosing namespaces or classes by 2291/// prefixing the name with '<enclosing>::'. Does not match typedefs 2292/// of an underlying type with the given name. 2293/// 2294/// Example matches X (regexp == "::X") 2295/// \code 2296/// class X; 2297/// \endcode 2298/// 2299/// Example matches X (regexp is one of "::X", "^foo::.*X", among others) 2300/// \code 2301/// namespace foo { namespace bar { class X; } } 2302/// \endcode 2303AST_MATCHER_P(NamedDecl, matchesName, std::string, RegExp) { 2304 assert(!RegExp.empty()); 2305 std::string FullNameString = "::" + Node.getQualifiedNameAsString(); 2306 llvm::Regex RE(RegExp); 2307 return RE.match(FullNameString); 2308} 2309 2310/// \brief Matches overloaded operator names. 2311/// 2312/// Matches overloaded operator names specified in strings without the 2313/// "operator" prefix: e.g. "<<". 2314/// 2315/// Given: 2316/// \code 2317/// class A { int operator*(); }; 2318/// const A &operator<<(const A &a, const A &b); 2319/// A a; 2320/// a << a; // <-- This matches 2321/// \endcode 2322/// 2323/// \c cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the 2324/// specified line and 2325/// \c cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*"))) 2326/// matches the declaration of \c A. 2327/// 2328/// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl> 2329inline internal::PolymorphicMatcherWithParam1< 2330 internal::HasOverloadedOperatorNameMatcher, StringRef, 2331 AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)> 2332hasOverloadedOperatorName(StringRef Name) { 2333 return internal::PolymorphicMatcherWithParam1< 2334 internal::HasOverloadedOperatorNameMatcher, StringRef, 2335 AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)>(Name); 2336} 2337 2338/// \brief Matches C++ classes that are directly or indirectly derived from 2339/// a class matching \c Base. 2340/// 2341/// Note that a class is not considered to be derived from itself. 2342/// 2343/// Example matches Y, Z, C (Base == hasName("X")) 2344/// \code 2345/// class X; 2346/// class Y : public X {}; // directly derived 2347/// class Z : public Y {}; // indirectly derived 2348/// typedef X A; 2349/// typedef A B; 2350/// class C : public B {}; // derived from a typedef of X 2351/// \endcode 2352/// 2353/// In the following example, Bar matches isDerivedFrom(hasName("X")): 2354/// \code 2355/// class Foo; 2356/// typedef Foo X; 2357/// class Bar : public Foo {}; // derived from a type that X is a typedef of 2358/// \endcode 2359AST_MATCHER_P(CXXRecordDecl, isDerivedFrom, 2360 internal::Matcher<NamedDecl>, Base) { 2361 return Finder->classIsDerivedFrom(&Node, Base, Builder); 2362} 2363 2364/// \brief Overloaded method as shortcut for \c isDerivedFrom(hasName(...)). 2365AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isDerivedFrom, std::string, BaseName, 1) { 2366 assert(!BaseName.empty()); 2367 return isDerivedFrom(hasName(BaseName)).matches(Node, Finder, Builder); 2368} 2369 2370/// \brief Similar to \c isDerivedFrom(), but also matches classes that directly 2371/// match \c Base. 2372AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isSameOrDerivedFrom, 2373 internal::Matcher<NamedDecl>, Base, 0) { 2374 return Matcher<CXXRecordDecl>(anyOf(Base, isDerivedFrom(Base))) 2375 .matches(Node, Finder, Builder); 2376} 2377 2378/// \brief Overloaded method as shortcut for 2379/// \c isSameOrDerivedFrom(hasName(...)). 2380AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isSameOrDerivedFrom, std::string, 2381 BaseName, 1) { 2382 assert(!BaseName.empty()); 2383 return isSameOrDerivedFrom(hasName(BaseName)).matches(Node, Finder, Builder); 2384} 2385 2386/// \brief Matches the first method of a class or struct that satisfies \c 2387/// InnerMatcher. 2388/// 2389/// Given: 2390/// \code 2391/// class A { void func(); }; 2392/// class B { void member(); }; 2393/// \endcode 2394/// 2395/// \c cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of 2396/// \c A but not \c B. 2397AST_MATCHER_P(CXXRecordDecl, hasMethod, internal::Matcher<CXXMethodDecl>, 2398 InnerMatcher) { 2399 return matchesFirstInPointerRange(InnerMatcher, Node.method_begin(), 2400 Node.method_end(), Finder, Builder); 2401} 2402 2403/// \brief Matches the generated class of lambda expressions. 2404/// 2405/// Given: 2406/// \code 2407/// auto x = []{}; 2408/// \endcode 2409/// 2410/// \c cxxRecordDecl(isLambda()) matches the implicit class declaration of 2411/// \c decltype(x) 2412AST_MATCHER(CXXRecordDecl, isLambda) { 2413 return Node.isLambda(); 2414} 2415 2416/// \brief Matches AST nodes that have child AST nodes that match the 2417/// provided matcher. 2418/// 2419/// Example matches X, Y 2420/// (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X"))) 2421/// \code 2422/// class X {}; // Matches X, because X::X is a class of name X inside X. 2423/// class Y { class X {}; }; 2424/// class Z { class Y { class X {}; }; }; // Does not match Z. 2425/// \endcode 2426/// 2427/// ChildT must be an AST base type. 2428/// 2429/// Usable as: Any Matcher 2430/// Note that has is direct matcher, so it also matches things like implicit 2431/// casts and paren casts. If you are matching with expr then you should 2432/// probably consider using ignoringParenImpCasts like: 2433/// has(ignoringParenImpCasts(expr())). 2434const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> 2435LLVM_ATTRIBUTE_UNUSED has = {}; 2436 2437/// \brief Matches AST nodes that have descendant AST nodes that match the 2438/// provided matcher. 2439/// 2440/// Example matches X, Y, Z 2441/// (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X"))))) 2442/// \code 2443/// class X {}; // Matches X, because X::X is a class of name X inside X. 2444/// class Y { class X {}; }; 2445/// class Z { class Y { class X {}; }; }; 2446/// \endcode 2447/// 2448/// DescendantT must be an AST base type. 2449/// 2450/// Usable as: Any Matcher 2451const internal::ArgumentAdaptingMatcherFunc<internal::HasDescendantMatcher> 2452LLVM_ATTRIBUTE_UNUSED hasDescendant = {}; 2453 2454/// \brief Matches AST nodes that have child AST nodes that match the 2455/// provided matcher. 2456/// 2457/// Example matches X, Y 2458/// (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X"))) 2459/// \code 2460/// class X {}; // Matches X, because X::X is a class of name X inside X. 2461/// class Y { class X {}; }; 2462/// class Z { class Y { class X {}; }; }; // Does not match Z. 2463/// \endcode 2464/// 2465/// ChildT must be an AST base type. 2466/// 2467/// As opposed to 'has', 'forEach' will cause a match for each result that 2468/// matches instead of only on the first one. 2469/// 2470/// Usable as: Any Matcher 2471const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> 2472LLVM_ATTRIBUTE_UNUSED forEach = {}; 2473 2474/// \brief Matches AST nodes that have descendant AST nodes that match the 2475/// provided matcher. 2476/// 2477/// Example matches X, A, B, C 2478/// (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X"))))) 2479/// \code 2480/// class X {}; // Matches X, because X::X is a class of name X inside X. 2481/// class A { class X {}; }; 2482/// class B { class C { class X {}; }; }; 2483/// \endcode 2484/// 2485/// DescendantT must be an AST base type. 2486/// 2487/// As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for 2488/// each result that matches instead of only on the first one. 2489/// 2490/// Note: Recursively combined ForEachDescendant can cause many matches: 2491/// cxxRecordDecl(forEachDescendant(cxxRecordDecl( 2492/// forEachDescendant(cxxRecordDecl()) 2493/// ))) 2494/// will match 10 times (plus injected class name matches) on: 2495/// \code 2496/// class A { class B { class C { class D { class E {}; }; }; }; }; 2497/// \endcode 2498/// 2499/// Usable as: Any Matcher 2500const internal::ArgumentAdaptingMatcherFunc<internal::ForEachDescendantMatcher> 2501LLVM_ATTRIBUTE_UNUSED forEachDescendant = {}; 2502 2503/// \brief Matches if the node or any descendant matches. 2504/// 2505/// Generates results for each match. 2506/// 2507/// For example, in: 2508/// \code 2509/// class A { class B {}; class C {}; }; 2510/// \endcode 2511/// The matcher: 2512/// \code 2513/// cxxRecordDecl(hasName("::A"), 2514/// findAll(cxxRecordDecl(isDefinition()).bind("m"))) 2515/// \endcode 2516/// will generate results for \c A, \c B and \c C. 2517/// 2518/// Usable as: Any Matcher 2519template <typename T> 2520internal::Matcher<T> findAll(const internal::Matcher<T> &Matcher) { 2521 return eachOf(Matcher, forEachDescendant(Matcher)); 2522} 2523 2524/// \brief Matches AST nodes that have a parent that matches the provided 2525/// matcher. 2526/// 2527/// Given 2528/// \code 2529/// void f() { for (;;) { int x = 42; if (true) { int x = 43; } } } 2530/// \endcode 2531/// \c compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }". 2532/// 2533/// Usable as: Any Matcher 2534const internal::ArgumentAdaptingMatcherFunc< 2535 internal::HasParentMatcher, 2536 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>, 2537 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>> 2538 LLVM_ATTRIBUTE_UNUSED hasParent = {}; 2539 2540/// \brief Matches AST nodes that have an ancestor that matches the provided 2541/// matcher. 2542/// 2543/// Given 2544/// \code 2545/// void f() { if (true) { int x = 42; } } 2546/// void g() { for (;;) { int x = 43; } } 2547/// \endcode 2548/// \c expr(integerLiteral(hasAncestor(ifStmt()))) matches \c 42, but not 43. 2549/// 2550/// Usable as: Any Matcher 2551const internal::ArgumentAdaptingMatcherFunc< 2552 internal::HasAncestorMatcher, 2553 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>, 2554 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>> 2555 LLVM_ATTRIBUTE_UNUSED hasAncestor = {}; 2556 2557/// \brief Matches if the provided matcher does not match. 2558/// 2559/// Example matches Y (matcher = cxxRecordDecl(unless(hasName("X")))) 2560/// \code 2561/// class X {}; 2562/// class Y {}; 2563/// \endcode 2564/// 2565/// Usable as: Any Matcher 2566const internal::VariadicOperatorMatcherFunc<1, 1> unless = { 2567 internal::DynTypedMatcher::VO_UnaryNot 2568}; 2569 2570/// \brief Matches a node if the declaration associated with that node 2571/// matches the given matcher. 2572/// 2573/// The associated declaration is: 2574/// - for type nodes, the declaration of the underlying type 2575/// - for CallExpr, the declaration of the callee 2576/// - for MemberExpr, the declaration of the referenced member 2577/// - for CXXConstructExpr, the declaration of the constructor 2578/// - for CXXNewExpr, the declaration of the operator new 2579/// 2580/// For type nodes, hasDeclaration will generally match the declaration of the 2581/// sugared type. Given 2582/// \code 2583/// class X {}; 2584/// typedef X Y; 2585/// Y y; 2586/// \endcode 2587/// in varDecl(hasType(hasDeclaration(decl()))) the decl will match the 2588/// typedefDecl. A common use case is to match the underlying, desugared type. 2589/// This can be achieved by using the hasUnqualifiedDesugaredType matcher: 2590/// \code 2591/// varDecl(hasType(hasUnqualifiedDesugaredType( 2592/// recordType(hasDeclaration(decl()))))) 2593/// \endcode 2594/// In this matcher, the decl will match the CXXRecordDecl of class X. 2595/// 2596/// Usable as: Matcher<AddrLabelExpr>, Matcher<CallExpr>, 2597/// Matcher<CXXConstructExpr>, Matcher<CXXNewExpr>, Matcher<DeclRefExpr>, 2598/// Matcher<EnumType>, Matcher<InjectedClassNameType>, Matcher<LabelStmt>, 2599/// Matcher<MemberExpr>, Matcher<QualType>, Matcher<RecordType>, 2600/// Matcher<TagType>, Matcher<TemplateSpecializationType>, 2601/// Matcher<TemplateTypeParmType>, Matcher<TypedefType>, 2602/// Matcher<UnresolvedUsingType> 2603inline internal::PolymorphicMatcherWithParam1< 2604 internal::HasDeclarationMatcher, internal::Matcher<Decl>, 2605 void(internal::HasDeclarationSupportedTypes)> 2606hasDeclaration(const internal::Matcher<Decl> &InnerMatcher) { 2607 return internal::PolymorphicMatcherWithParam1< 2608 internal::HasDeclarationMatcher, internal::Matcher<Decl>, 2609 void(internal::HasDeclarationSupportedTypes)>(InnerMatcher); 2610} 2611 2612/// \brief Matches a \c NamedDecl whose underlying declaration matches the given 2613/// matcher. 2614/// 2615/// Given 2616/// \code 2617/// namespace N { template<class T> void f(T t); } 2618/// template <class T> void g() { using N::f; f(T()); } 2619/// \endcode 2620/// \c unresolvedLookupExpr(hasAnyDeclaration( 2621/// namedDecl(hasUnderlyingDecl(hasName("::N::f"))))) 2622/// matches the use of \c f in \c g() . 2623AST_MATCHER_P(NamedDecl, hasUnderlyingDecl, internal::Matcher<NamedDecl>, 2624 InnerMatcher) { 2625 const NamedDecl *UnderlyingDecl = Node.getUnderlyingDecl(); 2626 2627 return UnderlyingDecl != nullptr && 2628 InnerMatcher.matches(*UnderlyingDecl, Finder, Builder); 2629} 2630 2631/// \brief Matches on the implicit object argument of a member call expression. 2632/// 2633/// Example matches y.x() 2634/// (matcher = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y")))))) 2635/// \code 2636/// class Y { public: void x(); }; 2637/// void z() { Y y; y.x(); }", 2638/// \endcode 2639/// 2640/// FIXME: Overload to allow directly matching types? 2641AST_MATCHER_P(CXXMemberCallExpr, on, internal::Matcher<Expr>, 2642 InnerMatcher) { 2643 const Expr *ExprNode = Node.getImplicitObjectArgument() 2644 ->IgnoreParenImpCasts(); 2645 return (ExprNode != nullptr && 2646 InnerMatcher.matches(*ExprNode, Finder, Builder)); 2647} 2648 2649 2650/// \brief Matches on the receiver of an ObjectiveC Message expression. 2651/// 2652/// Example 2653/// matcher = objCMessageExpr(hasReceiverType(asString("UIWebView *"))); 2654/// matches the [webView ...] message invocation. 2655/// \code 2656/// NSString *webViewJavaScript = ... 2657/// UIWebView *webView = ... 2658/// [webView stringByEvaluatingJavaScriptFromString:webViewJavascript]; 2659/// \endcode 2660AST_MATCHER_P(ObjCMessageExpr, hasReceiverType, internal::Matcher<QualType>, 2661 InnerMatcher) { 2662 const QualType TypeDecl = Node.getReceiverType(); 2663 return InnerMatcher.matches(TypeDecl, Finder, Builder); 2664} 2665 2666/// \brief Matches when BaseName == Selector.getAsString() 2667/// 2668/// matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:")); 2669/// matches the outer message expr in the code below, but NOT the message 2670/// invocation for self.bodyView. 2671/// \code 2672/// [self.bodyView loadHTMLString:html baseURL:NULL]; 2673/// \endcode 2674AST_MATCHER_P(ObjCMessageExpr, hasSelector, std::string, BaseName) { 2675 Selector Sel = Node.getSelector(); 2676 return BaseName.compare(Sel.getAsString()) == 0; 2677} 2678 2679 2680/// \brief Matches ObjC selectors whose name contains 2681/// a substring matched by the given RegExp. 2682/// matcher = objCMessageExpr(matchesSelector("loadHTMLString\:baseURL?")); 2683/// matches the outer message expr in the code below, but NOT the message 2684/// invocation for self.bodyView. 2685/// \code 2686/// [self.bodyView loadHTMLString:html baseURL:NULL]; 2687/// \endcode 2688AST_MATCHER_P(ObjCMessageExpr, matchesSelector, std::string, RegExp) { 2689 assert(!RegExp.empty()); 2690 std::string SelectorString = Node.getSelector().getAsString(); 2691 llvm::Regex RE(RegExp); 2692 return RE.match(SelectorString); 2693} 2694 2695/// \brief Matches when the selector is the empty selector 2696/// 2697/// Matches only when the selector of the objCMessageExpr is NULL. This may 2698/// represent an error condition in the tree! 2699AST_MATCHER(ObjCMessageExpr, hasNullSelector) { 2700 return Node.getSelector().isNull(); 2701} 2702 2703/// \brief Matches when the selector is a Unary Selector 2704/// 2705/// matcher = objCMessageExpr(matchesSelector(hasUnarySelector()); 2706/// matches self.bodyView in the code below, but NOT the outer message 2707/// invocation of "loadHTMLString:baseURL:". 2708/// \code 2709/// [self.bodyView loadHTMLString:html baseURL:NULL]; 2710/// \endcode 2711AST_MATCHER(ObjCMessageExpr, hasUnarySelector) { 2712 return Node.getSelector().isUnarySelector(); 2713} 2714 2715/// \brief Matches when the selector is a keyword selector 2716/// 2717/// objCMessageExpr(hasKeywordSelector()) matches the generated setFrame 2718/// message expression in 2719/// 2720/// \code 2721/// UIWebView *webView = ...; 2722/// CGRect bodyFrame = webView.frame; 2723/// bodyFrame.size.height = self.bodyContentHeight; 2724/// webView.frame = bodyFrame; 2725/// // ^---- matches here 2726/// \endcode 2727AST_MATCHER(ObjCMessageExpr, hasKeywordSelector) { 2728 return Node.getSelector().isKeywordSelector(); 2729} 2730 2731/// \brief Matches when the selector has the specified number of arguments 2732/// 2733/// matcher = objCMessageExpr(numSelectorArgs(0)); 2734/// matches self.bodyView in the code below 2735/// 2736/// matcher = objCMessageExpr(numSelectorArgs(2)); 2737/// matches the invocation of "loadHTMLString:baseURL:" but not that 2738/// of self.bodyView 2739/// \code 2740/// [self.bodyView loadHTMLString:html baseURL:NULL]; 2741/// \endcode 2742AST_MATCHER_P(ObjCMessageExpr, numSelectorArgs, unsigned, N) { 2743 return Node.getSelector().getNumArgs() == N; 2744} 2745 2746/// \brief Matches if the call expression's callee expression matches. 2747/// 2748/// Given 2749/// \code 2750/// class Y { void x() { this->x(); x(); Y y; y.x(); } }; 2751/// void f() { f(); } 2752/// \endcode 2753/// callExpr(callee(expr())) 2754/// matches this->x(), x(), y.x(), f() 2755/// with callee(...) 2756/// matching this->x, x, y.x, f respectively 2757/// 2758/// Note: Callee cannot take the more general internal::Matcher<Expr> 2759/// because this introduces ambiguous overloads with calls to Callee taking a 2760/// internal::Matcher<Decl>, as the matcher hierarchy is purely 2761/// implemented in terms of implicit casts. 2762AST_MATCHER_P(CallExpr, callee, internal::Matcher<Stmt>, 2763 InnerMatcher) { 2764 const Expr *ExprNode = Node.getCallee(); 2765 return (ExprNode != nullptr && 2766 InnerMatcher.matches(*ExprNode, Finder, Builder)); 2767} 2768 2769/// \brief Matches if the call expression's callee's declaration matches the 2770/// given matcher. 2771/// 2772/// Example matches y.x() (matcher = callExpr(callee( 2773/// cxxMethodDecl(hasName("x"))))) 2774/// \code 2775/// class Y { public: void x(); }; 2776/// void z() { Y y; y.x(); } 2777/// \endcode 2778AST_MATCHER_P_OVERLOAD(CallExpr, callee, internal::Matcher<Decl>, InnerMatcher, 2779 1) { 2780 return callExpr(hasDeclaration(InnerMatcher)).matches(Node, Finder, Builder); 2781} 2782 2783/// \brief Matches if the expression's or declaration's type matches a type 2784/// matcher. 2785/// 2786/// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X"))))) 2787/// and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X"))))) 2788/// and U (matcher = typedefDecl(hasType(asString("int"))) 2789/// \code 2790/// class X {}; 2791/// void y(X &x) { x; X z; } 2792/// typedef int U; 2793/// \endcode 2794AST_POLYMORPHIC_MATCHER_P_OVERLOAD( 2795 hasType, AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, TypedefNameDecl, ValueDecl), 2796 internal::Matcher<QualType>, InnerMatcher, 0) { 2797 return InnerMatcher.matches(internal::getUnderlyingType(Node), 2798 Finder, Builder); 2799} 2800 2801/// \brief Overloaded to match the declaration of the expression's or value 2802/// declaration's type. 2803/// 2804/// In case of a value declaration (for example a variable declaration), 2805/// this resolves one layer of indirection. For example, in the value 2806/// declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of 2807/// X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the 2808/// declaration of x. 2809/// 2810/// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X"))))) 2811/// and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X"))))) 2812/// \code 2813/// class X {}; 2814/// void y(X &x) { x; X z; } 2815/// \endcode 2816/// 2817/// Usable as: Matcher<Expr>, Matcher<ValueDecl> 2818AST_POLYMORPHIC_MATCHER_P_OVERLOAD(hasType, 2819 AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, 2820 ValueDecl), 2821 internal::Matcher<Decl>, InnerMatcher, 1) { 2822 return qualType(hasDeclaration(InnerMatcher)) 2823 .matches(Node.getType(), Finder, Builder); 2824} 2825 2826/// \brief Matches if the type location of the declarator decl's type matches 2827/// the inner matcher. 2828/// 2829/// Given 2830/// \code 2831/// int x; 2832/// \endcode 2833/// declaratorDecl(hasTypeLoc(loc(asString("int")))) 2834/// matches int x 2835AST_MATCHER_P(DeclaratorDecl, hasTypeLoc, internal::Matcher<TypeLoc>, Inner) { 2836 if (!Node.getTypeSourceInfo()) 2837 // This happens for example for implicit destructors. 2838 return false; 2839 return Inner.matches(Node.getTypeSourceInfo()->getTypeLoc(), Finder, Builder); 2840} 2841 2842/// \brief Matches if the matched type is represented by the given string. 2843/// 2844/// Given 2845/// \code 2846/// class Y { public: void x(); }; 2847/// void z() { Y* y; y->x(); } 2848/// \endcode 2849/// cxxMemberCallExpr(on(hasType(asString("class Y *")))) 2850/// matches y->x() 2851AST_MATCHER_P(QualType, asString, std::string, Name) { 2852 return Name == Node.getAsString(); 2853} 2854 2855/// \brief Matches if the matched type is a pointer type and the pointee type 2856/// matches the specified matcher. 2857/// 2858/// Example matches y->x() 2859/// (matcher = cxxMemberCallExpr(on(hasType(pointsTo 2860/// cxxRecordDecl(hasName("Y"))))))) 2861/// \code 2862/// class Y { public: void x(); }; 2863/// void z() { Y *y; y->x(); } 2864/// \endcode 2865AST_MATCHER_P( 2866 QualType, pointsTo, internal::Matcher<QualType>, 2867 InnerMatcher) { 2868 return (!Node.isNull() && Node->isAnyPointerType() && 2869 InnerMatcher.matches(Node->getPointeeType(), Finder, Builder)); 2870} 2871 2872/// \brief Overloaded to match the pointee type's declaration. 2873AST_MATCHER_P_OVERLOAD(QualType, pointsTo, internal::Matcher<Decl>, 2874 InnerMatcher, 1) { 2875 return pointsTo(qualType(hasDeclaration(InnerMatcher))) 2876 .matches(Node, Finder, Builder); 2877} 2878 2879/// \brief Matches if the matched type matches the unqualified desugared 2880/// type of the matched node. 2881/// 2882/// For example, in: 2883/// \code 2884/// class A {}; 2885/// using B = A; 2886/// \endcode 2887/// The matcher type(hasUnqualifeidDesugaredType(recordType())) matches 2888/// both B and A. 2889AST_MATCHER_P(Type, hasUnqualifiedDesugaredType, internal::Matcher<Type>, 2890 InnerMatcher) { 2891 return InnerMatcher.matches(*Node.getUnqualifiedDesugaredType(), Finder, 2892 Builder); 2893} 2894 2895/// \brief Matches if the matched type is a reference type and the referenced 2896/// type matches the specified matcher. 2897/// 2898/// Example matches X &x and const X &y 2899/// (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X")))))) 2900/// \code 2901/// class X { 2902/// void a(X b) { 2903/// X &x = b; 2904/// const X &y = b; 2905/// } 2906/// }; 2907/// \endcode 2908AST_MATCHER_P(QualType, references, internal::Matcher<QualType>, 2909 InnerMatcher) { 2910 return (!Node.isNull() && Node->isReferenceType() && 2911 InnerMatcher.matches(Node->getPointeeType(), Finder, Builder)); 2912} 2913 2914/// \brief Matches QualTypes whose canonical type matches InnerMatcher. 2915/// 2916/// Given: 2917/// \code 2918/// typedef int &int_ref; 2919/// int a; 2920/// int_ref b = a; 2921/// \endcode 2922/// 2923/// \c varDecl(hasType(qualType(referenceType()))))) will not match the 2924/// declaration of b but \c 2925/// varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does. 2926AST_MATCHER_P(QualType, hasCanonicalType, internal::Matcher<QualType>, 2927 InnerMatcher) { 2928 if (Node.isNull()) 2929 return false; 2930 return InnerMatcher.matches(Node.getCanonicalType(), Finder, Builder); 2931} 2932 2933/// \brief Overloaded to match the referenced type's declaration. 2934AST_MATCHER_P_OVERLOAD(QualType, references, internal::Matcher<Decl>, 2935 InnerMatcher, 1) { 2936 return references(qualType(hasDeclaration(InnerMatcher))) 2937 .matches(Node, Finder, Builder); 2938} 2939 2940AST_MATCHER_P(CXXMemberCallExpr, onImplicitObjectArgument, 2941 internal::Matcher<Expr>, InnerMatcher) { 2942 const Expr *ExprNode = Node.getImplicitObjectArgument(); 2943 return (ExprNode != nullptr && 2944 InnerMatcher.matches(*ExprNode, Finder, Builder)); 2945} 2946 2947/// \brief Matches if the expression's type either matches the specified 2948/// matcher, or is a pointer to a type that matches the InnerMatcher. 2949AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType, 2950 internal::Matcher<QualType>, InnerMatcher, 0) { 2951 return onImplicitObjectArgument( 2952 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher)))) 2953 .matches(Node, Finder, Builder); 2954} 2955 2956/// \brief Overloaded to match the type's declaration. 2957AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType, 2958 internal::Matcher<Decl>, InnerMatcher, 1) { 2959 return onImplicitObjectArgument( 2960 anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher)))) 2961 .matches(Node, Finder, Builder); 2962} 2963 2964/// \brief Matches a DeclRefExpr that refers to a declaration that matches the 2965/// specified matcher. 2966/// 2967/// Example matches x in if(x) 2968/// (matcher = declRefExpr(to(varDecl(hasName("x"))))) 2969/// \code 2970/// bool x; 2971/// if (x) {} 2972/// \endcode 2973AST_MATCHER_P(DeclRefExpr, to, internal::Matcher<Decl>, 2974 InnerMatcher) { 2975 const Decl *DeclNode = Node.getDecl(); 2976 return (DeclNode != nullptr && 2977 InnerMatcher.matches(*DeclNode, Finder, Builder)); 2978} 2979 2980/// \brief Matches a \c DeclRefExpr that refers to a declaration through a 2981/// specific using shadow declaration. 2982/// 2983/// Given 2984/// \code 2985/// namespace a { void f() {} } 2986/// using a::f; 2987/// void g() { 2988/// f(); // Matches this .. 2989/// a::f(); // .. but not this. 2990/// } 2991/// \endcode 2992/// declRefExpr(throughUsingDecl(anything())) 2993/// matches \c f() 2994AST_MATCHER_P(DeclRefExpr, throughUsingDecl, 2995 internal::Matcher<UsingShadowDecl>, InnerMatcher) { 2996 const NamedDecl *FoundDecl = Node.getFoundDecl(); 2997 if (const UsingShadowDecl *UsingDecl = dyn_cast<UsingShadowDecl>(FoundDecl)) 2998 return InnerMatcher.matches(*UsingDecl, Finder, Builder); 2999 return false; 3000} 3001 3002/// \brief Matches an \c OverloadExpr if any of the declarations in the set of 3003/// overloads matches the given matcher. 3004/// 3005/// Given 3006/// \code 3007/// template <typename T> void foo(T); 3008/// template <typename T> void bar(T); 3009/// template <typename T> void baz(T t) { 3010/// foo(t); 3011/// bar(t); 3012/// } 3013/// \endcode 3014/// unresolvedLookupExpr(hasAnyDeclaration( 3015/// functionTemplateDecl(hasName("foo")))) 3016/// matches \c foo in \c foo(t); but not \c bar in \c bar(t); 3017AST_MATCHER_P(OverloadExpr, hasAnyDeclaration, internal::Matcher<Decl>, 3018 InnerMatcher) { 3019 return matchesFirstInPointerRange(InnerMatcher, Node.decls_begin(), 3020 Node.decls_end(), Finder, Builder); 3021} 3022 3023/// \brief Matches the Decl of a DeclStmt which has a single declaration. 3024/// 3025/// Given 3026/// \code 3027/// int a, b; 3028/// int c; 3029/// \endcode 3030/// declStmt(hasSingleDecl(anything())) 3031/// matches 'int c;' but not 'int a, b;'. 3032AST_MATCHER_P(DeclStmt, hasSingleDecl, internal::Matcher<Decl>, InnerMatcher) { 3033 if (Node.isSingleDecl()) { 3034 const Decl *FoundDecl = Node.getSingleDecl(); 3035 return InnerMatcher.matches(*FoundDecl, Finder, Builder); 3036 } 3037 return false; 3038} 3039 3040/// \brief Matches a variable declaration that has an initializer expression 3041/// that matches the given matcher. 3042/// 3043/// Example matches x (matcher = varDecl(hasInitializer(callExpr()))) 3044/// \code 3045/// bool y() { return true; } 3046/// bool x = y(); 3047/// \endcode 3048AST_MATCHER_P( 3049 VarDecl, hasInitializer, internal::Matcher<Expr>, 3050 InnerMatcher) { 3051 const Expr *Initializer = Node.getAnyInitializer(); 3052 return (Initializer != nullptr && 3053 InnerMatcher.matches(*Initializer, Finder, Builder)); 3054} 3055 3056/// \brief Matches a variable declaration that has function scope and is a 3057/// non-static local variable. 3058/// 3059/// Example matches x (matcher = varDecl(hasLocalStorage()) 3060/// \code 3061/// void f() { 3062/// int x; 3063/// static int y; 3064/// } 3065/// int z; 3066/// \endcode 3067AST_MATCHER(VarDecl, hasLocalStorage) { 3068 return Node.hasLocalStorage(); 3069} 3070 3071/// \brief Matches a variable declaration that does not have local storage. 3072/// 3073/// Example matches y and z (matcher = varDecl(hasGlobalStorage()) 3074/// \code 3075/// void f() { 3076/// int x; 3077/// static int y; 3078/// } 3079/// int z; 3080/// \endcode 3081AST_MATCHER(VarDecl, hasGlobalStorage) { 3082 return Node.hasGlobalStorage(); 3083} 3084 3085/// \brief Matches a variable declaration that has automatic storage duration. 3086/// 3087/// Example matches x, but not y, z, or a. 3088/// (matcher = varDecl(hasAutomaticStorageDuration()) 3089/// \code 3090/// void f() { 3091/// int x; 3092/// static int y; 3093/// thread_local int z; 3094/// } 3095/// int a; 3096/// \endcode 3097AST_MATCHER(VarDecl, hasAutomaticStorageDuration) { 3098 return Node.getStorageDuration() == SD_Automatic; 3099} 3100 3101/// \brief Matches a variable declaration that has static storage duration. 3102/// It includes the variable declared at namespace scope and those declared 3103/// with "static" and "extern" storage class specifiers. 3104/// 3105/// \code 3106/// void f() { 3107/// int x; 3108/// static int y; 3109/// thread_local int z; 3110/// } 3111/// int a; 3112/// static int b; 3113/// extern int c; 3114/// varDecl(hasStaticStorageDuration()) 3115/// matches the function declaration y, a, b and c. 3116/// \endcode 3117AST_MATCHER(VarDecl, hasStaticStorageDuration) { 3118 return Node.getStorageDuration() == SD_Static; 3119} 3120 3121/// \brief Matches a variable declaration that has thread storage duration. 3122/// 3123/// Example matches z, but not x, z, or a. 3124/// (matcher = varDecl(hasThreadStorageDuration()) 3125/// \code 3126/// void f() { 3127/// int x; 3128/// static int y; 3129/// thread_local int z; 3130/// } 3131/// int a; 3132/// \endcode 3133AST_MATCHER(VarDecl, hasThreadStorageDuration) { 3134 return Node.getStorageDuration() == SD_Thread; 3135} 3136 3137/// \brief Matches a variable declaration that is an exception variable from 3138/// a C++ catch block, or an Objective-C \@catch statement. 3139/// 3140/// Example matches x (matcher = varDecl(isExceptionVariable()) 3141/// \code 3142/// void f(int y) { 3143/// try { 3144/// } catch (int x) { 3145/// } 3146/// } 3147/// \endcode 3148AST_MATCHER(VarDecl, isExceptionVariable) { 3149 return Node.isExceptionVariable(); 3150} 3151 3152/// \brief Checks that a call expression or a constructor call expression has 3153/// a specific number of arguments (including absent default arguments). 3154/// 3155/// Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2))) 3156/// \code 3157/// void f(int x, int y); 3158/// f(0, 0); 3159/// \endcode 3160AST_POLYMORPHIC_MATCHER_P(argumentCountIs, 3161 AST_POLYMORPHIC_SUPPORTED_TYPES(CallExpr, 3162 CXXConstructExpr, 3163 ObjCMessageExpr), 3164 unsigned, N) { 3165 return Node.getNumArgs() == N; 3166} 3167 3168/// \brief Matches the n'th argument of a call expression or a constructor 3169/// call expression. 3170/// 3171/// Example matches y in x(y) 3172/// (matcher = callExpr(hasArgument(0, declRefExpr()))) 3173/// \code 3174/// void x(int) { int y; x(y); } 3175/// \endcode 3176AST_POLYMORPHIC_MATCHER_P2(hasArgument, 3177 AST_POLYMORPHIC_SUPPORTED_TYPES(CallExpr, 3178 CXXConstructExpr, 3179 ObjCMessageExpr), 3180 unsigned, N, internal::Matcher<Expr>, InnerMatcher) { 3181 return (N < Node.getNumArgs() && 3182 InnerMatcher.matches( 3183 *Node.getArg(N)->IgnoreParenImpCasts(), Finder, Builder)); 3184} 3185 3186/// \brief Matches declaration statements that contain a specific number of 3187/// declarations. 3188/// 3189/// Example: Given 3190/// \code 3191/// int a, b; 3192/// int c; 3193/// int d = 2, e; 3194/// \endcode 3195/// declCountIs(2) 3196/// matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'. 3197AST_MATCHER_P(DeclStmt, declCountIs, unsigned, N) { 3198 return std::distance(Node.decl_begin(), Node.decl_end()) == (ptrdiff_t)N; 3199} 3200 3201/// \brief Matches the n'th declaration of a declaration statement. 3202/// 3203/// Note that this does not work for global declarations because the AST 3204/// breaks up multiple-declaration DeclStmt's into multiple single-declaration 3205/// DeclStmt's. 3206/// Example: Given non-global declarations 3207/// \code 3208/// int a, b = 0; 3209/// int c; 3210/// int d = 2, e; 3211/// \endcode 3212/// declStmt(containsDeclaration( 3213/// 0, varDecl(hasInitializer(anything())))) 3214/// matches only 'int d = 2, e;', and 3215/// declStmt(containsDeclaration(1, varDecl())) 3216/// \code 3217/// matches 'int a, b = 0' as well as 'int d = 2, e;' 3218/// but 'int c;' is not matched. 3219/// \endcode 3220AST_MATCHER_P2(DeclStmt, containsDeclaration, unsigned, N, 3221 internal::Matcher<Decl>, InnerMatcher) { 3222 const unsigned NumDecls = std::distance(Node.decl_begin(), Node.decl_end()); 3223 if (N >= NumDecls) 3224 return false; 3225 DeclStmt::const_decl_iterator Iterator = Node.decl_begin(); 3226 std::advance(Iterator, N); 3227 return InnerMatcher.matches(**Iterator, Finder, Builder); 3228} 3229 3230/// \brief Matches a C++ catch statement that has a catch-all handler. 3231/// 3232/// Given 3233/// \code 3234/// try { 3235/// // ... 3236/// } catch (int) { 3237/// // ... 3238/// } catch (...) { 3239/// // ... 3240/// } 3241/// /endcode 3242/// cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int). 3243AST_MATCHER(CXXCatchStmt, isCatchAll) { 3244 return Node.getExceptionDecl() == nullptr; 3245} 3246 3247/// \brief Matches a constructor initializer. 3248/// 3249/// Given 3250/// \code 3251/// struct Foo { 3252/// Foo() : foo_(1) { } 3253/// int foo_; 3254/// }; 3255/// \endcode 3256/// cxxRecordDecl(has(cxxConstructorDecl( 3257/// hasAnyConstructorInitializer(anything()) 3258/// ))) 3259/// record matches Foo, hasAnyConstructorInitializer matches foo_(1) 3260AST_MATCHER_P(CXXConstructorDecl, hasAnyConstructorInitializer, 3261 internal::Matcher<CXXCtorInitializer>, InnerMatcher) { 3262 return matchesFirstInPointerRange(InnerMatcher, Node.init_begin(), 3263 Node.init_end(), Finder, Builder); 3264} 3265 3266/// \brief Matches the field declaration of a constructor initializer. 3267/// 3268/// Given 3269/// \code 3270/// struct Foo { 3271/// Foo() : foo_(1) { } 3272/// int foo_; 3273/// }; 3274/// \endcode 3275/// cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer( 3276/// forField(hasName("foo_")))))) 3277/// matches Foo 3278/// with forField matching foo_ 3279AST_MATCHER_P(CXXCtorInitializer, forField, 3280 internal::Matcher<FieldDecl>, InnerMatcher) { 3281 const FieldDecl *NodeAsDecl = Node.getAnyMember(); 3282 return (NodeAsDecl != nullptr && 3283 InnerMatcher.matches(*NodeAsDecl, Finder, Builder)); 3284} 3285 3286/// \brief Matches the initializer expression of a constructor initializer. 3287/// 3288/// Given 3289/// \code 3290/// struct Foo { 3291/// Foo() : foo_(1) { } 3292/// int foo_; 3293/// }; 3294/// \endcode 3295/// cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer( 3296/// withInitializer(integerLiteral(equals(1))))))) 3297/// matches Foo 3298/// with withInitializer matching (1) 3299AST_MATCHER_P(CXXCtorInitializer, withInitializer, 3300 internal::Matcher<Expr>, InnerMatcher) { 3301 const Expr* NodeAsExpr = Node.getInit(); 3302 return (NodeAsExpr != nullptr && 3303 InnerMatcher.matches(*NodeAsExpr, Finder, Builder)); 3304} 3305 3306/// \brief Matches a constructor initializer if it is explicitly written in 3307/// code (as opposed to implicitly added by the compiler). 3308/// 3309/// Given 3310/// \code 3311/// struct Foo { 3312/// Foo() { } 3313/// Foo(int) : foo_("A") { } 3314/// string foo_; 3315/// }; 3316/// \endcode 3317/// cxxConstructorDecl(hasAnyConstructorInitializer(isWritten())) 3318/// will match Foo(int), but not Foo() 3319AST_MATCHER(CXXCtorInitializer, isWritten) { 3320 return Node.isWritten(); 3321} 3322 3323/// \brief Matches a constructor initializer if it is initializing a base, as 3324/// opposed to a member. 3325/// 3326/// Given 3327/// \code 3328/// struct B {}; 3329/// struct D : B { 3330/// int I; 3331/// D(int i) : I(i) {} 3332/// }; 3333/// struct E : B { 3334/// E() : B() {} 3335/// }; 3336/// \endcode 3337/// cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer())) 3338/// will match E(), but not match D(int). 3339AST_MATCHER(CXXCtorInitializer, isBaseInitializer) { 3340 return Node.isBaseInitializer(); 3341} 3342 3343/// \brief Matches a constructor initializer if it is initializing a member, as 3344/// opposed to a base. 3345/// 3346/// Given 3347/// \code 3348/// struct B {}; 3349/// struct D : B { 3350/// int I; 3351/// D(int i) : I(i) {} 3352/// }; 3353/// struct E : B { 3354/// E() : B() {} 3355/// }; 3356/// \endcode 3357/// cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer())) 3358/// will match D(int), but not match E(). 3359AST_MATCHER(CXXCtorInitializer, isMemberInitializer) { 3360 return Node.isMemberInitializer(); 3361} 3362 3363/// \brief Matches any argument of a call expression or a constructor call 3364/// expression. 3365/// 3366/// Given 3367/// \code 3368/// void x(int, int, int) { int y; x(1, y, 42); } 3369/// \endcode 3370/// callExpr(hasAnyArgument(declRefExpr())) 3371/// matches x(1, y, 42) 3372/// with hasAnyArgument(...) 3373/// matching y 3374AST_POLYMORPHIC_MATCHER_P(hasAnyArgument, 3375 AST_POLYMORPHIC_SUPPORTED_TYPES(CallExpr, 3376 CXXConstructExpr), 3377 internal::Matcher<Expr>, InnerMatcher) { 3378 for (const Expr *Arg : Node.arguments()) { 3379 BoundNodesTreeBuilder Result(*Builder); 3380 if (InnerMatcher.matches(*Arg, Finder, &Result)) { 3381 *Builder = std::move(Result); 3382 return true; 3383 } 3384 } 3385 return false; 3386} 3387 3388/// \brief Matches a constructor call expression which uses list initialization. 3389AST_MATCHER(CXXConstructExpr, isListInitialization) { 3390 return Node.isListInitialization(); 3391} 3392 3393/// \brief Matches a constructor call expression which requires 3394/// zero initialization. 3395/// 3396/// Given 3397/// \code 3398/// void foo() { 3399/// struct point { double x; double y; }; 3400/// point pt[2] = { { 1.0, 2.0 } }; 3401/// } 3402/// \endcode 3403/// initListExpr(has(cxxConstructExpr(requiresZeroInitialization())) 3404/// will match the implicit array filler for pt[1]. 3405AST_MATCHER(CXXConstructExpr, requiresZeroInitialization) { 3406 return Node.requiresZeroInitialization(); 3407} 3408 3409/// \brief Matches the n'th parameter of a function declaration. 3410/// 3411/// Given 3412/// \code 3413/// class X { void f(int x) {} }; 3414/// \endcode 3415/// cxxMethodDecl(hasParameter(0, hasType(varDecl()))) 3416/// matches f(int x) {} 3417/// with hasParameter(...) 3418/// matching int x 3419AST_MATCHER_P2(FunctionDecl, hasParameter, 3420 unsigned, N, internal::Matcher<ParmVarDecl>, 3421 InnerMatcher) { 3422 return (N < Node.getNumParams() && 3423 InnerMatcher.matches( 3424 *Node.getParamDecl(N), Finder, Builder)); 3425} 3426 3427/// \brief Matches all arguments and their respective ParmVarDecl. 3428/// 3429/// Given 3430/// \code 3431/// void f(int i); 3432/// int y; 3433/// f(y); 3434/// \endcode 3435/// callExpr( 3436/// forEachArgumentWithParam( 3437/// declRefExpr(to(varDecl(hasName("y")))), 3438/// parmVarDecl(hasType(isInteger())) 3439/// )) 3440/// matches f(y); 3441/// with declRefExpr(...) 3442/// matching int y 3443/// and parmVarDecl(...) 3444/// matching int i 3445AST_POLYMORPHIC_MATCHER_P2(forEachArgumentWithParam, 3446 AST_POLYMORPHIC_SUPPORTED_TYPES(CallExpr, 3447 CXXConstructExpr), 3448 internal::Matcher<Expr>, ArgMatcher, 3449 internal::Matcher<ParmVarDecl>, ParamMatcher) { 3450 BoundNodesTreeBuilder Result; 3451 // The first argument of an overloaded member operator is the implicit object 3452 // argument of the method which should not be matched against a parameter, so 3453 // we skip over it here. 3454 BoundNodesTreeBuilder Matches; 3455 unsigned ArgIndex = cxxOperatorCallExpr(callee(cxxMethodDecl())) 3456 .matches(Node, Finder, &Matches) 3457 ? 1 3458 : 0; 3459 int ParamIndex = 0; 3460 bool Matched = false; 3461 for (; ArgIndex < Node.getNumArgs(); ++ArgIndex) { 3462 BoundNodesTreeBuilder ArgMatches(*Builder); 3463 if (ArgMatcher.matches(*(Node.getArg(ArgIndex)->IgnoreParenCasts()), 3464 Finder, &ArgMatches)) { 3465 BoundNodesTreeBuilder ParamMatches(ArgMatches); 3466 if (expr(anyOf(cxxConstructExpr(hasDeclaration(cxxConstructorDecl( 3467 hasParameter(ParamIndex, ParamMatcher)))), 3468 callExpr(callee(functionDecl( 3469 hasParameter(ParamIndex, ParamMatcher)))))) 3470 .matches(Node, Finder, &ParamMatches)) { 3471 Result.addMatch(ParamMatches); 3472 Matched = true; 3473 } 3474 } 3475 ++ParamIndex; 3476 } 3477 *Builder = std::move(Result); 3478 return Matched; 3479} 3480 3481/// \brief Matches any parameter of a function declaration. 3482/// 3483/// Does not match the 'this' parameter of a method. 3484/// 3485/// Given 3486/// \code 3487/// class X { void f(int x, int y, int z) {} }; 3488/// \endcode 3489/// cxxMethodDecl(hasAnyParameter(hasName("y"))) 3490/// matches f(int x, int y, int z) {} 3491/// with hasAnyParameter(...) 3492/// matching int y 3493AST_MATCHER_P(FunctionDecl, hasAnyParameter, 3494 internal::Matcher<ParmVarDecl>, InnerMatcher) { 3495 return matchesFirstInPointerRange(InnerMatcher, Node.param_begin(), 3496 Node.param_end(), Finder, Builder); 3497} 3498 3499/// \brief Matches \c FunctionDecls and \c FunctionProtoTypes that have a 3500/// specific parameter count. 3501/// 3502/// Given 3503/// \code 3504/// void f(int i) {} 3505/// void g(int i, int j) {} 3506/// void h(int i, int j); 3507/// void j(int i); 3508/// void k(int x, int y, int z, ...); 3509/// \endcode 3510/// functionDecl(parameterCountIs(2)) 3511/// matches void g(int i, int j) {} 3512/// functionProtoType(parameterCountIs(2)) 3513/// matches void h(int i, int j) 3514/// functionProtoType(parameterCountIs(3)) 3515/// matches void k(int x, int y, int z, ...); 3516AST_POLYMORPHIC_MATCHER_P(parameterCountIs, 3517 AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, 3518 FunctionProtoType), 3519 unsigned, N) { 3520 return Node.getNumParams() == N; 3521} 3522 3523/// \brief Matches the return type of a function declaration. 3524/// 3525/// Given: 3526/// \code 3527/// class X { int f() { return 1; } }; 3528/// \endcode 3529/// cxxMethodDecl(returns(asString("int"))) 3530/// matches int f() { return 1; } 3531AST_MATCHER_P(FunctionDecl, returns, 3532 internal::Matcher<QualType>, InnerMatcher) { 3533 return InnerMatcher.matches(Node.getReturnType(), Finder, Builder); 3534} 3535 3536/// \brief Matches extern "C" function or variable declarations. 3537/// 3538/// Given: 3539/// \code 3540/// extern "C" void f() {} 3541/// extern "C" { void g() {} } 3542/// void h() {} 3543/// extern "C" int x = 1; 3544/// extern "C" int y = 2; 3545/// int z = 3; 3546/// \endcode 3547/// functionDecl(isExternC()) 3548/// matches the declaration of f and g, but not the declaration of h. 3549/// varDecl(isExternC()) 3550/// matches the declaration of x and y, but not the declaration of z. 3551AST_POLYMORPHIC_MATCHER(isExternC, AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, 3552 VarDecl)) { 3553 return Node.isExternC(); 3554} 3555 3556/// \brief Matches variable/function declarations that have "static" storage 3557/// class specifier ("static" keyword) written in the source. 3558/// 3559/// Given: 3560/// \code 3561/// static void f() {} 3562/// static int i = 0; 3563/// extern int j; 3564/// int k; 3565/// \endcode 3566/// functionDecl(isStaticStorageClass()) 3567/// matches the function declaration f. 3568/// varDecl(isStaticStorageClass()) 3569/// matches the variable declaration i. 3570AST_POLYMORPHIC_MATCHER(isStaticStorageClass, 3571 AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, 3572 VarDecl)) { 3573 return Node.getStorageClass() == SC_Static; 3574} 3575 3576/// \brief Matches deleted function declarations. 3577/// 3578/// Given: 3579/// \code 3580/// void Func(); 3581/// void DeletedFunc() = delete; 3582/// \endcode 3583/// functionDecl(isDeleted()) 3584/// matches the declaration of DeletedFunc, but not Func. 3585AST_MATCHER(FunctionDecl, isDeleted) { 3586 return Node.isDeleted(); 3587} 3588 3589/// \brief Matches defaulted function declarations. 3590/// 3591/// Given: 3592/// \code 3593/// class A { ~A(); }; 3594/// class B { ~B() = default; }; 3595/// \endcode 3596/// functionDecl(isDefaulted()) 3597/// matches the declaration of ~B, but not ~A. 3598AST_MATCHER(FunctionDecl, isDefaulted) { 3599 return Node.isDefaulted(); 3600} 3601 3602/// \brief Matches functions that have a dynamic exception specification. 3603/// 3604/// Given: 3605/// \code 3606/// void f(); 3607/// void g() noexcept; 3608/// void h() noexcept(true); 3609/// void i() noexcept(false); 3610/// void j() throw(); 3611/// void k() throw(int); 3612/// void l() throw(...); 3613/// \endcode 3614/// functionDecl(hasDynamicExceptionSpec()) and 3615/// functionProtoType(hasDynamicExceptionSpec()) 3616/// match the declarations of j, k, and l, but not f, g, h, or i. 3617AST_POLYMORPHIC_MATCHER(hasDynamicExceptionSpec, 3618 AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, 3619 FunctionProtoType)) { 3620 if (const FunctionProtoType *FnTy = internal::getFunctionProtoType(Node)) 3621 return FnTy->hasDynamicExceptionSpec(); 3622 return false; 3623} 3624 3625/// \brief Matches functions that have a non-throwing exception specification. 3626/// 3627/// Given: 3628/// \code 3629/// void f(); 3630/// void g() noexcept; 3631/// void h() throw(); 3632/// void i() throw(int); 3633/// void j() noexcept(false); 3634/// \endcode 3635/// functionDecl(isNoThrow()) and functionProtoType(isNoThrow()) 3636/// match the declarations of g, and h, but not f, i or j. 3637AST_POLYMORPHIC_MATCHER(isNoThrow, 3638 AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, 3639 FunctionProtoType)) { 3640 const FunctionProtoType *FnTy = internal::getFunctionProtoType(Node); 3641 3642 // If the function does not have a prototype, then it is assumed to be a 3643 // throwing function (as it would if the function did not have any exception 3644 // specification). 3645 if (!FnTy) 3646 return false; 3647 3648 // Assume the best for any unresolved exception specification. 3649 if (isUnresolvedExceptionSpec(FnTy->getExceptionSpecType())) 3650 return true; 3651 3652 return FnTy->isNothrow(Finder->getASTContext()); 3653} 3654 3655/// \brief Matches constexpr variable and function declarations. 3656/// 3657/// Given: 3658/// \code 3659/// constexpr int foo = 42; 3660/// constexpr int bar(); 3661/// \endcode 3662/// varDecl(isConstexpr()) 3663/// matches the declaration of foo. 3664/// functionDecl(isConstexpr()) 3665/// matches the declaration of bar. 3666AST_POLYMORPHIC_MATCHER(isConstexpr, 3667 AST_POLYMORPHIC_SUPPORTED_TYPES(VarDecl, 3668 FunctionDecl)) { 3669 return Node.isConstexpr(); 3670} 3671 3672/// \brief Matches the condition expression of an if statement, for loop, 3673/// switch statement or conditional operator. 3674/// 3675/// Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true)))) 3676/// \code 3677/// if (true) {} 3678/// \endcode 3679AST_POLYMORPHIC_MATCHER_P( 3680 hasCondition, 3681 AST_POLYMORPHIC_SUPPORTED_TYPES(IfStmt, ForStmt, WhileStmt, DoStmt, 3682 SwitchStmt, AbstractConditionalOperator), 3683 internal::Matcher<Expr>, InnerMatcher) { 3684 const Expr *const Condition = Node.getCond(); 3685 return (Condition != nullptr && 3686 InnerMatcher.matches(*Condition, Finder, Builder)); 3687} 3688 3689/// \brief Matches the then-statement of an if statement. 3690/// 3691/// Examples matches the if statement 3692/// (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true))))) 3693/// \code 3694/// if (false) true; else false; 3695/// \endcode 3696AST_MATCHER_P(IfStmt, hasThen, internal::Matcher<Stmt>, InnerMatcher) { 3697 const Stmt *const Then = Node.getThen(); 3698 return (Then != nullptr && InnerMatcher.matches(*Then, Finder, Builder)); 3699} 3700 3701/// \brief Matches the else-statement of an if statement. 3702/// 3703/// Examples matches the if statement 3704/// (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true))))) 3705/// \code 3706/// if (false) false; else true; 3707/// \endcode 3708AST_MATCHER_P(IfStmt, hasElse, internal::Matcher<Stmt>, InnerMatcher) { 3709 const Stmt *const Else = Node.getElse(); 3710 return (Else != nullptr && InnerMatcher.matches(*Else, Finder, Builder)); 3711} 3712 3713/// \brief Matches if a node equals a previously bound node. 3714/// 3715/// Matches a node if it equals the node previously bound to \p ID. 3716/// 3717/// Given 3718/// \code 3719/// class X { int a; int b; }; 3720/// \endcode 3721/// cxxRecordDecl( 3722/// has(fieldDecl(hasName("a"), hasType(type().bind("t")))), 3723/// has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t")))))) 3724/// matches the class \c X, as \c a and \c b have the same type. 3725/// 3726/// Note that when multiple matches are involved via \c forEach* matchers, 3727/// \c equalsBoundNodes acts as a filter. 3728/// For example: 3729/// compoundStmt( 3730/// forEachDescendant(varDecl().bind("d")), 3731/// forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d")))))) 3732/// will trigger a match for each combination of variable declaration 3733/// and reference to that variable declaration within a compound statement. 3734AST_POLYMORPHIC_MATCHER_P(equalsBoundNode, 3735 AST_POLYMORPHIC_SUPPORTED_TYPES(Stmt, Decl, Type, 3736 QualType), 3737 std::string, ID) { 3738 // FIXME: Figure out whether it makes sense to allow this 3739 // on any other node types. 3740 // For *Loc it probably does not make sense, as those seem 3741 // unique. For NestedNameSepcifier it might make sense, as 3742 // those also have pointer identity, but I'm not sure whether 3743 // they're ever reused. 3744 internal::NotEqualsBoundNodePredicate Predicate; 3745 Predicate.ID = ID; 3746 Predicate.Node = ast_type_traits::DynTypedNode::create(Node); 3747 return Builder->removeBindings(Predicate); 3748} 3749 3750/// \brief Matches the condition variable statement in an if statement. 3751/// 3752/// Given 3753/// \code 3754/// if (A* a = GetAPointer()) {} 3755/// \endcode 3756/// hasConditionVariableStatement(...) 3757/// matches 'A* a = GetAPointer()'. 3758AST_MATCHER_P(IfStmt, hasConditionVariableStatement, 3759 internal::Matcher<DeclStmt>, InnerMatcher) { 3760 const DeclStmt* const DeclarationStatement = 3761 Node.getConditionVariableDeclStmt(); 3762 return DeclarationStatement != nullptr && 3763 InnerMatcher.matches(*DeclarationStatement, Finder, Builder); 3764} 3765 3766/// \brief Matches the index expression of an array subscript expression. 3767/// 3768/// Given 3769/// \code 3770/// int i[5]; 3771/// void f() { i[1] = 42; } 3772/// \endcode 3773/// arraySubscriptExpression(hasIndex(integerLiteral())) 3774/// matches \c i[1] with the \c integerLiteral() matching \c 1 3775AST_MATCHER_P(ArraySubscriptExpr, hasIndex, 3776 internal::Matcher<Expr>, InnerMatcher) { 3777 if (const Expr* Expression = Node.getIdx()) 3778 return InnerMatcher.matches(*Expression, Finder, Builder); 3779 return false; 3780} 3781 3782/// \brief Matches the base expression of an array subscript expression. 3783/// 3784/// Given 3785/// \code 3786/// int i[5]; 3787/// void f() { i[1] = 42; } 3788/// \endcode 3789/// arraySubscriptExpression(hasBase(implicitCastExpr( 3790/// hasSourceExpression(declRefExpr())))) 3791/// matches \c i[1] with the \c declRefExpr() matching \c i 3792AST_MATCHER_P(ArraySubscriptExpr, hasBase, 3793 internal::Matcher<Expr>, InnerMatcher) { 3794 if (const Expr* Expression = Node.getBase()) 3795 return InnerMatcher.matches(*Expression, Finder, Builder); 3796 return false; 3797} 3798 3799/// \brief Matches a 'for', 'while', 'do while' statement or a function 3800/// definition that has a given body. 3801/// 3802/// Given 3803/// \code 3804/// for (;;) {} 3805/// \endcode 3806/// hasBody(compoundStmt()) 3807/// matches 'for (;;) {}' 3808/// with compoundStmt() 3809/// matching '{}' 3810AST_POLYMORPHIC_MATCHER_P(hasBody, 3811 AST_POLYMORPHIC_SUPPORTED_TYPES(DoStmt, ForStmt, 3812 WhileStmt, 3813 CXXForRangeStmt, 3814 FunctionDecl), 3815 internal::Matcher<Stmt>, InnerMatcher) { 3816 const Stmt *const Statement = internal::GetBodyMatcher<NodeType>::get(Node); 3817 return (Statement != nullptr && 3818 InnerMatcher.matches(*Statement, Finder, Builder)); 3819} 3820 3821/// \brief Matches compound statements where at least one substatement matches 3822/// a given matcher. Also matches StmtExprs that have CompoundStmt as children. 3823/// 3824/// Given 3825/// \code 3826/// { {}; 1+2; } 3827/// \endcode 3828/// hasAnySubstatement(compoundStmt()) 3829/// matches '{ {}; 1+2; }' 3830/// with compoundStmt() 3831/// matching '{}' 3832AST_POLYMORPHIC_MATCHER_P(hasAnySubstatement, 3833 AST_POLYMORPHIC_SUPPORTED_TYPES(CompoundStmt, 3834 StmtExpr), 3835 internal::Matcher<Stmt>, InnerMatcher) { 3836 const CompoundStmt *CS = CompoundStmtMatcher<NodeType>::get(Node); 3837 return CS && matchesFirstInPointerRange(InnerMatcher, CS->body_begin(), 3838 CS->body_end(), Finder, Builder); 3839} 3840 3841/// \brief Checks that a compound statement contains a specific number of 3842/// child statements. 3843/// 3844/// Example: Given 3845/// \code 3846/// { for (;;) {} } 3847/// \endcode 3848/// compoundStmt(statementCountIs(0))) 3849/// matches '{}' 3850/// but does not match the outer compound statement. 3851AST_MATCHER_P(CompoundStmt, statementCountIs, unsigned, N) { 3852 return Node.size() == N; 3853} 3854 3855/// \brief Matches literals that are equal to the given value of type ValueT. 3856/// 3857/// Given 3858/// \code 3859/// f('\0', false, 3.14, 42); 3860/// \endcode 3861/// characterLiteral(equals(0)) 3862/// matches '\0' 3863/// cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0)) 3864/// match false 3865/// floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2)) 3866/// match 3.14 3867/// integerLiteral(equals(42)) 3868/// matches 42 3869/// 3870/// Note that you cannot directly match a negative numeric literal because the 3871/// minus sign is not part of the literal: It is a unary operator whose operand 3872/// is the positive numeric literal. Instead, you must use a unaryOperator() 3873/// matcher to match the minus sign: 3874/// 3875/// unaryOperator(hasOperatorName("-"), 3876/// hasUnaryOperand(integerLiteral(equals(13)))) 3877/// 3878/// Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteralExpr>, 3879/// Matcher<FloatingLiteral>, Matcher<IntegerLiteral> 3880template <typename ValueT> 3881internal::PolymorphicMatcherWithParam1<internal::ValueEqualsMatcher, ValueT> 3882equals(const ValueT &Value) { 3883 return internal::PolymorphicMatcherWithParam1< 3884 internal::ValueEqualsMatcher, 3885 ValueT>(Value); 3886} 3887 3888AST_POLYMORPHIC_MATCHER_P_OVERLOAD(equals, 3889 AST_POLYMORPHIC_SUPPORTED_TYPES(CharacterLiteral, 3890 CXXBoolLiteralExpr, 3891 IntegerLiteral), 3892 bool, Value, 0) { 3893 return internal::ValueEqualsMatcher<NodeType, ParamT>(Value) 3894 .matchesNode(Node); 3895} 3896 3897AST_POLYMORPHIC_MATCHER_P_OVERLOAD(equals, 3898 AST_POLYMORPHIC_SUPPORTED_TYPES(CharacterLiteral, 3899 CXXBoolLiteralExpr, 3900 IntegerLiteral), 3901 unsigned, Value, 1) { 3902 return internal::ValueEqualsMatcher<NodeType, ParamT>(Value) 3903 .matchesNode(Node); 3904} 3905 3906AST_POLYMORPHIC_MATCHER_P_OVERLOAD(equals, 3907 AST_POLYMORPHIC_SUPPORTED_TYPES(CharacterLiteral, 3908 CXXBoolLiteralExpr, 3909 FloatingLiteral, 3910 IntegerLiteral), 3911 double, Value, 2) { 3912 return internal::ValueEqualsMatcher<NodeType, ParamT>(Value) 3913 .matchesNode(Node); 3914} 3915 3916/// \brief Matches the operator Name of operator expressions (binary or 3917/// unary). 3918/// 3919/// Example matches a || b (matcher = binaryOperator(hasOperatorName("||"))) 3920/// \code 3921/// !(a || b) 3922/// \endcode 3923AST_POLYMORPHIC_MATCHER_P(hasOperatorName, 3924 AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, 3925 UnaryOperator), 3926 std::string, Name) { 3927 return Name == Node.getOpcodeStr(Node.getOpcode()); 3928} 3929 3930/// \brief Matches the left hand side of binary operator expressions. 3931/// 3932/// Example matches a (matcher = binaryOperator(hasLHS())) 3933/// \code 3934/// a || b 3935/// \endcode 3936AST_POLYMORPHIC_MATCHER_P(hasLHS, 3937 AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, 3938 ArraySubscriptExpr), 3939 internal::Matcher<Expr>, InnerMatcher) { 3940 const Expr *LeftHandSide = Node.getLHS(); 3941 return (LeftHandSide != nullptr && 3942 InnerMatcher.matches(*LeftHandSide, Finder, Builder)); 3943} 3944 3945/// \brief Matches the right hand side of binary operator expressions. 3946/// 3947/// Example matches b (matcher = binaryOperator(hasRHS())) 3948/// \code 3949/// a || b 3950/// \endcode 3951AST_POLYMORPHIC_MATCHER_P(hasRHS, 3952 AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, 3953 ArraySubscriptExpr), 3954 internal::Matcher<Expr>, InnerMatcher) { 3955 const Expr *RightHandSide = Node.getRHS(); 3956 return (RightHandSide != nullptr && 3957 InnerMatcher.matches(*RightHandSide, Finder, Builder)); 3958} 3959 3960/// \brief Matches if either the left hand side or the right hand side of a 3961/// binary operator matches. 3962inline internal::Matcher<BinaryOperator> hasEitherOperand( 3963 const internal::Matcher<Expr> &InnerMatcher) { 3964 return anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher)); 3965} 3966 3967/// \brief Matches if the operand of a unary operator matches. 3968/// 3969/// Example matches true (matcher = hasUnaryOperand( 3970/// cxxBoolLiteral(equals(true)))) 3971/// \code 3972/// !true 3973/// \endcode 3974AST_MATCHER_P(UnaryOperator, hasUnaryOperand, 3975 internal::Matcher<Expr>, InnerMatcher) { 3976 const Expr * const Operand = Node.getSubExpr(); 3977 return (Operand != nullptr && 3978 InnerMatcher.matches(*Operand, Finder, Builder)); 3979} 3980 3981/// \brief Matches if the cast's source expression 3982/// or opaque value's source expression matches the given matcher. 3983/// 3984/// Example 1: matches "a string" 3985/// (matcher = castExpr(hasSourceExpression(cxxConstructExpr()))) 3986/// \code 3987/// class URL { URL(string); }; 3988/// URL url = "a string"; 3989/// \endcode 3990/// 3991/// Example 2: matches 'b' (matcher = 3992/// opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr()))) 3993/// \code 3994/// int a = b ?: 1; 3995/// \endcode 3996 3997AST_POLYMORPHIC_MATCHER_P(hasSourceExpression, 3998 AST_POLYMORPHIC_SUPPORTED_TYPES(CastExpr, 3999 OpaqueValueExpr), 4000 internal::Matcher<Expr>, InnerMatcher) { 4001 const Expr *const SubExpression = 4002 internal::GetSourceExpressionMatcher<NodeType>::get(Node); 4003 return (SubExpression != nullptr && 4004 InnerMatcher.matches(*SubExpression, Finder, Builder)); 4005} 4006 4007/// \brief Matches casts that has a given cast kind. 4008/// 4009/// Example: matches the implicit cast around \c 0 4010/// (matcher = castExpr(hasCastKind(CK_NullToPointer))) 4011/// \code 4012/// int *p = 0; 4013/// \endcode 4014AST_MATCHER_P(CastExpr, hasCastKind, CastKind, Kind) { 4015 return Node.getCastKind() == Kind; 4016} 4017 4018/// \brief Matches casts whose destination type matches a given matcher. 4019/// 4020/// (Note: Clang's AST refers to other conversions as "casts" too, and calls 4021/// actual casts "explicit" casts.) 4022AST_MATCHER_P(ExplicitCastExpr, hasDestinationType, 4023 internal::Matcher<QualType>, InnerMatcher) { 4024 const QualType NodeType = Node.getTypeAsWritten(); 4025 return InnerMatcher.matches(NodeType, Finder, Builder); 4026} 4027 4028/// \brief Matches implicit casts whose destination type matches a given 4029/// matcher. 4030/// 4031/// FIXME: Unit test this matcher 4032AST_MATCHER_P(ImplicitCastExpr, hasImplicitDestinationType, 4033 internal::Matcher<QualType>, InnerMatcher) { 4034 return InnerMatcher.matches(Node.getType(), Finder, Builder); 4035} 4036 4037/// \brief Matches RecordDecl object that are spelled with "struct." 4038/// 4039/// Example matches S, but not C or U. 4040/// \code 4041/// struct S {}; 4042/// class C {}; 4043/// union U {}; 4044/// \endcode 4045AST_MATCHER(RecordDecl, isStruct) { 4046 return Node.isStruct(); 4047} 4048 4049/// \brief Matches RecordDecl object that are spelled with "union." 4050/// 4051/// Example matches U, but not C or S. 4052/// \code 4053/// struct S {}; 4054/// class C {}; 4055/// union U {}; 4056/// \endcode 4057AST_MATCHER(RecordDecl, isUnion) { 4058 return Node.isUnion(); 4059} 4060 4061/// \brief Matches RecordDecl object that are spelled with "class." 4062/// 4063/// Example matches C, but not S or U. 4064/// \code 4065/// struct S {}; 4066/// class C {}; 4067/// union U {}; 4068/// \endcode 4069AST_MATCHER(RecordDecl, isClass) { 4070 return Node.isClass(); 4071} 4072 4073/// \brief Matches the true branch expression of a conditional operator. 4074/// 4075/// Example 1 (conditional ternary operator): matches a 4076/// \code 4077/// condition ? a : b 4078/// \endcode 4079/// 4080/// Example 2 (conditional binary operator): matches opaqueValueExpr(condition) 4081/// \code 4082/// condition ?: b 4083/// \endcode 4084AST_MATCHER_P(AbstractConditionalOperator, hasTrueExpression, 4085 internal::Matcher<Expr>, InnerMatcher) { 4086 const Expr *Expression = Node.getTrueExpr(); 4087 return (Expression != nullptr && 4088 InnerMatcher.matches(*Expression, Finder, Builder)); 4089} 4090 4091/// \brief Matches the false branch expression of a conditional operator 4092/// (binary or ternary). 4093/// 4094/// Example matches b 4095/// \code 4096/// condition ? a : b 4097/// condition ?: b 4098/// \endcode 4099AST_MATCHER_P(AbstractConditionalOperator, hasFalseExpression, 4100 internal::Matcher<Expr>, InnerMatcher) { 4101 const Expr *Expression = Node.getFalseExpr(); 4102 return (Expression != nullptr && 4103 InnerMatcher.matches(*Expression, Finder, Builder)); 4104} 4105 4106/// \brief Matches if a declaration has a body attached. 4107/// 4108/// Example matches A, va, fa 4109/// \code 4110/// class A {}; 4111/// class B; // Doesn't match, as it has no body. 4112/// int va; 4113/// extern int vb; // Doesn't match, as it doesn't define the variable. 4114/// void fa() {} 4115/// void fb(); // Doesn't match, as it has no body. 4116/// \endcode 4117/// 4118/// Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl> 4119AST_POLYMORPHIC_MATCHER(isDefinition, 4120 AST_POLYMORPHIC_SUPPORTED_TYPES(TagDecl, VarDecl, 4121 FunctionDecl)) { 4122 return Node.isThisDeclarationADefinition(); 4123} 4124 4125/// \brief Matches if a function declaration is variadic. 4126/// 4127/// Example matches f, but not g or h. The function i will not match, even when 4128/// compiled in C mode. 4129/// \code 4130/// void f(...); 4131/// void g(int); 4132/// template <typename... Ts> void h(Ts...); 4133/// void i(); 4134/// \endcode 4135AST_MATCHER(FunctionDecl, isVariadic) { 4136 return Node.isVariadic(); 4137} 4138 4139/// \brief Matches the class declaration that the given method declaration 4140/// belongs to. 4141/// 4142/// FIXME: Generalize this for other kinds of declarations. 4143/// FIXME: What other kind of declarations would we need to generalize 4144/// this to? 4145/// 4146/// Example matches A() in the last line 4147/// (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl( 4148/// ofClass(hasName("A")))))) 4149/// \code 4150/// class A { 4151/// public: 4152/// A(); 4153/// }; 4154/// A a = A(); 4155/// \endcode 4156AST_MATCHER_P(CXXMethodDecl, ofClass, 4157 internal::Matcher<CXXRecordDecl>, InnerMatcher) { 4158 const CXXRecordDecl *Parent = Node.getParent(); 4159 return (Parent != nullptr && 4160 InnerMatcher.matches(*Parent, Finder, Builder)); 4161} 4162 4163/// \brief Matches each method overriden by the given method. This matcher may 4164/// produce multiple matches. 4165/// 4166/// Given 4167/// \code 4168/// class A { virtual void f(); }; 4169/// class B : public A { void f(); }; 4170/// class C : public B { void f(); }; 4171/// \endcode 4172/// cxxMethodDecl(ofClass(hasName("C")), 4173/// forEachOverridden(cxxMethodDecl().bind("b"))).bind("d") 4174/// matches once, with "b" binding "A::f" and "d" binding "C::f" (Note 4175/// that B::f is not overridden by C::f). 4176/// 4177/// The check can produce multiple matches in case of multiple inheritance, e.g. 4178/// \code 4179/// class A1 { virtual void f(); }; 4180/// class A2 { virtual void f(); }; 4181/// class C : public A1, public A2 { void f(); }; 4182/// \endcode 4183/// cxxMethodDecl(ofClass(hasName("C")), 4184/// forEachOverridden(cxxMethodDecl().bind("b"))).bind("d") 4185/// matches twice, once with "b" binding "A1::f" and "d" binding "C::f", and 4186/// once with "b" binding "A2::f" and "d" binding "C::f". 4187AST_MATCHER_P(CXXMethodDecl, forEachOverridden, 4188 internal::Matcher<CXXMethodDecl>, InnerMatcher) { 4189 BoundNodesTreeBuilder Result; 4190 bool Matched = false; 4191 for (const auto *Overridden : Node.overridden_methods()) { 4192 BoundNodesTreeBuilder OverriddenBuilder(*Builder); 4193 const bool OverriddenMatched = 4194 InnerMatcher.matches(*Overridden, Finder, &OverriddenBuilder); 4195 if (OverriddenMatched) { 4196 Matched = true; 4197 Result.addMatch(OverriddenBuilder); 4198 } 4199 } 4200 *Builder = std::move(Result); 4201 return Matched; 4202} 4203 4204/// \brief Matches if the given method declaration is virtual. 4205/// 4206/// Given 4207/// \code 4208/// class A { 4209/// public: 4210/// virtual void x(); 4211/// }; 4212/// \endcode 4213/// matches A::x 4214AST_MATCHER(CXXMethodDecl, isVirtual) { 4215 return Node.isVirtual(); 4216} 4217 4218/// \brief Matches if the given method declaration has an explicit "virtual". 4219/// 4220/// Given 4221/// \code 4222/// class A { 4223/// public: 4224/// virtual void x(); 4225/// }; 4226/// class B : public A { 4227/// public: 4228/// void x(); 4229/// }; 4230/// \endcode 4231/// matches A::x but not B::x 4232AST_MATCHER(CXXMethodDecl, isVirtualAsWritten) { 4233 return Node.isVirtualAsWritten(); 4234} 4235 4236/// \brief Matches if the given method or class declaration is final. 4237/// 4238/// Given: 4239/// \code 4240/// class A final {}; 4241/// 4242/// struct B { 4243/// virtual void f(); 4244/// }; 4245/// 4246/// struct C : B { 4247/// void f() final; 4248/// }; 4249/// \endcode 4250/// matches A and C::f, but not B, C, or B::f 4251AST_POLYMORPHIC_MATCHER(isFinal, 4252 AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, 4253 CXXMethodDecl)) { 4254 return Node.template hasAttr<FinalAttr>(); 4255} 4256 4257/// \brief Matches if the given method declaration is pure. 4258/// 4259/// Given 4260/// \code 4261/// class A { 4262/// public: 4263/// virtual void x() = 0; 4264/// }; 4265/// \endcode 4266/// matches A::x 4267AST_MATCHER(CXXMethodDecl, isPure) { 4268 return Node.isPure(); 4269} 4270 4271/// \brief Matches if the given method declaration is const. 4272/// 4273/// Given 4274/// \code 4275/// struct A { 4276/// void foo() const; 4277/// void bar(); 4278/// }; 4279/// \endcode 4280/// 4281/// cxxMethodDecl(isConst()) matches A::foo() but not A::bar() 4282AST_MATCHER(CXXMethodDecl, isConst) { 4283 return Node.isConst(); 4284} 4285 4286/// \brief Matches if the given method declaration declares a copy assignment 4287/// operator. 4288/// 4289/// Given 4290/// \code 4291/// struct A { 4292/// A &operator=(const A &); 4293/// A &operator=(A &&); 4294/// }; 4295/// \endcode 4296/// 4297/// cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not 4298/// the second one. 4299AST_MATCHER(CXXMethodDecl, isCopyAssignmentOperator) { 4300 return Node.isCopyAssignmentOperator(); 4301} 4302 4303/// \brief Matches if the given method declaration declares a move assignment 4304/// operator. 4305/// 4306/// Given 4307/// \code 4308/// struct A { 4309/// A &operator=(const A &); 4310/// A &operator=(A &&); 4311/// }; 4312/// \endcode 4313/// 4314/// cxxMethodDecl(isMoveAssignmentOperator()) matches the second method but not 4315/// the first one. 4316AST_MATCHER(CXXMethodDecl, isMoveAssignmentOperator) { 4317 return Node.isMoveAssignmentOperator(); 4318} 4319 4320/// \brief Matches if the given method declaration overrides another method. 4321/// 4322/// Given 4323/// \code 4324/// class A { 4325/// public: 4326/// virtual void x(); 4327/// }; 4328/// class B : public A { 4329/// public: 4330/// virtual void x(); 4331/// }; 4332/// \endcode 4333/// matches B::x 4334AST_MATCHER(CXXMethodDecl, isOverride) { 4335 return Node.size_overridden_methods() > 0 || Node.hasAttr<OverrideAttr>(); 4336} 4337 4338/// \brief Matches method declarations that are user-provided. 4339/// 4340/// Given 4341/// \code 4342/// struct S { 4343/// S(); // #1 4344/// S(const S &) = default; // #2 4345/// S(S &&) = delete; // #3 4346/// }; 4347/// \endcode 4348/// cxxConstructorDecl(isUserProvided()) will match #1, but not #2 or #3. 4349AST_MATCHER(CXXMethodDecl, isUserProvided) { 4350 return Node.isUserProvided(); 4351} 4352 4353/// \brief Matches member expressions that are called with '->' as opposed 4354/// to '.'. 4355/// 4356/// Member calls on the implicit this pointer match as called with '->'. 4357/// 4358/// Given 4359/// \code 4360/// class Y { 4361/// void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; } 4362/// int a; 4363/// static int b; 4364/// }; 4365/// \endcode 4366/// memberExpr(isArrow()) 4367/// matches this->x, x, y.x, a, this->b 4368AST_MATCHER(MemberExpr, isArrow) { 4369 return Node.isArrow(); 4370} 4371 4372/// \brief Matches QualType nodes that are of integer type. 4373/// 4374/// Given 4375/// \code 4376/// void a(int); 4377/// void b(long); 4378/// void c(double); 4379/// \endcode 4380/// functionDecl(hasAnyParameter(hasType(isInteger()))) 4381/// matches "a(int)", "b(long)", but not "c(double)". 4382AST_MATCHER(QualType, isInteger) { 4383 return Node->isIntegerType(); 4384} 4385 4386/// \brief Matches QualType nodes that are of unsigned integer type. 4387/// 4388/// Given 4389/// \code 4390/// void a(int); 4391/// void b(unsigned long); 4392/// void c(double); 4393/// \endcode 4394/// functionDecl(hasAnyParameter(hasType(isUnsignedInteger()))) 4395/// matches "b(unsigned long)", but not "a(int)" and "c(double)". 4396AST_MATCHER(QualType, isUnsignedInteger) { 4397 return Node->isUnsignedIntegerType(); 4398} 4399 4400/// \brief Matches QualType nodes that are of signed integer type. 4401/// 4402/// Given 4403/// \code 4404/// void a(int); 4405/// void b(unsigned long); 4406/// void c(double); 4407/// \endcode 4408/// functionDecl(hasAnyParameter(hasType(isSignedInteger()))) 4409/// matches "a(int)", but not "b(unsigned long)" and "c(double)". 4410AST_MATCHER(QualType, isSignedInteger) { 4411 return Node->isSignedIntegerType(); 4412} 4413 4414/// \brief Matches QualType nodes that are of character type. 4415/// 4416/// Given 4417/// \code 4418/// void a(char); 4419/// void b(wchar_t); 4420/// void c(double); 4421/// \endcode 4422/// functionDecl(hasAnyParameter(hasType(isAnyCharacter()))) 4423/// matches "a(char)", "b(wchar_t)", but not "c(double)". 4424AST_MATCHER(QualType, isAnyCharacter) { 4425 return Node->isAnyCharacterType(); 4426} 4427 4428/// \brief Matches QualType nodes that are of any pointer type; this includes 4429/// the Objective-C object pointer type, which is different despite being 4430/// syntactically similar. 4431/// 4432/// Given 4433/// \code 4434/// int *i = nullptr; 4435/// 4436/// @interface Foo 4437/// @end 4438/// Foo *f; 4439/// 4440/// int j; 4441/// \endcode 4442/// varDecl(hasType(isAnyPointer())) 4443/// matches "int *i" and "Foo *f", but not "int j". 4444AST_MATCHER(QualType, isAnyPointer) { 4445 return Node->isAnyPointerType(); 4446} 4447 4448/// \brief Matches QualType nodes that are const-qualified, i.e., that 4449/// include "top-level" const. 4450/// 4451/// Given 4452/// \code 4453/// void a(int); 4454/// void b(int const); 4455/// void c(const int); 4456/// void d(const int*); 4457/// void e(int const) {}; 4458/// \endcode 4459/// functionDecl(hasAnyParameter(hasType(isConstQualified()))) 4460/// matches "void b(int const)", "void c(const int)" and 4461/// "void e(int const) {}". It does not match d as there 4462/// is no top-level const on the parameter type "const int *". 4463AST_MATCHER(QualType, isConstQualified) { 4464 return Node.isConstQualified(); 4465} 4466 4467/// \brief Matches QualType nodes that are volatile-qualified, i.e., that 4468/// include "top-level" volatile. 4469/// 4470/// Given 4471/// \code 4472/// void a(int); 4473/// void b(int volatile); 4474/// void c(volatile int); 4475/// void d(volatile int*); 4476/// void e(int volatile) {}; 4477/// \endcode 4478/// functionDecl(hasAnyParameter(hasType(isVolatileQualified()))) 4479/// matches "void b(int volatile)", "void c(volatile int)" and 4480/// "void e(int volatile) {}". It does not match d as there 4481/// is no top-level volatile on the parameter type "volatile int *". 4482AST_MATCHER(QualType, isVolatileQualified) { 4483 return Node.isVolatileQualified(); 4484} 4485 4486/// \brief Matches QualType nodes that have local CV-qualifiers attached to 4487/// the node, not hidden within a typedef. 4488/// 4489/// Given 4490/// \code 4491/// typedef const int const_int; 4492/// const_int i; 4493/// int *const j; 4494/// int *volatile k; 4495/// int m; 4496/// \endcode 4497/// \c varDecl(hasType(hasLocalQualifiers())) matches only \c j and \c k. 4498/// \c i is const-qualified but the qualifier is not local. 4499AST_MATCHER(QualType, hasLocalQualifiers) { 4500 return Node.hasLocalQualifiers(); 4501} 4502 4503/// \brief Matches a member expression where the member is matched by a 4504/// given matcher. 4505/// 4506/// Given 4507/// \code 4508/// struct { int first, second; } first, second; 4509/// int i(second.first); 4510/// int j(first.second); 4511/// \endcode 4512/// memberExpr(member(hasName("first"))) 4513/// matches second.first 4514/// but not first.second (because the member name there is "second"). 4515AST_MATCHER_P(MemberExpr, member, 4516 internal::Matcher<ValueDecl>, InnerMatcher) { 4517 return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder); 4518} 4519 4520/// \brief Matches a member expression where the object expression is 4521/// matched by a given matcher. 4522/// 4523/// Given 4524/// \code 4525/// struct X { int m; }; 4526/// void f(X x) { x.m; m; } 4527/// \endcode 4528/// memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X"))))))) 4529/// matches "x.m" and "m" 4530/// with hasObjectExpression(...) 4531/// matching "x" and the implicit object expression of "m" which has type X*. 4532AST_MATCHER_P(MemberExpr, hasObjectExpression, 4533 internal::Matcher<Expr>, InnerMatcher) { 4534 return InnerMatcher.matches(*Node.getBase(), Finder, Builder); 4535} 4536 4537/// \brief Matches any using shadow declaration. 4538/// 4539/// Given 4540/// \code 4541/// namespace X { void b(); } 4542/// using X::b; 4543/// \endcode 4544/// usingDecl(hasAnyUsingShadowDecl(hasName("b")))) 4545/// matches \code using X::b \endcode 4546AST_MATCHER_P(UsingDecl, hasAnyUsingShadowDecl, 4547 internal::Matcher<UsingShadowDecl>, InnerMatcher) { 4548 return matchesFirstInPointerRange(InnerMatcher, Node.shadow_begin(), 4549 Node.shadow_end(), Finder, Builder); 4550} 4551 4552/// \brief Matches a using shadow declaration where the target declaration is 4553/// matched by the given matcher. 4554/// 4555/// Given 4556/// \code 4557/// namespace X { int a; void b(); } 4558/// using X::a; 4559/// using X::b; 4560/// \endcode 4561/// usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl()))) 4562/// matches \code using X::b \endcode 4563/// but not \code using X::a \endcode 4564AST_MATCHER_P(UsingShadowDecl, hasTargetDecl, 4565 internal::Matcher<NamedDecl>, InnerMatcher) { 4566 return InnerMatcher.matches(*Node.getTargetDecl(), Finder, Builder); 4567} 4568 4569/// \brief Matches template instantiations of function, class, or static 4570/// member variable template instantiations. 4571/// 4572/// Given 4573/// \code 4574/// template <typename T> class X {}; class A {}; X<A> x; 4575/// \endcode 4576/// or 4577/// \code 4578/// template <typename T> class X {}; class A {}; template class X<A>; 4579/// \endcode 4580/// cxxRecordDecl(hasName("::X"), isTemplateInstantiation()) 4581/// matches the template instantiation of X<A>. 4582/// 4583/// But given 4584/// \code 4585/// template <typename T> class X {}; class A {}; 4586/// template <> class X<A> {}; X<A> x; 4587/// \endcode 4588/// cxxRecordDecl(hasName("::X"), isTemplateInstantiation()) 4589/// does not match, as X<A> is an explicit template specialization. 4590/// 4591/// Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl> 4592AST_POLYMORPHIC_MATCHER(isTemplateInstantiation, 4593 AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, VarDecl, 4594 CXXRecordDecl)) { 4595 return (Node.getTemplateSpecializationKind() == TSK_ImplicitInstantiation || 4596 Node.getTemplateSpecializationKind() == 4597 TSK_ExplicitInstantiationDefinition); 4598} 4599 4600/// \brief Matches declarations that are template instantiations or are inside 4601/// template instantiations. 4602/// 4603/// Given 4604/// \code 4605/// template<typename T> void A(T t) { T i; } 4606/// A(0); 4607/// A(0U); 4608/// \endcode 4609/// functionDecl(isInstantiated()) 4610/// matches 'A(int) {...};' and 'A(unsigned) {...}'. 4611AST_MATCHER_FUNCTION(internal::Matcher<Decl>, isInstantiated) { 4612 auto IsInstantiation = decl(anyOf(cxxRecordDecl(isTemplateInstantiation()), 4613 functionDecl(isTemplateInstantiation()))); 4614 return decl(anyOf(IsInstantiation, hasAncestor(IsInstantiation))); 4615} 4616 4617/// \brief Matches statements inside of a template instantiation. 4618/// 4619/// Given 4620/// \code 4621/// int j; 4622/// template<typename T> void A(T t) { T i; j += 42;} 4623/// A(0); 4624/// A(0U); 4625/// \endcode 4626/// declStmt(isInTemplateInstantiation()) 4627/// matches 'int i;' and 'unsigned i'. 4628/// unless(stmt(isInTemplateInstantiation())) 4629/// will NOT match j += 42; as it's shared between the template definition and 4630/// instantiation. 4631AST_MATCHER_FUNCTION(internal::Matcher<Stmt>, isInTemplateInstantiation) { 4632 return stmt( 4633 hasAncestor(decl(anyOf(cxxRecordDecl(isTemplateInstantiation()), 4634 functionDecl(isTemplateInstantiation()))))); 4635} 4636 4637/// \brief Matches explicit template specializations of function, class, or 4638/// static member variable template instantiations. 4639/// 4640/// Given 4641/// \code 4642/// template<typename T> void A(T t) { } 4643/// template<> void A(int N) { } 4644/// \endcode 4645/// functionDecl(isExplicitTemplateSpecialization()) 4646/// matches the specialization A<int>(). 4647/// 4648/// Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl> 4649AST_POLYMORPHIC_MATCHER(isExplicitTemplateSpecialization, 4650 AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, VarDecl, 4651 CXXRecordDecl)) { 4652 return (Node.getTemplateSpecializationKind() == TSK_ExplicitSpecialization); 4653} 4654 4655/// \brief Matches \c TypeLocs for which the given inner 4656/// QualType-matcher matches. 4657AST_MATCHER_FUNCTION_P_OVERLOAD(internal::BindableMatcher<TypeLoc>, loc, 4658 internal::Matcher<QualType>, InnerMatcher, 0) { 4659 return internal::BindableMatcher<TypeLoc>( 4660 new internal::TypeLocTypeMatcher(InnerMatcher)); 4661} 4662 4663/// \brief Matches type \c bool. 4664/// 4665/// Given 4666/// \code 4667/// struct S { bool func(); }; 4668/// \endcode 4669/// functionDecl(returns(booleanType())) 4670/// matches "bool func();" 4671AST_MATCHER(Type, booleanType) { 4672 return Node.isBooleanType(); 4673} 4674 4675/// \brief Matches type \c void. 4676/// 4677/// Given 4678/// \code 4679/// struct S { void func(); }; 4680/// \endcode 4681/// functionDecl(returns(voidType())) 4682/// matches "void func();" 4683AST_MATCHER(Type, voidType) { 4684 return Node.isVoidType(); 4685} 4686 4687/// \brief Matches builtin Types. 4688/// 4689/// Given 4690/// \code 4691/// struct A {}; 4692/// A a; 4693/// int b; 4694/// float c; 4695/// bool d; 4696/// \endcode 4697/// builtinType() 4698/// matches "int b", "float c" and "bool d" 4699AST_TYPE_MATCHER(BuiltinType, builtinType); 4700 4701/// \brief Matches all kinds of arrays. 4702/// 4703/// Given 4704/// \code 4705/// int a[] = { 2, 3 }; 4706/// int b[4]; 4707/// void f() { int c[a[0]]; } 4708/// \endcode 4709/// arrayType() 4710/// matches "int a[]", "int b[4]" and "int c[a[0]]"; 4711AST_TYPE_MATCHER(ArrayType, arrayType); 4712 4713/// \brief Matches C99 complex types. 4714/// 4715/// Given 4716/// \code 4717/// _Complex float f; 4718/// \endcode 4719/// complexType() 4720/// matches "_Complex float f" 4721AST_TYPE_MATCHER(ComplexType, complexType); 4722 4723/// \brief Matches any real floating-point type (float, double, long double). 4724/// 4725/// Given 4726/// \code 4727/// int i; 4728/// float f; 4729/// \endcode 4730/// realFloatingPointType() 4731/// matches "float f" but not "int i" 4732AST_MATCHER(Type, realFloatingPointType) { 4733 return Node.isRealFloatingType(); 4734} 4735 4736/// \brief Matches arrays and C99 complex types that have a specific element 4737/// type. 4738/// 4739/// Given 4740/// \code 4741/// struct A {}; 4742/// A a[7]; 4743/// int b[7]; 4744/// \endcode 4745/// arrayType(hasElementType(builtinType())) 4746/// matches "int b[7]" 4747/// 4748/// Usable as: Matcher<ArrayType>, Matcher<ComplexType> 4749AST_TYPELOC_TRAVERSE_MATCHER(hasElementType, getElement, 4750 AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType, 4751 ComplexType)); 4752 4753/// \brief Matches C arrays with a specified constant size. 4754/// 4755/// Given 4756/// \code 4757/// void() { 4758/// int a[2]; 4759/// int b[] = { 2, 3 }; 4760/// int c[b[0]]; 4761/// } 4762/// \endcode 4763/// constantArrayType() 4764/// matches "int a[2]" 4765AST_TYPE_MATCHER(ConstantArrayType, constantArrayType); 4766 4767/// \brief Matches nodes that have the specified size. 4768/// 4769/// Given 4770/// \code 4771/// int a[42]; 4772/// int b[2 * 21]; 4773/// int c[41], d[43]; 4774/// char *s = "abcd"; 4775/// wchar_t *ws = L"abcd"; 4776/// char *w = "a"; 4777/// \endcode 4778/// constantArrayType(hasSize(42)) 4779/// matches "int a[42]" and "int b[2 * 21]" 4780/// stringLiteral(hasSize(4)) 4781/// matches "abcd", L"abcd" 4782AST_POLYMORPHIC_MATCHER_P(hasSize, 4783 AST_POLYMORPHIC_SUPPORTED_TYPES(ConstantArrayType, 4784 StringLiteral), 4785 unsigned, N) { 4786 return internal::HasSizeMatcher<NodeType>::hasSize(Node, N); 4787} 4788 4789/// \brief Matches C++ arrays whose size is a value-dependent expression. 4790/// 4791/// Given 4792/// \code 4793/// template<typename T, int Size> 4794/// class array { 4795/// T data[Size]; 4796/// }; 4797/// \endcode 4798/// dependentSizedArrayType 4799/// matches "T data[Size]" 4800AST_TYPE_MATCHER(DependentSizedArrayType, dependentSizedArrayType); 4801 4802/// \brief Matches C arrays with unspecified size. 4803/// 4804/// Given 4805/// \code 4806/// int a[] = { 2, 3 }; 4807/// int b[42]; 4808/// void f(int c[]) { int d[a[0]]; }; 4809/// \endcode 4810/// incompleteArrayType() 4811/// matches "int a[]" and "int c[]" 4812AST_TYPE_MATCHER(IncompleteArrayType, incompleteArrayType); 4813 4814/// \brief Matches C arrays with a specified size that is not an 4815/// integer-constant-expression. 4816/// 4817/// Given 4818/// \code 4819/// void f() { 4820/// int a[] = { 2, 3 } 4821/// int b[42]; 4822/// int c[a[0]]; 4823/// } 4824/// \endcode 4825/// variableArrayType() 4826/// matches "int c[a[0]]" 4827AST_TYPE_MATCHER(VariableArrayType, variableArrayType); 4828 4829/// \brief Matches \c VariableArrayType nodes that have a specific size 4830/// expression. 4831/// 4832/// Given 4833/// \code 4834/// void f(int b) { 4835/// int a[b]; 4836/// } 4837/// \endcode 4838/// variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to( 4839/// varDecl(hasName("b"))))))) 4840/// matches "int a[b]" 4841AST_MATCHER_P(VariableArrayType, hasSizeExpr, 4842 internal::Matcher<Expr>, InnerMatcher) { 4843 return InnerMatcher.matches(*Node.getSizeExpr(), Finder, Builder); 4844} 4845 4846/// \brief Matches atomic types. 4847/// 4848/// Given 4849/// \code 4850/// _Atomic(int) i; 4851/// \endcode 4852/// atomicType() 4853/// matches "_Atomic(int) i" 4854AST_TYPE_MATCHER(AtomicType, atomicType); 4855 4856/// \brief Matches atomic types with a specific value type. 4857/// 4858/// Given 4859/// \code 4860/// _Atomic(int) i; 4861/// _Atomic(float) f; 4862/// \endcode 4863/// atomicType(hasValueType(isInteger())) 4864/// matches "_Atomic(int) i" 4865/// 4866/// Usable as: Matcher<AtomicType> 4867AST_TYPELOC_TRAVERSE_MATCHER(hasValueType, getValue, 4868 AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType)); 4869 4870/// \brief Matches types nodes representing C++11 auto types. 4871/// 4872/// Given: 4873/// \code 4874/// auto n = 4; 4875/// int v[] = { 2, 3 } 4876/// for (auto i : v) { } 4877/// \endcode 4878/// autoType() 4879/// matches "auto n" and "auto i" 4880AST_TYPE_MATCHER(AutoType, autoType); 4881 4882/// \brief Matches \c AutoType nodes where the deduced type is a specific type. 4883/// 4884/// Note: There is no \c TypeLoc for the deduced type and thus no 4885/// \c getDeducedLoc() matcher. 4886/// 4887/// Given 4888/// \code 4889/// auto a = 1; 4890/// auto b = 2.0; 4891/// \endcode 4892/// autoType(hasDeducedType(isInteger())) 4893/// matches "auto a" 4894/// 4895/// Usable as: Matcher<AutoType> 4896AST_TYPE_TRAVERSE_MATCHER(hasDeducedType, getDeducedType, 4897 AST_POLYMORPHIC_SUPPORTED_TYPES(AutoType)); 4898 4899/// \brief Matches \c FunctionType nodes. 4900/// 4901/// Given 4902/// \code 4903/// int (*f)(int); 4904/// void g(); 4905/// \endcode 4906/// functionType() 4907/// matches "int (*f)(int)" and the type of "g". 4908AST_TYPE_MATCHER(FunctionType, functionType); 4909 4910/// \brief Matches \c FunctionProtoType nodes. 4911/// 4912/// Given 4913/// \code 4914/// int (*f)(int); 4915/// void g(); 4916/// \endcode 4917/// functionProtoType() 4918/// matches "int (*f)(int)" and the type of "g" in C++ mode. 4919/// In C mode, "g" is not matched because it does not contain a prototype. 4920AST_TYPE_MATCHER(FunctionProtoType, functionProtoType); 4921 4922/// \brief Matches \c ParenType nodes. 4923/// 4924/// Given 4925/// \code 4926/// int (*ptr_to_array)[4]; 4927/// int *array_of_ptrs[4]; 4928/// \endcode 4929/// 4930/// \c varDecl(hasType(pointsTo(parenType()))) matches \c ptr_to_array but not 4931/// \c array_of_ptrs. 4932AST_TYPE_MATCHER(ParenType, parenType); 4933 4934/// \brief Matches \c ParenType nodes where the inner type is a specific type. 4935/// 4936/// Given 4937/// \code 4938/// int (*ptr_to_array)[4]; 4939/// int (*ptr_to_func)(int); 4940/// \endcode 4941/// 4942/// \c varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches 4943/// \c ptr_to_func but not \c ptr_to_array. 4944/// 4945/// Usable as: Matcher<ParenType> 4946AST_TYPE_TRAVERSE_MATCHER(innerType, getInnerType, 4947 AST_POLYMORPHIC_SUPPORTED_TYPES(ParenType)); 4948 4949/// \brief Matches block pointer types, i.e. types syntactically represented as 4950/// "void (^)(int)". 4951/// 4952/// The \c pointee is always required to be a \c FunctionType. 4953AST_TYPE_MATCHER(BlockPointerType, blockPointerType); 4954 4955/// \brief Matches member pointer types. 4956/// Given 4957/// \code 4958/// struct A { int i; } 4959/// A::* ptr = A::i; 4960/// \endcode 4961/// memberPointerType() 4962/// matches "A::* ptr" 4963AST_TYPE_MATCHER(MemberPointerType, memberPointerType); 4964 4965/// \brief Matches pointer types, but does not match Objective-C object pointer 4966/// types. 4967/// 4968/// Given 4969/// \code 4970/// int *a; 4971/// int &b = *a; 4972/// int c = 5; 4973/// 4974/// @interface Foo 4975/// @end 4976/// Foo *f; 4977/// \endcode 4978/// pointerType() 4979/// matches "int *a", but does not match "Foo *f". 4980AST_TYPE_MATCHER(PointerType, pointerType); 4981 4982/// \brief Matches an Objective-C object pointer type, which is different from 4983/// a pointer type, despite being syntactically similar. 4984/// 4985/// Given 4986/// \code 4987/// int *a; 4988/// 4989/// @interface Foo 4990/// @end 4991/// Foo *f; 4992/// \endcode 4993/// pointerType() 4994/// matches "Foo *f", but does not match "int *a". 4995AST_TYPE_MATCHER(ObjCObjectPointerType, objcObjectPointerType); 4996 4997/// \brief Matches both lvalue and rvalue reference types. 4998/// 4999/// Given 5000/// \code 5001/// int *a; 5002/// int &b = *a; 5003/// int &&c = 1; 5004/// auto &d = b; 5005/// auto &&e = c; 5006/// auto &&f = 2; 5007/// int g = 5; 5008/// \endcode 5009/// 5010/// \c referenceType() matches the types of \c b, \c c, \c d, \c e, and \c f. 5011AST_TYPE_MATCHER(ReferenceType, referenceType); 5012 5013/// \brief Matches lvalue reference types. 5014/// 5015/// Given: 5016/// \code 5017/// int *a; 5018/// int &b = *a; 5019/// int &&c = 1; 5020/// auto &d = b; 5021/// auto &&e = c; 5022/// auto &&f = 2; 5023/// int g = 5; 5024/// \endcode 5025/// 5026/// \c lValueReferenceType() matches the types of \c b, \c d, and \c e. \c e is 5027/// matched since the type is deduced as int& by reference collapsing rules. 5028AST_TYPE_MATCHER(LValueReferenceType, lValueReferenceType); 5029 5030/// \brief Matches rvalue reference types. 5031/// 5032/// Given: 5033/// \code 5034/// int *a; 5035/// int &b = *a; 5036/// int &&c = 1; 5037/// auto &d = b; 5038/// auto &&e = c; 5039/// auto &&f = 2; 5040/// int g = 5; 5041/// \endcode 5042/// 5043/// \c rValueReferenceType() matches the types of \c c and \c f. \c e is not 5044/// matched as it is deduced to int& by reference collapsing rules. 5045AST_TYPE_MATCHER(RValueReferenceType, rValueReferenceType); 5046 5047/// \brief Narrows PointerType (and similar) matchers to those where the 5048/// \c pointee matches a given matcher. 5049/// 5050/// Given 5051/// \code 5052/// int *a; 5053/// int const *b; 5054/// float const *f; 5055/// \endcode 5056/// pointerType(pointee(isConstQualified(), isInteger())) 5057/// matches "int const *b" 5058/// 5059/// Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>, 5060/// Matcher<PointerType>, Matcher<ReferenceType> 5061AST_TYPELOC_TRAVERSE_MATCHER(pointee, getPointee, 5062 AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, 5063 MemberPointerType, 5064 PointerType, 5065 ReferenceType)); 5066 5067/// \brief Matches typedef types. 5068/// 5069/// Given 5070/// \code 5071/// typedef int X; 5072/// \endcode 5073/// typedefType() 5074/// matches "typedef int X" 5075AST_TYPE_MATCHER(TypedefType, typedefType); 5076 5077/// \brief Matches enum types. 5078/// 5079/// Given 5080/// \code 5081/// enum C { Green }; 5082/// enum class S { Red }; 5083/// 5084/// C c; 5085/// S s; 5086/// \endcode 5087// 5088/// \c enumType() matches the type of the variable declarations of both \c c and 5089/// \c s. 5090AST_TYPE_MATCHER(EnumType, enumType); 5091 5092/// \brief Matches template specialization types. 5093/// 5094/// Given 5095/// \code 5096/// template <typename T> 5097/// class C { }; 5098/// 5099/// template class C<int>; // A 5100/// C<char> var; // B 5101/// \endcode 5102/// 5103/// \c templateSpecializationType() matches the type of the explicit 5104/// instantiation in \c A and the type of the variable declaration in \c B. 5105AST_TYPE_MATCHER(TemplateSpecializationType, templateSpecializationType); 5106 5107/// \brief Matches types nodes representing unary type transformations. 5108/// 5109/// Given: 5110/// \code 5111/// typedef __underlying_type(T) type; 5112/// \endcode 5113/// unaryTransformType() 5114/// matches "__underlying_type(T)" 5115AST_TYPE_MATCHER(UnaryTransformType, unaryTransformType); 5116 5117/// \brief Matches record types (e.g. structs, classes). 5118/// 5119/// Given 5120/// \code 5121/// class C {}; 5122/// struct S {}; 5123/// 5124/// C c; 5125/// S s; 5126/// \endcode 5127/// 5128/// \c recordType() matches the type of the variable declarations of both \c c 5129/// and \c s. 5130AST_TYPE_MATCHER(RecordType, recordType); 5131 5132/// \brief Matches tag types (record and enum types). 5133/// 5134/// Given 5135/// \code 5136/// enum E {}; 5137/// class C {}; 5138/// 5139/// E e; 5140/// C c; 5141/// \endcode 5142/// 5143/// \c tagType() matches the type of the variable declarations of both \c e 5144/// and \c c. 5145AST_TYPE_MATCHER(TagType, tagType); 5146 5147/// \brief Matches types specified with an elaborated type keyword or with a 5148/// qualified name. 5149/// 5150/// Given 5151/// \code 5152/// namespace N { 5153/// namespace M { 5154/// class D {}; 5155/// } 5156/// } 5157/// class C {}; 5158/// 5159/// class C c; 5160/// N::M::D d; 5161/// \endcode 5162/// 5163/// \c elaboratedType() matches the type of the variable declarations of both 5164/// \c c and \c d. 5165AST_TYPE_MATCHER(ElaboratedType, elaboratedType); 5166 5167/// \brief Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier, 5168/// matches \c InnerMatcher if the qualifier exists. 5169/// 5170/// Given 5171/// \code 5172/// namespace N { 5173/// namespace M { 5174/// class D {}; 5175/// } 5176/// } 5177/// N::M::D d; 5178/// \endcode 5179/// 5180/// \c elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))) 5181/// matches the type of the variable declaration of \c d. 5182AST_MATCHER_P(ElaboratedType, hasQualifier, 5183 internal::Matcher<NestedNameSpecifier>, InnerMatcher) { 5184 if (const NestedNameSpecifier *Qualifier = Node.getQualifier()) 5185 return InnerMatcher.matches(*Qualifier, Finder, Builder); 5186 5187 return false; 5188} 5189 5190/// \brief Matches ElaboratedTypes whose named type matches \c InnerMatcher. 5191/// 5192/// Given 5193/// \code 5194/// namespace N { 5195/// namespace M { 5196/// class D {}; 5197/// } 5198/// } 5199/// N::M::D d; 5200/// \endcode 5201/// 5202/// \c elaboratedType(namesType(recordType( 5203/// hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable 5204/// declaration of \c d. 5205AST_MATCHER_P(ElaboratedType, namesType, internal::Matcher<QualType>, 5206 InnerMatcher) { 5207 return InnerMatcher.matches(Node.getNamedType(), Finder, Builder); 5208} 5209 5210/// \brief Matches types that represent the result of substituting a type for a 5211/// template type parameter. 5212/// 5213/// Given 5214/// \code 5215/// template <typename T> 5216/// void F(T t) { 5217/// int i = 1 + t; 5218/// } 5219/// \endcode 5220/// 5221/// \c substTemplateTypeParmType() matches the type of 't' but not '1' 5222AST_TYPE_MATCHER(SubstTemplateTypeParmType, substTemplateTypeParmType); 5223 5224/// \brief Matches template type parameter substitutions that have a replacement 5225/// type that matches the provided matcher. 5226/// 5227/// Given 5228/// \code 5229/// template <typename T> 5230/// double F(T t); 5231/// int i; 5232/// double j = F(i); 5233/// \endcode 5234/// 5235/// \c substTemplateTypeParmType(hasReplacementType(type())) matches int 5236AST_TYPE_TRAVERSE_MATCHER( 5237 hasReplacementType, getReplacementType, 5238 AST_POLYMORPHIC_SUPPORTED_TYPES(SubstTemplateTypeParmType)); 5239 5240/// \brief Matches template type parameter types. 5241/// 5242/// Example matches T, but not int. 5243/// (matcher = templateTypeParmType()) 5244/// \code 5245/// template <typename T> void f(int i); 5246/// \endcode 5247AST_TYPE_MATCHER(TemplateTypeParmType, templateTypeParmType); 5248 5249/// \brief Matches injected class name types. 5250/// 5251/// Example matches S s, but not S<T> s. 5252/// (matcher = parmVarDecl(hasType(injectedClassNameType()))) 5253/// \code 5254/// template <typename T> struct S { 5255/// void f(S s); 5256/// void g(S<T> s); 5257/// }; 5258/// \endcode 5259AST_TYPE_MATCHER(InjectedClassNameType, injectedClassNameType); 5260 5261/// \brief Matches decayed type 5262/// Example matches i[] in declaration of f. 5263/// (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType()))))) 5264/// Example matches i[1]. 5265/// (matcher = expr(hasType(decayedType(hasDecayedType(pointerType()))))) 5266/// \code 5267/// void f(int i[]) { 5268/// i[1] = 0; 5269/// } 5270/// \endcode 5271AST_TYPE_MATCHER(DecayedType, decayedType); 5272 5273/// \brief Matches the decayed type, whos decayed type matches \c InnerMatcher 5274AST_MATCHER_P(DecayedType, hasDecayedType, internal::Matcher<QualType>, 5275 InnerType) { 5276 return InnerType.matches(Node.getDecayedType(), Finder, Builder); 5277} 5278 5279/// \brief Matches declarations whose declaration context, interpreted as a 5280/// Decl, matches \c InnerMatcher. 5281/// 5282/// Given 5283/// \code 5284/// namespace N { 5285/// namespace M { 5286/// class D {}; 5287/// } 5288/// } 5289/// \endcode 5290/// 5291/// \c cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the 5292/// declaration of \c class \c D. 5293AST_MATCHER_P(Decl, hasDeclContext, internal::Matcher<Decl>, InnerMatcher) { 5294 const DeclContext *DC = Node.getDeclContext(); 5295 if (!DC) return false; 5296 return InnerMatcher.matches(*Decl::castFromDeclContext(DC), Finder, Builder); 5297} 5298 5299/// \brief Matches nested name specifiers. 5300/// 5301/// Given 5302/// \code 5303/// namespace ns { 5304/// struct A { static void f(); }; 5305/// void A::f() {} 5306/// void g() { A::f(); } 5307/// } 5308/// ns::A a; 5309/// \endcode 5310/// nestedNameSpecifier() 5311/// matches "ns::" and both "A::" 5312const internal::VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier; 5313 5314/// \brief Same as \c nestedNameSpecifier but matches \c NestedNameSpecifierLoc. 5315const internal::VariadicAllOfMatcher< 5316 NestedNameSpecifierLoc> nestedNameSpecifierLoc; 5317 5318/// \brief Matches \c NestedNameSpecifierLocs for which the given inner 5319/// NestedNameSpecifier-matcher matches. 5320AST_MATCHER_FUNCTION_P_OVERLOAD( 5321 internal::BindableMatcher<NestedNameSpecifierLoc>, loc, 5322 internal::Matcher<NestedNameSpecifier>, InnerMatcher, 1) { 5323 return internal::BindableMatcher<NestedNameSpecifierLoc>( 5324 new internal::LocMatcher<NestedNameSpecifierLoc, NestedNameSpecifier>( 5325 InnerMatcher)); 5326} 5327 5328/// \brief Matches nested name specifiers that specify a type matching the 5329/// given \c QualType matcher without qualifiers. 5330/// 5331/// Given 5332/// \code 5333/// struct A { struct B { struct C {}; }; }; 5334/// A::B::C c; 5335/// \endcode 5336/// nestedNameSpecifier(specifiesType( 5337/// hasDeclaration(cxxRecordDecl(hasName("A"))) 5338/// )) 5339/// matches "A::" 5340AST_MATCHER_P(NestedNameSpecifier, specifiesType, 5341 internal::Matcher<QualType>, InnerMatcher) { 5342 if (!Node.getAsType()) 5343 return false; 5344 return InnerMatcher.matches(QualType(Node.getAsType(), 0), Finder, Builder); 5345} 5346 5347/// \brief Matches nested name specifier locs that specify a type matching the 5348/// given \c TypeLoc. 5349/// 5350/// Given 5351/// \code 5352/// struct A { struct B { struct C {}; }; }; 5353/// A::B::C c; 5354/// \endcode 5355/// nestedNameSpecifierLoc(specifiesTypeLoc(loc(type( 5356/// hasDeclaration(cxxRecordDecl(hasName("A"))))))) 5357/// matches "A::" 5358AST_MATCHER_P(NestedNameSpecifierLoc, specifiesTypeLoc, 5359 internal::Matcher<TypeLoc>, InnerMatcher) { 5360 return Node && InnerMatcher.matches(Node.getTypeLoc(), Finder, Builder); 5361} 5362 5363/// \brief Matches on the prefix of a \c NestedNameSpecifier. 5364/// 5365/// Given 5366/// \code 5367/// struct A { struct B { struct C {}; }; }; 5368/// A::B::C c; 5369/// \endcode 5370/// nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and 5371/// matches "A::" 5372AST_MATCHER_P_OVERLOAD(NestedNameSpecifier, hasPrefix, 5373 internal::Matcher<NestedNameSpecifier>, InnerMatcher, 5374 0) { 5375 const NestedNameSpecifier *NextNode = Node.getPrefix(); 5376 if (!NextNode) 5377 return false; 5378 return InnerMatcher.matches(*NextNode, Finder, Builder); 5379} 5380 5381/// \brief Matches on the prefix of a \c NestedNameSpecifierLoc. 5382/// 5383/// Given 5384/// \code 5385/// struct A { struct B { struct C {}; }; }; 5386/// A::B::C c; 5387/// \endcode 5388/// nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A"))))) 5389/// matches "A::" 5390AST_MATCHER_P_OVERLOAD(NestedNameSpecifierLoc, hasPrefix, 5391 internal::Matcher<NestedNameSpecifierLoc>, InnerMatcher, 5392 1) { 5393 NestedNameSpecifierLoc NextNode = Node.getPrefix(); 5394 if (!NextNode) 5395 return false; 5396 return InnerMatcher.matches(NextNode, Finder, Builder); 5397} 5398 5399/// \brief Matches nested name specifiers that specify a namespace matching the 5400/// given namespace matcher. 5401/// 5402/// Given 5403/// \code 5404/// namespace ns { struct A {}; } 5405/// ns::A a; 5406/// \endcode 5407/// nestedNameSpecifier(specifiesNamespace(hasName("ns"))) 5408/// matches "ns::" 5409AST_MATCHER_P(NestedNameSpecifier, specifiesNamespace, 5410 internal::Matcher<NamespaceDecl>, InnerMatcher) { 5411 if (!Node.getAsNamespace()) 5412 return false; 5413 return InnerMatcher.matches(*Node.getAsNamespace(), Finder, Builder); 5414} 5415 5416/// \brief Overloads for the \c equalsNode matcher. 5417/// FIXME: Implement for other node types. 5418/// @{ 5419 5420/// \brief Matches if a node equals another node. 5421/// 5422/// \c Decl has pointer identity in the AST. 5423AST_MATCHER_P_OVERLOAD(Decl, equalsNode, const Decl*, Other, 0) { 5424 return &Node == Other; 5425} 5426/// \brief Matches if a node equals another node. 5427/// 5428/// \c Stmt has pointer identity in the AST. 5429AST_MATCHER_P_OVERLOAD(Stmt, equalsNode, const Stmt*, Other, 1) { 5430 return &Node == Other; 5431} 5432/// \brief Matches if a node equals another node. 5433/// 5434/// \c Type has pointer identity in the AST. 5435AST_MATCHER_P_OVERLOAD(Type, equalsNode, const Type*, Other, 2) { 5436 return &Node == Other; 5437} 5438 5439/// @} 5440 5441/// \brief Matches each case or default statement belonging to the given switch 5442/// statement. This matcher may produce multiple matches. 5443/// 5444/// Given 5445/// \code 5446/// switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } } 5447/// \endcode 5448/// switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s") 5449/// matches four times, with "c" binding each of "case 1:", "case 2:", 5450/// "case 3:" and "case 4:", and "s" respectively binding "switch (1)", 5451/// "switch (1)", "switch (2)" and "switch (2)". 5452AST_MATCHER_P(SwitchStmt, forEachSwitchCase, internal::Matcher<SwitchCase>, 5453 InnerMatcher) { 5454 BoundNodesTreeBuilder Result; 5455 // FIXME: getSwitchCaseList() does not necessarily guarantee a stable 5456 // iteration order. We should use the more general iterating matchers once 5457 // they are capable of expressing this matcher (for example, it should ignore 5458 // case statements belonging to nested switch statements). 5459 bool Matched = false; 5460 for (const SwitchCase *SC = Node.getSwitchCaseList(); SC; 5461 SC = SC->getNextSwitchCase()) { 5462 BoundNodesTreeBuilder CaseBuilder(*Builder); 5463 bool CaseMatched = InnerMatcher.matches(*SC, Finder, &CaseBuilder); 5464 if (CaseMatched) { 5465 Matched = true; 5466 Result.addMatch(CaseBuilder); 5467 } 5468 } 5469 *Builder = std::move(Result); 5470 return Matched; 5471} 5472 5473/// \brief Matches each constructor initializer in a constructor definition. 5474/// 5475/// Given 5476/// \code 5477/// class A { A() : i(42), j(42) {} int i; int j; }; 5478/// \endcode 5479/// cxxConstructorDecl(forEachConstructorInitializer( 5480/// forField(decl().bind("x")) 5481/// )) 5482/// will trigger two matches, binding for 'i' and 'j' respectively. 5483AST_MATCHER_P(CXXConstructorDecl, forEachConstructorInitializer, 5484 internal::Matcher<CXXCtorInitializer>, InnerMatcher) { 5485 BoundNodesTreeBuilder Result; 5486 bool Matched = false; 5487 for (const auto *I : Node.inits()) { 5488 BoundNodesTreeBuilder InitBuilder(*Builder); 5489 if (InnerMatcher.matches(*I, Finder, &InitBuilder)) { 5490 Matched = true; 5491 Result.addMatch(InitBuilder); 5492 } 5493 } 5494 *Builder = std::move(Result); 5495 return Matched; 5496} 5497 5498/// \brief Matches constructor declarations that are copy constructors. 5499/// 5500/// Given 5501/// \code 5502/// struct S { 5503/// S(); // #1 5504/// S(const S &); // #2 5505/// S(S &&); // #3 5506/// }; 5507/// \endcode 5508/// cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3. 5509AST_MATCHER(CXXConstructorDecl, isCopyConstructor) { 5510 return Node.isCopyConstructor(); 5511} 5512 5513/// \brief Matches constructor declarations that are move constructors. 5514/// 5515/// Given 5516/// \code 5517/// struct S { 5518/// S(); // #1 5519/// S(const S &); // #2 5520/// S(S &&); // #3 5521/// }; 5522/// \endcode 5523/// cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2. 5524AST_MATCHER(CXXConstructorDecl, isMoveConstructor) { 5525 return Node.isMoveConstructor(); 5526} 5527 5528/// \brief Matches constructor declarations that are default constructors. 5529/// 5530/// Given 5531/// \code 5532/// struct S { 5533/// S(); // #1 5534/// S(const S &); // #2 5535/// S(S &&); // #3 5536/// }; 5537/// \endcode 5538/// cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3. 5539AST_MATCHER(CXXConstructorDecl, isDefaultConstructor) { 5540 return Node.isDefaultConstructor(); 5541} 5542 5543/// \brief Matches constructors that delegate to another constructor. 5544/// 5545/// Given 5546/// \code 5547/// struct S { 5548/// S(); // #1 5549/// S(int) {} // #2 5550/// S(S &&) : S() {} // #3 5551/// }; 5552/// S::S() : S(0) {} // #4 5553/// \endcode 5554/// cxxConstructorDecl(isDelegatingConstructor()) will match #3 and #4, but not 5555/// #1 or #2. 5556AST_MATCHER(CXXConstructorDecl, isDelegatingConstructor) { 5557 return Node.isDelegatingConstructor(); 5558} 5559 5560/// \brief Matches constructor and conversion declarations that are marked with 5561/// the explicit keyword. 5562/// 5563/// Given 5564/// \code 5565/// struct S { 5566/// S(int); // #1 5567/// explicit S(double); // #2 5568/// operator int(); // #3 5569/// explicit operator bool(); // #4 5570/// }; 5571/// \endcode 5572/// cxxConstructorDecl(isExplicit()) will match #2, but not #1. 5573/// cxxConversionDecl(isExplicit()) will match #4, but not #3. 5574AST_POLYMORPHIC_MATCHER(isExplicit, 5575 AST_POLYMORPHIC_SUPPORTED_TYPES(CXXConstructorDecl, 5576 CXXConversionDecl)) { 5577 return Node.isExplicit(); 5578} 5579 5580/// \brief Matches function and namespace declarations that are marked with 5581/// the inline keyword. 5582/// 5583/// Given 5584/// \code 5585/// inline void f(); 5586/// void g(); 5587/// namespace n { 5588/// inline namespace m {} 5589/// } 5590/// \endcode 5591/// functionDecl(isInline()) will match ::f(). 5592/// namespaceDecl(isInline()) will match n::m. 5593AST_POLYMORPHIC_MATCHER(isInline, 5594 AST_POLYMORPHIC_SUPPORTED_TYPES(NamespaceDecl, 5595 FunctionDecl)) { 5596 // This is required because the spelling of the function used to determine 5597 // whether inline is specified or not differs between the polymorphic types. 5598 if (const auto *FD = dyn_cast<FunctionDecl>(&Node)) 5599 return FD->isInlineSpecified(); 5600 else if (const auto *NSD = dyn_cast<NamespaceDecl>(&Node)) 5601 return NSD->isInline(); 5602 llvm_unreachable("Not a valid polymorphic type"); 5603} 5604 5605/// \brief Matches anonymous namespace declarations. 5606/// 5607/// Given 5608/// \code 5609/// namespace n { 5610/// namespace {} // #1 5611/// } 5612/// \endcode 5613/// namespaceDecl(isAnonymous()) will match #1 but not ::n. 5614AST_MATCHER(NamespaceDecl, isAnonymous) { 5615 return Node.isAnonymousNamespace(); 5616} 5617 5618/// \brief If the given case statement does not use the GNU case range 5619/// extension, matches the constant given in the statement. 5620/// 5621/// Given 5622/// \code 5623/// switch (1) { case 1: case 1+1: case 3 ... 4: ; } 5624/// \endcode 5625/// caseStmt(hasCaseConstant(integerLiteral())) 5626/// matches "case 1:" 5627AST_MATCHER_P(CaseStmt, hasCaseConstant, internal::Matcher<Expr>, 5628 InnerMatcher) { 5629 if (Node.getRHS()) 5630 return false; 5631 5632 return InnerMatcher.matches(*Node.getLHS(), Finder, Builder); 5633} 5634 5635/// \brief Matches declaration that has a given attribute. 5636/// 5637/// Given 5638/// \code 5639/// __attribute__((device)) void f() { ... } 5640/// \endcode 5641/// decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of 5642/// f. If the matcher is use from clang-query, attr::Kind parameter should be 5643/// passed as a quoted string. e.g., hasAttr("attr::CUDADevice"). 5644AST_MATCHER_P(Decl, hasAttr, attr::Kind, AttrKind) { 5645 for (const auto *Attr : Node.attrs()) { 5646 if (Attr->getKind() == AttrKind) 5647 return true; 5648 } 5649 return false; 5650} 5651 5652/// \brief Matches the return value expression of a return statement 5653/// 5654/// Given 5655/// \code 5656/// return a + b; 5657/// \endcode 5658/// hasReturnValue(binaryOperator()) 5659/// matches 'return a + b' 5660/// with binaryOperator() 5661/// matching 'a + b' 5662AST_MATCHER_P(ReturnStmt, hasReturnValue, internal::Matcher<Expr>, 5663 InnerMatcher) { 5664 if (const auto *RetValue = Node.getRetValue()) 5665 return InnerMatcher.matches(*RetValue, Finder, Builder); 5666 return false; 5667} 5668 5669 5670/// \brief Matches CUDA kernel call expression. 5671/// 5672/// Example matches, 5673/// \code 5674/// kernel<<<i,j>>>(); 5675/// \endcode 5676const internal::VariadicDynCastAllOfMatcher< 5677 Stmt, 5678 CUDAKernelCallExpr> cudaKernelCallExpr; 5679 5680 5681/// \brief Matches expressions that resolve to a null pointer constant, such as 5682/// GNU's __null, C++11's nullptr, or C's NULL macro. 5683/// 5684/// Given: 5685/// \code 5686/// void *v1 = NULL; 5687/// void *v2 = nullptr; 5688/// void *v3 = __null; // GNU extension 5689/// char *cp = (char *)0; 5690/// int *ip = 0; 5691/// int i = 0; 5692/// \endcode 5693/// expr(nullPointerConstant()) 5694/// matches the initializer for v1, v2, v3, cp, and ip. Does not match the 5695/// initializer for i. 5696AST_MATCHER_FUNCTION(internal::Matcher<Expr>, nullPointerConstant) { 5697 return anyOf( 5698 gnuNullExpr(), cxxNullPtrLiteralExpr(), 5699 integerLiteral(equals(0), hasParent(expr(hasType(pointerType()))))); 5700} 5701 5702/// \brief Matches declaration of the function the statement belongs to 5703/// 5704/// Given: 5705/// \code 5706/// F& operator=(const F& o) { 5707/// std::copy_if(o.begin(), o.end(), begin(), [](V v) { return v > 0; }); 5708/// return *this; 5709/// } 5710/// \endcode 5711/// returnStmt(forFunction(hasName("operator="))) 5712/// matches 'return *this' 5713/// but does match 'return > 0' 5714AST_MATCHER_P(Stmt, forFunction, internal::Matcher<FunctionDecl>, 5715 InnerMatcher) { 5716 const auto &Parents = Finder->getASTContext().getParents(Node); 5717 5718 llvm::SmallVector<ast_type_traits::DynTypedNode, 8> Stack(Parents.begin(), 5719 Parents.end()); 5720 while(!Stack.empty()) { 5721 const auto &CurNode = Stack.back(); 5722 Stack.pop_back(); 5723 if(const auto *FuncDeclNode = CurNode.get<FunctionDecl>()) { 5724 if(InnerMatcher.matches(*FuncDeclNode, Finder, Builder)) { 5725 return true; 5726 } 5727 } else if(const auto *LambdaExprNode = CurNode.get<LambdaExpr>()) { 5728 if(InnerMatcher.matches(*LambdaExprNode->getCallOperator(), 5729 Finder, Builder)) { 5730 return true; 5731 } 5732 } else { 5733 for(const auto &Parent: Finder->getASTContext().getParents(CurNode)) 5734 Stack.push_back(Parent); 5735 } 5736 } 5737 return false; 5738} 5739 5740/// \brief Matches a declaration that has external formal linkage. 5741/// 5742/// Example matches only z (matcher = varDecl(hasExternalFormalLinkage())) 5743/// \code 5744/// void f() { 5745/// int x; 5746/// static int y; 5747/// } 5748/// int z; 5749/// \endcode 5750/// 5751/// Example matches f() because it has external formal linkage despite being 5752/// unique to the translation unit as though it has internal likage 5753/// (matcher = functionDecl(hasExternalFormalLinkage())) 5754/// 5755/// \code 5756/// namespace { 5757/// void f() {} 5758/// } 5759/// \endcode 5760AST_MATCHER(NamedDecl, hasExternalFormalLinkage) { 5761 return Node.hasExternalFormalLinkage(); 5762} 5763 5764} // end namespace ast_matchers 5765} // end namespace clang 5766 5767#endif 5768