clang/include/clang/ASTMatchers/ASTMatchers.h

   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 //    record(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 //    record(hasName("MyClass"), hasChild(id("child", record())))
  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 CXXRecordDecl 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_AST_MATCHERS_AST_MATCHERS_H
  46 #define LLVM_CLANG_AST_MATCHERS_AST_MATCHERS_H
  47
  48 #include "clang/AST/DeclTemplate.h"
  49 #include "clang/ASTMatchers/ASTMatchersInternal.h"
  50 #include "clang/ASTMatchers/ASTMatchersMacros.h"
  51 #include "llvm/ADT/Twine.h"
  52 #include "llvm/Support/Regex.h"
  53 #include <iterator>
  54
  55 namespace clang {
  56 namespace ast_matchers {
  57
  58 /// \brief Maps string IDs to AST nodes matched by parts of a matcher.
  59 ///
  60 /// The bound nodes are generated by adding id(...) matchers into the
  61 /// match expression around the matchers for the nodes we want to access later.
  62 ///
  63 /// The instances of BoundNodes are created by MatchFinder when the user's
  64 /// callbacks are executed every time a match is found.
  65 class BoundNodes {
  66 public:
  67   /// \brief Returns the AST node bound to 'ID'.
  68   /// Returns NULL if there was no node bound to 'ID' or if there is a node but
  69   /// it cannot be converted to the specified type.
  70   /// FIXME: We'll need one of those for every base type.
  71   /// @{
  72   template <typename T>
  73   const T *getDeclAs(StringRef ID) const {
  74     return getNodeAs<T>(DeclBindings, ID);
  75   }
  76   template <typename T>
  77   const T *getStmtAs(StringRef ID) const {
  78     return getNodeAs<T>(StmtBindings, ID);
  79   }
  80   /// @}
  81
  82 private:
  83   /// \brief Create BoundNodes from a pre-filled map of bindings.
  84   BoundNodes(const std::map<std::string, const Decl*> &DeclBindings,
  85              const std::map<std::string, const Stmt*> &StmtBindings)
  86       : DeclBindings(DeclBindings), StmtBindings(StmtBindings) {}
  87
  88   template <typename T, typename MapT>
  89   const T *getNodeAs(const MapT &Bindings, StringRef ID) const {
  90     typename MapT::const_iterator It = Bindings.find(ID);
  91     if (It == Bindings.end()) {
  92       return NULL;
  93     }
  94     return llvm::dyn_cast<T>(It->second);
  95   }
  96
  97   std::map<std::string, const Decl*> DeclBindings;
  98   std::map<std::string, const Stmt*> StmtBindings;
  99
 100   friend class internal::BoundNodesTree;
 101 };
 102
 103 /// \brief If the provided matcher matches a node, binds the node to 'ID'.
 104 ///
 105 /// FIXME: Add example for accessing it.
 106 template <typename T>
 107 internal::Matcher<T> id(const std::string &ID,
 108                         const internal::BindableMatcher<T> &InnerMatcher) {
 109   return InnerMatcher.bind(ID);
 110 }
 111
 112 /// \brief Types of matchers for the top-level classes in the AST class
 113 /// hierarchy.
 114 /// @{
 115 typedef internal::Matcher<Decl> DeclarationMatcher;
 116 typedef internal::Matcher<QualType> TypeMatcher;
 117 typedef internal::Matcher<Stmt> StatementMatcher;
 118 /// @}
 119
 120 /// \brief Matches any node.
 121 ///
 122 /// Useful when another matcher requires a child matcher, but there's no
 123 /// additional constraint. This will often be used with an explicit conversion
 124 /// to a internal::Matcher<> type such as TypeMatcher.
 125 ///
 126 /// Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
 127 /// "int* p" and "void f()" in
 128 ///   int* p;
 129 ///   void f();
 130 inline internal::PolymorphicMatcherWithParam0<internal::TrueMatcher> anything() {
 131   return internal::PolymorphicMatcherWithParam0<internal::TrueMatcher>();
 132 }
 133
 134 /// \brief Matches declarations.
 135 ///
 136 /// Examples matches \c X, \c C, and the friend declaration inside \c C;
 137 /// \code
 138 ///   void X();
 139 ///   class C {
 140 ///     friend X;
 141 ///   };
 142 /// \endcode
 143 const internal::VariadicDynCastAllOfMatcher<Decl, Decl> decl;
 144
 145 /// \brief Matches a declaration of anything that could have a name.
 146 ///
 147 /// Example matches X, S, the anonymous union type, i, and U;
 148 ///   typedef int X;
 149 ///   struct S {
 150 ///     union {
 151 ///       int i;
 152 ///     } U;
 153 ///   };
 154 const internal::VariadicDynCastAllOfMatcher<
 155   Decl,
 156   NamedDecl> nameableDeclaration;
 157
 158 /// \brief Matches C++ class declarations.
 159 ///
 160 /// Example matches X, Z
 161 ///   class X;
 162 ///   template<class T> class Z {};
 163 const internal::VariadicDynCastAllOfMatcher<
 164   Decl,
 165   CXXRecordDecl> record;
 166
 167 /// \brief Matches C++ class template specializations.
 168 ///
 169 /// Given
 170 ///   template<typename T> class A {};
 171 ///   template<> class A<double> {};
 172 ///   A<int> a;
 173 /// classTemplateSpecialization()
 174 ///   matches the specializations \c A<int> and \c A<double>
 175 const internal::VariadicDynCastAllOfMatcher<
 176   Decl,
 177   ClassTemplateSpecializationDecl> classTemplateSpecialization;
 178
 179 /// \brief Matches classTemplateSpecializations that have at least one
 180 /// TemplateArgument matching the given Matcher.
 181 ///
 182 /// Given
 183 ///   template<typename T> class A {};
 184 ///   template<> class A<double> {};
 185 ///   A<int> a;
 186 /// classTemplateSpecialization(hasAnyTemplateArgument(
 187 ///     refersToType(asString("int"))))
 188 ///   matches the specialization \c A<int>
 189 AST_MATCHER_P(ClassTemplateSpecializationDecl, hasAnyTemplateArgument,
 190               internal::Matcher<TemplateArgument>, Matcher) {
 191   const TemplateArgumentList &List = Node.getTemplateArgs();
 192   for (unsigned i = 0; i < List.size(); ++i) {
 193     if (Matcher.matches(List.get(i), Finder, Builder))
 194       return true;
 195   }
 196   return false;
 197 }
 198
 199 /// \brief Matches expressions that match InnerMatcher after any implicit casts
 200 /// are stripped off.
 201 ///
 202 /// Parentheses and explicit casts are not discarded.
 203 /// Given
 204 ///   int arr[5];
 205 ///   int a = 0;
 206 ///   char b = 0;
 207 ///   const int c = a;
 208 ///   int *d = arr;
 209 ///   long e = (long) 0l;
 210 /// The matchers
 211 ///    variable(hasInitializer(ignoringImpCasts(integerLiteral())))
 212 ///    variable(hasInitializer(ignoringImpCasts(declarationReference())))
 213 /// would match the declarations for a, b, c, and d, but not e.
 214 /// while
 215 ///    variable(hasInitializer(integerLiteral()))
 216 ///    variable(hasInitializer(declarationReference()))
 217 /// only match the declarations for b, c, and d.
 218 AST_MATCHER_P(Expr, ignoringImpCasts,
 219               internal::Matcher<Expr>, InnerMatcher) {
 220   return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder);
 221 }
 222
 223 /// \brief Matches expressions that match InnerMatcher after parentheses and
 224 /// casts are stripped off.
 225 ///
 226 /// Implicit and non-C Style casts are also discarded.
 227 /// Given
 228 ///   int a = 0;
 229 ///   char b = (0);
 230 ///   void* c = reinterpret_cast<char*>(0);
 231 ///   char d = char(0);
 232 /// The matcher
 233 ///    variable(hasInitializer(ignoringParenCasts(integerLiteral())))
 234 /// would match the declarations for a, b, c, and d.
 235 /// while
 236 ///    variable(hasInitializer(integerLiteral()))
 237 /// only match the declaration for a.
 238 AST_MATCHER_P(Expr, ignoringParenCasts, internal::Matcher<Expr>, InnerMatcher) {
 239   return InnerMatcher.matches(*Node.IgnoreParenCasts(), Finder, Builder);
 240 }
 241
 242 /// \brief Matches expressions that match InnerMatcher after implicit casts and
 243 /// parentheses are stripped off.
 244 ///
 245 /// Explicit casts are not discarded.
 246 /// Given
 247 ///   int arr[5];
 248 ///   int a = 0;
 249 ///   char b = (0);
 250 ///   const int c = a;
 251 ///   int *d = (arr);
 252 ///   long e = ((long) 0l);
 253 /// The matchers
 254 ///    variable(hasInitializer(ignoringParenImpCasts(
 255 ///       integerLiteral())))
 256 ///    variable(hasInitializer(ignoringParenImpCasts(
 257 ///       declarationReference())))
 258 /// would match the declarations for a, b, c, and d, but not e.
 259 /// while
 260 ///    variable(hasInitializer(integerLiteral()))
 261 ///    variable(hasInitializer(declarationReference()))
 262 /// would only match the declaration for a.
 263 AST_MATCHER_P(Expr, ignoringParenImpCasts,
 264               internal::Matcher<Expr>, InnerMatcher) {
 265   return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder);
 266 }
 267
 268 /// \brief Matches classTemplateSpecializations where the n'th TemplateArgument
 269 /// matches the given Matcher.
 270 ///
 271 /// Given
 272 ///   template<typename T, typename U> class A {};
 273 ///   A<bool, int> b;
 274 ///   A<int, bool> c;
 275 /// classTemplateSpecialization(hasTemplateArgument(
 276 ///     1, refersToType(asString("int"))))
 277 ///   matches the specialization \c A<bool, int>
 278 AST_MATCHER_P2(ClassTemplateSpecializationDecl, hasTemplateArgument,
 279                unsigned, N, internal::Matcher<TemplateArgument>, Matcher) {
 280   const TemplateArgumentList &List = Node.getTemplateArgs();
 281   if (List.size() <= N)
 282     return false;
 283   return Matcher.matches(List.get(N), Finder, Builder);
 284 }
 285
 286 /// \brief Matches a TemplateArgument that refers to a certain type.
 287 ///
 288 /// Given
 289 ///   struct X {};
 290 ///   template<typename T> struct A {};
 291 ///   A<X> a;
 292 /// classTemplateSpecialization(hasAnyTemplateArgument(
 293 ///     refersToType(class(hasName("X")))))
 294 ///   matches the specialization \c A<X>
 295 AST_MATCHER_P(TemplateArgument, refersToType,
 296               internal::Matcher<QualType>, Matcher) {
 297   if (Node.getKind() != TemplateArgument::Type)
 298     return false;
 299   return Matcher.matches(Node.getAsType(), Finder, Builder);
 300 }
 301
 302 /// \brief Matches a TemplateArgument that refers to a certain declaration.
 303 ///
 304 /// Given
 305 ///   template<typename T> struct A {};
 306 ///   struct B { B* next; };
 307 ///   A<&B::next> a;
 308 /// classTemplateSpecialization(hasAnyTemplateArgument(
 309 ///     refersToDeclaration(field(hasName("next"))))
 310 ///   matches the specialization \c A<&B::next> with \c field(...) matching
 311 ///     \c B::next
 312 AST_MATCHER_P(TemplateArgument, refersToDeclaration,
 313               internal::Matcher<Decl>, Matcher) {
 314   if (const Decl *Declaration = Node.getAsDecl())
 315     return Matcher.matches(*Declaration, Finder, Builder);
 316   return false;
 317 }
 318
 319 /// \brief Matches C++ constructor declarations.
 320 ///
 321 /// Example matches Foo::Foo() and Foo::Foo(int)
 322 ///   class Foo {
 323 ///    public:
 324 ///     Foo();
 325 ///     Foo(int);
 326 ///     int DoSomething();
 327 ///   };
 328 const internal::VariadicDynCastAllOfMatcher<
 329   Decl,
 330   CXXConstructorDecl> constructor;
 331
 332 /// \brief Matches explicit C++ destructor declarations.
 333 ///
 334 /// Example matches Foo::~Foo()
 335 ///   class Foo {
 336 ///    public:
 337 ///     virtual ~Foo();
 338 ///   };
 339 const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl> destructor;
 340
 341 /// \brief Matches enum declarations.
 342 ///
 343 /// Example matches X
 344 ///   enum X {
 345 ///     A, B, C
 346 ///   };
 347 const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
 348
 349 /// \brief Matches enum constants.
 350 ///
 351 /// Example matches A, B, C
 352 ///   enum X {
 353 ///     A, B, C
 354 ///   };
 355 const internal::VariadicDynCastAllOfMatcher<
 356   Decl,
 357   EnumConstantDecl> enumConstant;
 358
 359 /// \brief Matches method declarations.
 360 ///
 361 /// Example matches y
 362 ///   class X { void y() };
 363 const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> method;
 364
 365 /// \brief Matches variable declarations.
 366 ///
 367 /// Note: this does not match declarations of member variables, which are
 368 /// "field" declarations in Clang parlance.
 369 ///
 370 /// Example matches a
 371 ///   int a;
 372 const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> variable;
 373
 374 /// \brief Matches field declarations.
 375 ///
 376 /// Given
 377 ///   class X { int m; };
 378 /// field()
 379 ///   matches 'm'.
 380 const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> field;
 381
 382 /// \brief Matches function declarations.
 383 ///
 384 /// Example matches f
 385 ///   void f();
 386 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> function;
 387
 388
 389 /// \brief Matches statements.
 390 ///
 391 /// Given
 392 ///   { ++a; }
 393 /// statement()
 394 ///   matches both the compound statement '{ ++a; }' and '++a'.
 395 const internal::VariadicDynCastAllOfMatcher<Stmt, Stmt> statement;
 396
 397 /// \brief Matches declaration statements.
 398 ///
 399 /// Given
 400 ///   int a;
 401 /// declarationStatement()
 402 ///   matches 'int a'.
 403 const internal::VariadicDynCastAllOfMatcher<
 404   Stmt,
 405   DeclStmt> declarationStatement;
 406
 407 /// \brief Matches member expressions.
 408 ///
 409 /// Given
 410 ///   class Y {
 411 ///     void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
 412 ///     int a; static int b;
 413 ///   };
 414 /// memberExpression()
 415 ///   matches this->x, x, y.x, a, this->b
 416 const internal::VariadicDynCastAllOfMatcher<
 417   Stmt,
 418   MemberExpr> memberExpression;
 419
 420 /// \brief Matches call expressions.
 421 ///
 422 /// Example matches x.y() and y()
 423 ///   X x;
 424 ///   x.y();
 425 ///   y();
 426 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> call;
 427
 428 /// \brief Matches member call expressions.
 429 ///
 430 /// Example matches x.y()
 431 ///   X x;
 432 ///   x.y();
 433 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr> memberCall;
 434
 435 /// \brief Matches init list expressions.
 436 ///
 437 /// Given
 438 ///   int a[] = { 1, 2 };
 439 ///   struct B { int x, y; };
 440 ///   B b = { 5, 6 };
 441 /// initList()
 442 ///   matches "{ 1, 2 }" and "{ 5, 6 }"
 443 const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
 444
 445 /// \brief Matches using declarations.
 446 ///
 447 /// Given
 448 ///   namespace X { int x; }
 449 ///   using X::x;
 450 /// usingDecl()
 451 ///   matches \code using X::x \endcode
 452 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
 453
 454 /// \brief Matches constructor call expressions (including implicit ones).
 455 ///
 456 /// Example matches string(ptr, n) and ptr within arguments of f
 457 ///     (matcher = constructorCall())
 458 ///   void f(const string &a, const string &b);
 459 ///   char *ptr;
 460 ///   int n;
 461 ///   f(string(ptr, n), ptr);
 462 const internal::VariadicDynCastAllOfMatcher<
 463   Stmt,
 464   CXXConstructExpr> constructorCall;
 465
 466 /// \brief Matches nodes where temporaries are created.
 467 ///
 468 /// Example matches FunctionTakesString(GetStringByValue())
 469 ///     (matcher = bindTemporaryExpression())
 470 ///   FunctionTakesString(GetStringByValue());
 471 ///   FunctionTakesStringByPointer(GetStringPointer());
 472 const internal::VariadicDynCastAllOfMatcher<
 473   Stmt,
 474   CXXBindTemporaryExpr> bindTemporaryExpression;
 475
 476 /// \brief Matches new expressions.
 477 ///
 478 /// Given
 479 ///   new X;
 480 /// newExpression()
 481 ///   matches 'new X'.
 482 const internal::VariadicDynCastAllOfMatcher<
 483   Stmt,
 484   CXXNewExpr> newExpression;
 485
 486 /// \brief Matches delete expressions.
 487 ///
 488 /// Given
 489 ///   delete X;
 490 /// deleteExpression()
 491 ///   matches 'delete X'.
 492 const internal::VariadicDynCastAllOfMatcher<
 493   Stmt,
 494   CXXDeleteExpr> deleteExpression;
 495
 496 /// \brief Matches array subscript expressions.
 497 ///
 498 /// Given
 499 ///   int i = a[1];
 500 /// arraySubscriptExpr()
 501 ///   matches "a[1]"
 502 const internal::VariadicDynCastAllOfMatcher<
 503   Stmt,
 504   ArraySubscriptExpr> arraySubscriptExpr;
 505
 506 /// \brief Matches the value of a default argument at the call site.
 507 ///
 508 /// Example matches the CXXDefaultArgExpr placeholder inserted for the
 509 ///     default value of the second parameter in the call expression f(42)
 510 ///     (matcher = defaultArgument())
 511 ///   void f(int x, int y = 0);
 512 ///   f(42);
 513 const internal::VariadicDynCastAllOfMatcher<
 514   Stmt,
 515   CXXDefaultArgExpr> defaultArgument;
 516
 517 /// \brief Matches overloaded operator calls.
 518 ///
 519 /// Note that if an operator isn't overloaded, it won't match. Instead, use
 520 /// binaryOperator matcher.
 521 /// Currently it does not match operators such as new delete.
 522 /// FIXME: figure out why these do not match?
 523 ///
 524 /// Example matches both operator<<((o << b), c) and operator<<(o, b)
 525 ///     (matcher = overloadedOperatorCall())
 526 ///   ostream &operator<< (ostream &out, int i) { };
 527 ///   ostream &o; int b = 1, c = 1;
 528 ///   o << b << c;
 529 const internal::VariadicDynCastAllOfMatcher<
 530   Stmt,
 531   CXXOperatorCallExpr> overloadedOperatorCall;
 532
 533 /// \brief Matches expressions.
 534 ///
 535 /// Example matches x()
 536 ///   void f() { x(); }
 537 const internal::VariadicDynCastAllOfMatcher<
 538   Stmt,
 539   Expr> expression;
 540
 541 /// \brief Matches expressions that refer to declarations.
 542 ///
 543 /// Example matches x in if (x)
 544 ///   bool x;
 545 ///   if (x) {}
 546 const internal::VariadicDynCastAllOfMatcher<
 547   Stmt,
 548   DeclRefExpr> declarationReference;
 549
 550 /// \brief Matches if statements.
 551 ///
 552 /// Example matches 'if (x) {}'
 553 ///   if (x) {}
 554 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
 555
 556 /// \brief Matches for statements.
 557 ///
 558 /// Example matches 'for (;;) {}'
 559 ///   for (;;) {}
 560 const internal::VariadicDynCastAllOfMatcher<
 561   Stmt, ForStmt> forStmt;
 562
 563 /// \brief Matches the increment statement of a for loop.
 564 ///
 565 /// Example:
 566 ///     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
 567 /// matches '++x' in
 568 ///     for (x; x < N; ++x) { }
 569 AST_MATCHER_P(ForStmt, hasIncrement, internal::Matcher<Stmt>,
 570               InnerMatcher) {
 571   const Stmt *const Increment = Node.getInc();
 572   return (Increment != NULL &&
 573           InnerMatcher.matches(*Increment, Finder, Builder));
 574 }
 575
 576 /// \brief Matches the initialization statement of a for loop.
 577 ///
 578 /// Example:
 579 ///     forStmt(hasLoopInit(declarationStatement()))
 580 /// matches 'int x = 0' in
 581 ///     for (int x = 0; x < N; ++x) { }
 582 AST_MATCHER_P(ForStmt, hasLoopInit, internal::Matcher<Stmt>,
 583               InnerMatcher) {
 584   const Stmt *const Init = Node.getInit();
 585   return (Init != NULL && InnerMatcher.matches(*Init, Finder, Builder));
 586 }
 587
 588 /// \brief Matches while statements.
 589 ///
 590 /// Given
 591 ///   while (true) {}
 592 /// whileStmt()
 593 ///   matches 'while (true) {}'.
 594 const internal::VariadicDynCastAllOfMatcher<
 595   Stmt,
 596   WhileStmt> whileStmt;
 597
 598 /// \brief Matches do statements.
 599 ///
 600 /// Given
 601 ///   do {} while (true);
 602 /// doStmt()
 603 ///   matches 'do {} while(true)'
 604 const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
 605
 606 /// \brief Matches case and default statements inside switch statements.
 607 ///
 608 /// Given
 609 ///   switch(a) { case 42: break; default: break; }
 610 /// switchCase()
 611 ///   matches 'case 42: break;' and 'default: break;'.
 612 const internal::VariadicDynCastAllOfMatcher<
 613   Stmt,
 614   SwitchCase> switchCase;
 615
 616 /// \brief Matches compound statements.
 617 ///
 618 /// Example matches '{}' and '{{}}'in 'for (;;) {{}}'
 619 ///   for (;;) {{}}
 620 const internal::VariadicDynCastAllOfMatcher<
 621   Stmt,
 622   CompoundStmt> compoundStatement;
 623
 624 /// \brief Matches bool literals.
 625 ///
 626 /// Example matches true
 627 ///   true
 628 const internal::VariadicDynCastAllOfMatcher<
 629   Expr,
 630   CXXBoolLiteralExpr> boolLiteral;
 631
 632 /// \brief Matches string literals (also matches wide string literals).
 633 ///
 634 /// Example matches "abcd", L"abcd"
 635 ///   char *s = "abcd"; wchar_t *ws = L"abcd"
 636 const internal::VariadicDynCastAllOfMatcher<
 637   Expr,
 638   StringLiteral> stringLiteral;
 639
 640 /// \brief Matches character literals (also matches wchar_t).
 641 ///
 642 /// Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
 643 /// though.
 644 ///
 645 /// Example matches 'a', L'a'
 646 ///   char ch = 'a'; wchar_t chw = L'a';
 647 const internal::VariadicDynCastAllOfMatcher<
 648   Expr,
 649   CharacterLiteral> characterLiteral;
 650
 651 /// \brief Matches integer literals of all sizes / encodings.
 652 ///
 653 /// Not matching character-encoded integers such as L'a'.
 654 ///
 655 /// Example matches 1, 1L, 0x1, 1U
 656 const internal::VariadicDynCastAllOfMatcher<
 657   Expr,
 658   IntegerLiteral> integerLiteral;
 659
 660 /// \brief Matches binary operator expressions.
 661 ///
 662 /// Example matches a || b
 663 ///   !(a || b)
 664 const internal::VariadicDynCastAllOfMatcher<
 665   Stmt,
 666   BinaryOperator> binaryOperator;
 667
 668 /// \brief Matches unary operator expressions.
 669 ///
 670 /// Example matches !a
 671 ///   !a || b
 672 const internal::VariadicDynCastAllOfMatcher<
 673   Stmt,
 674   UnaryOperator> unaryOperator;
 675
 676 /// \brief Matches conditional operator expressions.
 677 ///
 678 /// Example matches a ? b : c
 679 ///   (a ? b : c) + 42
 680 const internal::VariadicDynCastAllOfMatcher<
 681   Stmt,
 682   ConditionalOperator> conditionalOperator;
 683
 684 /// \brief Matches a reinterpret_cast expression.
 685 ///
 686 /// Either the source expression or the destination type can be matched
 687 /// using has(), but hasDestinationType() is more specific and can be
 688 /// more readable.
 689 ///
 690 /// Example matches reinterpret_cast<char*>(&p) in
 691 ///   void* p = reinterpret_cast<char*>(&p);
 692 const internal::VariadicDynCastAllOfMatcher<
 693   Expr,
 694   CXXReinterpretCastExpr> reinterpretCast;
 695
 696 /// \brief Matches a C++ static_cast expression.
 697 ///
 698 /// \see hasDestinationType
 699 /// \see reinterpretCast
 700 ///
 701 /// Example:
 702 ///   staticCast()
 703 /// matches
 704 ///   static_cast<long>(8)
 705 /// in
 706 ///   long eight(static_cast<long>(8));
 707 const internal::VariadicDynCastAllOfMatcher<
 708   Expr,
 709   CXXStaticCastExpr> staticCast;
 710
 711 /// \brief Matches a dynamic_cast expression.
 712 ///
 713 /// Example:
 714 ///   dynamicCast()
 715 /// matches
 716 ///   dynamic_cast<D*>(&b);
 717 /// in
 718 ///   struct B { virtual ~B() {} }; struct D : B {};
 719 ///   B b;
 720 ///   D* p = dynamic_cast<D*>(&b);
 721 const internal::VariadicDynCastAllOfMatcher<
 722   Expr,
 723   CXXDynamicCastExpr> dynamicCast;
 724
 725 /// \brief Matches a const_cast expression.
 726 ///
 727 /// Example: Matches const_cast<int*>(&r) in
 728 ///   int n = 42;
 729 ///   const int& r(n);
 730 ///   int* p = const_cast<int*>(&r);
 731 const internal::VariadicDynCastAllOfMatcher<
 732   Expr,
 733   CXXConstCastExpr> constCast;
 734
 735 /// \brief Matches explicit cast expressions.
 736 ///
 737 /// Matches any cast expression written in user code, whether it be a
 738 /// C-style cast, a functional-style cast, or a keyword cast.
 739 ///
 740 /// Does not match implicit conversions.
 741 ///
 742 /// Note: the name "explicitCast" is chosen to match Clang's terminology, as
 743 /// Clang uses the term "cast" to apply to implicit conversions as well as to
 744 /// actual cast expressions.
 745 ///
 746 /// \see hasDestinationType.
 747 ///
 748 /// Example: matches all five of the casts in
 749 ///   int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42)))))
 750 /// but does not match the implicit conversion in
 751 ///   long ell = 42;
 752 const internal::VariadicDynCastAllOfMatcher<
 753   Expr,
 754   ExplicitCastExpr> explicitCast;
 755
 756 /// \brief Matches the implicit cast nodes of Clang's AST.
 757 ///
 758 /// This matches many different places, including function call return value
 759 /// eliding, as well as any type conversions.
 760 const internal::VariadicDynCastAllOfMatcher<
 761   Expr,
 762   ImplicitCastExpr> implicitCast;
 763
 764 /// \brief Matches any cast nodes of Clang's AST.
 765 ///
 766 /// Example: castExpr() matches each of the following:
 767 ///   (int) 3;
 768 ///   const_cast<Expr *>(SubExpr);
 769 ///   char c = 0;
 770 /// but does not match
 771 ///   int i = (0);
 772 ///   int k = 0;
 773 const internal::VariadicDynCastAllOfMatcher<
 774   Expr,
 775   CastExpr> castExpr;
 776
 777 /// \brief Matches functional cast expressions
 778 ///
 779 /// Example: Matches Foo(bar);
 780 ///   Foo f = bar;
 781 ///   Foo g = (Foo) bar;
 782 ///   Foo h = Foo(bar);
 783 const internal::VariadicDynCastAllOfMatcher<
 784   Expr,
 785   CXXFunctionalCastExpr> functionalCast;
 786
 787 /// \brief Various overloads for the anyOf matcher.
 788 /// @{
 789 template<typename C1, typename C2>
 790 internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C1, C2>
 791 anyOf(const C1 &P1, const C2 &P2) {
 792   return internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher,
 793                                                 C1, C2 >(P1, P2);
 794 }
 795 template<typename C1, typename C2, typename C3>
 796 internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C1,
 797     internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C2, C3> >
 798 anyOf(const C1 &P1, const C2 &P2, const C3 &P3) {
 799   return anyOf(P1, anyOf(P2, P3));
 800 }
 801 template<typename C1, typename C2, typename C3, typename C4>
 802 internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C1,
 803     internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C2,
 804         internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher,
 805                                                C3, C4> > >
 806 anyOf(const C1 &P1, const C2 &P2, const C3 &P3, const C4 &P4) {
 807   return anyOf(P1, anyOf(P2, anyOf(P3, P4)));
 808 }
 809 template<typename C1, typename C2, typename C3, typename C4, typename C5>
 810 internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C1,
 811     internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C2,
 812         internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher, C3,
 813             internal::PolymorphicMatcherWithParam2<internal::AnyOfMatcher,
 814                                                    C4, C5> > > >
 815 anyOf(const C1& P1, const C2& P2, const C3& P3, const C4& P4, const C5& P5) {
 816   return anyOf(P1, anyOf(P2, anyOf(P3, anyOf(P4, P5))));
 817 }
 818 /// @}
 819
 820 /// \brief Various overloads for the allOf matcher.
 821 /// @{
 822 template<typename C1, typename C2>
 823 internal::PolymorphicMatcherWithParam2<internal::AllOfMatcher, C1, C2>
 824 allOf(const C1 &P1, const C2 &P2) {
 825   return internal::PolymorphicMatcherWithParam2<internal::AllOfMatcher,
 826                                                 C1, C2>(P1, P2);
 827 }
 828 template<typename C1, typename C2, typename C3>
 829 internal::PolymorphicMatcherWithParam2<internal::AllOfMatcher, C1,
 830     internal::PolymorphicMatcherWithParam2<internal::AllOfMatcher, C2, C3> >
 831 allOf(const C1& P1, const C2& P2, const C3& P3) {
 832   return allOf(P1, allOf(P2, P3));
 833 }
 834 /// @}
 835
 836 /// \brief Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
 837 ///
 838 /// Given
 839 ///   Foo x = bar;
 840 ///   int y = sizeof(x) + alignof(x);
 841 /// unaryExprOrTypeTraitExpr()
 842 ///   matches \c sizeof(x) and \c alignof(x)
 843 const internal::VariadicDynCastAllOfMatcher<
 844   Stmt,
 845   UnaryExprOrTypeTraitExpr> unaryExprOrTypeTraitExpr;
 846
 847 /// \brief Matches unary expressions that have a specific type of argument.
 848 ///
 849 /// Given
 850 ///   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
 851 /// unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
 852 ///   matches \c sizeof(a) and \c alignof(c)
 853 AST_MATCHER_P(UnaryExprOrTypeTraitExpr, hasArgumentOfType,
 854               internal::Matcher<QualType>, Matcher) {
 855   const QualType ArgumentType = Node.getTypeOfArgument();
 856   return Matcher.matches(ArgumentType, Finder, Builder);
 857 }
 858
 859 /// \brief Matches unary expressions of a certain kind.
 860 ///
 861 /// Given
 862 ///   int x;
 863 ///   int s = sizeof(x) + alignof(x)
 864 /// unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
 865 ///   matches \c sizeof(x)
 866 AST_MATCHER_P(UnaryExprOrTypeTraitExpr, ofKind, UnaryExprOrTypeTrait, Kind) {
 867   return Node.getKind() == Kind;
 868 }
 869
 870 /// \brief Same as unaryExprOrTypeTraitExpr, but only matching
 871 /// alignof.
 872 inline internal::Matcher<Stmt> alignOfExpr(
 873     const internal::Matcher<UnaryExprOrTypeTraitExpr> &Matcher) {
 874   return internal::Matcher<Stmt>(unaryExprOrTypeTraitExpr(allOf(
 875       ofKind(UETT_AlignOf), Matcher)));
 876 }
 877
 878 /// \brief Same as unaryExprOrTypeTraitExpr, but only matching
 879 /// sizeof.
 880 inline internal::Matcher<Stmt> sizeOfExpr(
 881     const internal::Matcher<UnaryExprOrTypeTraitExpr> &Matcher) {
 882   return internal::Matcher<Stmt>(unaryExprOrTypeTraitExpr(allOf(
 883       ofKind(UETT_SizeOf), Matcher)));
 884 }
 885
 886 /// \brief Matches NamedDecl nodes that have the specified name.
 887 ///
 888 /// Supports specifying enclosing namespaces or classes by prefixing the name
 889 /// with '<enclosing>::'.
 890 /// Does not match typedefs of an underlying type with the given name.
 891 ///
 892 /// Example matches X (Name == "X")
 893 ///   class X;
 894 ///
 895 /// Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
 896 /// namespace a { namespace b { class X; } }
 897 AST_MATCHER_P(NamedDecl, hasName, std::string, Name) {
 898   assert(!Name.empty());
 899   const std::string FullNameString = "::" + Node.getQualifiedNameAsString();
 900   const llvm::StringRef FullName = FullNameString;
 901   const llvm::StringRef Pattern = Name;
 902   if (Pattern.startswith("::")) {
 903     return FullName == Pattern;
 904   } else {
 905     return FullName.endswith(("::" + Pattern).str());
 906   }
 907 }
 908
 909 /// \brief Matches NamedDecl nodes whose full names partially match the
 910 /// given RegExp.
 911 ///
 912 /// Supports specifying enclosing namespaces or classes by
 913 /// prefixing the name with '<enclosing>::'.  Does not match typedefs
 914 /// of an underlying type with the given name.
 915 ///
 916 /// Example matches X (regexp == "::X")
 917 ///   class X;
 918 ///
 919 /// Example matches X (regexp is one of "::X", "^foo::.*X", among others)
 920 /// namespace foo { namespace bar { class X; } }
 921 AST_MATCHER_P(NamedDecl, matchesName, std::string, RegExp) {
 922   assert(!RegExp.empty());
 923   std::string FullNameString = "::" + Node.getQualifiedNameAsString();
 924   llvm::Regex RE(RegExp);
 925   return RE.match(FullNameString);
 926 }
 927
 928 /// \brief Matches overloaded operator names.
 929 ///
 930 /// Matches overloaded operator names specified in strings without the
 931 /// "operator" prefix, such as "<<", for OverloadedOperatorCall's.
 932 ///
 933 /// Example matches a << b
 934 ///     (matcher == overloadedOperatorCall(hasOverloadedOperatorName("<<")))
 935 ///   a << b;
 936 ///   c && d;  // assuming both operator<<
 937 ///            // and operator&& are overloaded somewhere.
 938 AST_MATCHER_P(CXXOperatorCallExpr,
 939               hasOverloadedOperatorName, std::string, Name) {
 940   return getOperatorSpelling(Node.getOperator()) == Name;
 941 }
 942
 943 /// \brief Matches C++ classes that are directly or indirectly derived from
 944 /// a class matching \c Base.
 945 ///
 946 /// Note that a class is considered to be also derived from itself.
 947 ///
 948 /// Example matches X, Y, Z, C (Base == hasName("X"))
 949 ///   class X;                // A class is considered to be derived from itself
 950 ///   class Y : public X {};  // directly derived
 951 ///   class Z : public Y {};  // indirectly derived
 952 ///   typedef X A;
 953 ///   typedef A B;
 954 ///   class C : public B {};  // derived from a typedef of X
 955 ///
 956 /// In the following example, Bar matches isDerivedFrom(hasName("X")):
 957 ///   class Foo;
 958 ///   typedef Foo X;
 959 ///   class Bar : public Foo {};  // derived from a type that X is a typedef of
 960 AST_MATCHER_P(CXXRecordDecl, isDerivedFrom,
 961               internal::Matcher<NamedDecl>, Base) {
 962   return Finder->classIsDerivedFrom(&Node, Base, Builder);
 963 }
 964
 965 /// \brief Overloaded method as shortcut for \c isDerivedFrom(hasName(...)).
 966 inline internal::Matcher<CXXRecordDecl> isDerivedFrom(StringRef BaseName) {
 967   assert(!BaseName.empty());
 968   return isDerivedFrom(hasName(BaseName));
 969 }
 970
 971 /// \brief Matches AST nodes that have child AST nodes that match the
 972 /// provided matcher.
 973 ///
 974 /// Example matches X, Y (matcher = record(has(record(hasName("X")))
 975 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 976 ///   class Y { class X {}; };
 977 ///   class Z { class Y { class X {}; }; };  // Does not match Z.
 978 ///
 979 /// ChildT must be an AST base type.
 980 template <typename ChildT>
 981 internal::ArgumentAdaptingMatcher<internal::HasMatcher, ChildT> has(
 982     const internal::Matcher<ChildT> &ChildMatcher) {
 983   return internal::ArgumentAdaptingMatcher<internal::HasMatcher,
 984                                            ChildT>(ChildMatcher);
 985 }
 986
 987 /// \brief Matches AST nodes that have descendant AST nodes that match the
 988 /// provided matcher.
 989 ///
 990 /// Example matches X, Y, Z
 991 ///     (matcher = record(hasDescendant(record(hasName("X")))))
 992 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 993 ///   class Y { class X {}; };
 994 ///   class Z { class Y { class X {}; }; };
 995 ///
 996 /// DescendantT must be an AST base type.
 997 template <typename DescendantT>
 998 internal::ArgumentAdaptingMatcher<internal::HasDescendantMatcher, DescendantT>
 999 hasDescendant(const internal::Matcher<DescendantT> &DescendantMatcher) {
1000   return internal::ArgumentAdaptingMatcher<
1001     internal::HasDescendantMatcher,
1002     DescendantT>(DescendantMatcher);
1003 }
1004
1005
1006 /// \brief Matches AST nodes that have child AST nodes that match the
1007 /// provided matcher.
1008 ///
1009 /// Example matches X, Y (matcher = record(forEach(record(hasName("X")))
1010 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
1011 ///   class Y { class X {}; };
1012 ///   class Z { class Y { class X {}; }; };  // Does not match Z.
1013 ///
1014 /// ChildT must be an AST base type.
1015 ///
1016 /// As opposed to 'has', 'forEach' will cause a match for each result that
1017 /// matches instead of only on the first one.
1018 template <typename ChildT>
1019 internal::ArgumentAdaptingMatcher<internal::ForEachMatcher, ChildT> forEach(
1020     const internal::Matcher<ChildT>& ChildMatcher) {
1021   return internal::ArgumentAdaptingMatcher<
1022     internal::ForEachMatcher,
1023     ChildT>(ChildMatcher);
1024 }
1025
1026 /// \brief Matches AST nodes that have descendant AST nodes that match the
1027 /// provided matcher.
1028 ///
1029 /// Example matches X, A, B, C
1030 ///     (matcher = record(forEachDescendant(record(hasName("X")))))
1031 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
1032 ///   class A { class X {}; };
1033 ///   class B { class C { class X {}; }; };
1034 ///
1035 /// DescendantT must be an AST base type.
1036 ///
1037 /// As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
1038 /// each result that matches instead of only on the first one.
1039 ///
1040 /// Note: Recursively combined ForEachDescendant can cause many matches:
1041 ///   record(forEachDescendant(record(forEachDescendant(record()))))
1042 /// will match 10 times (plus injected class name matches) on:
1043 ///   class A { class B { class C { class D { class E {}; }; }; }; };
1044 template <typename DescendantT>
1045 internal::ArgumentAdaptingMatcher<internal::ForEachDescendantMatcher, DescendantT>
1046 forEachDescendant(
1047     const internal::Matcher<DescendantT>& DescendantMatcher) {
1048   return internal::ArgumentAdaptingMatcher<
1049     internal::ForEachDescendantMatcher,
1050     DescendantT>(DescendantMatcher);
1051 }
1052
1053 /// \brief Matches if the provided matcher does not match.
1054 ///
1055 /// Example matches Y (matcher = record(unless(hasName("X"))))
1056 ///   class X {};
1057 ///   class Y {};
1058 template <typename M>
1059 internal::PolymorphicMatcherWithParam1<internal::NotMatcher, M> unless(const M &InnerMatcher) {
1060   return internal::PolymorphicMatcherWithParam1<
1061     internal::NotMatcher, M>(InnerMatcher);
1062 }
1063
1064 /// \brief Matches a type if the declaration of the type matches the given
1065 /// matcher.
1066 ///
1067 /// Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>
1068 inline internal::PolymorphicMatcherWithParam1< internal::HasDeclarationMatcher,
1069                                      internal::Matcher<Decl> >
1070     hasDeclaration(const internal::Matcher<Decl> &InnerMatcher) {
1071   return internal::PolymorphicMatcherWithParam1<
1072     internal::HasDeclarationMatcher,
1073     internal::Matcher<Decl> >(InnerMatcher);
1074 }
1075
1076 /// \brief Matches on the implicit object argument of a member call expression.
1077 ///
1078 /// Example matches y.x() (matcher = call(on(hasType(record(hasName("Y"))))))
1079 ///   class Y { public: void x(); };
1080 ///   void z() { Y y; y.x(); }",
1081 ///
1082 /// FIXME: Overload to allow directly matching types?
1083 AST_MATCHER_P(CXXMemberCallExpr, on, internal::Matcher<Expr>,
1084               InnerMatcher) {
1085   const Expr *ExprNode = const_cast<CXXMemberCallExpr&>(Node)
1086       .getImplicitObjectArgument()
1087       ->IgnoreParenImpCasts();
1088   return (ExprNode != NULL &&
1089           InnerMatcher.matches(*ExprNode, Finder, Builder));
1090 }
1091
1092 /// \brief Matches if the call expression's callee expression matches.
1093 ///
1094 /// Given
1095 ///   class Y { void x() { this->x(); x(); Y y; y.x(); } };
1096 ///   void f() { f(); }
1097 /// call(callee(expression()))
1098 ///   matches this->x(), x(), y.x(), f()
1099 /// with callee(...)
1100 ///   matching this->x, x, y.x, f respectively
1101 ///
1102 /// Note: Callee cannot take the more general internal::Matcher<Expr>
1103 /// because this introduces ambiguous overloads with calls to Callee taking a
1104 /// internal::Matcher<Decl>, as the matcher hierarchy is purely
1105 /// implemented in terms of implicit casts.
1106 AST_MATCHER_P(CallExpr, callee, internal::Matcher<Stmt>,
1107               InnerMatcher) {
1108   const Expr *ExprNode = Node.getCallee();
1109   return (ExprNode != NULL &&
1110           InnerMatcher.matches(*ExprNode, Finder, Builder));
1111 }
1112
1113 /// \brief Matches if the call expression's callee's declaration matches the
1114 /// given matcher.
1115 ///
1116 /// Example matches y.x() (matcher = call(callee(method(hasName("x")))))
1117 ///   class Y { public: void x(); };
1118 ///   void z() { Y y; y.x();
1119 inline internal::Matcher<CallExpr> callee(
1120     const internal::Matcher<Decl> &InnerMatcher) {
1121   return internal::Matcher<CallExpr>(hasDeclaration(InnerMatcher));
1122 }
1123
1124 /// \brief Matches if the expression's or declaration's type matches a type
1125 /// matcher.
1126 ///
1127 /// Example matches x (matcher = expression(hasType(
1128 ///                        hasDeclaration(record(hasName("X"))))))
1129 ///             and z (matcher = variable(hasType(
1130 ///                        hasDeclaration(record(hasName("X"))))))
1131 ///  class X {};
1132 ///  void y(X &x) { x; X z; }
1133 AST_POLYMORPHIC_MATCHER_P(hasType, internal::Matcher<QualType>,
1134                           InnerMatcher) {
1135   TOOLING_COMPILE_ASSERT((llvm::is_base_of<Expr, NodeType>::value ||
1136                           llvm::is_base_of<ValueDecl, NodeType>::value),
1137                          instantiated_with_wrong_types);
1138   return InnerMatcher.matches(Node.getType(), Finder, Builder);
1139 }
1140
1141 /// \brief Overloaded to match the declaration of the expression's or value
1142 /// declaration's type.
1143 ///
1144 /// In case of a value declaration (for example a variable declaration),
1145 /// this resolves one layer of indirection. For example, in the value
1146 /// declaration "X x;", record(hasName("X")) matches the declaration of X,
1147 /// while variable(hasType(record(hasName("X")))) matches the declaration
1148 /// of x."
1149 ///
1150 /// Example matches x (matcher = expression(hasType(record(hasName("X")))))
1151 ///             and z (matcher = variable(hasType(record(hasName("X")))))
1152 ///  class X {};
1153 ///  void y(X &x) { x; X z; }
1154 ///
1155 /// Usable as: Matcher<Expr>, Matcher<ValueDecl>
1156 inline internal::PolymorphicMatcherWithParam1<
1157   internal::matcher_hasTypeMatcher,
1158   internal::Matcher<QualType> >
1159 hasType(const internal::Matcher<Decl> &InnerMatcher) {
1160   return hasType(internal::Matcher<QualType>(
1161     hasDeclaration(InnerMatcher)));
1162 }
1163
1164 /// \brief Matches if the matched type is represented by the given string.
1165 ///
1166 /// Given
1167 ///   class Y { public: void x(); };
1168 ///   void z() { Y* y; y->x(); }
1169 /// call(on(hasType(asString("class Y *"))))
1170 ///   matches y->x()
1171 AST_MATCHER_P(QualType, asString, std::string, Name) {
1172   return Name == Node.getAsString();
1173 }
1174
1175 /// \brief Matches if the matched type is a pointer type and the pointee type
1176 /// matches the specified matcher.
1177 ///
1178 /// Example matches y->x()
1179 ///     (matcher = call(on(hasType(pointsTo(record(hasName("Y")))))))
1180 ///   class Y { public: void x(); };
1181 ///   void z() { Y *y; y->x(); }
1182 AST_MATCHER_P(
1183     QualType, pointsTo, internal::Matcher<QualType>,
1184     InnerMatcher) {
1185   return (!Node.isNull() && Node->isPointerType() &&
1186           InnerMatcher.matches(Node->getPointeeType(), Finder, Builder));
1187 }
1188
1189 /// \brief Overloaded to match the pointee type's declaration.
1190 inline internal::Matcher<QualType> pointsTo(
1191     const internal::Matcher<Decl> &InnerMatcher) {
1192   return pointsTo(internal::Matcher<QualType>(
1193     hasDeclaration(InnerMatcher)));
1194 }
1195
1196 /// \brief Matches if the matched type is a reference type and the referenced
1197 /// type matches the specified matcher.
1198 ///
1199 /// Example matches X &x and const X &y
1200 ///     (matcher = variable(hasType(references(record(hasName("X"))))))
1201 ///   class X {
1202 ///     void a(X b) {
1203 ///       X &x = b;
1204 ///       const X &y = b;
1205 ///   };
1206 AST_MATCHER_P(QualType, references, internal::Matcher<QualType>,
1207               InnerMatcher) {
1208   return (!Node.isNull() && Node->isReferenceType() &&
1209           InnerMatcher.matches(Node->getPointeeType(), Finder, Builder));
1210 }
1211
1212 /// \brief Overloaded to match the referenced type's declaration.
1213 inline internal::Matcher<QualType> references(
1214     const internal::Matcher<Decl> &InnerMatcher) {
1215   return references(internal::Matcher<QualType>(
1216     hasDeclaration(InnerMatcher)));
1217 }
1218
1219 AST_MATCHER_P(CXXMemberCallExpr, onImplicitObjectArgument,
1220               internal::Matcher<Expr>, InnerMatcher) {
1221   const Expr *ExprNode =
1222       const_cast<CXXMemberCallExpr&>(Node).getImplicitObjectArgument();
1223   return (ExprNode != NULL &&
1224           InnerMatcher.matches(*ExprNode, Finder, Builder));
1225 }
1226
1227 /// \brief Matches if the expression's type either matches the specified
1228 /// matcher, or is a pointer to a type that matches the InnerMatcher.
1229 inline internal::Matcher<CXXMemberCallExpr> thisPointerType(
1230     const internal::Matcher<QualType> &InnerMatcher) {
1231   return onImplicitObjectArgument(
1232       anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))));
1233 }
1234
1235 /// \brief Overloaded to match the type's declaration.
1236 inline internal::Matcher<CXXMemberCallExpr> thisPointerType(
1237     const internal::Matcher<Decl> &InnerMatcher) {
1238   return onImplicitObjectArgument(
1239       anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))));
1240 }
1241
1242 /// \brief Matches a DeclRefExpr that refers to a declaration that matches the
1243 /// specified matcher.
1244 ///
1245 /// Example matches x in if(x)
1246 ///     (matcher = declarationReference(to(variable(hasName("x")))))
1247 ///   bool x;
1248 ///   if (x) {}
1249 AST_MATCHER_P(DeclRefExpr, to, internal::Matcher<Decl>,
1250               InnerMatcher) {
1251   const Decl *DeclNode = Node.getDecl();
1252   return (DeclNode != NULL &&
1253           InnerMatcher.matches(*DeclNode, Finder, Builder));
1254 }
1255
1256 /// \brief Matches a \c DeclRefExpr that refers to a declaration through a
1257 /// specific using shadow declaration.
1258 ///
1259 /// FIXME: This currently only works for functions. Fix.
1260 ///
1261 /// Given
1262 ///   namespace a { void f() {} }
1263 ///   using a::f;
1264 ///   void g() {
1265 ///     f();     // Matches this ..
1266 ///     a::f();  // .. but not this.
1267 ///   }
1268 /// declarationReference(throughUsingDeclaration(anything()))
1269 ///   matches \c f()
1270 AST_MATCHER_P(DeclRefExpr, throughUsingDecl,
1271               internal::Matcher<UsingShadowDecl>, Matcher) {
1272   const NamedDecl *FoundDecl = Node.getFoundDecl();
1273   if (const UsingShadowDecl *UsingDecl =
1274       llvm::dyn_cast<UsingShadowDecl>(FoundDecl))
1275     return Matcher.matches(*UsingDecl, Finder, Builder);
1276   return false;
1277 }
1278
1279 /// \brief Matches the Decl of a DeclStmt which has a single declaration.
1280 ///
1281 /// Given
1282 ///   int a, b;
1283 ///   int c;
1284 /// declarationStatement(hasSingleDecl(anything()))
1285 ///   matches 'int c;' but not 'int a, b;'.
1286 AST_MATCHER_P(DeclStmt, hasSingleDecl, internal::Matcher<Decl>, InnerMatcher) {
1287   if (Node.isSingleDecl()) {
1288     const Decl *FoundDecl = Node.getSingleDecl();
1289     return InnerMatcher.matches(*FoundDecl, Finder, Builder);
1290   }
1291   return false;
1292 }
1293
1294 /// \brief Matches a variable declaration that has an initializer expression
1295 /// that matches the given matcher.
1296 ///
1297 /// Example matches x (matcher = variable(hasInitializer(call())))
1298 ///   bool y() { return true; }
1299 ///   bool x = y();
1300 AST_MATCHER_P(
1301     VarDecl, hasInitializer, internal::Matcher<Expr>,
1302     InnerMatcher) {
1303   const Expr *Initializer = Node.getAnyInitializer();
1304   return (Initializer != NULL &&
1305           InnerMatcher.matches(*Initializer, Finder, Builder));
1306 }
1307
1308 /// \brief Checks that a call expression or a constructor call expression has
1309 /// a specific number of arguments (including absent default arguments).
1310 ///
1311 /// Example matches f(0, 0) (matcher = call(argumentCountIs(2)))
1312 ///   void f(int x, int y);
1313 ///   f(0, 0);
1314 AST_POLYMORPHIC_MATCHER_P(argumentCountIs, unsigned, N) {
1315   TOOLING_COMPILE_ASSERT((llvm::is_base_of<CallExpr, NodeType>::value ||
1316                           llvm::is_base_of<CXXConstructExpr,
1317                                            NodeType>::value),
1318                          instantiated_with_wrong_types);
1319   return Node.getNumArgs() == N;
1320 }
1321
1322 /// \brief Matches the n'th argument of a call expression or a constructor
1323 /// call expression.
1324 ///
1325 /// Example matches y in x(y)
1326 ///     (matcher = call(hasArgument(0, declarationReference())))
1327 ///   void x(int) { int y; x(y); }
1328 AST_POLYMORPHIC_MATCHER_P2(
1329     hasArgument, unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
1330   TOOLING_COMPILE_ASSERT((llvm::is_base_of<CallExpr, NodeType>::value ||
1331                          llvm::is_base_of<CXXConstructExpr,
1332                                           NodeType>::value),
1333                          instantiated_with_wrong_types);
1334   return (N < Node.getNumArgs() &&
1335           InnerMatcher.matches(
1336               *Node.getArg(N)->IgnoreParenImpCasts(), Finder, Builder));
1337 }
1338
1339 /// \brief Matches declaration statements that contain a specific number of
1340 /// declarations.
1341 ///
1342 /// Example: Given
1343 ///   int a, b;
1344 ///   int c;
1345 ///   int d = 2, e;
1346 /// declCountIs(2)
1347 ///   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
1348 AST_MATCHER_P(DeclStmt, declCountIs, unsigned, N) {
1349   return std::distance(Node.decl_begin(), Node.decl_end()) == N;
1350 }
1351
1352 /// \brief Matches the n'th declaration of a declaration statement.
1353 ///
1354 /// Note that this does not work for global declarations because the AST
1355 /// breaks up multiple-declaration DeclStmt's into multiple single-declaration
1356 /// DeclStmt's.
1357 /// Example: Given non-global declarations
1358 ///   int a, b = 0;
1359 ///   int c;
1360 ///   int d = 2, e;
1361 /// declarationStatement(containsDeclaration(
1362 ///       0, variable(hasInitializer(anything()))))
1363 ///   matches only 'int d = 2, e;', and
1364 /// declarationStatement(containsDeclaration(1, variable()))
1365 ///   matches 'int a, b = 0' as well as 'int d = 2, e;'
1366 ///   but 'int c;' is not matched.
1367 AST_MATCHER_P2(DeclStmt, containsDeclaration, unsigned, N,
1368                internal::Matcher<Decl>, InnerMatcher) {
1369   const unsigned NumDecls = std::distance(Node.decl_begin(), Node.decl_end());
1370   if (N >= NumDecls)
1371     return false;
1372   DeclStmt::const_decl_iterator Iterator = Node.decl_begin();
1373   std::advance(Iterator, N);
1374   return InnerMatcher.matches(**Iterator, Finder, Builder);
1375 }
1376
1377 /// \brief Matches a constructor initializer.
1378 ///
1379 /// Given
1380 ///   struct Foo {
1381 ///     Foo() : foo_(1) { }
1382 ///     int foo_;
1383 ///   };
1384 /// record(has(constructor(hasAnyConstructorInitializer(anything()))))
1385 ///   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
1386 AST_MATCHER_P(CXXConstructorDecl, hasAnyConstructorInitializer,
1387               internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
1388   for (CXXConstructorDecl::init_const_iterator I = Node.init_begin();
1389        I != Node.init_end(); ++I) {
1390     if (InnerMatcher.matches(**I, Finder, Builder)) {
1391       return true;
1392     }
1393   }
1394   return false;
1395 }
1396
1397 /// \brief Matches the field declaration of a constructor initializer.
1398 ///
1399 /// Given
1400 ///   struct Foo {
1401 ///     Foo() : foo_(1) { }
1402 ///     int foo_;
1403 ///   };
1404 /// record(has(constructor(hasAnyConstructorInitializer(
1405 ///     forField(hasName("foo_"))))))
1406 ///   matches Foo
1407 /// with forField matching foo_
1408 AST_MATCHER_P(CXXCtorInitializer, forField,
1409               internal::Matcher<FieldDecl>, InnerMatcher) {
1410   const FieldDecl *NodeAsDecl = Node.getMember();
1411   return (NodeAsDecl != NULL &&
1412       InnerMatcher.matches(*NodeAsDecl, Finder, Builder));
1413 }
1414
1415 /// \brief Matches the initializer expression of a constructor initializer.
1416 ///
1417 /// Given
1418 ///   struct Foo {
1419 ///     Foo() : foo_(1) { }
1420 ///     int foo_;
1421 ///   };
1422 /// record(has(constructor(hasAnyConstructorInitializer(
1423 ///     withInitializer(integerLiteral(equals(1)))))))
1424 ///   matches Foo
1425 /// with withInitializer matching (1)
1426 AST_MATCHER_P(CXXCtorInitializer, withInitializer,
1427               internal::Matcher<Expr>, InnerMatcher) {
1428   const Expr* NodeAsExpr = Node.getInit();
1429   return (NodeAsExpr != NULL &&
1430       InnerMatcher.matches(*NodeAsExpr, Finder, Builder));
1431 }
1432
1433 /// \brief Matches a contructor initializer if it is explicitly written in
1434 /// code (as opposed to implicitly added by the compiler).
1435 ///
1436 /// Given
1437 ///   struct Foo {
1438 ///     Foo() { }
1439 ///     Foo(int) : foo_("A") { }
1440 ///     string foo_;
1441 ///   };
1442 /// constructor(hasAnyConstructorInitializer(isWritten()))
1443 ///   will match Foo(int), but not Foo()
1444 AST_MATCHER(CXXCtorInitializer, isWritten) {
1445   return Node.isWritten();
1446 }
1447
1448 /// \brief Matches a constructor declaration that has been implicitly added
1449 /// by the compiler (eg. implicit default/copy constructors).
1450 AST_MATCHER(CXXConstructorDecl, isImplicit) {
1451   return Node.isImplicit();
1452 }
1453
1454 /// \brief Matches any argument of a call expression or a constructor call
1455 /// expression.
1456 ///
1457 /// Given
1458 ///   void x(int, int, int) { int y; x(1, y, 42); }
1459 /// call(hasAnyArgument(declarationReference()))
1460 ///   matches x(1, y, 42)
1461 /// with hasAnyArgument(...)
1462 ///   matching y
1463 AST_POLYMORPHIC_MATCHER_P(hasAnyArgument, internal::Matcher<Expr>,
1464                           InnerMatcher) {
1465   TOOLING_COMPILE_ASSERT((llvm::is_base_of<CallExpr, NodeType>::value ||
1466                          llvm::is_base_of<CXXConstructExpr,
1467                                           NodeType>::value),
1468                          instantiated_with_wrong_types);
1469   for (unsigned I = 0; I < Node.getNumArgs(); ++I) {
1470     if (InnerMatcher.matches(*Node.getArg(I)->IgnoreParenImpCasts(),
1471                              Finder, Builder)) {
1472       return true;
1473     }
1474   }
1475   return false;
1476 }
1477
1478 /// \brief Matches the n'th parameter of a function declaration.
1479 ///
1480 /// Given
1481 ///   class X { void f(int x) {} };
1482 /// method(hasParameter(0, hasType(variable())))
1483 ///   matches f(int x) {}
1484 /// with hasParameter(...)
1485 ///   matching int x
1486 AST_MATCHER_P2(FunctionDecl, hasParameter,
1487                unsigned, N, internal::Matcher<ParmVarDecl>,
1488                InnerMatcher) {
1489   return (N < Node.getNumParams() &&
1490           InnerMatcher.matches(
1491               *Node.getParamDecl(N), Finder, Builder));
1492 }
1493
1494 /// \brief Matches any parameter of a function declaration.
1495 ///
1496 /// Does not match the 'this' parameter of a method.
1497 ///
1498 /// Given
1499 ///   class X { void f(int x, int y, int z) {} };
1500 /// method(hasAnyParameter(hasName("y")))
1501 ///   matches f(int x, int y, int z) {}
1502 /// with hasAnyParameter(...)
1503 ///   matching int y
1504 AST_MATCHER_P(FunctionDecl, hasAnyParameter,
1505               internal::Matcher<ParmVarDecl>, InnerMatcher) {
1506   for (unsigned I = 0; I < Node.getNumParams(); ++I) {
1507     if (InnerMatcher.matches(*Node.getParamDecl(I), Finder, Builder)) {
1508       return true;
1509     }
1510   }
1511   return false;
1512 }
1513
1514 /// \brief Matches the return type of a function declaration.
1515 ///
1516 /// Given:
1517 ///   class X { int f() { return 1; } };
1518 /// method(returns(asString("int")))
1519 ///   matches int f() { return 1; }
1520 AST_MATCHER_P(FunctionDecl, returns, internal::Matcher<QualType>, Matcher) {
1521   return Matcher.matches(Node.getResultType(), Finder, Builder);
1522 }
1523
1524 /// \brief Matches extern "C" function declarations.
1525 ///
1526 /// Given:
1527 ///   extern "C" void f() {}
1528 ///   extern "C" { void g() {} }
1529 ///   void h() {}
1530 /// function(isExternC())
1531 ///   matches the declaration of f and g, but not the declaration h
1532 AST_MATCHER(FunctionDecl, isExternC) {
1533   return Node.isExternC();
1534 }
1535
1536 /// \brief Matches the condition expression of an if statement, for loop,
1537 /// or conditional operator.
1538 ///
1539 /// Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
1540 ///   if (true) {}
1541 AST_POLYMORPHIC_MATCHER_P(hasCondition, internal::Matcher<Expr>,
1542                           InnerMatcher) {
1543   TOOLING_COMPILE_ASSERT(
1544     (llvm::is_base_of<IfStmt, NodeType>::value) ||
1545     (llvm::is_base_of<ForStmt, NodeType>::value) ||
1546     (llvm::is_base_of<WhileStmt, NodeType>::value) ||
1547     (llvm::is_base_of<DoStmt, NodeType>::value) ||
1548     (llvm::is_base_of<ConditionalOperator, NodeType>::value),
1549     has_condition_requires_if_statement_conditional_operator_or_loop);
1550   const Expr *const Condition = Node.getCond();
1551   return (Condition != NULL &&
1552           InnerMatcher.matches(*Condition, Finder, Builder));
1553 }
1554
1555 /// \brief Matches the condition variable statement in an if statement.
1556 ///
1557 /// Given
1558 ///   if (A* a = GetAPointer()) {}
1559 /// hasConditionVariableStatment(...)
1560 ///   matches 'A* a = GetAPointer()'.
1561 AST_MATCHER_P(IfStmt, hasConditionVariableStatement,
1562               internal::Matcher<DeclStmt>, InnerMatcher) {
1563   const DeclStmt* const DeclarationStatement =
1564     Node.getConditionVariableDeclStmt();
1565   return DeclarationStatement != NULL &&
1566          InnerMatcher.matches(*DeclarationStatement, Finder, Builder);
1567 }
1568
1569 /// \brief Matches the index expression of an array subscript expression.
1570 ///
1571 /// Given
1572 ///   int i[5];
1573 ///   void f() { i[1] = 42; }
1574 /// arraySubscriptExpression(hasIndex(integerLiteral()))
1575 ///   matches \c i[1] with the \c integerLiteral() matching \c 1
1576 AST_MATCHER_P(ArraySubscriptExpr, hasIndex,
1577               internal::Matcher<Expr>, matcher) {
1578   if (const Expr* Expression = Node.getIdx())
1579     return matcher.matches(*Expression, Finder, Builder);
1580   return false;
1581 }
1582
1583 /// \brief Matches the base expression of an array subscript expression.
1584 ///
1585 /// Given
1586 ///   int i[5];
1587 ///   void f() { i[1] = 42; }
1588 /// arraySubscriptExpression(hasBase(implicitCast(
1589 ///     hasSourceExpression(declarationReference()))))
1590 ///   matches \c i[1] with the \c declarationReference() matching \c i
1591 AST_MATCHER_P(ArraySubscriptExpr, hasBase,
1592               internal::Matcher<Expr>, matcher) {
1593   if (const Expr* Expression = Node.getBase())
1594     return matcher.matches(*Expression, Finder, Builder);
1595   return false;
1596 }
1597
1598 /// \brief Matches a 'for', 'while', or 'do while' statement that has
1599 /// a given body.
1600 ///
1601 /// Given
1602 ///   for (;;) {}
1603 /// hasBody(compoundStatement())
1604 ///   matches 'for (;;) {}'
1605 /// with compoundStatement()
1606 ///   matching '{}'
1607 AST_POLYMORPHIC_MATCHER_P(hasBody, internal::Matcher<Stmt>,
1608                           InnerMatcher) {
1609   TOOLING_COMPILE_ASSERT(
1610       (llvm::is_base_of<DoStmt, NodeType>::value) ||
1611       (llvm::is_base_of<ForStmt, NodeType>::value) ||
1612       (llvm::is_base_of<WhileStmt, NodeType>::value),
1613       has_body_requires_for_while_or_do_statement);
1614   const Stmt *const Statement = Node.getBody();
1615   return (Statement != NULL &&
1616           InnerMatcher.matches(*Statement, Finder, Builder));
1617 }
1618
1619 /// \brief Matches compound statements where at least one substatement matches
1620 /// a given matcher.
1621 ///
1622 /// Given
1623 ///   { {}; 1+2; }
1624 /// hasAnySubstatement(compoundStatement())
1625 ///   matches '{ {}; 1+2; }'
1626 /// with compoundStatement()
1627 ///   matching '{}'
1628 AST_MATCHER_P(CompoundStmt, hasAnySubstatement,
1629               internal::Matcher<Stmt>, InnerMatcher) {
1630   for (CompoundStmt::const_body_iterator It = Node.body_begin();
1631        It != Node.body_end();
1632        ++It) {
1633     if (InnerMatcher.matches(**It, Finder, Builder)) return true;
1634   }
1635   return false;
1636 }
1637
1638 /// \brief Checks that a compound statement contains a specific number of
1639 /// child statements.
1640 ///
1641 /// Example: Given
1642 ///   { for (;;) {} }
1643 /// compoundStatement(statementCountIs(0)))
1644 ///   matches '{}'
1645 ///   but does not match the outer compound statement.
1646 AST_MATCHER_P(CompoundStmt, statementCountIs, unsigned, N) {
1647   return Node.size() == N;
1648 }
1649
1650 /// \brief Matches literals that are equal to the given value.
1651 ///
1652 /// Example matches true (matcher = boolLiteral(equals(true)))
1653 ///   true
1654 ///
1655 /// Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
1656 ///            Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
1657 template <typename ValueT>
1658 internal::PolymorphicMatcherWithParam1<internal::ValueEqualsMatcher, ValueT>
1659 equals(const ValueT &Value) {
1660   return internal::PolymorphicMatcherWithParam1<
1661     internal::ValueEqualsMatcher,
1662     ValueT>(Value);
1663 }
1664
1665 /// \brief Matches the operator Name of operator expressions (binary or
1666 /// unary).
1667 ///
1668 /// Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
1669 ///   !(a || b)
1670 AST_POLYMORPHIC_MATCHER_P(hasOperatorName, std::string, Name) {
1671   TOOLING_COMPILE_ASSERT(
1672     (llvm::is_base_of<BinaryOperator, NodeType>::value) ||
1673     (llvm::is_base_of<UnaryOperator, NodeType>::value),
1674     has_condition_requires_if_statement_or_conditional_operator);
1675   return Name == Node.getOpcodeStr(Node.getOpcode());
1676 }
1677
1678 /// \brief Matches the left hand side of binary operator expressions.
1679 ///
1680 /// Example matches a (matcher = binaryOperator(hasLHS()))
1681 ///   a || b
1682 AST_MATCHER_P(BinaryOperator, hasLHS,
1683               internal::Matcher<Expr>, InnerMatcher) {
1684   Expr *LeftHandSide = Node.getLHS();
1685   return (LeftHandSide != NULL &&
1686           InnerMatcher.matches(*LeftHandSide, Finder, Builder));
1687 }
1688
1689 /// \brief Matches the right hand side of binary operator expressions.
1690 ///
1691 /// Example matches b (matcher = binaryOperator(hasRHS()))
1692 ///   a || b
1693 AST_MATCHER_P(BinaryOperator, hasRHS,
1694               internal::Matcher<Expr>, InnerMatcher) {
1695   Expr *RightHandSide = Node.getRHS();
1696   return (RightHandSide != NULL &&
1697           InnerMatcher.matches(*RightHandSide, Finder, Builder));
1698 }
1699
1700 /// \brief Matches if either the left hand side or the right hand side of a
1701 /// binary operator matches.
1702 inline internal::Matcher<BinaryOperator> hasEitherOperand(
1703     const internal::Matcher<Expr> &InnerMatcher) {
1704   return anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher));
1705 }
1706
1707 /// \brief Matches if the operand of a unary operator matches.
1708 ///
1709 /// Example matches true (matcher = hasOperand(boolLiteral(equals(true))))
1710 ///   !true
1711 AST_MATCHER_P(UnaryOperator, hasUnaryOperand,
1712               internal::Matcher<Expr>, InnerMatcher) {
1713   const Expr * const Operand = Node.getSubExpr();
1714   return (Operand != NULL &&
1715           InnerMatcher.matches(*Operand, Finder, Builder));
1716 }
1717
1718 /// \brief Matches if the cast's source expression matches the given matcher.
1719 ///
1720 /// Example: matches "a string" (matcher =
1721 ///                                  hasSourceExpression(constructorCall()))
1722 ///
1723 /// class URL { URL(string); };
1724 /// URL url = "a string";
1725 AST_MATCHER_P(CastExpr, hasSourceExpression,
1726               internal::Matcher<Expr>, InnerMatcher) {
1727   const Expr* const SubExpression = Node.getSubExpr();
1728   return (SubExpression != NULL &&
1729           InnerMatcher.matches(*SubExpression, Finder, Builder));
1730 }
1731
1732 /// \brief Matches casts whose destination type matches a given matcher.
1733 ///
1734 /// (Note: Clang's AST refers to other conversions as "casts" too, and calls
1735 /// actual casts "explicit" casts.)
1736 AST_MATCHER_P(ExplicitCastExpr, hasDestinationType,
1737               internal::Matcher<QualType>, InnerMatcher) {
1738   const QualType NodeType = Node.getTypeAsWritten();
1739   return InnerMatcher.matches(NodeType, Finder, Builder);
1740 }
1741
1742 /// \brief Matches implicit casts whose destination type matches a given
1743 /// matcher.
1744 ///
1745 /// FIXME: Unit test this matcher
1746 AST_MATCHER_P(ImplicitCastExpr, hasImplicitDestinationType,
1747               internal::Matcher<QualType>, InnerMatcher) {
1748   return InnerMatcher.matches(Node.getType(), Finder, Builder);
1749 }
1750
1751 /// \brief Matches the true branch expression of a conditional operator.
1752 ///
1753 /// Example matches a
1754 ///   condition ? a : b
1755 AST_MATCHER_P(ConditionalOperator, hasTrueExpression,
1756               internal::Matcher<Expr>, InnerMatcher) {
1757   Expr *Expression = Node.getTrueExpr();
1758   return (Expression != NULL &&
1759           InnerMatcher.matches(*Expression, Finder, Builder));
1760 }
1761
1762 /// \brief Matches the false branch expression of a conditional operator.
1763 ///
1764 /// Example matches b
1765 ///   condition ? a : b
1766 AST_MATCHER_P(ConditionalOperator, hasFalseExpression,
1767               internal::Matcher<Expr>, InnerMatcher) {
1768   Expr *Expression = Node.getFalseExpr();
1769   return (Expression != NULL &&
1770           InnerMatcher.matches(*Expression, Finder, Builder));
1771 }
1772
1773 /// \brief Matches if a declaration has a body attached.
1774 ///
1775 /// Example matches A, va, fa
1776 ///   class A {};
1777 ///   class B;  // Doesn't match, as it has no body.
1778 ///   int va;
1779 ///   extern int vb;  // Doesn't match, as it doesn't define the variable.
1780 ///   void fa() {}
1781 ///   void fb();  // Doesn't match, as it has no body.
1782 ///
1783 /// Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
1784 inline internal::PolymorphicMatcherWithParam0<internal::IsDefinitionMatcher>
1785 isDefinition() {
1786   return internal::PolymorphicMatcherWithParam0<
1787     internal::IsDefinitionMatcher>();
1788 }
1789
1790 /// \brief Matches the class declaration that the given method declaration
1791 /// belongs to.
1792 ///
1793 /// FIXME: Generalize this for other kinds of declarations.
1794 /// FIXME: What other kind of declarations would we need to generalize
1795 /// this to?
1796 ///
1797 /// Example matches A() in the last line
1798 ///     (matcher = constructorCall(hasDeclaration(method(
1799 ///         ofClass(hasName("A"))))))
1800 ///   class A {
1801 ///    public:
1802 ///     A();
1803 ///   };
1804 ///   A a = A();
1805 AST_MATCHER_P(CXXMethodDecl, ofClass,
1806               internal::Matcher<CXXRecordDecl>, InnerMatcher) {
1807   const CXXRecordDecl *Parent = Node.getParent();
1808   return (Parent != NULL &&
1809           InnerMatcher.matches(*Parent, Finder, Builder));
1810 }
1811
1812 /// \brief Matches member expressions that are called with '->' as opposed
1813 /// to '.'.
1814 ///
1815 /// Member calls on the implicit this pointer match as called with '->'.
1816 ///
1817 /// Given
1818 ///   class Y {
1819 ///     void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
1820 ///     int a;
1821 ///     static int b;
1822 ///   };
1823 /// memberExpression(isArrow())
1824 ///   matches this->x, x, y.x, a, this->b
1825 inline internal::Matcher<MemberExpr> isArrow() {
1826   return makeMatcher(new internal::IsArrowMatcher());
1827 }
1828
1829 /// \brief Matches QualType nodes that are of integer type.
1830 ///
1831 /// Given
1832 ///   void a(int);
1833 ///   void b(long);
1834 ///   void c(double);
1835 /// function(hasAnyParameter(hasType(isInteger())))
1836 /// matches "a(int)", "b(long)", but not "c(double)".
1837 AST_MATCHER(QualType, isInteger) {
1838     return Node->isIntegerType();
1839 }
1840
1841 /// \brief Matches QualType nodes that are const-qualified, i.e., that
1842 /// include "top-level" const.
1843 ///
1844 /// Given
1845 ///   void a(int);
1846 ///   void b(int const);
1847 ///   void c(const int);
1848 ///   void d(const int*);
1849 ///   void e(int const) {};
1850 /// function(hasAnyParameter(hasType(isConstQualified())))
1851 ///   matches "void b(int const)", "void c(const int)" and
1852 ///   "void e(int const) {}". It does not match d as there
1853 ///   is no top-level const on the parameter type "const int *".
1854 inline internal::Matcher<QualType> isConstQualified() {
1855   return makeMatcher(new internal::IsConstQualifiedMatcher());
1856 }
1857
1858 /// \brief Matches a member expression where the member is matched by a
1859 /// given matcher.
1860 ///
1861 /// Given
1862 ///   struct { int first, second; } first, second;
1863 ///   int i(second.first);
1864 ///   int j(first.second);
1865 /// memberExpression(member(hasName("first")))
1866 ///   matches second.first
1867 ///   but not first.second (because the member name there is "second").
1868 AST_MATCHER_P(MemberExpr, member,
1869               internal::Matcher<ValueDecl>, InnerMatcher) {
1870   return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder);
1871 }
1872
1873 /// \brief Matches a member expression where the object expression is
1874 /// matched by a given matcher.
1875 ///
1876 /// Given
1877 ///   struct X { int m; };
1878 ///   void f(X x) { x.m; m; }
1879 /// memberExpression(hasObjectExpression(hasType(record(hasName("X")))))))
1880 ///   matches "x.m" and "m"
1881 /// with hasObjectExpression(...)
1882 ///   matching "x" and the implicit object expression of "m" which has type X*.
1883 AST_MATCHER_P(MemberExpr, hasObjectExpression,
1884               internal::Matcher<Expr>, InnerMatcher) {
1885   return InnerMatcher.matches(*Node.getBase(), Finder, Builder);
1886 }
1887
1888 /// \brief Matches any using shadow declaration.
1889 ///
1890 /// Given
1891 ///   namespace X { void b(); }
1892 ///   using X::b;
1893 /// usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
1894 ///   matches \code using X::b \endcode
1895 AST_MATCHER_P(UsingDecl, hasAnyUsingShadowDecl,
1896               internal::Matcher<UsingShadowDecl>, Matcher) {
1897   for (UsingDecl::shadow_iterator II = Node.shadow_begin();
1898        II != Node.shadow_end(); ++II) {
1899     if (Matcher.matches(**II, Finder, Builder))
1900       return true;
1901   }
1902   return false;
1903 }
1904
1905 /// \brief Matches a using shadow declaration where the target declaration is
1906 /// matched by the given matcher.
1907 ///
1908 /// Given
1909 ///   namespace X { int a; void b(); }
1910 ///   using X::a;
1911 ///   using X::b;
1912 /// usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(function())))
1913 ///   matches \code using X::b \endcode
1914 ///   but not \code using X::a \endcode
1915 AST_MATCHER_P(UsingShadowDecl, hasTargetDecl,
1916               internal::Matcher<NamedDecl>, Matcher) {
1917   return Matcher.matches(*Node.getTargetDecl(), Finder, Builder);
1918 }
1919
1920 /// \brief Matches template instantiations of function, class, or static
1921 /// member variable template instantiations.
1922 ///
1923 /// Given
1924 ///   template <typename T> class X {}; class A {}; X<A> x;
1925 /// or
1926 ///   template <typename T> class X {}; class A {}; template class X<A>;
1927 /// record(hasName("::X"), isTemplateInstantiation())
1928 ///   matches the template instantiation of X<A>.
1929 ///
1930 /// But given
1931 ///   template <typename T> class X {}; class A {};
1932 ///   template <> class X<A> {}; X<A> x;
1933 /// record(hasName("::X"), isTemplateInstantiation())
1934 ///   does not match, as X<A> is an explicit template specialization.
1935 ///
1936 /// Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
1937 inline internal::PolymorphicMatcherWithParam0<
1938   internal::IsTemplateInstantiationMatcher>
1939 isTemplateInstantiation() {
1940   return internal::PolymorphicMatcherWithParam0<
1941     internal::IsTemplateInstantiationMatcher>();
1942 }
1943
1944 } // end namespace ast_matchers
1945 } // end namespace clang
1946
1947 #endif // LLVM_CLANG_AST_MATCHERS_AST_MATCHERS_H