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