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