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