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