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