From: Benjamin Kramer Date: Fri, 20 Nov 2015 07:46:19 +0000 (+0000) Subject: Fix ASTMatcher reference newlines and make the generator script windows-proof. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=8180a1c7125fc6884123ff3d8c8489af8d5d40c4;p=clang Fix ASTMatcher reference newlines and make the generator script windows-proof. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@253653 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/docs/LibASTMatchersReference.html b/docs/LibASTMatchersReference.html index 8b757f1276..1c042099ce 100644 --- a/docs/LibASTMatchersReference.html +++ b/docs/LibASTMatchersReference.html @@ -98,4725 +98,4725 @@ recordDecl(decl().bind("id"), hasName("::MyClass")) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Return typeNameParameters
Matcher<CXXCtorInitializer>cxxCtorInitializerMatcher<CXXCtorInitializer>...
Matches constructor initializers.
-
-Examples matches i(42).
-  class C {
-    C() : i(42) {}
-    int i;
-  };
-
Matcher<Decl>accessSpecDeclMatcher<AccessSpecDecl>...
Matches C++ access specifier declarations.
-
-Given
-  class C {
-  public:
-    int a;
-  };
-accessSpecDecl()
-  matches 'public:'
-
Matcher<Decl>classTemplateDeclMatcher<ClassTemplateDecl>...
Matches C++ class template declarations.
-
-Example matches Z
-  template<class T> class Z {};
-
Matcher<Decl>classTemplateSpecializationDeclMatcher<ClassTemplateSpecializationDecl>...
Matches C++ class template specializations.
-
-Given
-  template<typename T> class A {};
-  template<> class A<double> {};
-  A<int> a;
-classTemplateSpecializationDecl()
-  matches the specializations A<int> and A<double>
-
Matcher<Decl>cxxConstructorDeclMatcher<CXXConstructorDecl>...
Matches C++ constructor declarations.
-
-Example matches Foo::Foo() and Foo::Foo(int)
-  class Foo {
-   public:
-    Foo();
-    Foo(int);
-    int DoSomething();
-  };
-
Matcher<Decl>cxxConversionDeclMatcher<CXXConversionDecl>...
Matches conversion operator declarations.
-
-Example matches the operator.
-  class X { operator int() const; };
-
Matcher<Decl>cxxDestructorDeclMatcher<CXXDestructorDecl>...
Matches explicit C++ destructor declarations.
-
-Example matches Foo::~Foo()
-  class Foo {
-   public:
-    virtual ~Foo();
-  };
-
Matcher<Decl>cxxMethodDeclMatcher<CXXMethodDecl>...
Matches method declarations.
-
-Example matches y
-  class X { void y(); };
-
Matcher<Decl>cxxRecordDeclMatcher<CXXRecordDecl>...
Matches C++ class declarations.
-
-Example matches X, Z
-  class X;
-  template<class T> class Z {};
-
Matcher<Decl>declMatcher<Decl>...
Matches declarations.
-
-Examples matches X, C, and the friend declaration inside C;
-  void X();
-  class C {
-    friend X;
-  };
-
Matcher<Decl>declaratorDeclMatcher<DeclaratorDecl>...
Matches declarator declarations (field, variable, function
-and non-type template parameter declarations).
-
-Given
-  class X { int y; };
-declaratorDecl()
-  matches int y.
-
Matcher<Decl>enumConstantDeclMatcher<EnumConstantDecl>...
Matches enum constants.
-
-Example matches A, B, C
-  enum X {
-    A, B, C
-  };
-
Matcher<Decl>enumDeclMatcher<EnumDecl>...
Matches enum declarations.
-
-Example matches X
-  enum X {
-    A, B, C
-  };
-
Matcher<Decl>fieldDeclMatcher<FieldDecl>...
Matches field declarations.
-
-Given
-  class X { int m; };
-fieldDecl()
-  matches 'm'.
-
Matcher<Decl>friendDeclMatcher<FriendDecl>...
Matches friend declarations.
-
-Given
-  class X { friend void foo(); };
-friendDecl()
-  matches 'friend void foo()'.
-
Matcher<Decl>functionDeclMatcher<FunctionDecl>...
Matches function declarations.
-
-Example matches f
-  void f();
-
Matcher<Decl>functionTemplateDeclMatcher<FunctionTemplateDecl>...
Matches C++ function template declarations.
-
-Example matches f
-  template<class T> void f(T t) {}
-
Matcher<Decl>linkageSpecDeclMatcher<LinkageSpecDecl>...
Matches a declaration of a linkage specification.
-
-Given
-  extern "C" {}
-linkageSpecDecl()
-  matches "extern "C" {}"
-
Matcher<Decl>namedDeclMatcher<NamedDecl>...
Matches a declaration of anything that could have a name.
-
-Example matches X, S, the anonymous union type, i, and U;
-  typedef int X;
-  struct S {
-    union {
-      int i;
-    } U;
-  };
-
Matcher<Decl>namespaceAliasDeclMatcher<NamespaceAliasDecl>...
Matches a declaration of a namespace alias.
-
-Given
-  namespace test {}
-  namespace alias = ::test;
-namespaceAliasDecl()
-  matches "namespace alias" but not "namespace test"
-
Matcher<Decl>namespaceDeclMatcher<NamespaceDecl>...
Matches a declaration of a namespace.
-
-Given
-  namespace {}
-  namespace test {}
-namespaceDecl()
-  matches "namespace {}" and "namespace test {}"
-
Matcher<Decl>nonTypeTemplateParmDeclMatcher<NonTypeTemplateParmDecl>...
Matches non-type template parameter declarations.
-
-Given
-  template <typename T, int N> struct C {};
-nonTypeTemplateParmDecl()
-  matches 'N', but not 'T'.
-
Matcher<Decl>objcInterfaceDeclMatcher<ObjCInterfaceDecl>...
Matches Objective-C interface declarations.
-
-Example matches Foo
-  @interface Foo
-  @end
-
Matcher<Decl>parmVarDeclMatcher<ParmVarDecl>...
Matches parameter variable declarations.
-
-Given
-  void f(int x);
-parmVarDecl()
-  matches int x.
-
Matcher<Decl>recordDeclMatcher<RecordDecl>...
Matches class, struct, and union declarations.
-
-Example matches X, Z, U, and S
-  class X;
-  template<class T> class Z {};
-  struct S {};
-  union U {};
-
Matcher<Decl>staticAssertDeclMatcher<StaticAssertDecl>...
Matches a C++ static_assert declaration.
-
-Example:
-  staticAssertExpr()
-matches
-  static_assert(sizeof(S) == sizeof(int))
-in
-  struct S {
-    int x;
-  };
-  static_assert(sizeof(S) == sizeof(int));
-
Matcher<Decl>templateTypeParmDeclMatcher<TemplateTypeParmDecl>...
Matches template type parameter declarations.
-
-Given
-  template <typename T, int N> struct C {};
-templateTypeParmDecl()
-  matches 'T', but not 'N'.
-
Matcher<Decl>translationUnitDeclMatcher<TranslationUnitDecl>...
Matches the top declaration context.
-
-Given
-  int X;
-  namespace NS {
-  int Y;
-  }  namespace NS
-decl(hasDeclContext(translationUnitDecl()))
-  matches "int X", but not "int Y".
-
Matcher<Decl>typedefDeclMatcher<TypedefDecl>...
Matches typedef declarations.
-
-Given
-  typedef int X;
-typedefDecl()
-  matches "typedef int X"
-
Matcher<Decl>unresolvedUsingTypenameDeclMatcher<UnresolvedUsingTypenameDecl>...
Matches unresolved using value declarations that involve the
-typename.
-
-Given
-  template <typename T>
-  struct Base { typedef T Foo; };
-
-  template<typename T>
-  struct S : private Base<T> {
-    using typename Base<T>::Foo;
-  };
-unresolvedUsingTypenameDecl()
-  matches using Base<T>::Foo
Matcher<Decl>unresolvedUsingValueDeclMatcher<UnresolvedUsingValueDecl>...
Matches unresolved using value declarations.
-
-Given
-  template<typename X>
-  class C : private X {
-    using X::x;
-  };
-unresolvedUsingValueDecl()
-  matches using X::x
Matcher<Decl>usingDeclMatcher<UsingDecl>...
Matches using declarations.
-
-Given
-  namespace X { int x; }
-  using X::x;
-usingDecl()
-  matches using X::x
Matcher<Decl>usingDirectiveDeclMatcher<UsingDirectiveDecl>...
Matches using namespace declarations.
-
-Given
-  namespace X { int x; }
-  using namespace X;
-usingDirectiveDecl()
-  matches using namespace X
Matcher<Decl>valueDeclMatcher<ValueDecl>...
Matches any value declaration.
-
-Example matches A, B, C and F
-  enum X { A, B, C };
-  void F();
-
Matcher<Decl>varDeclMatcher<VarDecl>...
Matches variable declarations.
-
-Note: this does not match declarations of member variables, which are
-"field" declarations in Clang parlance.
-
-Example matches a
-  int a;
-
Matcher<NestedNameSpecifierLoc>nestedNameSpecifierLocMatcher<NestedNameSpecifierLoc>...
Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
-
Matcher<NestedNameSpecifier>nestedNameSpecifierMatcher<NestedNameSpecifier>...
Matches nested name specifiers.
-
-Given
-  namespace ns {
-    struct A { static void f(); };
-    void A::f() {}
-    void g() { A::f(); }
-  }
-  ns::A a;
-nestedNameSpecifier()
-  matches "ns::" and both "A::"
-
Matcher<QualType>qualTypeMatcher<QualType>...
Matches QualTypes in the clang AST.
-
Matcher<Stmt>arraySubscriptExprMatcher<ArraySubscriptExpr>...
Matches array subscript expressions.
-
-Given
-  int i = a[1];
-arraySubscriptExpr()
-  matches "a[1]"
-
Matcher<Stmt>asmStmtMatcher<AsmStmt>...
Matches asm statements.
-
- int i = 100;
-  __asm("mov al, 2");
-asmStmt()
-  matches '__asm("mov al, 2")'
-
Matcher<Stmt>binaryOperatorMatcher<BinaryOperator>...
Matches binary operator expressions.
-
-Example matches a || b
-  !(a || b)
-
Matcher<Stmt>breakStmtMatcher<BreakStmt>...
Matches break statements.
-
-Given
-  while (true) { break; }
-breakStmt()
-  matches 'break'
-
Matcher<Stmt>cStyleCastExprMatcher<CStyleCastExpr>...
Matches a C-style cast expression.
-
-Example: Matches (int*) 2.2f in
-  int i = (int) 2.2f;
-
Matcher<Stmt>callExprMatcher<CallExpr>...
Matches call expressions.
-
-Example matches x.y() and y()
-  X x;
-  x.y();
-  y();
-
Matcher<Stmt>caseStmtMatcher<CaseStmt>...
Matches case statements inside switch statements.
-
-Given
-  switch(a) { case 42: break; default: break; }
-caseStmt()
-  matches 'case 42: break;'.
-
Matcher<Stmt>castExprMatcher<CastExpr>...
Matches any cast nodes of Clang's AST.
-
-Example: castExpr() matches each of the following:
-  (int) 3;
-  const_cast<Expr *>(SubExpr);
-  char c = 0;
-but does not match
-  int i = (0);
-  int k = 0;
-
Matcher<Stmt>characterLiteralMatcher<CharacterLiteral>...
Matches character literals (also matches wchar_t).
-
-Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
-though.
-
-Example matches 'a', L'a'
-  char ch = 'a'; wchar_t chw = L'a';
-
Matcher<Stmt>compoundLiteralExprMatcher<CompoundLiteralExpr>...
Matches compound (i.e. non-scalar) literals
-
-Example match: {1}, (1, 2)
-  int array[4] = {1}; vector int myvec = (vector int)(1, 2);
-
Matcher<Stmt>compoundStmtMatcher<CompoundStmt>...
Matches compound statements.
-
-Example matches '{}' and '{{}}'in 'for (;;) {{}}'
-  for (;;) {{}}
-
Matcher<Stmt>conditionalOperatorMatcher<ConditionalOperator>...
Matches conditional operator expressions.
-
-Example matches a ? b : c
-  (a ? b : c) + 42
-
Matcher<Stmt>continueStmtMatcher<ContinueStmt>...
Matches continue statements.
-
-Given
-  while (true) { continue; }
-continueStmt()
-  matches 'continue'
-
Matcher<Stmt>cudaKernelCallExprMatcher<CUDAKernelCallExpr>...
Matches CUDA kernel call expression.
-
-Example matches,
-  kernel<<<i,j>>>();
-
Matcher<Stmt>cxxBindTemporaryExprMatcher<CXXBindTemporaryExpr>...
Matches nodes where temporaries are created.
-
-Example matches FunctionTakesString(GetStringByValue())
-    (matcher = cxxBindTemporaryExpr())
-  FunctionTakesString(GetStringByValue());
-  FunctionTakesStringByPointer(GetStringPointer());
-
Matcher<Stmt>cxxBoolLiteralMatcher<CXXBoolLiteralExpr>...
Matches bool literals.
-
-Example matches true
-  true
-
Matcher<Stmt>cxxCatchStmtMatcher<CXXCatchStmt>...
Matches catch statements.
-
-  try {} catch(int i) {}
-cxxCatchStmt()
-  matches 'catch(int i)'
-
Matcher<Stmt>cxxConstCastExprMatcher<CXXConstCastExpr>...
Matches a const_cast expression.
-
-Example: Matches const_cast<int*>(&r) in
-  int n = 42;
-  const int &r(n);
-  int* p = const_cast<int*>(&r);
-
Matcher<Stmt>cxxConstructExprMatcher<CXXConstructExpr>...
Matches constructor call expressions (including implicit ones).
-
-Example matches string(ptr, n) and ptr within arguments of f
-    (matcher = cxxConstructExpr())
-  void f(const string &a, const string &b);
-  char *ptr;
-  int n;
-  f(string(ptr, n), ptr);
-
Matcher<Stmt>cxxDefaultArgExprMatcher<CXXDefaultArgExpr>...
Matches the value of a default argument at the call site.
-
-Example matches the CXXDefaultArgExpr placeholder inserted for the
-    default value of the second parameter in the call expression f(42)
-    (matcher = cxxDefaultArgExpr())
-  void f(int x, int y = 0);
-  f(42);
-
Matcher<Stmt>cxxDeleteExprMatcher<CXXDeleteExpr>...
Matches delete expressions.
-
-Given
-  delete X;
-cxxDeleteExpr()
-  matches 'delete X'.
-
Matcher<Stmt>cxxDynamicCastExprMatcher<CXXDynamicCastExpr>...
Matches a dynamic_cast expression.
-
-Example:
-  cxxDynamicCastExpr()
-matches
-  dynamic_cast<D*>(&b);
-in
-  struct B { virtual ~B() {} }; struct D : B {};
-  B b;
-  D* p = dynamic_cast<D*>(&b);
-
Matcher<Stmt>cxxForRangeStmtMatcher<CXXForRangeStmt>...
Matches range-based for statements.
-
-cxxForRangeStmt() matches 'for (auto a : i)'
-  int i[] =  {1, 2, 3}; for (auto a : i);
-  for(int j = 0; j < 5; ++j);
-
Matcher<Stmt>cxxFunctionalCastExprMatcher<CXXFunctionalCastExpr>...
Matches functional cast expressions
-
-Example: Matches Foo(bar);
-  Foo f = bar;
-  Foo g = (Foo) bar;
-  Foo h = Foo(bar);
-
Matcher<Stmt>cxxMemberCallExprMatcher<CXXMemberCallExpr>...
Matches member call expressions.
-
-Example matches x.y()
-  X x;
-  x.y();
-
Matcher<Stmt>cxxNewExprMatcher<CXXNewExpr>...
Matches new expressions.
-
-Given
-  new X;
-cxxNewExpr()
-  matches 'new X'.
-
Matcher<Stmt>cxxNullPtrLiteralExprMatcher<CXXNullPtrLiteralExpr>...
Matches nullptr literal.
-
Matcher<Stmt>cxxOperatorCallExprMatcher<CXXOperatorCallExpr>...
Matches overloaded operator calls.
-
-Note that if an operator isn't overloaded, it won't match. Instead, use
-binaryOperator matcher.
-Currently it does not match operators such as new delete.
-FIXME: figure out why these do not match?
-
-Example matches both operator<<((o << b), c) and operator<<(o, b)
-    (matcher = cxxOperatorCallExpr())
-  ostream &operator<< (ostream &out, int i) { };
-  ostream &o; int b = 1, c = 1;
-  o << b << c;
-
Matcher<Stmt>cxxReinterpretCastExprMatcher<CXXReinterpretCastExpr>...
Matches a reinterpret_cast expression.
-
-Either the source expression or the destination type can be matched
-using has(), but hasDestinationType() is more specific and can be
-more readable.
-
-Example matches reinterpret_cast<char*>(&p) in
-  void* p = reinterpret_cast<char*>(&p);
-
Matcher<Stmt>cxxStaticCastExprMatcher<CXXStaticCastExpr>...
Matches a C++ static_cast expression.
-
-hasDestinationType
-reinterpretCast
-
-Example:
-  cxxStaticCastExpr()
-matches
-  static_cast<long>(8)
-in
-  long eight(static_cast<long>(8));
-
Matcher<Stmt>cxxTemporaryObjectExprMatcher<CXXTemporaryObjectExpr>...
Matches functional cast expressions having N != 1 arguments
-
-Example: Matches Foo(bar, bar)
-  Foo h = Foo(bar, bar);
-
Matcher<Stmt>cxxThisExprMatcher<CXXThisExpr>...
Matches implicit and explicit this expressions.
-
-Example matches the implicit this expression in "return i".
-    (matcher = cxxThisExpr())
-struct foo {
-  int i;
-  int f() { return i; }
-};
-
Matcher<Stmt>cxxThrowExprMatcher<CXXThrowExpr>...
Matches throw expressions.
-
-  try { throw 5; } catch(int i) {}
-cxxThrowExpr()
-  matches 'throw 5'
-
Matcher<Stmt>cxxTryStmtMatcher<CXXTryStmt>...
Matches try statements.
-
-  try {} catch(int i) {}
-cxxTryStmt()
-  matches 'try {}'
-
Matcher<Stmt>cxxUnresolvedConstructExprMatcher<CXXUnresolvedConstructExpr>...
Matches unresolved constructor call expressions.
-
-Example matches T(t) in return statement of f
-    (matcher = cxxUnresolvedConstructExpr())
-  template <typename T>
-  void f(const T& t) { return T(t); }
-
Matcher<Stmt>declRefExprMatcher<DeclRefExpr>...
Matches expressions that refer to declarations.
-
-Example matches x in if (x)
-  bool x;
-  if (x) {}
-
Matcher<Stmt>declStmtMatcher<DeclStmt>...
Matches declaration statements.
-
-Given
-  int a;
-declStmt()
-  matches 'int a'.
-
Matcher<Stmt>defaultStmtMatcher<DefaultStmt>...
Matches default statements inside switch statements.
-
-Given
-  switch(a) { case 42: break; default: break; }
-defaultStmt()
-  matches 'default: break;'.
-
Matcher<Stmt>doStmtMatcher<DoStmt>...
Matches do statements.
-
-Given
-  do {} while (true);
-doStmt()
-  matches 'do {} while(true)'
-
Matcher<Stmt>explicitCastExprMatcher<ExplicitCastExpr>...
Matches explicit cast expressions.
-
-Matches any cast expression written in user code, whether it be a
-C-style cast, a functional-style cast, or a keyword cast.
-
-Does not match implicit conversions.
-
-Note: the name "explicitCast" is chosen to match Clang's terminology, as
-Clang uses the term "cast" to apply to implicit conversions as well as to
-actual cast expressions.
-
-hasDestinationType.
-
-Example: matches all five of the casts in
-  int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42)))))
-but does not match the implicit conversion in
-  long ell = 42;
-
Matcher<Stmt>exprMatcher<Expr>...
Matches expressions.
-
-Example matches x()
-  void f() { x(); }
-
Matcher<Stmt>exprWithCleanupsMatcher<ExprWithCleanups>...
Matches expressions that introduce cleanups to be run at the end
-of the sub-expression's evaluation.
-
-Example matches std::string()
-  const std::string str = std::string();
-
Matcher<Stmt>floatLiteralMatcher<FloatingLiteral>...
Matches float literals of all sizes encodings, e.g.
-1.0, 1.0f, 1.0L and 1e10.
-
-Does not match implicit conversions such as
-  float a = 10;
-
Matcher<Stmt>forStmtMatcher<ForStmt>...
Matches for statements.
-
-Example matches 'for (;;) {}'
-  for (;;) {}
-  int i[] =  {1, 2, 3}; for (auto a : i);
-
Matcher<Stmt>gnuNullExprMatcher<GNUNullExpr>...
Matches GNU __null expression.
-
Matcher<Stmt>gotoStmtMatcher<GotoStmt>...
Matches goto statements.
-
-Given
-  goto FOO;
-  FOO: bar();
-gotoStmt()
-  matches 'goto FOO'
-
Matcher<Stmt>ifStmtMatcher<IfStmt>...
Matches if statements.
-
-Example matches 'if (x) {}'
-  if (x) {}
-
Matcher<Stmt>implicitCastExprMatcher<ImplicitCastExpr>...
Matches the implicit cast nodes of Clang's AST.
-
-This matches many different places, including function call return value
-eliding, as well as any type conversions.
-
Matcher<Stmt>initListExprMatcher<InitListExpr>...
Matches init list expressions.
-
-Given
-  int a[] = { 1, 2 };
-  struct B { int x, y; };
-  B b = { 5, 6 };
-initListExpr()
-  matches "{ 1, 2 }" and "{ 5, 6 }"
-
Matcher<Stmt>integerLiteralMatcher<IntegerLiteral>...
Matches integer literals of all sizes encodings, e.g.
-1, 1L, 0x1 and 1U.
-
-Does not match character-encoded integers such as L'a'.
-
Matcher<Stmt>labelStmtMatcher<LabelStmt>...
Matches label statements.
-
-Given
-  goto FOO;
-  FOO: bar();
-labelStmt()
-  matches 'FOO:'
-
Matcher<Stmt>lambdaExprMatcher<LambdaExpr>...
Matches lambda expressions.
-
-Example matches [&](){return 5;}
-  [&](){return 5;}
-
Matcher<Stmt>materializeTemporaryExprMatcher<MaterializeTemporaryExpr>...
Matches nodes where temporaries are materialized.
-
-Example: Given
-  struct T {void func()};
-  T f();
-  void g(T);
-materializeTemporaryExpr() matches 'f()' in these statements
-  T u(f());
-  g(f());
-but does not match
-  f();
-  f().func();
-
Matcher<Stmt>memberExprMatcher<MemberExpr>...
Matches member expressions.
-
-Given
-  class Y {
-    void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
-    int a; static int b;
-  };
-memberExpr()
-  matches this->x, x, y.x, a, this->b
-
Matcher<Stmt>nullStmtMatcher<NullStmt>...
Matches null statements.
-
-  foo();;
-nullStmt()
-  matches the second ';'
-
Matcher<Stmt>objcMessageExprMatcher<ObjCMessageExpr>...
Matches ObjectiveC Message invocation expressions.
-
-The innermost message send invokes the "alloc" class method on the
-NSString class, while the outermost message send invokes the
-"initWithString" instance method on the object returned from
-NSString's "alloc". This matcher should match both message sends.
-  [[NSString alloc] initWithString:@"Hello"]
-
Matcher<Stmt>returnStmtMatcher<ReturnStmt>...
Matches return statements.
-
-Given
-  return 1;
-returnStmt()
-  matches 'return 1'
-
Matcher<Stmt>stmtMatcher<Stmt>...
Matches statements.
-
-Given
-  { ++a; }
-stmt()
-  matches both the compound statement '{ ++a; }' and '++a'.
-
Matcher<Stmt>stringLiteralMatcher<StringLiteral>...
Matches string literals (also matches wide string literals).
-
-Example matches "abcd", L"abcd"
-  char *s = "abcd"; wchar_t *ws = L"abcd"
-
Matcher<Stmt>substNonTypeTemplateParmExprMatcher<SubstNonTypeTemplateParmExpr>...
Matches substitutions of non-type template parameters.
-
-Given
-  template <int N>
-  struct A { static const int n = N; };
-  struct B : public A<42> {};
-substNonTypeTemplateParmExpr()
-  matches "N" in the right-hand side of "static const int n = N;"
-
Matcher<Stmt>switchCaseMatcher<SwitchCase>...
Matches case and default statements inside switch statements.
-
-Given
-  switch(a) { case 42: break; default: break; }
-switchCase()
-  matches 'case 42: break;' and 'default: break;'.
-
Matcher<Stmt>switchStmtMatcher<SwitchStmt>...
Matches switch statements.
-
-Given
-  switch(a) { case 42: break; default: break; }
-switchStmt()
-  matches 'switch(a)'.
-
Matcher<Stmt>unaryExprOrTypeTraitExprMatcher<UnaryExprOrTypeTraitExpr>...
Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
-
-Given
-  Foo x = bar;
-  int y = sizeof(x) + alignof(x);
-unaryExprOrTypeTraitExpr()
-  matches sizeof(x) and alignof(x)
-
Matcher<Stmt>unaryOperatorMatcher<UnaryOperator>...
Matches unary operator expressions.
-
-Example matches !a
-  !a || b
-
Matcher<Stmt>userDefinedLiteralMatcher<UserDefinedLiteral>...
Matches user defined literal operator call.
-
-Example match: "foo"_suffix
-
Matcher<Stmt>whileStmtMatcher<WhileStmt>...
Matches while statements.
-
-Given
-  while (true) {}
-whileStmt()
-  matches 'while (true) {}'.
-
Matcher<TemplateArgument>templateArgumentMatcher<TemplateArgument>...
Matches template arguments.
-
-Given
-  template <typename T> struct C {};
-  C<int> c;
-templateArgument()
-  matches 'int' in C<int>.
-
Matcher<TypeLoc>typeLocMatcher<TypeLoc>...
Matches TypeLocs in the clang AST.
-
Matcher<Type>arrayTypeMatcher<ArrayType>...
Matches all kinds of arrays.
-
-Given
-  int a[] = { 2, 3 };
-  int b[4];
-  void f() { int c[a[0]]; }
-arrayType()
-  matches "int a[]", "int b[4]" and "int c[a[0]]";
-
Matcher<Type>atomicTypeMatcher<AtomicType>...
Matches atomic types.
-
-Given
-  _Atomic(int) i;
-atomicType()
-  matches "_Atomic(int) i"
-
Matcher<Type>autoTypeMatcher<AutoType>...
Matches types nodes representing C++11 auto types.
-
-Given:
-  auto n = 4;
-  int v[] = { 2, 3 }
-  for (auto i : v) { }
-autoType()
-  matches "auto n" and "auto i"
-
Matcher<Type>blockPointerTypeMatcher<BlockPointerType>...
Matches block pointer types, i.e. types syntactically represented as
-"void (^)(int)".
-
-The pointee is always required to be a FunctionType.
-
Matcher<Type>builtinTypeMatcher<BuiltinType>...
Matches builtin Types.
-
-Given
-  struct A {};
-  A a;
-  int b;
-  float c;
-  bool d;
-builtinType()
-  matches "int b", "float c" and "bool d"
-
Matcher<Type>complexTypeMatcher<ComplexType>...
Matches C99 complex types.
-
-Given
-  _Complex float f;
-complexType()
-  matches "_Complex float f"
-
Matcher<Type>constantArrayTypeMatcher<ConstantArrayType>...
Matches C arrays with a specified constant size.
-
-Given
-  void() {
-    int a[2];
-    int b[] = { 2, 3 };
-    int c[b[0]];
-  }
-constantArrayType()
-  matches "int a[2]"
-
Matcher<Type>decayedTypeMatcher<DecayedType>...
Matches decayed type
-Example matches i[] in declaration of f.
-    (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
-Example matches i[1].
-    (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
-  void f(int i[]) {
-    i[1] = 0;
-  }
-
Matcher<Type>dependentSizedArrayTypeMatcher<DependentSizedArrayType>...
Matches C++ arrays whose size is a value-dependent expression.
-
-Given
-  template<typename T, int Size>
-  class array {
-    T data[Size];
-  };
-dependentSizedArrayType
-  matches "T data[Size]"
-
Matcher<Type>elaboratedTypeMatcher<ElaboratedType>...
Matches types specified with an elaborated type keyword or with a
-qualified name.
-
-Given
-  namespace N {
-    namespace M {
-      class D {};
-    }
-  }
-  class C {};
-
-  class C c;
-  N::M::D d;
-
-elaboratedType() matches the type of the variable declarations of both
-c and d.
-
Matcher<Type>functionTypeMatcher<FunctionType>...
Matches FunctionType nodes.
-
-Given
-  int (*f)(int);
-  void g();
-functionType()
-  matches "int (*f)(int)" and the type of "g".
-
Matcher<Type>incompleteArrayTypeMatcher<IncompleteArrayType>...
Matches C arrays with unspecified size.
-
-Given
-  int a[] = { 2, 3 };
-  int b[42];
-  void f(int c[]) { int d[a[0]]; };
-incompleteArrayType()
-  matches "int a[]" and "int c[]"
-
Matcher<Type>injectedClassNameTypeMatcher<InjectedClassNameType>...
Matches injected class name types.
-
-Example matches S s, but not S<T> s.
-    (matcher = parmVarDecl(hasType(injectedClassNameType())))
-  template <typename T> struct S {
-    void f(S s);
-    void g(S<T> s);
-  };
-
Matcher<Type>lValueReferenceTypeMatcher<LValueReferenceType>...
Matches lvalue reference types.
-
-Given:
-  int *a;
-  int &b = *a;
-  int &&c = 1;
-  auto &d = b;
-  auto &&e = c;
-  auto &&f = 2;
-  int g = 5;
-
-lValueReferenceType() matches the types of b, d, and e. e is
-matched since the type is deduced as int& by reference collapsing rules.
-
Matcher<Type>memberPointerTypeMatcher<MemberPointerType>...
Matches member pointer types.
-Given
-  struct A { int i; }
-  A::* ptr = A::i;
-memberPointerType()
-  matches "A::* ptr"
-
Matcher<Type>objcObjectPointerTypeMatcher<ObjCObjectPointerType>...
Matches an Objective-C object pointer type, which is different from
-a pointer type, despite being syntactically similar.
-
-Given
-  int *a;
-
-  @interface Foo
-  @end
-  Foo *f;
-pointerType()
-  matches "Foo *f", but does not match "int *a".
-
Matcher<Type>parenTypeMatcher<ParenType>...
Matches ParenType nodes.
-
-Given
-  int (*ptr_to_array)[4];
-  int *array_of_ptrs[4];
-
-varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
-array_of_ptrs.
-
Matcher<Type>pointerTypeMatcher<PointerType>...
Matches pointer types, but does not match Objective-C object pointer
-types.
-
-Given
-  int *a;
-  int &b = *a;
-  int c = 5;
-
-  @interface Foo
-  @end
-  Foo *f;
-pointerType()
-  matches "int *a", but does not match "Foo *f".
-
Matcher<Type>rValueReferenceTypeMatcher<RValueReferenceType>...
Matches rvalue reference types.
-
-Given:
-  int *a;
-  int &b = *a;
-  int &&c = 1;
-  auto &d = b;
-  auto &&e = c;
-  auto &&f = 2;
-  int g = 5;
-
-rValueReferenceType() matches the types of c and f. e is not
-matched as it is deduced to int& by reference collapsing rules.
-
Matcher<Type>recordTypeMatcher<RecordType>...
Matches record types (e.g. structs, classes).
-
-Given
-  class C {};
-  struct S {};
-
-  C c;
-  S s;
-
-recordType() matches the type of the variable declarations of both c
-and s.
-
Matcher<Type>referenceTypeMatcher<ReferenceType>...
Matches both lvalue and rvalue reference types.
-
-Given
-  int *a;
-  int &b = *a;
-  int &&c = 1;
-  auto &d = b;
-  auto &&e = c;
-  auto &&f = 2;
-  int g = 5;
-
-referenceType() matches the types of b, c, d, e, and f.
-
Matcher<Type>substTemplateTypeParmTypeMatcher<SubstTemplateTypeParmType>...
Matches types that represent the result of substituting a type for a
-template type parameter.
-
-Given
-  template <typename T>
-  void F(T t) {
-    int i = 1 + t;
-  }
-
-substTemplateTypeParmType() matches the type of 't' but not '1'
-
Matcher<Type>templateSpecializationTypeMatcher<TemplateSpecializationType>...
Matches template specialization types.
-
-Given
-  template <typename T>
-  class C { };
-
-  template class C<int>;  A
-  C<char> var;            B
-
-templateSpecializationType() matches the type of the explicit
-instantiation in A and the type of the variable declaration in B.
-
Matcher<Type>templateTypeParmTypeMatcher<TemplateTypeParmType>...
Matches template type parameter types.
-
-Example matches T, but not int.
-    (matcher = templateTypeParmType())
-  template <typename T> void f(int i);
-
Matcher<Type>typeMatcher<Type>...
Matches Types in the clang AST.
-
Matcher<Type>typedefTypeMatcher<TypedefType>...
Matches typedef types.
-
-Given
-  typedef int X;
-typedefType()
-  matches "typedef int X"
-
Matcher<Type>unaryTransformTypeMatcher<UnaryTransformType>...
Matches types nodes representing unary type transformations.
-
-Given:
-  typedef __underlying_type(T) type;
-unaryTransformType()
-  matches "__underlying_type(T)"
-
Matcher<Type>variableArrayTypeMatcher<VariableArrayType>...
Matches C arrays with a specified size that is not an
-integer-constant-expression.
-
-Given
-  void f() {
-    int a[] = { 2, 3 }
-    int b[42];
-    int c[a[0]];
-  }
-variableArrayType()
-  matches "int c[a[0]]"
-
- - -

Narrowing Matchers

- - -

Narrowing matchers match certain attributes on the current node, thus -narrowing down the set of nodes of the current type to match on.

- -

There are special logical narrowing matchers (allOf, anyOf, anything and unless) -which allow users to create more powerful match expressions.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Return typeNameParameters
Matcher<*>allOfMatcher<*>, ..., Matcher<*>
Matches if all given matchers match.
-
-Usable as: Any Matcher
-
Matcher<*>anyOfMatcher<*>, ..., Matcher<*>
Matches if any of the given matchers matches.
-
-Usable as: Any Matcher
-
Matcher<*>anything
Matches any node.
-
-Useful when another matcher requires a child matcher, but there's no
-additional constraint. This will often be used with an explicit conversion
-to an internal::Matcher<> type such as TypeMatcher.
-
-Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
-"int* p" and "void f()" in
-  int* p;
-  void f();
-
-Usable as: Any Matcher
-
Matcher<*>unlessMatcher<*>
Matches if the provided matcher does not match.
-
-Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
-  class X {};
-  class Y {};
-
-Usable as: Any Matcher
-
Matcher<BinaryOperator>hasOperatorNamestd::string Name
Matches the operator Name of operator expressions (binary or
-unary).
-
-Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
-  !(a || b)
-
Matcher<CXXBoolLiteral>equalsValueT Value
Matches literals that are equal to the given value.
-
-Example matches true (matcher = cxxBoolLiteral(equals(true)))
-  true
-
-Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
-           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
-
Matcher<CXXCatchStmt>isCatchAll
Matches a C++ catch statement that has a catch-all handler.
-
-Given
-  try {
-    ...
-  } catch (int) {
-    ...
-  } catch (...) {
-    ...
-  }
-endcode
-cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
-
Matcher<CXXConstructExpr>argumentCountIsunsigned N
Checks that a call expression or a constructor call expression has
-a specific number of arguments (including absent default arguments).
-
-Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
-  void f(int x, int y);
-  f(0, 0);
-
Matcher<CXXConstructExpr>isListInitialization
Matches a constructor call expression which uses list initialization.
-
Matcher<CXXConstructorDecl>isCopyConstructor
Matches constructor declarations that are copy constructors.
-
-Given
-  struct S {
-    S(); #1
-    S(const S &); #2
-    S(S &&); #3
-  };
-cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
-
Matcher<CXXConstructorDecl>isDefaultConstructor
Matches constructor declarations that are default constructors.
-
-Given
-  struct S {
-    S(); #1
-    S(const S &); #2
-    S(S &&); #3
-  };
-cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
-
Matcher<CXXConstructorDecl>isExplicit
Matches constructor and conversion declarations that are marked with
-the explicit keyword.
-
-Given
-  struct S {
-    S(int); #1
-    explicit S(double); #2
-    operator int(); #3
-    explicit operator bool(); #4
-  };
-cxxConstructorDecl(isExplicit()) will match #2, but not #1.
-cxxConversionDecl(isExplicit()) will match #4, but not #3.
-
Matcher<CXXConstructorDecl>isMoveConstructor
Matches constructor declarations that are move constructors.
-
-Given
-  struct S {
-    S(); #1
-    S(const S &); #2
-    S(S &&); #3
-  };
-cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
-
Matcher<CXXConversionDecl>isExplicit
Matches constructor and conversion declarations that are marked with
-the explicit keyword.
-
-Given
-  struct S {
-    S(int); #1
-    explicit S(double); #2
-    operator int(); #3
-    explicit operator bool(); #4
-  };
-cxxConstructorDecl(isExplicit()) will match #2, but not #1.
-cxxConversionDecl(isExplicit()) will match #4, but not #3.
-
Matcher<CXXCtorInitializer>isBaseInitializer
Matches a constructor initializer if it is initializing a base, as
-opposed to a member.
-
-Given
-  struct B {};
-  struct D : B {
-    int I;
-    D(int i) : I(i) {}
-  };
-  struct E : B {
-    E() : B() {}
-  };
-cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
-  will match E(), but not match D(int).
-
Matcher<CXXCtorInitializer>isMemberInitializer
Matches a constructor initializer if it is initializing a member, as
-opposed to a base.
-
-Given
-  struct B {};
-  struct D : B {
-    int I;
-    D(int i) : I(i) {}
-  };
-  struct E : B {
-    E() : B() {}
-  };
-cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
-  will match D(int), but not match E().
-
Matcher<CXXCtorInitializer>isWritten
Matches a constructor initializer if it is explicitly written in
-code (as opposed to implicitly added by the compiler).
-
-Given
-  struct Foo {
-    Foo() { }
-    Foo(int) : foo_("A") { }
-    string foo_;
-  };
-cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
-  will match Foo(int), but not Foo()
-
Matcher<CXXMethodDecl>isConst
Matches if the given method declaration is const.
-
-Given
-struct A {
-  void foo() const;
-  void bar();
-};
-
-cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
-
Matcher<CXXMethodDecl>isCopyAssignmentOperator
Matches if the given method declaration declares a copy assignment
-operator.
-
-Given
-struct A {
-  A &operator=(const A &);
-  A &operator=(A &&);
-};
-
-cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
-the second one.
-
Matcher<CXXMethodDecl>isFinal
Matches if the given method or class declaration is final.
-
-Given:
-  class A final {};
-
-  struct B {
-    virtual void f();
-  };
-
-  struct C : B {
-    void f() final;
-  };
-matches A and C::f, but not B, C, or B::f
-
Matcher<CXXMethodDecl>isOverride
Matches if the given method declaration overrides another method.
-
-Given
-  class A {
-   public:
-    virtual void x();
-  };
-  class B : public A {
-   public:
-    virtual void x();
-  };
-  matches B::x
-
Matcher<CXXMethodDecl>isPure
Matches if the given method declaration is pure.
-
-Given
-  class A {
-   public:
-    virtual void x() = 0;
-  };
-  matches A::x
-
Matcher<CXXMethodDecl>isVirtual
Matches if the given method declaration is virtual.
-
-Given
-  class A {
-   public:
-    virtual void x();
-  };
-  matches A::x
-
Matcher<CXXOperatorCallExpr>hasOverloadedOperatorNameStringRef Name
Matches overloaded operator names.
-
-Matches overloaded operator names specified in strings without the
-"operator" prefix: e.g. "<<".
-
-Given:
-  class A { int operator*(); };
-  const A &operator<<(const A &a, const A &b);
-  A a;
-  a << a;   <-- This matches
-
-cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the
-specified line and
-cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
-matches the declaration of A.
-
-Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
-
Matcher<CXXRecordDecl>isDerivedFromstd::string BaseName
Overloaded method as shortcut for isDerivedFrom(hasName(...)).
-
Matcher<CXXRecordDecl>isExplicitTemplateSpecialization
Matches explicit template specializations of function, class, or
-static member variable template instantiations.
-
-Given
-  template<typename T> void A(T t) { }
-  template<> void A(int N) { }
-functionDecl(isExplicitTemplateSpecialization())
-  matches the specialization A<int>().
-
-Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
-
Matcher<CXXRecordDecl>isFinal
Matches if the given method or class declaration is final.
-
-Given:
-  class A final {};
-
-  struct B {
-    virtual void f();
-  };
-
-  struct C : B {
-    void f() final;
-  };
-matches A and C::f, but not B, C, or B::f
-
Matcher<CXXRecordDecl>isSameOrDerivedFromstd::string BaseName
Overloaded method as shortcut for
-isSameOrDerivedFrom(hasName(...)).
-
Matcher<CXXRecordDecl>isTemplateInstantiation
Matches template instantiations of function, class, or static
-member variable template instantiations.
-
-Given
-  template <typename T> class X {}; class A {}; X<A> x;
-or
-  template <typename T> class X {}; class A {}; template class X<A>;
-cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
-  matches the template instantiation of X<A>.
-
-But given
-  template <typename T>  class X {}; class A {};
-  template <> class X<A> {}; X<A> x;
-cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
-  does not match, as X<A> is an explicit template specialization.
-
-Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
-
Matcher<CallExpr>argumentCountIsunsigned N
Checks that a call expression or a constructor call expression has
-a specific number of arguments (including absent default arguments).
-
-Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
-  void f(int x, int y);
-  f(0, 0);
-
Matcher<CharacterLiteral>equalsValueT Value
Matches literals that are equal to the given value.
-
-Example matches true (matcher = cxxBoolLiteral(equals(true)))
-  true
-
-Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
-           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
-
Matcher<ClassTemplateSpecializationDecl>templateArgumentCountIsunsigned N
Matches if the number of template arguments equals N.
-
-Given
-  template<typename T> struct C {};
-  C<int> c;
-classTemplateSpecializationDecl(templateArgumentCountIs(1))
-  matches C<int>.
-
Matcher<CompoundStmt>statementCountIsunsigned N
Checks that a compound statement contains a specific number of
-child statements.
-
-Example: Given
-  { for (;;) {} }
-compoundStmt(statementCountIs(0)))
-  matches '{}'
-  but does not match the outer compound statement.
-
Matcher<ConstantArrayType>hasSizeunsigned N
Matches ConstantArrayType nodes that have the specified size.
-
-Given
-  int a[42];
-  int b[2 * 21];
-  int c[41], d[43];
-constantArrayType(hasSize(42))
-  matches "int a[42]" and "int b[2 * 21]"
-
Matcher<DeclStmt>declCountIsunsigned N
Matches declaration statements that contain a specific number of
-declarations.
-
-Example: Given
-  int a, b;
-  int c;
-  int d = 2, e;
-declCountIs(2)
-  matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
-
Matcher<Decl>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
-
-Matches a node if it equals the node previously bound to ID.
-
-Given
-  class X { int a; int b; };
-cxxRecordDecl(
-    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
-    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
-  matches the class X, as a and b have the same type.
-
-Note that when multiple matches are involved via forEach* matchers,
-equalsBoundNodes acts as a filter.
-For example:
-compoundStmt(
-    forEachDescendant(varDecl().bind("d")),
-    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
-will trigger a match for each combination of variable declaration
-and reference to that variable declaration within a compound statement.
-
Matcher<Decl>hasAttrattr::Kind AttrKind
Matches declaration that has a given attribute.
-
-Given
-  __attribute__((device)) void f() { ... }
-decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
-f. If the matcher is use from clang-query, attr::Kind parameter should be
-passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
-
Matcher<Decl>isExpansionInFileMatchingstd::string RegExp
Matches AST nodes that were expanded within files whose name is
-partially matching a given regex.
-
-Example matches Y but not X
-    (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
-  #include "ASTMatcher.h"
-  class X {};
-ASTMatcher.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<Decl>isExpansionInMainFile
Matches AST nodes that were expanded within the main-file.
-
-Example matches X but not Y
-  (matcher = cxxRecordDecl(isExpansionInMainFile())
-  #include <Y.h>
-  class X {};
-Y.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<Decl>isExpansionInSystemHeader
Matches AST nodes that were expanded within system-header-files.
-
-Example matches Y but not X
-    (matcher = cxxRecordDecl(isExpansionInSystemHeader())
-  #include <SystemHeader.h>
-  class X {};
-SystemHeader.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<Decl>isImplicit
Matches a declaration that has been implicitly added
-by the compiler (eg. implicit defaultcopy constructors).
-
Matcher<Decl>isPrivate
Matches private C++ declarations.
-
-Given
-  class C {
-  public:    int a;
-  protected: int b;
-  private:   int c;
-  };
-fieldDecl(isPrivate())
-  matches 'int c;' 
-
Matcher<Decl>isProtected
Matches protected C++ declarations.
-
-Given
-  class C {
-  public:    int a;
-  protected: int b;
-  private:   int c;
-  };
-fieldDecl(isProtected())
-  matches 'int b;' 
-
Matcher<Decl>isPublic
Matches public C++ declarations.
-
-Given
-  class C {
-  public:    int a;
-  protected: int b;
-  private:   int c;
-  };
-fieldDecl(isPublic())
-  matches 'int a;' 
-
Matcher<FloatingLiteral>equalsValueT Value
Matches literals that are equal to the given value.
-
-Example matches true (matcher = cxxBoolLiteral(equals(true)))
-  true
-
-Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
-           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
-
Matcher<FunctionDecl>hasOverloadedOperatorNameStringRef Name
Matches overloaded operator names.
-
-Matches overloaded operator names specified in strings without the
-"operator" prefix: e.g. "<<".
-
-Given:
-  class A { int operator*(); };
-  const A &operator<<(const A &a, const A &b);
-  A a;
-  a << a;   <-- This matches
-
-cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the
-specified line and
-cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
-matches the declaration of A.
-
-Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
-
Matcher<FunctionDecl>isConstexpr
Matches constexpr variable and function declarations.
-
-Given:
-  constexpr int foo = 42;
-  constexpr int bar();
-varDecl(isConstexpr())
-  matches the declaration of foo.
-functionDecl(isConstexpr())
-  matches the declaration of bar.
-
Matcher<FunctionDecl>isDefinition
Matches if a declaration has a body attached.
-
-Example matches A, va, fa
-  class A {};
-  class B;  Doesn't match, as it has no body.
-  int va;
-  extern int vb;  Doesn't match, as it doesn't define the variable.
-  void fa() {}
-  void fb();  Doesn't match, as it has no body.
-
-Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
-
Matcher<FunctionDecl>isDeleted
Matches deleted function declarations.
-
-Given:
-  void Func();
-  void DeletedFunc() = delete;
-functionDecl(isDeleted())
-  matches the declaration of DeletedFunc, but not Func.
-
Matcher<FunctionDecl>isExplicitTemplateSpecialization
Matches explicit template specializations of function, class, or
-static member variable template instantiations.
-
-Given
-  template<typename T> void A(T t) { }
-  template<> void A(int N) { }
-functionDecl(isExplicitTemplateSpecialization())
-  matches the specialization A<int>().
-
-Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
-
Matcher<FunctionDecl>isExternC
Matches extern "C" function declarations.
-
-Given:
-  extern "C" void f() {}
-  extern "C" { void g() {} }
-  void h() {}
-functionDecl(isExternC())
-  matches the declaration of f and g, but not the declaration h
-
Matcher<FunctionDecl>isInline
Matches function and namespace declarations that are marked with
-the inline keyword.
-
-Given
-  inline void f();
-  void g();
-  namespace n {
-  inline namespace m {}
-  }
-functionDecl(isInline()) will match ::f().
-namespaceDecl(isInline()) will match n::m.
-
Matcher<FunctionDecl>isTemplateInstantiation
Matches template instantiations of function, class, or static
-member variable template instantiations.
-
-Given
-  template <typename T> class X {}; class A {}; X<A> x;
-or
-  template <typename T> class X {}; class A {}; template class X<A>;
-cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
-  matches the template instantiation of X<A>.
-
-But given
-  template <typename T>  class X {}; class A {};
-  template <> class X<A> {}; X<A> x;
-cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
-  does not match, as X<A> is an explicit template specialization.
-
-Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
-
Matcher<FunctionDecl>isVariadic
Matches if a function declaration is variadic.
-
-Example matches f, but not g or h. The function i will not match, even when
-compiled in C mode.
-  void f(...);
-  void g(int);
-  template <typename... Ts> void h(Ts...);
-  void i();
-
Matcher<FunctionDecl>parameterCountIsunsigned N
Matches FunctionDecls that have a specific parameter count.
-
-Given
-  void f(int i) {}
-  void g(int i, int j) {}
-functionDecl(parameterCountIs(2))
-  matches g(int i, int j) {}
-
Matcher<IntegerLiteral>equalsValueT Value
Matches literals that are equal to the given value.
-
-Example matches true (matcher = cxxBoolLiteral(equals(true)))
-  true
-
-Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
-           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
-
Matcher<MemberExpr>isArrow
Matches member expressions that are called with '->' as opposed
-to '.'.
-
-Member calls on the implicit this pointer match as called with '->'.
-
-Given
-  class Y {
-    void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
-    int a;
-    static int b;
-  };
-memberExpr(isArrow())
-  matches this->x, x, y.x, a, this->b
-
Matcher<NamedDecl>hasNamestd::string Name
Matches NamedDecl nodes that have the specified name.
-
-Supports specifying enclosing namespaces or classes by prefixing the name
-with '<enclosing>::'.
-Does not match typedefs of an underlying type with the given name.
-
-Example matches X (Name == "X")
-  class X;
-
-Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
-  namespace a { namespace b { class X; } }
-
Matcher<NamedDecl>matchesNamestd::string RegExp
Matches NamedDecl nodes whose fully qualified names contain
-a substring matched by the given RegExp.
-
-Supports specifying enclosing namespaces or classes by
-prefixing the name with '<enclosing>::'.  Does not match typedefs
-of an underlying type with the given name.
-
-Example matches X (regexp == "::X")
-  class X;
-
-Example matches X (regexp is one of "::X", "^foo::.*X", among others)
-  namespace foo { namespace bar { class X; } }
-
Matcher<NamespaceDecl>isAnonymous
Matches anonymous namespace declarations.
-
-Given
-  namespace n {
-  namespace {} #1
-  }
-namespaceDecl(isAnonymous()) will match #1 but not ::n.
-
Matcher<NamespaceDecl>isInline
Matches function and namespace declarations that are marked with
-the inline keyword.
-
-Given
-  inline void f();
-  void g();
-  namespace n {
-  inline namespace m {}
-  }
-functionDecl(isInline()) will match ::f().
-namespaceDecl(isInline()) will match n::m.
-
Matcher<ObjCMessageExpr>argumentCountIsunsigned N
Checks that a call expression or a constructor call expression has
-a specific number of arguments (including absent default arguments).
-
-Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
-  void f(int x, int y);
-  f(0, 0);
-
Matcher<ObjCMessageExpr>hasKeywordSelector
Matches when the selector is a keyword selector
-
-objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
-message expression in
-
-  UIWebView *webView = ...;
-  CGRect bodyFrame = webView.frame;
-  bodyFrame.size.height = self.bodyContentHeight;
-  webView.frame = bodyFrame;
-      ^---- matches here
-
Matcher<ObjCMessageExpr>hasNullSelector
Matches when the selector is the empty selector
-
-Matches only when the selector of the objCMessageExpr is NULL. This may
-represent an error condition in the tree!
-
Matcher<ObjCMessageExpr>hasSelectorstd::string BaseName
Matches when BaseName == Selector.getAsString()
-
- matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
- matches the outer message expr in the code below, but NOT the message
- invocation for self.bodyView.
-    [self.bodyView loadHTMLString:html baseURL:NULL];
-
Matcher<ObjCMessageExpr>hasUnarySelector
Matches when the selector is a Unary Selector
-
- matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
- matches self.bodyView in the code below, but NOT the outer message
- invocation of "loadHTMLString:baseURL:".
-    [self.bodyView loadHTMLString:html baseURL:NULL];
-
Matcher<ObjCMessageExpr>matchesSelectorstd::string RegExp
Matches ObjC selectors whose name contains
-a substring matched by the given RegExp.
- matcher = objCMessageExpr(matchesSelector("loadHTMLStringmatches the outer message expr in the code below, but NOT the message
- invocation for self.bodyView.
-    [self.bodyView loadHTMLString:html baseURL:NULL];
-
Matcher<ObjCMessageExpr>numSelectorArgsunsigned N
Matches when the selector has the specified number of arguments
-
- matcher = objCMessageExpr(numSelectorArgs(0));
- matches self.bodyView in the code below
-
- matcher = objCMessageExpr(numSelectorArgs(2));
- matches the invocation of "loadHTMLString:baseURL:" but not that
- of self.bodyView
-    [self.bodyView loadHTMLString:html baseURL:NULL];
-
Matcher<QualType>asStringstd::string Name
Matches if the matched type is represented by the given string.
-
-Given
-  class Y { public: void x(); };
-  void z() { Y* y; y->x(); }
-cxxMemberCallExpr(on(hasType(asString("class Y *"))))
-  matches y->x()
-
Matcher<QualType>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
-
-Matches a node if it equals the node previously bound to ID.
-
-Given
-  class X { int a; int b; };
-cxxRecordDecl(
-    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
-    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
-  matches the class X, as a and b have the same type.
-
-Note that when multiple matches are involved via forEach* matchers,
-equalsBoundNodes acts as a filter.
-For example:
-compoundStmt(
-    forEachDescendant(varDecl().bind("d")),
-    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
-will trigger a match for each combination of variable declaration
-and reference to that variable declaration within a compound statement.
-
Matcher<QualType>hasLocalQualifiers
Matches QualType nodes that have local CV-qualifiers attached to
-the node, not hidden within a typedef.
-
-Given
-  typedef const int const_int;
-  const_int i;
-  int *const j;
-  int *volatile k;
-  int m;
-varDecl(hasType(hasLocalQualifiers())) matches only j and k.
-i is const-qualified but the qualifier is not local.
-
Matcher<QualType>isConstQualified
Matches QualType nodes that are const-qualified, i.e., that
-include "top-level" const.
-
-Given
-  void a(int);
-  void b(int const);
-  void c(const int);
-  void d(const int*);
-  void e(int const) {};
-functionDecl(hasAnyParameter(hasType(isConstQualified())))
-  matches "void b(int const)", "void c(const int)" and
-  "void e(int const) {}". It does not match d as there
-  is no top-level const on the parameter type "const int *".
-
Matcher<QualType>isInteger
Matches QualType nodes that are of integer type.
-
-Given
-  void a(int);
-  void b(long);
-  void c(double);
-functionDecl(hasAnyParameter(hasType(isInteger())))
-matches "a(int)", "b(long)", but not "c(double)".
-
Matcher<RecordDecl>isClass
Matches RecordDecl object that are spelled with "class."
-
-Example matches C, but not S or U.
-  struct S {};
-  class C {};
-  union U {};
-
Matcher<RecordDecl>isStruct
Matches RecordDecl object that are spelled with "struct."
-
-Example matches S, but not C or U.
-  struct S {};
-  class C {};
-  union U {};
-
Matcher<RecordDecl>isUnion
Matches RecordDecl object that are spelled with "union."
-
-Example matches U, but not C or S.
-  struct S {};
-  class C {};
-  union U {};
-
Matcher<Stmt>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
-
-Matches a node if it equals the node previously bound to ID.
-
-Given
-  class X { int a; int b; };
-cxxRecordDecl(
-    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
-    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
-  matches the class X, as a and b have the same type.
-
-Note that when multiple matches are involved via forEach* matchers,
-equalsBoundNodes acts as a filter.
-For example:
-compoundStmt(
-    forEachDescendant(varDecl().bind("d")),
-    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
-will trigger a match for each combination of variable declaration
-and reference to that variable declaration within a compound statement.
-
Matcher<Stmt>isExpansionInFileMatchingstd::string RegExp
Matches AST nodes that were expanded within files whose name is
-partially matching a given regex.
-
-Example matches Y but not X
-    (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
-  #include "ASTMatcher.h"
-  class X {};
-ASTMatcher.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<Stmt>isExpansionInMainFile
Matches AST nodes that were expanded within the main-file.
-
-Example matches X but not Y
-  (matcher = cxxRecordDecl(isExpansionInMainFile())
-  #include <Y.h>
-  class X {};
-Y.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<Stmt>isExpansionInSystemHeader
Matches AST nodes that were expanded within system-header-files.
-
-Example matches Y but not X
-    (matcher = cxxRecordDecl(isExpansionInSystemHeader())
-  #include <SystemHeader.h>
-  class X {};
-SystemHeader.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<TagDecl>isDefinition
Matches if a declaration has a body attached.
-
-Example matches A, va, fa
-  class A {};
-  class B;  Doesn't match, as it has no body.
-  int va;
-  extern int vb;  Doesn't match, as it doesn't define the variable.
-  void fa() {}
-  void fb();  Doesn't match, as it has no body.
-
-Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
-
Matcher<TemplateArgument>equalsIntegralValuestd::string Value
Matches a TemplateArgument of integral type with a given value.
-
-Note that 'Value' is a string as the template argument's value is
-an arbitrary precision integer. 'Value' must be euqal to the canonical
-representation of that integral value in base 10.
-
-Given
-  template<int T> struct A {};
-  C<42> c;
-classTemplateSpecializationDecl(
-  hasAnyTemplateArgument(equalsIntegralValue("42")))
-  matches the implicit instantiation of C in C<42>.
-
Matcher<TemplateArgument>isIntegral
Matches a TemplateArgument that is an integral value.
-
-Given
-  template<int T> struct A {};
-  C<42> c;
-classTemplateSpecializationDecl(
-  hasAnyTemplateArgument(isIntegral()))
-  matches the implicit instantiation of C in C<42>
-  with isIntegral() matching 42.
-
Matcher<TemplateSpecializationType>templateArgumentCountIsunsigned N
Matches if the number of template arguments equals N.
-
-Given
-  template<typename T> struct C {};
-  C<int> c;
-classTemplateSpecializationDecl(templateArgumentCountIs(1))
-  matches C<int>.
-
Matcher<TypeLoc>isExpansionInFileMatchingstd::string RegExp
Matches AST nodes that were expanded within files whose name is
-partially matching a given regex.
-
-Example matches Y but not X
-    (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
-  #include "ASTMatcher.h"
-  class X {};
-ASTMatcher.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<TypeLoc>isExpansionInMainFile
Matches AST nodes that were expanded within the main-file.
-
-Example matches X but not Y
-  (matcher = cxxRecordDecl(isExpansionInMainFile())
-  #include <Y.h>
-  class X {};
-Y.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<TypeLoc>isExpansionInSystemHeader
Matches AST nodes that were expanded within system-header-files.
-
-Example matches Y but not X
-    (matcher = cxxRecordDecl(isExpansionInSystemHeader())
-  #include <SystemHeader.h>
-  class X {};
-SystemHeader.h:
-  class Y {};
-
-Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
-
Matcher<Type>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
-
-Matches a node if it equals the node previously bound to ID.
-
-Given
-  class X { int a; int b; };
-cxxRecordDecl(
-    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
-    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
-  matches the class X, as a and b have the same type.
-
-Note that when multiple matches are involved via forEach* matchers,
-equalsBoundNodes acts as a filter.
-For example:
-compoundStmt(
-    forEachDescendant(varDecl().bind("d")),
-    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
-will trigger a match for each combination of variable declaration
-and reference to that variable declaration within a compound statement.
-
Matcher<Type>voidType
Matches type void.
-
-Given
- struct S { void func(); };
-functionDecl(returns(voidType()))
-  matches "void func();"
-
Matcher<UnaryExprOrTypeTraitExpr>ofKindUnaryExprOrTypeTrait Kind
Matches unary expressions of a certain kind.
-
-Given
-  int x;
-  int s = sizeof(x) + alignof(x)
-unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
-  matches sizeof(x)
-
Matcher<UnaryOperator>hasOperatorNamestd::string Name
Matches the operator Name of operator expressions (binary or
-unary).
-
-Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
-  !(a || b)
-
Matcher<VarDecl>hasAutomaticStorageDuration
Matches a variable declaration that has automatic storage duration.
-
-Example matches x, but not y, z, or a.
-(matcher = varDecl(hasAutomaticStorageDuration())
-void f() {
-  int x;
-  static int y;
-  thread_local int z;
-}
-int a;
-
Matcher<VarDecl>hasGlobalStorage
Matches a variable declaration that does not have local storage.
-
-Example matches y and z (matcher = varDecl(hasGlobalStorage())
-void f() {
-  int x;
-  static int y;
-}
-int z;
-
Matcher<VarDecl>hasLocalStorage
Matches a variable declaration that has function scope and is a
-non-static local variable.
-
-Example matches x (matcher = varDecl(hasLocalStorage())
-void f() {
-  int x;
-  static int y;
-}
-int z;
-
Matcher<VarDecl>hasStaticStorageDuration
Matches a variable declaration that has static storage duration.
-
-Example matches y and a, but not x or z.
-(matcher = varDecl(hasStaticStorageDuration())
-void f() {
-  int x;
-  static int y;
-  thread_local int z;
-}
-int a;
-
Matcher<VarDecl>hasThreadStorageDuration
Matches a variable declaration that has thread storage duration.
-
-Example matches z, but not x, z, or a.
-(matcher = varDecl(hasThreadStorageDuration())
-void f() {
-  int x;
-  static int y;
-  thread_local int z;
-}
-int a;
-
Matcher<VarDecl>isConstexpr
Matches constexpr variable and function declarations.
-
-Given:
-  constexpr int foo = 42;
-  constexpr int bar();
-varDecl(isConstexpr())
-  matches the declaration of foo.
-functionDecl(isConstexpr())
-  matches the declaration of bar.
-
Matcher<VarDecl>isDefinition
Matches if a declaration has a body attached.
-
-Example matches A, va, fa
-  class A {};
-  class B;  Doesn't match, as it has no body.
-  int va;
-  extern int vb;  Doesn't match, as it doesn't define the variable.
-  void fa() {}
-  void fb();  Doesn't match, as it has no body.
-
-Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
-
Matcher<VarDecl>isExceptionVariable
Matches a variable declaration that is an exception variable from
-a C++ catch block, or an Objective-C statement.
-
-Example matches x (matcher = varDecl(isExceptionVariable())
-void f(int y) {
-  try {
-  } catch (int x) {
-  }
-}
-
Matcher<VarDecl>isExplicitTemplateSpecialization
Matches explicit template specializations of function, class, or
-static member variable template instantiations.
-
-Given
-  template<typename T> void A(T t) { }
-  template<> void A(int N) { }
-functionDecl(isExplicitTemplateSpecialization())
-  matches the specialization A<int>().
-
-Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
-
Matcher<VarDecl>isTemplateInstantiation
Matches template instantiations of function, class, or static
-member variable template instantiations.
-
-Given
-  template <typename T> class X {}; class A {}; X<A> x;
-or
-  template <typename T> class X {}; class A {}; template class X<A>;
-cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
-  matches the template instantiation of X<A>.
-
-But given
-  template <typename T>  class X {}; class A {};
-  template <> class X<A> {}; X<A> x;
-cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
-  does not match, as X<A> is an explicit template specialization.
-
-Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
-
Matcher<internal::Matcher<Decl>>isInstantiated
Matches declarations that are template instantiations or are inside
-template instantiations.
-
-Given
-  template<typename T> void A(T t) { T i; }
-  A(0);
-  A(0U);
-functionDecl(isInstantiated())
-  matches 'A(int) {...};' and 'A(unsigned) {...}'.
-
Matcher<internal::Matcher<Stmt>>isInTemplateInstantiation
Matches statements inside of a template instantiation.
-
-Given
-  int j;
-  template<typename T> void A(T t) { T i; j += 42;}
-  A(0);
-  A(0U);
-declStmt(isInTemplateInstantiation())
-  matches 'int i;' and 'unsigned i'.
-unless(stmt(isInTemplateInstantiation()))
-  will NOT match j += 42; as it's shared between the template definition and
-  instantiation.
-
- - -

AST Traversal Matchers

- - -

Traversal matchers specify the relationship to other nodes that are -reachable from the current node.

- -

Note that there are special traversal matchers (has, hasDescendant, forEach and -forEachDescendant) which work on all nodes and allow users to write more generic -match expressions.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Return typeNameParameters
Matcher<*>eachOfMatcher<*>, ..., Matcher<*>
Matches if any of the given matchers matches.
-
-Unlike anyOf, eachOf will generate a match result for each
-matching submatcher.
-
-For example, in:
-  class A { int a; int b; };
-The matcher:
-  cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
-                       has(fieldDecl(hasName("b")).bind("v"))))
-will generate two results binding "v", the first of which binds
-the field declaration of a, the second the field declaration of
-b.
-
-Usable as: Any Matcher
-
Matcher<*>forEachDescendantMatcher<*>
Matches AST nodes that have descendant AST nodes that match the
-provided matcher.
-
-Example matches X, A, B, C
-  (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X")))))
-  class X {};  Matches X, because X::X is a class of name X inside X.
-  class A { class X {}; };
-  class B { class C { class X {}; }; };
-
-DescendantT must be an AST base type.
-
-As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
-each result that matches instead of only on the first one.
-
-Note: Recursively combined ForEachDescendant can cause many matches:
-  cxxRecordDecl(forEachDescendant(cxxRecordDecl(
-    forEachDescendant(cxxRecordDecl())
-  )))
-will match 10 times (plus injected class name matches) on:
-  class A { class B { class C { class D { class E {}; }; }; }; };
-
-Usable as: Any Matcher
-
Matcher<*>forEachMatcher<*>
Matches AST nodes that have child AST nodes that match the
-provided matcher.
-
-Example matches X, Y
-  (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X")))
-  class X {};  Matches X, because X::X is a class of name X inside X.
-  class Y { class X {}; };
-  class Z { class Y { class X {}; }; };  Does not match Z.
-
-ChildT must be an AST base type.
-
-As opposed to 'has', 'forEach' will cause a match for each result that
-matches instead of only on the first one.
-
-Usable as: Any Matcher
-
Matcher<*>hasAncestorMatcher<*>
Matches AST nodes that have an ancestor that matches the provided
-matcher.
-
-Given
-void f() { if (true) { int x = 42; } }
-void g() { for (;;) { int x = 43; } }
-expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
-
-Usable as: Any Matcher
-
Matcher<*>hasDescendantMatcher<*>
Matches AST nodes that have descendant AST nodes that match the
-provided matcher.
-
-Example matches X, Y, Z
-    (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))
-  class X {};  Matches X, because X::X is a class of name X inside X.
-  class Y { class X {}; };
-  class Z { class Y { class X {}; }; };
-
-DescendantT must be an AST base type.
-
-Usable as: Any Matcher
-
Matcher<*>hasMatcher<*>
Matches AST nodes that have child AST nodes that match the
-provided matcher.
-
-Example matches X, Y
-  (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X")))
-  class X {};  Matches X, because X::X is a class of name X inside X.
-  class Y { class X {}; };
-  class Z { class Y { class X {}; }; };  Does not match Z.
-
-ChildT must be an AST base type.
-
-Usable as: Any Matcher
-
Matcher<*>hasParentMatcher<*>
Matches AST nodes that have a parent that matches the provided
-matcher.
-
-Given
-void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
-compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
-
-Usable as: Any Matcher
-
Matcher<ArraySubscriptExpr>hasBaseMatcher<Expr> InnerMatcher
Matches the base expression of an array subscript expression.
-
-Given
-  int i[5];
-  void f() { i[1] = 42; }
-arraySubscriptExpression(hasBase(implicitCastExpr(
-    hasSourceExpression(declRefExpr()))))
-  matches i[1] with the declRefExpr() matching i
-
Matcher<ArraySubscriptExpr>hasIndexMatcher<Expr> InnerMatcher
Matches the index expression of an array subscript expression.
-
-Given
-  int i[5];
-  void f() { i[1] = 42; }
-arraySubscriptExpression(hasIndex(integerLiteral()))
-  matches i[1] with the integerLiteral() matching 1
-
Matcher<ArraySubscriptExpr>hasLHSMatcher<Expr> InnerMatcher
Matches the left hand side of binary operator expressions.
-
-Example matches a (matcher = binaryOperator(hasLHS()))
-  a || b
-
Matcher<ArraySubscriptExpr>hasRHSMatcher<Expr> InnerMatcher
Matches the right hand side of binary operator expressions.
-
-Example matches b (matcher = binaryOperator(hasRHS()))
-  a || b
-
Matcher<ArrayTypeLoc>hasElementTypeLocMatcher<TypeLoc>
Matches arrays and C99 complex types that have a specific element
-type.
-
-Given
-  struct A {};
-  A a[7];
-  int b[7];
-arrayType(hasElementType(builtinType()))
-  matches "int b[7]"
-
-Usable as: Matcher<ArrayType>, Matcher<ComplexType>
-
Matcher<ArrayType>hasElementTypeMatcher<Type>
Matches arrays and C99 complex types that have a specific element
-type.
-
-Given
-  struct A {};
-  A a[7];
-  int b[7];
-arrayType(hasElementType(builtinType()))
-  matches "int b[7]"
-
-Usable as: Matcher<ArrayType>, Matcher<ComplexType>
-
Matcher<AtomicTypeLoc>hasValueTypeLocMatcher<TypeLoc>
Matches atomic types with a specific value type.
-
-Given
-  _Atomic(int) i;
-  _Atomic(float) f;
-atomicType(hasValueType(isInteger()))
- matches "_Atomic(int) i"
-
-Usable as: Matcher<AtomicType>
-
Matcher<AtomicType>hasValueTypeMatcher<Type>
Matches atomic types with a specific value type.
-
-Given
-  _Atomic(int) i;
-  _Atomic(float) f;
-atomicType(hasValueType(isInteger()))
- matches "_Atomic(int) i"
-
-Usable as: Matcher<AtomicType>
-
Matcher<AutoType>hasDeducedTypeMatcher<Type>
Matches AutoType nodes where the deduced type is a specific type.
-
-Note: There is no TypeLoc for the deduced type and thus no
-getDeducedLoc() matcher.
-
-Given
-  auto a = 1;
-  auto b = 2.0;
-autoType(hasDeducedType(isInteger()))
-  matches "auto a"
-
-Usable as: Matcher<AutoType>
-
Matcher<BinaryOperator>hasEitherOperandMatcher<Expr> InnerMatcher
Matches if either the left hand side or the right hand side of a
-binary operator matches.
-
Matcher<BinaryOperator>hasLHSMatcher<Expr> InnerMatcher
Matches the left hand side of binary operator expressions.
-
-Example matches a (matcher = binaryOperator(hasLHS()))
-  a || b
-
Matcher<BinaryOperator>hasRHSMatcher<Expr> InnerMatcher
Matches the right hand side of binary operator expressions.
-
-Example matches b (matcher = binaryOperator(hasRHS()))
-  a || b
-
Matcher<BlockPointerTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<BlockPointerType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<CXXConstructExpr>hasAnyArgumentMatcher<Expr> InnerMatcher
Matches any argument of a call expression or a constructor call
-expression.
-
-Given
-  void x(int, int, int) { int y; x(1, y, 42); }
-callExpr(hasAnyArgument(declRefExpr()))
-  matches x(1, y, 42)
-with hasAnyArgument(...)
-  matching y
-
-FIXME: Currently this will ignore parentheses and implicit casts on
-the argument before applying the inner matcher. We'll want to remove
-this to allow for greater control by the user once ignoreImplicit()
-has been implemented.
-
Matcher<CXXConstructExpr>hasArgumentunsigned N, Matcher<Expr> InnerMatcher
Matches the n'th argument of a call expression or a constructor
-call expression.
-
-Example matches y in x(y)
-    (matcher = callExpr(hasArgument(0, declRefExpr())))
-  void x(int) { int y; x(y); }
-
Matcher<CXXConstructExpr>hasDeclarationMatcher<Decl> InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<CXXConstructorDecl>forEachConstructorInitializerMatcher<CXXCtorInitializer> InnerMatcher
Matches each constructor initializer in a constructor definition.
-
-Given
-  class A { A() : i(42), j(42) {} int i; int j; };
-cxxConstructorDecl(forEachConstructorInitializer(
-  forField(decl().bind("x"))
-))
-  will trigger two matches, binding for 'i' and 'j' respectively.
-
Matcher<CXXConstructorDecl>hasAnyConstructorInitializerMatcher<CXXCtorInitializer> InnerMatcher
Matches a constructor initializer.
-
-Given
-  struct Foo {
-    Foo() : foo_(1) { }
-    int foo_;
-  };
-cxxRecordDecl(has(cxxConstructorDecl(
-  hasAnyConstructorInitializer(anything())
-)))
-  record matches Foo, hasAnyConstructorInitializer matches foo_(1)
-
Matcher<CXXCtorInitializer>forFieldMatcher<FieldDecl> InnerMatcher
Matches the field declaration of a constructor initializer.
-
-Given
-  struct Foo {
-    Foo() : foo_(1) { }
-    int foo_;
-  };
-cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
-    forField(hasName("foo_"))))))
-  matches Foo
-with forField matching foo_
-
Matcher<CXXCtorInitializer>withInitializerMatcher<Expr> InnerMatcher
Matches the initializer expression of a constructor initializer.
-
-Given
-  struct Foo {
-    Foo() : foo_(1) { }
-    int foo_;
-  };
-cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
-    withInitializer(integerLiteral(equals(1)))))))
-  matches Foo
-with withInitializer matching (1)
-
Matcher<CXXForRangeStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
-a given body.
-
-Given
-  for (;;) {}
-hasBody(compoundStmt())
-  matches 'for (;;) {}'
-with compoundStmt()
-  matching '{}'
-
Matcher<CXXForRangeStmt>hasLoopVariableMatcher<VarDecl> InnerMatcher
Matches the initialization statement of a for loop.
-
-Example:
-    forStmt(hasLoopVariable(anything()))
-matches 'int x' in
-    for (int x : a) { }
-
Matcher<CXXForRangeStmt>hasRangeInitMatcher<Expr> InnerMatcher
Matches the range initialization statement of a for loop.
-
-Example:
-    forStmt(hasRangeInit(anything()))
-matches 'a' in
-    for (int x : a) { }
-
Matcher<CXXMemberCallExpr>onImplicitObjectArgumentMatcher<Expr> InnerMatcher
Matcher<CXXMemberCallExpr>onMatcher<Expr> InnerMatcher
Matches on the implicit object argument of a member call expression.
-
-Example matches y.x()
-  (matcher = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y"))))))
-  class Y { public: void x(); };
-  void z() { Y y; y.x(); }",
-
-FIXME: Overload to allow directly matching types?
-
Matcher<CXXMemberCallExpr>thisPointerTypeMatcher<Decl> InnerMatcher
Overloaded to match the type's declaration.
-
Matcher<CXXMemberCallExpr>thisPointerTypeMatcher<QualType> InnerMatcher
Matches if the expression's type either matches the specified
-matcher, or is a pointer to a type that matches the InnerMatcher.
-
Matcher<CXXMethodDecl>ofClassMatcher<CXXRecordDecl> InnerMatcher
Matches the class declaration that the given method declaration
-belongs to.
-
-FIXME: Generalize this for other kinds of declarations.
-FIXME: What other kind of declarations would we need to generalize
-this to?
-
-Example matches A() in the last line
-    (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
-        ofClass(hasName("A"))))))
-  class A {
-   public:
-    A();
-  };
-  A a = A();
-
Matcher<CXXRecordDecl>hasMethodMatcher<CXXMethodDecl> InnerMatcher
Matches the first method of a class or struct that satisfies InnerMatcher.
-
-Given:
-  class A { void func(); };
-  class B { void member(); };
-
-cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
-A but not B.
-
Matcher<CXXRecordDecl>isDerivedFromMatcher<NamedDecl> Base
Matches C++ classes that are directly or indirectly derived from
-a class matching Base.
-
-Note that a class is not considered to be derived from itself.
-
-Example matches Y, Z, C (Base == hasName("X"))
-  class X;
-  class Y : public X {};  directly derived
-  class Z : public Y {};  indirectly derived
-  typedef X A;
-  typedef A B;
-  class C : public B {};  derived from a typedef of X
-
-In the following example, Bar matches isDerivedFrom(hasName("X")):
-  class Foo;
-  typedef Foo X;
-  class Bar : public Foo {};  derived from a type that X is a typedef of
-
Matcher<CXXRecordDecl>isSameOrDerivedFromMatcher<NamedDecl> Base
Similar to isDerivedFrom(), but also matches classes that directly
-match Base.
-
Matcher<CallExpr>calleeMatcher<Decl> InnerMatcher
Matches if the call expression's callee's declaration matches the
-given matcher.
-
-Example matches y.x() (matcher = callExpr(callee(
-                                   cxxMethodDecl(hasName("x")))))
-  class Y { public: void x(); };
-  void z() { Y y; y.x(); }
-
Matcher<CallExpr>calleeMatcher<Stmt> InnerMatcher
Matches if the call expression's callee expression matches.
-
-Given
-  class Y { void x() { this->x(); x(); Y y; y.x(); } };
-  void f() { f(); }
-callExpr(callee(expr()))
-  matches this->x(), x(), y.x(), f()
-with callee(...)
-  matching this->x, x, y.x, f respectively
-
-Note: Callee cannot take the more general internal::Matcher<Expr>
-because this introduces ambiguous overloads with calls to Callee taking a
-internal::Matcher<Decl>, as the matcher hierarchy is purely
-implemented in terms of implicit casts.
-
Matcher<CallExpr>hasAnyArgumentMatcher<Expr> InnerMatcher
Matches any argument of a call expression or a constructor call
-expression.
-
-Given
-  void x(int, int, int) { int y; x(1, y, 42); }
-callExpr(hasAnyArgument(declRefExpr()))
-  matches x(1, y, 42)
-with hasAnyArgument(...)
-  matching y
-
-FIXME: Currently this will ignore parentheses and implicit casts on
-the argument before applying the inner matcher. We'll want to remove
-this to allow for greater control by the user once ignoreImplicit()
-has been implemented.
-
Matcher<CallExpr>hasArgumentunsigned N, Matcher<Expr> InnerMatcher
Matches the n'th argument of a call expression or a constructor
-call expression.
-
-Example matches y in x(y)
-    (matcher = callExpr(hasArgument(0, declRefExpr())))
-  void x(int) { int y; x(y); }
-
Matcher<CallExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<CaseStmt>hasCaseConstantMatcher<Expr> InnerMatcher
If the given case statement does not use the GNU case range
-extension, matches the constant given in the statement.
-
-Given
-  switch (1) { case 1: case 1+1: case 3 ... 4: ; }
-caseStmt(hasCaseConstant(integerLiteral()))
-  matches "case 1:"
-
Matcher<CastExpr>hasSourceExpressionMatcher<Expr> InnerMatcher
Matches if the cast's source expression matches the given matcher.
-
-Example: matches "a string" (matcher =
-                                 hasSourceExpression(cxxConstructExpr()))
-class URL { URL(string); };
-URL url = "a string";
-
Matcher<ClassTemplateSpecializationDecl>hasAnyTemplateArgumentMatcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations that have at least one
-TemplateArgument matching the given InnerMatcher.
-
-Given
-  template<typename T> class A {};
-  template<> class A<double> {};
-  A<int> a;
-classTemplateSpecializationDecl(hasAnyTemplateArgument(
-    refersToType(asString("int"))))
-  matches the specialization A<int>
-
Matcher<ClassTemplateSpecializationDecl>hasTemplateArgumentunsigned N, Matcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations where the n'th TemplateArgument
-matches the given InnerMatcher.
-
-Given
-  template<typename T, typename U> class A {};
-  A<bool, int> b;
-  A<int, bool> c;
-classTemplateSpecializationDecl(hasTemplateArgument(
-    1, refersToType(asString("int"))))
-  matches the specialization A<bool, int>
-
Matcher<ComplexTypeLoc>hasElementTypeLocMatcher<TypeLoc>
Matches arrays and C99 complex types that have a specific element
-type.
-
-Given
-  struct A {};
-  A a[7];
-  int b[7];
-arrayType(hasElementType(builtinType()))
-  matches "int b[7]"
-
-Usable as: Matcher<ArrayType>, Matcher<ComplexType>
-
Matcher<ComplexType>hasElementTypeMatcher<Type>
Matches arrays and C99 complex types that have a specific element
-type.
-
-Given
-  struct A {};
-  A a[7];
-  int b[7];
-arrayType(hasElementType(builtinType()))
-  matches "int b[7]"
-
-Usable as: Matcher<ArrayType>, Matcher<ComplexType>
-
Matcher<CompoundStmt>hasAnySubstatementMatcher<Stmt> InnerMatcher
Matches compound statements where at least one substatement matches
-a given matcher.
-
-Given
-  { {}; 1+2; }
-hasAnySubstatement(compoundStmt())
-  matches '{ {}; 1+2; }'
-with compoundStmt()
-  matching '{}'
-
Matcher<ConditionalOperator>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
-or conditional operator.
-
-Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
-  if (true) {}
-
Matcher<ConditionalOperator>hasFalseExpressionMatcher<Expr> InnerMatcher
Matches the false branch expression of a conditional operator.
-
-Example matches b
-  condition ? a : b
-
Matcher<ConditionalOperator>hasTrueExpressionMatcher<Expr> InnerMatcher
Matches the true branch expression of a conditional operator.
-
-Example matches a
-  condition ? a : b
-
Matcher<DecayedType>hasDecayedTypeMatcher<QualType> InnerType
Matches the decayed type, whos decayed type matches InnerMatcher
-
Matcher<DeclRefExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<DeclRefExpr>throughUsingDeclMatcher<UsingShadowDecl> InnerMatcher
Matches a DeclRefExpr that refers to a declaration through a
-specific using shadow declaration.
-
-Given
-  namespace a { void f() {} }
-  using a::f;
-  void g() {
-    f();     Matches this ..
-    a::f();  .. but not this.
-  }
-declRefExpr(throughUsingDecl(anything()))
-  matches f()
-
Matcher<DeclRefExpr>toMatcher<Decl> InnerMatcher
Matches a DeclRefExpr that refers to a declaration that matches the
-specified matcher.
-
-Example matches x in if(x)
-    (matcher = declRefExpr(to(varDecl(hasName("x")))))
-  bool x;
-  if (x) {}
-
Matcher<DeclStmt>containsDeclarationunsigned N, Matcher<Decl> InnerMatcher
Matches the n'th declaration of a declaration statement.
-
-Note that this does not work for global declarations because the AST
-breaks up multiple-declaration DeclStmt's into multiple single-declaration
-DeclStmt's.
-Example: Given non-global declarations
-  int a, b = 0;
-  int c;
-  int d = 2, e;
-declStmt(containsDeclaration(
-      0, varDecl(hasInitializer(anything()))))
-  matches only 'int d = 2, e;', and
-declStmt(containsDeclaration(1, varDecl()))
-  matches 'int a, b = 0' as well as 'int d = 2, e;'
-  but 'int c;' is not matched.
-
Matcher<DeclStmt>hasSingleDeclMatcher<Decl> InnerMatcher
Matches the Decl of a DeclStmt which has a single declaration.
-
-Given
-  int a, b;
-  int c;
-declStmt(hasSingleDecl(anything()))
-  matches 'int c;' but not 'int a, b;'.
-
Matcher<DeclaratorDecl>hasTypeLocMatcher<TypeLoc> Inner
Matches if the type location of the declarator decl's type matches
-the inner matcher.
-
-Given
-  int x;
-declaratorDecl(hasTypeLoc(loc(asString("int"))))
-  matches int x
-
Matcher<Decl>hasDeclContextMatcher<Decl> InnerMatcher
Matches declarations whose declaration context, interpreted as a
-Decl, matches InnerMatcher.
-
-Given
-  namespace N {
-    namespace M {
-      class D {};
-    }
-  }
-
-cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
-declaration of class D.
-
Matcher<DoStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
-a given body.
-
-Given
-  for (;;) {}
-hasBody(compoundStmt())
-  matches 'for (;;) {}'
-with compoundStmt()
-  matching '{}'
-
Matcher<DoStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
-or conditional operator.
-
-Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
-  if (true) {}
-
Matcher<ElaboratedType>hasQualifierMatcher<NestedNameSpecifier> InnerMatcher
Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
-matches InnerMatcher if the qualifier exists.
-
-Given
-  namespace N {
-    namespace M {
-      class D {};
-    }
-  }
-  N::M::D d;
-
-elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
-matches the type of the variable declaration of d.
-
Matcher<ElaboratedType>namesTypeMatcher<QualType> InnerMatcher
Matches ElaboratedTypes whose named type matches InnerMatcher.
-
-Given
-  namespace N {
-    namespace M {
-      class D {};
-    }
-  }
-  N::M::D d;
-
-elaboratedType(namesType(recordType(
-hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
-declaration of d.
-
Matcher<EnumType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<ExplicitCastExpr>hasDestinationTypeMatcher<QualType> InnerMatcher
Matches casts whose destination type matches a given matcher.
-
-(Note: Clang's AST refers to other conversions as "casts" too, and calls
-actual casts "explicit" casts.)
-
Matcher<Expr>hasTypeMatcher<Decl> InnerMatcher
Overloaded to match the declaration of the expression's or value
-declaration's type.
-
-In case of a value declaration (for example a variable declaration),
-this resolves one layer of indirection. For example, in the value
-declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
-X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
-declaration of x.
-
-Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
-            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
- class X {};
- void y(X &x) { x; X z; }
-
-Usable as: Matcher<Expr>, Matcher<ValueDecl>
-
Matcher<Expr>hasTypeMatcher<QualType> InnerMatcher
Matches if the expression's or declaration's type matches a type
-matcher.
-
-Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
-            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
- class X {};
- void y(X &x) { x; X z; }
-
Matcher<Expr>ignoringImpCastsMatcher<Expr> InnerMatcher
Matches expressions that match InnerMatcher after any implicit casts
-are stripped off.
-
-Parentheses and explicit casts are not discarded.
-Given
-  int arr[5];
-  int a = 0;
-  char b = 0;
-  const int c = a;
-  int *d = arr;
-  long e = (long) 0l;
-The matchers
-   varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
-   varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
-would match the declarations for a, b, c, and d, but not e.
-While
-   varDecl(hasInitializer(integerLiteral()))
-   varDecl(hasInitializer(declRefExpr()))
-only match the declarations for b, c, and d.
-
Matcher<Expr>ignoringParenCastsMatcher<Expr> InnerMatcher
Matches expressions that match InnerMatcher after parentheses and
-casts are stripped off.
-
-Implicit and non-C Style casts are also discarded.
-Given
-  int a = 0;
-  char b = (0);
-  void* c = reinterpret_cast<char*>(0);
-  char d = char(0);
-The matcher
-   varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
-would match the declarations for a, b, c, and d.
-while
-   varDecl(hasInitializer(integerLiteral()))
-only match the declaration for a.
-
Matcher<Expr>ignoringParenImpCastsMatcher<Expr> InnerMatcher
Matches expressions that match InnerMatcher after implicit casts and
-parentheses are stripped off.
-
-Explicit casts are not discarded.
-Given
-  int arr[5];
-  int a = 0;
-  char b = (0);
-  const int c = a;
-  int *d = (arr);
-  long e = ((long) 0l);
-The matchers
-   varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
-   varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
-would match the declarations for a, b, c, and d, but not e.
-while
-   varDecl(hasInitializer(integerLiteral()))
-   varDecl(hasInitializer(declRefExpr()))
-would only match the declaration for a.
-
Matcher<ForStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
-a given body.
-
-Given
-  for (;;) {}
-hasBody(compoundStmt())
-  matches 'for (;;) {}'
-with compoundStmt()
-  matching '{}'
-
Matcher<ForStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
-or conditional operator.
-
-Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
-  if (true) {}
-
Matcher<ForStmt>hasIncrementMatcher<Stmt> InnerMatcher
Matches the increment statement of a for loop.
-
-Example:
-    forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
-matches '++x' in
-    for (x; x < N; ++x) { }
-
Matcher<ForStmt>hasLoopInitMatcher<Stmt> InnerMatcher
Matches the initialization statement of a for loop.
-
-Example:
-    forStmt(hasLoopInit(declStmt()))
-matches 'int x = 0' in
-    for (int x = 0; x < N; ++x) { }
-
Matcher<FunctionDecl>hasAnyParameterMatcher<ParmVarDecl> InnerMatcher
Matches any parameter of a function declaration.
-
-Does not match the 'this' parameter of a method.
-
-Given
-  class X { void f(int x, int y, int z) {} };
-cxxMethodDecl(hasAnyParameter(hasName("y")))
-  matches f(int x, int y, int z) {}
-with hasAnyParameter(...)
-  matching int y
-
Matcher<FunctionDecl>hasParameterunsigned N, Matcher<ParmVarDecl> InnerMatcher
Matches the n'th parameter of a function declaration.
-
-Given
-  class X { void f(int x) {} };
-cxxMethodDecl(hasParameter(0, hasType(varDecl())))
-  matches f(int x) {}
-with hasParameter(...)
-  matching int x
-
Matcher<FunctionDecl>returnsMatcher<QualType> InnerMatcher
Matches the return type of a function declaration.
-
-Given:
-  class X { int f() { return 1; } };
-cxxMethodDecl(returns(asString("int")))
-  matches int f() { return 1; }
-
Matcher<IfStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
-or conditional operator.
-
-Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
-  if (true) {}
-
Matcher<IfStmt>hasConditionVariableStatementMatcher<DeclStmt> InnerMatcher
Matches the condition variable statement in an if statement.
-
-Given
-  if (A* a = GetAPointer()) {}
-hasConditionVariableStatement(...)
-  matches 'A* a = GetAPointer()'.
-
Matcher<IfStmt>hasElseMatcher<Stmt> InnerMatcher
Matches the else-statement of an if statement.
-
-Examples matches the if statement
-  (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true)))))
-  if (false) false; else true;
-
Matcher<IfStmt>hasThenMatcher<Stmt> InnerMatcher
Matches the then-statement of an if statement.
-
-Examples matches the if statement
-  (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true)))))
-  if (false) true; else false;
-
Matcher<ImplicitCastExpr>hasImplicitDestinationTypeMatcher<QualType> InnerMatcher
Matches implicit casts whose destination type matches a given
-matcher.
-
-FIXME: Unit test this matcher
-
Matcher<InjectedClassNameType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<LabelStmt>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<MemberExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<MemberExpr>hasObjectExpressionMatcher<Expr> InnerMatcher
Matches a member expression where the object expression is
-matched by a given matcher.
-
-Given
-  struct X { int m; };
-  void f(X x) { x.m; m; }
-memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))))
-  matches "x.m" and "m"
-with hasObjectExpression(...)
-  matching "x" and the implicit object expression of "m" which has type X*.
-
Matcher<MemberExpr>memberMatcher<ValueDecl> InnerMatcher
Matches a member expression where the member is matched by a
-given matcher.
-
-Given
-  struct { int first, second; } first, second;
-  int i(second.first);
-  int j(first.second);
-memberExpr(member(hasName("first")))
-  matches second.first
-  but not first.second (because the member name there is "second").
-
Matcher<MemberPointerTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<MemberPointerType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<NestedNameSpecifierLoc>hasPrefixMatcher<NestedNameSpecifierLoc> InnerMatcher
Matches on the prefix of a NestedNameSpecifierLoc.
-
-Given
-  struct A { struct B { struct C {}; }; };
-  A::B::C c;
-nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
-  matches "A::"
-
Matcher<NestedNameSpecifierLoc>specifiesTypeLocMatcher<TypeLoc> InnerMatcher
Matches nested name specifier locs that specify a type matching the
-given TypeLoc.
-
-Given
-  struct A { struct B { struct C {}; }; };
-  A::B::C c;
-nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
-  hasDeclaration(cxxRecordDecl(hasName("A")))))))
-  matches "A::"
-
Matcher<NestedNameSpecifier>hasPrefixMatcher<NestedNameSpecifier> InnerMatcher
Matches on the prefix of a NestedNameSpecifier.
-
-Given
-  struct A { struct B { struct C {}; }; };
-  A::B::C c;
-nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
-  matches "A::"
-
Matcher<NestedNameSpecifier>specifiesNamespaceMatcher<NamespaceDecl> InnerMatcher
Matches nested name specifiers that specify a namespace matching the
-given namespace matcher.
-
-Given
-  namespace ns { struct A {}; }
-  ns::A a;
-nestedNameSpecifier(specifiesNamespace(hasName("ns")))
-  matches "ns::"
-
Matcher<NestedNameSpecifier>specifiesTypeMatcher<QualType> InnerMatcher
Matches nested name specifiers that specify a type matching the
-given QualType matcher without qualifiers.
-
-Given
-  struct A { struct B { struct C {}; }; };
-  A::B::C c;
-nestedNameSpecifier(specifiesType(
-  hasDeclaration(cxxRecordDecl(hasName("A")))
-))
-  matches "A::"
-
Matcher<ObjCMessageExpr>hasArgumentunsigned N, Matcher<Expr> InnerMatcher
Matches the n'th argument of a call expression or a constructor
-call expression.
-
-Example matches y in x(y)
-    (matcher = callExpr(hasArgument(0, declRefExpr())))
-  void x(int) { int y; x(y); }
-
Matcher<ObjCMessageExpr>hasReceiverTypeMatcher<QualType> InnerMatcher
Matches on the receiver of an ObjectiveC Message expression.
-
-Example
-matcher = objCMessageExpr(hasRecieverType(asString("UIWebView *")));
-matches the [webView ...] message invocation.
-  NSString *webViewJavaScript = ...
-  UIWebView *webView = ...
-  [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
-
Matcher<ParenType>innerTypeMatcher<Type>
Matches ParenType nodes where the inner type is a specific type.
-
-Given
-  int (*ptr_to_array)[4];
-  int (*ptr_to_func)(int);
-
-varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
-ptr_to_func but not ptr_to_array.
-
-Usable as: Matcher<ParenType>
-
Matcher<PointerTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<PointerType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<QualType>hasCanonicalTypeMatcher<QualType> InnerMatcher
Matches QualTypes whose canonical type matches InnerMatcher.
-
-Given:
-  typedef int &int_ref;
-  int a;
-  int_ref b = a;
-
-varDecl(hasType(qualType(referenceType()))))) will not match the
-declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
-
Matcher<QualType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<QualType>pointsToMatcher<Decl> InnerMatcher
Overloaded to match the pointee type's declaration.
-
Matcher<QualType>pointsToMatcher<QualType> InnerMatcher
Matches if the matched type is a pointer type and the pointee type
-matches the specified matcher.
-
-Example matches y->x()
-  (matcher = cxxMemberCallExpr(on(hasType(pointsTo
-     cxxRecordDecl(hasName("Y")))))))
-  class Y { public: void x(); };
-  void z() { Y *y; y->x(); }
-
Matcher<QualType>referencesMatcher<Decl> InnerMatcher
Overloaded to match the referenced type's declaration.
-
Matcher<QualType>referencesMatcher<QualType> InnerMatcher
Matches if the matched type is a reference type and the referenced
-type matches the specified matcher.
-
-Example matches X &x and const X &y
-    (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X"))))))
-  class X {
-    void a(X b) {
-      X &x = b;
-      const X &y = b;
-    }
-  };
-
Matcher<RecordType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<ReferenceTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<ReferenceType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
-pointee matches a given matcher.
-
-Given
-  int *a;
-  int const *b;
-  float const *f;
-pointerType(pointee(isConstQualified(), isInteger()))
-  matches "int const *b"
-
-Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
-  Matcher<PointerType>, Matcher<ReferenceType>
-
Matcher<Stmt>alignOfExprMatcher<UnaryExprOrTypeTraitExpr>  InnerMatcher
Same as unaryExprOrTypeTraitExpr, but only matching
-alignof.
-
Matcher<Stmt>sizeOfExprMatcher<UnaryExprOrTypeTraitExpr>  InnerMatcher
Same as unaryExprOrTypeTraitExpr, but only matching
-sizeof.
-
Matcher<SwitchStmt>forEachSwitchCaseMatcher<SwitchCase> InnerMatcher
Matches each case or default statement belonging to the given switch
-statement. This matcher may produce multiple matches.
-
-Given
-  switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
-switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
-  matches four times, with "c" binding each of "case 1:", "case 2:",
-"case 3:" and "case 4:", and "s" respectively binding "switch (1)",
-"switch (1)", "switch (2)" and "switch (2)".
-
Matcher<TagType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<TemplateArgument>isExprMatcher<Expr> InnerMatcher
Matches a sugar TemplateArgument that refers to a certain expression.
-
-Given
-  template<typename T> struct A {};
-  struct B { B* next; };
-  A<&B::next> a;
-templateSpecializationType(hasAnyTemplateArgument(
-  isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
-  matches the specialization A<&B::next> with fieldDecl(...) matching
-    B::next
-
Matcher<TemplateArgument>refersToDeclarationMatcher<Decl> InnerMatcher
Matches a canonical TemplateArgument that refers to a certain
-declaration.
-
-Given
-  template<typename T> struct A {};
-  struct B { B* next; };
-  A<&B::next> a;
-classTemplateSpecializationDecl(hasAnyTemplateArgument(
-    refersToDeclaration(fieldDecl(hasName("next"))))
-  matches the specialization A<&B::next> with fieldDecl(...) matching
-    B::next
-
Matcher<TemplateArgument>refersToIntegralTypeMatcher<QualType> InnerMatcher
Matches a TemplateArgument that referes to an integral type.
-
-Given
-  template<int T> struct A {};
-  C<42> c;
-classTemplateSpecializationDecl(
-  hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
-  matches the implicit instantiation of C in C<42>.
-
Matcher<TemplateArgument>refersToTypeMatcher<QualType> InnerMatcher
Matches a TemplateArgument that refers to a certain type.
-
-Given
-  struct X {};
-  template<typename T> struct A {};
-  A<X> a;
-classTemplateSpecializationDecl(hasAnyTemplateArgument(
-    refersToType(class(hasName("X")))))
-  matches the specialization A<X>
-
Matcher<TemplateSpecializationType>hasAnyTemplateArgumentMatcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations that have at least one
-TemplateArgument matching the given InnerMatcher.
-
-Given
-  template<typename T> class A {};
-  template<> class A<double> {};
-  A<int> a;
-classTemplateSpecializationDecl(hasAnyTemplateArgument(
-    refersToType(asString("int"))))
-  matches the specialization A<int>
-
Matcher<TemplateSpecializationType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<TemplateSpecializationType>hasTemplateArgumentunsigned N, Matcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations where the n'th TemplateArgument
-matches the given InnerMatcher.
-
-Given
-  template<typename T, typename U> class A {};
-  A<bool, int> b;
-  A<int, bool> c;
-classTemplateSpecializationDecl(hasTemplateArgument(
-    1, refersToType(asString("int"))))
-  matches the specialization A<bool, int>
-
Matcher<TemplateTypeParmType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<T>findAllMatcher<T>  Matcher
Matches if the node or any descendant matches.
-
-Generates results for each match.
-
-For example, in:
-  class A { class B {}; class C {}; };
-The matcher:
-  cxxRecordDecl(hasName("::A"),
-                findAll(cxxRecordDecl(isDefinition()).bind("m")))
-will generate results for A, B and C.
-
-Usable as: Any Matcher
-
Matcher<TypedefType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<UnaryExprOrTypeTraitExpr>hasArgumentOfTypeMatcher<QualType> InnerMatcher
Matches unary expressions that have a specific type of argument.
-
-Given
-  int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
-unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
-  matches sizeof(a) and alignof(c)
-
Matcher<UnaryOperator>hasUnaryOperandMatcher<Expr> InnerMatcher
Matches if the operand of a unary operator matches.
-
-Example matches true (matcher = hasUnaryOperand(
-                                  cxxBoolLiteral(equals(true))))
-  !true
-
Matcher<UnresolvedUsingType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
-matches the given matcher.
-
-The associated declaration is:
-- for type nodes, the declaration of the underlying type
-- for CallExpr, the declaration of the callee
-- for MemberExpr, the declaration of the referenced member
-- for CXXConstructExpr, the declaration of the constructor
-
-Also usable as Matcher<T> for any T supporting the getDecl() member
-function. e.g. various subtypes of clang::Type and various expressions.
-
-Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
-  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
-  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
-  Matcher<RecordType>, Matcher<TagType>,
-  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
-  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
-
Matcher<UsingDecl>hasAnyUsingShadowDeclMatcher<UsingShadowDecl> InnerMatcher
Matches any using shadow declaration.
-
-Given
-  namespace X { void b(); }
-  using X::b;
-usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
-  matches using X::b 
Matcher<UsingShadowDecl>hasTargetDeclMatcher<NamedDecl> InnerMatcher
Matches a using shadow declaration where the target declaration is
-matched by the given matcher.
-
-Given
-  namespace X { int a; void b(); }
-  using X::a;
-  using X::b;
-usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
-  matches using X::b but not using X::a 
Matcher<ValueDecl>hasTypeMatcher<Decl> InnerMatcher
Overloaded to match the declaration of the expression's or value
-declaration's type.
-
-In case of a value declaration (for example a variable declaration),
-this resolves one layer of indirection. For example, in the value
-declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
-X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
-declaration of x.
-
-Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
-            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
- class X {};
- void y(X &x) { x; X z; }
-
-Usable as: Matcher<Expr>, Matcher<ValueDecl>
-
Matcher<ValueDecl>hasTypeMatcher<QualType> InnerMatcher
Matches if the expression's or declaration's type matches a type
-matcher.
-
-Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
-            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
- class X {};
- void y(X &x) { x; X z; }
-
Matcher<VarDecl>hasInitializerMatcher<Expr> InnerMatcher
Matches a variable declaration that has an initializer expression
-that matches the given matcher.
-
-Example matches x (matcher = varDecl(hasInitializer(callExpr())))
-  bool y() { return true; }
-  bool x = y();
-
Matcher<VariableArrayType>hasSizeExprMatcher<Expr> InnerMatcher
Matches VariableArrayType nodes that have a specific size
-expression.
-
-Given
-  void f(int b) {
-    int a[b];
-  }
-variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
-  varDecl(hasName("b")))))))
-  matches "int a[b]"
-
Matcher<WhileStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
-a given body.
-
-Given
-  for (;;) {}
-hasBody(compoundStmt())
-  matches 'for (;;) {}'
-with compoundStmt()
-  matching '{}'
-
Matcher<CXXCtorInitializer>cxxCtorInitializerMatcher<CXXCtorInitializer>...
Matches constructor initializers.
+
+Examples matches i(42).
+  class C {
+    C() : i(42) {}
+    int i;
+  };
+
Matcher<Decl>accessSpecDeclMatcher<AccessSpecDecl>...
Matches C++ access specifier declarations.
+
+Given
+  class C {
+  public:
+    int a;
+  };
+accessSpecDecl()
+  matches 'public:'
+
Matcher<Decl>classTemplateDeclMatcher<ClassTemplateDecl>...
Matches C++ class template declarations.
+
+Example matches Z
+  template<class T> class Z {};
+
Matcher<Decl>classTemplateSpecializationDeclMatcher<ClassTemplateSpecializationDecl>...
Matches C++ class template specializations.
+
+Given
+  template<typename T> class A {};
+  template<> class A<double> {};
+  A<int> a;
+classTemplateSpecializationDecl()
+  matches the specializations A<int> and A<double>
+
Matcher<Decl>cxxConstructorDeclMatcher<CXXConstructorDecl>...
Matches C++ constructor declarations.
+
+Example matches Foo::Foo() and Foo::Foo(int)
+  class Foo {
+   public:
+    Foo();
+    Foo(int);
+    int DoSomething();
+  };
+
Matcher<Decl>cxxConversionDeclMatcher<CXXConversionDecl>...
Matches conversion operator declarations.
+
+Example matches the operator.
+  class X { operator int() const; };
+
Matcher<Decl>cxxDestructorDeclMatcher<CXXDestructorDecl>...
Matches explicit C++ destructor declarations.
+
+Example matches Foo::~Foo()
+  class Foo {
+   public:
+    virtual ~Foo();
+  };
+
Matcher<Decl>cxxMethodDeclMatcher<CXXMethodDecl>...
Matches method declarations.
+
+Example matches y
+  class X { void y(); };
+
Matcher<Decl>cxxRecordDeclMatcher<CXXRecordDecl>...
Matches C++ class declarations.
+
+Example matches X, Z
+  class X;
+  template<class T> class Z {};
+
Matcher<Decl>declMatcher<Decl>...
Matches declarations.
+
+Examples matches X, C, and the friend declaration inside C;
+  void X();
+  class C {
+    friend X;
+  };
+
Matcher<Decl>declaratorDeclMatcher<DeclaratorDecl>...
Matches declarator declarations (field, variable, function
+and non-type template parameter declarations).
+
+Given
+  class X { int y; };
+declaratorDecl()
+  matches int y.
+
Matcher<Decl>enumConstantDeclMatcher<EnumConstantDecl>...
Matches enum constants.
+
+Example matches A, B, C
+  enum X {
+    A, B, C
+  };
+
Matcher<Decl>enumDeclMatcher<EnumDecl>...
Matches enum declarations.
+
+Example matches X
+  enum X {
+    A, B, C
+  };
+
Matcher<Decl>fieldDeclMatcher<FieldDecl>...
Matches field declarations.
+
+Given
+  class X { int m; };
+fieldDecl()
+  matches 'm'.
+
Matcher<Decl>friendDeclMatcher<FriendDecl>...
Matches friend declarations.
+
+Given
+  class X { friend void foo(); };
+friendDecl()
+  matches 'friend void foo()'.
+
Matcher<Decl>functionDeclMatcher<FunctionDecl>...
Matches function declarations.
+
+Example matches f
+  void f();
+
Matcher<Decl>functionTemplateDeclMatcher<FunctionTemplateDecl>...
Matches C++ function template declarations.
+
+Example matches f
+  template<class T> void f(T t) {}
+
Matcher<Decl>linkageSpecDeclMatcher<LinkageSpecDecl>...
Matches a declaration of a linkage specification.
+
+Given
+  extern "C" {}
+linkageSpecDecl()
+  matches "extern "C" {}"
+
Matcher<Decl>namedDeclMatcher<NamedDecl>...
Matches a declaration of anything that could have a name.
+
+Example matches X, S, the anonymous union type, i, and U;
+  typedef int X;
+  struct S {
+    union {
+      int i;
+    } U;
+  };
+
Matcher<Decl>namespaceAliasDeclMatcher<NamespaceAliasDecl>...
Matches a declaration of a namespace alias.
+
+Given
+  namespace test {}
+  namespace alias = ::test;
+namespaceAliasDecl()
+  matches "namespace alias" but not "namespace test"
+
Matcher<Decl>namespaceDeclMatcher<NamespaceDecl>...
Matches a declaration of a namespace.
+
+Given
+  namespace {}
+  namespace test {}
+namespaceDecl()
+  matches "namespace {}" and "namespace test {}"
+
Matcher<Decl>nonTypeTemplateParmDeclMatcher<NonTypeTemplateParmDecl>...
Matches non-type template parameter declarations.
+
+Given
+  template <typename T, int N> struct C {};
+nonTypeTemplateParmDecl()
+  matches 'N', but not 'T'.
+
Matcher<Decl>objcInterfaceDeclMatcher<ObjCInterfaceDecl>...
Matches Objective-C interface declarations.
+
+Example matches Foo
+  @interface Foo
+  @end
+
Matcher<Decl>parmVarDeclMatcher<ParmVarDecl>...
Matches parameter variable declarations.
+
+Given
+  void f(int x);
+parmVarDecl()
+  matches int x.
+
Matcher<Decl>recordDeclMatcher<RecordDecl>...
Matches class, struct, and union declarations.
+
+Example matches X, Z, U, and S
+  class X;
+  template<class T> class Z {};
+  struct S {};
+  union U {};
+
Matcher<Decl>staticAssertDeclMatcher<StaticAssertDecl>...
Matches a C++ static_assert declaration.
+
+Example:
+  staticAssertExpr()
+matches
+  static_assert(sizeof(S) == sizeof(int))
+in
+  struct S {
+    int x;
+  };
+  static_assert(sizeof(S) == sizeof(int));
+
Matcher<Decl>templateTypeParmDeclMatcher<TemplateTypeParmDecl>...
Matches template type parameter declarations.
+
+Given
+  template <typename T, int N> struct C {};
+templateTypeParmDecl()
+  matches 'T', but not 'N'.
+
Matcher<Decl>translationUnitDeclMatcher<TranslationUnitDecl>...
Matches the top declaration context.
+
+Given
+  int X;
+  namespace NS {
+  int Y;
+  }  namespace NS
+decl(hasDeclContext(translationUnitDecl()))
+  matches "int X", but not "int Y".
+
Matcher<Decl>typedefDeclMatcher<TypedefDecl>...
Matches typedef declarations.
+
+Given
+  typedef int X;
+typedefDecl()
+  matches "typedef int X"
+
Matcher<Decl>unresolvedUsingTypenameDeclMatcher<UnresolvedUsingTypenameDecl>...
Matches unresolved using value declarations that involve the
+typename.
+
+Given
+  template <typename T>
+  struct Base { typedef T Foo; };
+
+  template<typename T>
+  struct S : private Base<T> {
+    using typename Base<T>::Foo;
+  };
+unresolvedUsingTypenameDecl()
+  matches using Base<T>::Foo 
Matcher<Decl>unresolvedUsingValueDeclMatcher<UnresolvedUsingValueDecl>...
Matches unresolved using value declarations.
+
+Given
+  template<typename X>
+  class C : private X {
+    using X::x;
+  };
+unresolvedUsingValueDecl()
+  matches using X::x 
Matcher<Decl>usingDeclMatcher<UsingDecl>...
Matches using declarations.
+
+Given
+  namespace X { int x; }
+  using X::x;
+usingDecl()
+  matches using X::x 
Matcher<Decl>usingDirectiveDeclMatcher<UsingDirectiveDecl>...
Matches using namespace declarations.
+
+Given
+  namespace X { int x; }
+  using namespace X;
+usingDirectiveDecl()
+  matches using namespace X 
Matcher<Decl>valueDeclMatcher<ValueDecl>...
Matches any value declaration.
+
+Example matches A, B, C and F
+  enum X { A, B, C };
+  void F();
+
Matcher<Decl>varDeclMatcher<VarDecl>...
Matches variable declarations.
+
+Note: this does not match declarations of member variables, which are
+"field" declarations in Clang parlance.
+
+Example matches a
+  int a;
+
Matcher<NestedNameSpecifierLoc>nestedNameSpecifierLocMatcher<NestedNameSpecifierLoc>...
Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
+
Matcher<NestedNameSpecifier>nestedNameSpecifierMatcher<NestedNameSpecifier>...
Matches nested name specifiers.
+
+Given
+  namespace ns {
+    struct A { static void f(); };
+    void A::f() {}
+    void g() { A::f(); }
+  }
+  ns::A a;
+nestedNameSpecifier()
+  matches "ns::" and both "A::"
+
Matcher<QualType>qualTypeMatcher<QualType>...
Matches QualTypes in the clang AST.
+
Matcher<Stmt>arraySubscriptExprMatcher<ArraySubscriptExpr>...
Matches array subscript expressions.
+
+Given
+  int i = a[1];
+arraySubscriptExpr()
+  matches "a[1]"
+
Matcher<Stmt>asmStmtMatcher<AsmStmt>...
Matches asm statements.
+
+ int i = 100;
+  __asm("mov al, 2");
+asmStmt()
+  matches '__asm("mov al, 2")'
+
Matcher<Stmt>binaryOperatorMatcher<BinaryOperator>...
Matches binary operator expressions.
+
+Example matches a || b
+  !(a || b)
+
Matcher<Stmt>breakStmtMatcher<BreakStmt>...
Matches break statements.
+
+Given
+  while (true) { break; }
+breakStmt()
+  matches 'break'
+
Matcher<Stmt>cStyleCastExprMatcher<CStyleCastExpr>...
Matches a C-style cast expression.
+
+Example: Matches (int*) 2.2f in
+  int i = (int) 2.2f;
+
Matcher<Stmt>callExprMatcher<CallExpr>...
Matches call expressions.
+
+Example matches x.y() and y()
+  X x;
+  x.y();
+  y();
+
Matcher<Stmt>caseStmtMatcher<CaseStmt>...
Matches case statements inside switch statements.
+
+Given
+  switch(a) { case 42: break; default: break; }
+caseStmt()
+  matches 'case 42: break;'.
+
Matcher<Stmt>castExprMatcher<CastExpr>...
Matches any cast nodes of Clang's AST.
+
+Example: castExpr() matches each of the following:
+  (int) 3;
+  const_cast<Expr *>(SubExpr);
+  char c = 0;
+but does not match
+  int i = (0);
+  int k = 0;
+
Matcher<Stmt>characterLiteralMatcher<CharacterLiteral>...
Matches character literals (also matches wchar_t).
+
+Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
+though.
+
+Example matches 'a', L'a'
+  char ch = 'a'; wchar_t chw = L'a';
+
Matcher<Stmt>compoundLiteralExprMatcher<CompoundLiteralExpr>...
Matches compound (i.e. non-scalar) literals
+
+Example match: {1}, (1, 2)
+  int array[4] = {1}; vector int myvec = (vector int)(1, 2);
+
Matcher<Stmt>compoundStmtMatcher<CompoundStmt>...
Matches compound statements.
+
+Example matches '{}' and '{{}}'in 'for (;;) {{}}'
+  for (;;) {{}}
+
Matcher<Stmt>conditionalOperatorMatcher<ConditionalOperator>...
Matches conditional operator expressions.
+
+Example matches a ? b : c
+  (a ? b : c) + 42
+
Matcher<Stmt>continueStmtMatcher<ContinueStmt>...
Matches continue statements.
+
+Given
+  while (true) { continue; }
+continueStmt()
+  matches 'continue'
+
Matcher<Stmt>cudaKernelCallExprMatcher<CUDAKernelCallExpr>...
Matches CUDA kernel call expression.
+
+Example matches,
+  kernel<<<i,j>>>();
+
Matcher<Stmt>cxxBindTemporaryExprMatcher<CXXBindTemporaryExpr>...
Matches nodes where temporaries are created.
+
+Example matches FunctionTakesString(GetStringByValue())
+    (matcher = cxxBindTemporaryExpr())
+  FunctionTakesString(GetStringByValue());
+  FunctionTakesStringByPointer(GetStringPointer());
+
Matcher<Stmt>cxxBoolLiteralMatcher<CXXBoolLiteralExpr>...
Matches bool literals.
+
+Example matches true
+  true
+
Matcher<Stmt>cxxCatchStmtMatcher<CXXCatchStmt>...
Matches catch statements.
+
+  try {} catch(int i) {}
+cxxCatchStmt()
+  matches 'catch(int i)'
+
Matcher<Stmt>cxxConstCastExprMatcher<CXXConstCastExpr>...
Matches a const_cast expression.
+
+Example: Matches const_cast<int*>(&r) in
+  int n = 42;
+  const int &r(n);
+  int* p = const_cast<int*>(&r);
+
Matcher<Stmt>cxxConstructExprMatcher<CXXConstructExpr>...
Matches constructor call expressions (including implicit ones).
+
+Example matches string(ptr, n) and ptr within arguments of f
+    (matcher = cxxConstructExpr())
+  void f(const string &a, const string &b);
+  char *ptr;
+  int n;
+  f(string(ptr, n), ptr);
+
Matcher<Stmt>cxxDefaultArgExprMatcher<CXXDefaultArgExpr>...
Matches the value of a default argument at the call site.
+
+Example matches the CXXDefaultArgExpr placeholder inserted for the
+    default value of the second parameter in the call expression f(42)
+    (matcher = cxxDefaultArgExpr())
+  void f(int x, int y = 0);
+  f(42);
+
Matcher<Stmt>cxxDeleteExprMatcher<CXXDeleteExpr>...
Matches delete expressions.
+
+Given
+  delete X;
+cxxDeleteExpr()
+  matches 'delete X'.
+
Matcher<Stmt>cxxDynamicCastExprMatcher<CXXDynamicCastExpr>...
Matches a dynamic_cast expression.
+
+Example:
+  cxxDynamicCastExpr()
+matches
+  dynamic_cast<D*>(&b);
+in
+  struct B { virtual ~B() {} }; struct D : B {};
+  B b;
+  D* p = dynamic_cast<D*>(&b);
+
Matcher<Stmt>cxxForRangeStmtMatcher<CXXForRangeStmt>...
Matches range-based for statements.
+
+cxxForRangeStmt() matches 'for (auto a : i)'
+  int i[] =  {1, 2, 3}; for (auto a : i);
+  for(int j = 0; j < 5; ++j);
+
Matcher<Stmt>cxxFunctionalCastExprMatcher<CXXFunctionalCastExpr>...
Matches functional cast expressions
+
+Example: Matches Foo(bar);
+  Foo f = bar;
+  Foo g = (Foo) bar;
+  Foo h = Foo(bar);
+
Matcher<Stmt>cxxMemberCallExprMatcher<CXXMemberCallExpr>...
Matches member call expressions.
+
+Example matches x.y()
+  X x;
+  x.y();
+
Matcher<Stmt>cxxNewExprMatcher<CXXNewExpr>...
Matches new expressions.
+
+Given
+  new X;
+cxxNewExpr()
+  matches 'new X'.
+
Matcher<Stmt>cxxNullPtrLiteralExprMatcher<CXXNullPtrLiteralExpr>...
Matches nullptr literal.
+
Matcher<Stmt>cxxOperatorCallExprMatcher<CXXOperatorCallExpr>...
Matches overloaded operator calls.
+
+Note that if an operator isn't overloaded, it won't match. Instead, use
+binaryOperator matcher.
+Currently it does not match operators such as new delete.
+FIXME: figure out why these do not match?
+
+Example matches both operator<<((o << b), c) and operator<<(o, b)
+    (matcher = cxxOperatorCallExpr())
+  ostream &operator<< (ostream &out, int i) { };
+  ostream &o; int b = 1, c = 1;
+  o << b << c;
+
Matcher<Stmt>cxxReinterpretCastExprMatcher<CXXReinterpretCastExpr>...
Matches a reinterpret_cast expression.
+
+Either the source expression or the destination type can be matched
+using has(), but hasDestinationType() is more specific and can be
+more readable.
+
+Example matches reinterpret_cast<char*>(&p) in
+  void* p = reinterpret_cast<char*>(&p);
+
Matcher<Stmt>cxxStaticCastExprMatcher<CXXStaticCastExpr>...
Matches a C++ static_cast expression.
+
+hasDestinationType
+reinterpretCast
+
+Example:
+  cxxStaticCastExpr()
+matches
+  static_cast<long>(8)
+in
+  long eight(static_cast<long>(8));
+
Matcher<Stmt>cxxTemporaryObjectExprMatcher<CXXTemporaryObjectExpr>...
Matches functional cast expressions having N != 1 arguments
+
+Example: Matches Foo(bar, bar)
+  Foo h = Foo(bar, bar);
+
Matcher<Stmt>cxxThisExprMatcher<CXXThisExpr>...
Matches implicit and explicit this expressions.
+
+Example matches the implicit this expression in "return i".
+    (matcher = cxxThisExpr())
+struct foo {
+  int i;
+  int f() { return i; }
+};
+
Matcher<Stmt>cxxThrowExprMatcher<CXXThrowExpr>...
Matches throw expressions.
+
+  try { throw 5; } catch(int i) {}
+cxxThrowExpr()
+  matches 'throw 5'
+
Matcher<Stmt>cxxTryStmtMatcher<CXXTryStmt>...
Matches try statements.
+
+  try {} catch(int i) {}
+cxxTryStmt()
+  matches 'try {}'
+
Matcher<Stmt>cxxUnresolvedConstructExprMatcher<CXXUnresolvedConstructExpr>...
Matches unresolved constructor call expressions.
+
+Example matches T(t) in return statement of f
+    (matcher = cxxUnresolvedConstructExpr())
+  template <typename T>
+  void f(const T& t) { return T(t); }
+
Matcher<Stmt>declRefExprMatcher<DeclRefExpr>...
Matches expressions that refer to declarations.
+
+Example matches x in if (x)
+  bool x;
+  if (x) {}
+
Matcher<Stmt>declStmtMatcher<DeclStmt>...
Matches declaration statements.
+
+Given
+  int a;
+declStmt()
+  matches 'int a'.
+
Matcher<Stmt>defaultStmtMatcher<DefaultStmt>...
Matches default statements inside switch statements.
+
+Given
+  switch(a) { case 42: break; default: break; }
+defaultStmt()
+  matches 'default: break;'.
+
Matcher<Stmt>doStmtMatcher<DoStmt>...
Matches do statements.
+
+Given
+  do {} while (true);
+doStmt()
+  matches 'do {} while(true)'
+
Matcher<Stmt>explicitCastExprMatcher<ExplicitCastExpr>...
Matches explicit cast expressions.
+
+Matches any cast expression written in user code, whether it be a
+C-style cast, a functional-style cast, or a keyword cast.
+
+Does not match implicit conversions.
+
+Note: the name "explicitCast" is chosen to match Clang's terminology, as
+Clang uses the term "cast" to apply to implicit conversions as well as to
+actual cast expressions.
+
+hasDestinationType.
+
+Example: matches all five of the casts in
+  int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42)))))
+but does not match the implicit conversion in
+  long ell = 42;
+
Matcher<Stmt>exprMatcher<Expr>...
Matches expressions.
+
+Example matches x()
+  void f() { x(); }
+
Matcher<Stmt>exprWithCleanupsMatcher<ExprWithCleanups>...
Matches expressions that introduce cleanups to be run at the end
+of the sub-expression's evaluation.
+
+Example matches std::string()
+  const std::string str = std::string();
+
Matcher<Stmt>floatLiteralMatcher<FloatingLiteral>...
Matches float literals of all sizes encodings, e.g.
+1.0, 1.0f, 1.0L and 1e10.
+
+Does not match implicit conversions such as
+  float a = 10;
+
Matcher<Stmt>forStmtMatcher<ForStmt>...
Matches for statements.
+
+Example matches 'for (;;) {}'
+  for (;;) {}
+  int i[] =  {1, 2, 3}; for (auto a : i);
+
Matcher<Stmt>gnuNullExprMatcher<GNUNullExpr>...
Matches GNU __null expression.
+
Matcher<Stmt>gotoStmtMatcher<GotoStmt>...
Matches goto statements.
+
+Given
+  goto FOO;
+  FOO: bar();
+gotoStmt()
+  matches 'goto FOO'
+
Matcher<Stmt>ifStmtMatcher<IfStmt>...
Matches if statements.
+
+Example matches 'if (x) {}'
+  if (x) {}
+
Matcher<Stmt>implicitCastExprMatcher<ImplicitCastExpr>...
Matches the implicit cast nodes of Clang's AST.
+
+This matches many different places, including function call return value
+eliding, as well as any type conversions.
+
Matcher<Stmt>initListExprMatcher<InitListExpr>...
Matches init list expressions.
+
+Given
+  int a[] = { 1, 2 };
+  struct B { int x, y; };
+  B b = { 5, 6 };
+initListExpr()
+  matches "{ 1, 2 }" and "{ 5, 6 }"
+
Matcher<Stmt>integerLiteralMatcher<IntegerLiteral>...
Matches integer literals of all sizes encodings, e.g.
+1, 1L, 0x1 and 1U.
+
+Does not match character-encoded integers such as L'a'.
+
Matcher<Stmt>labelStmtMatcher<LabelStmt>...
Matches label statements.
+
+Given
+  goto FOO;
+  FOO: bar();
+labelStmt()
+  matches 'FOO:'
+
Matcher<Stmt>lambdaExprMatcher<LambdaExpr>...
Matches lambda expressions.
+
+Example matches [&](){return 5;}
+  [&](){return 5;}
+
Matcher<Stmt>materializeTemporaryExprMatcher<MaterializeTemporaryExpr>...
Matches nodes where temporaries are materialized.
+
+Example: Given
+  struct T {void func()};
+  T f();
+  void g(T);
+materializeTemporaryExpr() matches 'f()' in these statements
+  T u(f());
+  g(f());
+but does not match
+  f();
+  f().func();
+
Matcher<Stmt>memberExprMatcher<MemberExpr>...
Matches member expressions.
+
+Given
+  class Y {
+    void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
+    int a; static int b;
+  };
+memberExpr()
+  matches this->x, x, y.x, a, this->b
+
Matcher<Stmt>nullStmtMatcher<NullStmt>...
Matches null statements.
+
+  foo();;
+nullStmt()
+  matches the second ';'
+
Matcher<Stmt>objcMessageExprMatcher<ObjCMessageExpr>...
Matches ObjectiveC Message invocation expressions.
+
+The innermost message send invokes the "alloc" class method on the
+NSString class, while the outermost message send invokes the
+"initWithString" instance method on the object returned from
+NSString's "alloc". This matcher should match both message sends.
+  [[NSString alloc] initWithString:@"Hello"]
+
Matcher<Stmt>returnStmtMatcher<ReturnStmt>...
Matches return statements.
+
+Given
+  return 1;
+returnStmt()
+  matches 'return 1'
+
Matcher<Stmt>stmtMatcher<Stmt>...
Matches statements.
+
+Given
+  { ++a; }
+stmt()
+  matches both the compound statement '{ ++a; }' and '++a'.
+
Matcher<Stmt>stringLiteralMatcher<StringLiteral>...
Matches string literals (also matches wide string literals).
+
+Example matches "abcd", L"abcd"
+  char *s = "abcd"; wchar_t *ws = L"abcd"
+
Matcher<Stmt>substNonTypeTemplateParmExprMatcher<SubstNonTypeTemplateParmExpr>...
Matches substitutions of non-type template parameters.
+
+Given
+  template <int N>
+  struct A { static const int n = N; };
+  struct B : public A<42> {};
+substNonTypeTemplateParmExpr()
+  matches "N" in the right-hand side of "static const int n = N;"
+
Matcher<Stmt>switchCaseMatcher<SwitchCase>...
Matches case and default statements inside switch statements.
+
+Given
+  switch(a) { case 42: break; default: break; }
+switchCase()
+  matches 'case 42: break;' and 'default: break;'.
+
Matcher<Stmt>switchStmtMatcher<SwitchStmt>...
Matches switch statements.
+
+Given
+  switch(a) { case 42: break; default: break; }
+switchStmt()
+  matches 'switch(a)'.
+
Matcher<Stmt>unaryExprOrTypeTraitExprMatcher<UnaryExprOrTypeTraitExpr>...
Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
+
+Given
+  Foo x = bar;
+  int y = sizeof(x) + alignof(x);
+unaryExprOrTypeTraitExpr()
+  matches sizeof(x) and alignof(x)
+
Matcher<Stmt>unaryOperatorMatcher<UnaryOperator>...
Matches unary operator expressions.
+
+Example matches !a
+  !a || b
+
Matcher<Stmt>userDefinedLiteralMatcher<UserDefinedLiteral>...
Matches user defined literal operator call.
+
+Example match: "foo"_suffix
+
Matcher<Stmt>whileStmtMatcher<WhileStmt>...
Matches while statements.
+
+Given
+  while (true) {}
+whileStmt()
+  matches 'while (true) {}'.
+
Matcher<TemplateArgument>templateArgumentMatcher<TemplateArgument>...
Matches template arguments.
+
+Given
+  template <typename T> struct C {};
+  C<int> c;
+templateArgument()
+  matches 'int' in C<int>.
+
Matcher<TypeLoc>typeLocMatcher<TypeLoc>...
Matches TypeLocs in the clang AST.
+
Matcher<Type>arrayTypeMatcher<ArrayType>...
Matches all kinds of arrays.
+
+Given
+  int a[] = { 2, 3 };
+  int b[4];
+  void f() { int c[a[0]]; }
+arrayType()
+  matches "int a[]", "int b[4]" and "int c[a[0]]";
+
Matcher<Type>atomicTypeMatcher<AtomicType>...
Matches atomic types.
+
+Given
+  _Atomic(int) i;
+atomicType()
+  matches "_Atomic(int) i"
+
Matcher<Type>autoTypeMatcher<AutoType>...
Matches types nodes representing C++11 auto types.
+
+Given:
+  auto n = 4;
+  int v[] = { 2, 3 }
+  for (auto i : v) { }
+autoType()
+  matches "auto n" and "auto i"
+
Matcher<Type>blockPointerTypeMatcher<BlockPointerType>...
Matches block pointer types, i.e. types syntactically represented as
+"void (^)(int)".
+
+The pointee is always required to be a FunctionType.
+
Matcher<Type>builtinTypeMatcher<BuiltinType>...
Matches builtin Types.
+
+Given
+  struct A {};
+  A a;
+  int b;
+  float c;
+  bool d;
+builtinType()
+  matches "int b", "float c" and "bool d"
+
Matcher<Type>complexTypeMatcher<ComplexType>...
Matches C99 complex types.
+
+Given
+  _Complex float f;
+complexType()
+  matches "_Complex float f"
+
Matcher<Type>constantArrayTypeMatcher<ConstantArrayType>...
Matches C arrays with a specified constant size.
+
+Given
+  void() {
+    int a[2];
+    int b[] = { 2, 3 };
+    int c[b[0]];
+  }
+constantArrayType()
+  matches "int a[2]"
+
Matcher<Type>decayedTypeMatcher<DecayedType>...
Matches decayed type
+Example matches i[] in declaration of f.
+    (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
+Example matches i[1].
+    (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
+  void f(int i[]) {
+    i[1] = 0;
+  }
+
Matcher<Type>dependentSizedArrayTypeMatcher<DependentSizedArrayType>...
Matches C++ arrays whose size is a value-dependent expression.
+
+Given
+  template<typename T, int Size>
+  class array {
+    T data[Size];
+  };
+dependentSizedArrayType
+  matches "T data[Size]"
+
Matcher<Type>elaboratedTypeMatcher<ElaboratedType>...
Matches types specified with an elaborated type keyword or with a
+qualified name.
+
+Given
+  namespace N {
+    namespace M {
+      class D {};
+    }
+  }
+  class C {};
+
+  class C c;
+  N::M::D d;
+
+elaboratedType() matches the type of the variable declarations of both
+c and d.
+
Matcher<Type>functionTypeMatcher<FunctionType>...
Matches FunctionType nodes.
+
+Given
+  int (*f)(int);
+  void g();
+functionType()
+  matches "int (*f)(int)" and the type of "g".
+
Matcher<Type>incompleteArrayTypeMatcher<IncompleteArrayType>...
Matches C arrays with unspecified size.
+
+Given
+  int a[] = { 2, 3 };
+  int b[42];
+  void f(int c[]) { int d[a[0]]; };
+incompleteArrayType()
+  matches "int a[]" and "int c[]"
+
Matcher<Type>injectedClassNameTypeMatcher<InjectedClassNameType>...
Matches injected class name types.
+
+Example matches S s, but not S<T> s.
+    (matcher = parmVarDecl(hasType(injectedClassNameType())))
+  template <typename T> struct S {
+    void f(S s);
+    void g(S<T> s);
+  };
+
Matcher<Type>lValueReferenceTypeMatcher<LValueReferenceType>...
Matches lvalue reference types.
+
+Given:
+  int *a;
+  int &b = *a;
+  int &&c = 1;
+  auto &d = b;
+  auto &&e = c;
+  auto &&f = 2;
+  int g = 5;
+
+lValueReferenceType() matches the types of b, d, and e. e is
+matched since the type is deduced as int& by reference collapsing rules.
+
Matcher<Type>memberPointerTypeMatcher<MemberPointerType>...
Matches member pointer types.
+Given
+  struct A { int i; }
+  A::* ptr = A::i;
+memberPointerType()
+  matches "A::* ptr"
+
Matcher<Type>objcObjectPointerTypeMatcher<ObjCObjectPointerType>...
Matches an Objective-C object pointer type, which is different from
+a pointer type, despite being syntactically similar.
+
+Given
+  int *a;
+
+  @interface Foo
+  @end
+  Foo *f;
+pointerType()
+  matches "Foo *f", but does not match "int *a".
+
Matcher<Type>parenTypeMatcher<ParenType>...
Matches ParenType nodes.
+
+Given
+  int (*ptr_to_array)[4];
+  int *array_of_ptrs[4];
+
+varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
+array_of_ptrs.
+
Matcher<Type>pointerTypeMatcher<PointerType>...
Matches pointer types, but does not match Objective-C object pointer
+types.
+
+Given
+  int *a;
+  int &b = *a;
+  int c = 5;
+
+  @interface Foo
+  @end
+  Foo *f;
+pointerType()
+  matches "int *a", but does not match "Foo *f".
+
Matcher<Type>rValueReferenceTypeMatcher<RValueReferenceType>...
Matches rvalue reference types.
+
+Given:
+  int *a;
+  int &b = *a;
+  int &&c = 1;
+  auto &d = b;
+  auto &&e = c;
+  auto &&f = 2;
+  int g = 5;
+
+rValueReferenceType() matches the types of c and f. e is not
+matched as it is deduced to int& by reference collapsing rules.
+
Matcher<Type>recordTypeMatcher<RecordType>...
Matches record types (e.g. structs, classes).
+
+Given
+  class C {};
+  struct S {};
+
+  C c;
+  S s;
+
+recordType() matches the type of the variable declarations of both c
+and s.
+
Matcher<Type>referenceTypeMatcher<ReferenceType>...
Matches both lvalue and rvalue reference types.
+
+Given
+  int *a;
+  int &b = *a;
+  int &&c = 1;
+  auto &d = b;
+  auto &&e = c;
+  auto &&f = 2;
+  int g = 5;
+
+referenceType() matches the types of b, c, d, e, and f.
+
Matcher<Type>substTemplateTypeParmTypeMatcher<SubstTemplateTypeParmType>...
Matches types that represent the result of substituting a type for a
+template type parameter.
+
+Given
+  template <typename T>
+  void F(T t) {
+    int i = 1 + t;
+  }
+
+substTemplateTypeParmType() matches the type of 't' but not '1'
+
Matcher<Type>templateSpecializationTypeMatcher<TemplateSpecializationType>...
Matches template specialization types.
+
+Given
+  template <typename T>
+  class C { };
+
+  template class C<int>;  A
+  C<char> var;            B
+
+templateSpecializationType() matches the type of the explicit
+instantiation in A and the type of the variable declaration in B.
+
Matcher<Type>templateTypeParmTypeMatcher<TemplateTypeParmType>...
Matches template type parameter types.
+
+Example matches T, but not int.
+    (matcher = templateTypeParmType())
+  template <typename T> void f(int i);
+
Matcher<Type>typeMatcher<Type>...
Matches Types in the clang AST.
+
Matcher<Type>typedefTypeMatcher<TypedefType>...
Matches typedef types.
+
+Given
+  typedef int X;
+typedefType()
+  matches "typedef int X"
+
Matcher<Type>unaryTransformTypeMatcher<UnaryTransformType>...
Matches types nodes representing unary type transformations.
+
+Given:
+  typedef __underlying_type(T) type;
+unaryTransformType()
+  matches "__underlying_type(T)"
+
Matcher<Type>variableArrayTypeMatcher<VariableArrayType>...
Matches C arrays with a specified size that is not an
+integer-constant-expression.
+
+Given
+  void f() {
+    int a[] = { 2, 3 }
+    int b[42];
+    int c[a[0]];
+  }
+variableArrayType()
+  matches "int c[a[0]]"
+

 
+
+
Narrowing Matchers

+
 
-Matcher<WhileStmt>hasConditionMatcher<Expr> InnerMatcher
-
Matches the condition expression of an if statement, for loop,
-or conditional operator.
+
Narrowing matchers match certain attributes on the current node, thus
+narrowing down the set of nodes of the current type to match on.

 
-Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
-  if (true) {}
-

+
There are special logical narrowing matchers (allOf, anyOf, anything and unless)
+which allow users to create more powerful match expressions.

 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Return typeNameParameters
Matcher<*>allOfMatcher<*>, ..., Matcher<*>
Matches if all given matchers match.
+
+Usable as: Any Matcher
+
Matcher<*>anyOfMatcher<*>, ..., Matcher<*>
Matches if any of the given matchers matches.
+
+Usable as: Any Matcher
+
Matcher<*>anything
Matches any node.
+
+Useful when another matcher requires a child matcher, but there's no
+additional constraint. This will often be used with an explicit conversion
+to an internal::Matcher<> type such as TypeMatcher.
+
+Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
+"int* p" and "void f()" in
+  int* p;
+  void f();
+
+Usable as: Any Matcher
+
Matcher<*>unlessMatcher<*>
Matches if the provided matcher does not match.
+
+Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
+  class X {};
+  class Y {};
+
+Usable as: Any Matcher
+
Matcher<BinaryOperator>hasOperatorNamestd::string Name
Matches the operator Name of operator expressions (binary or
+unary).
+
+Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
+  !(a || b)
+
Matcher<CXXBoolLiteral>equalsValueT  Value
Matches literals that are equal to the given value.
+
+Example matches true (matcher = cxxBoolLiteral(equals(true)))
+  true
+
+Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
+           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
+
Matcher<CXXCatchStmt>isCatchAll
Matches a C++ catch statement that has a catch-all handler.
+
+Given
+  try {
+    ...
+  } catch (int) {
+    ...
+  } catch (...) {
+    ...
+  }
+endcode
+cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
+
Matcher<CXXConstructExpr>argumentCountIsunsigned N
Checks that a call expression or a constructor call expression has
+a specific number of arguments (including absent default arguments).
+
+Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
+  void f(int x, int y);
+  f(0, 0);
+
Matcher<CXXConstructExpr>isListInitialization
Matches a constructor call expression which uses list initialization.
+
Matcher<CXXConstructorDecl>isCopyConstructor
Matches constructor declarations that are copy constructors.
+
+Given
+  struct S {
+    S(); #1
+    S(const S &); #2
+    S(S &&); #3
+  };
+cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
+
Matcher<CXXConstructorDecl>isDefaultConstructor
Matches constructor declarations that are default constructors.
+
+Given
+  struct S {
+    S(); #1
+    S(const S &); #2
+    S(S &&); #3
+  };
+cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
+
Matcher<CXXConstructorDecl>isExplicit
Matches constructor and conversion declarations that are marked with
+the explicit keyword.
+
+Given
+  struct S {
+    S(int); #1
+    explicit S(double); #2
+    operator int(); #3
+    explicit operator bool(); #4
+  };
+cxxConstructorDecl(isExplicit()) will match #2, but not #1.
+cxxConversionDecl(isExplicit()) will match #4, but not #3.
+
Matcher<CXXConstructorDecl>isMoveConstructor
Matches constructor declarations that are move constructors.
+
+Given
+  struct S {
+    S(); #1
+    S(const S &); #2
+    S(S &&); #3
+  };
+cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
+
Matcher<CXXConversionDecl>isExplicit
Matches constructor and conversion declarations that are marked with
+the explicit keyword.
+
+Given
+  struct S {
+    S(int); #1
+    explicit S(double); #2
+    operator int(); #3
+    explicit operator bool(); #4
+  };
+cxxConstructorDecl(isExplicit()) will match #2, but not #1.
+cxxConversionDecl(isExplicit()) will match #4, but not #3.
+
Matcher<CXXCtorInitializer>isBaseInitializer
Matches a constructor initializer if it is initializing a base, as
+opposed to a member.
+
+Given
+  struct B {};
+  struct D : B {
+    int I;
+    D(int i) : I(i) {}
+  };
+  struct E : B {
+    E() : B() {}
+  };
+cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
+  will match E(), but not match D(int).
+
Matcher<CXXCtorInitializer>isMemberInitializer
Matches a constructor initializer if it is initializing a member, as
+opposed to a base.
+
+Given
+  struct B {};
+  struct D : B {
+    int I;
+    D(int i) : I(i) {}
+  };
+  struct E : B {
+    E() : B() {}
+  };
+cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
+  will match D(int), but not match E().
+
Matcher<CXXCtorInitializer>isWritten
Matches a constructor initializer if it is explicitly written in
+code (as opposed to implicitly added by the compiler).
+
+Given
+  struct Foo {
+    Foo() { }
+    Foo(int) : foo_("A") { }
+    string foo_;
+  };
+cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
+  will match Foo(int), but not Foo()
+
Matcher<CXXMethodDecl>isConst
Matches if the given method declaration is const.
+
+Given
+struct A {
+  void foo() const;
+  void bar();
+};
+
+cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
+
Matcher<CXXMethodDecl>isCopyAssignmentOperator
Matches if the given method declaration declares a copy assignment
+operator.
+
+Given
+struct A {
+  A &operator=(const A &);
+  A &operator=(A &&);
+};
+
+cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
+the second one.
+
Matcher<CXXMethodDecl>isFinal
Matches if the given method or class declaration is final.
+
+Given:
+  class A final {};
+
+  struct B {
+    virtual void f();
+  };
+
+  struct C : B {
+    void f() final;
+  };
+matches A and C::f, but not B, C, or B::f
+
Matcher<CXXMethodDecl>isOverride
Matches if the given method declaration overrides another method.
+
+Given
+  class A {
+   public:
+    virtual void x();
+  };
+  class B : public A {
+   public:
+    virtual void x();
+  };
+  matches B::x
+
Matcher<CXXMethodDecl>isPure
Matches if the given method declaration is pure.
+
+Given
+  class A {
+   public:
+    virtual void x() = 0;
+  };
+  matches A::x
+
Matcher<CXXMethodDecl>isVirtual
Matches if the given method declaration is virtual.
+
+Given
+  class A {
+   public:
+    virtual void x();
+  };
+  matches A::x
+
Matcher<CXXOperatorCallExpr>hasOverloadedOperatorNameStringRef Name
Matches overloaded operator names.
+
+Matches overloaded operator names specified in strings without the
+"operator" prefix: e.g. "<<".
+
+Given:
+  class A { int operator*(); };
+  const A &operator<<(const A &a, const A &b);
+  A a;
+  a << a;   <-- This matches
+
+cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the
+specified line and
+cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
+matches the declaration of A.
+
+Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
+
Matcher<CXXRecordDecl>isDerivedFromstd::string BaseName
Overloaded method as shortcut for isDerivedFrom(hasName(...)).
+
Matcher<CXXRecordDecl>isExplicitTemplateSpecialization
Matches explicit template specializations of function, class, or
+static member variable template instantiations.
+
+Given
+  template<typename T> void A(T t) { }
+  template<> void A(int N) { }
+functionDecl(isExplicitTemplateSpecialization())
+  matches the specialization A<int>().
+
+Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
+
Matcher<CXXRecordDecl>isFinal
Matches if the given method or class declaration is final.
+
+Given:
+  class A final {};
+
+  struct B {
+    virtual void f();
+  };
+
+  struct C : B {
+    void f() final;
+  };
+matches A and C::f, but not B, C, or B::f
+
Matcher<CXXRecordDecl>isSameOrDerivedFromstd::string BaseName
Overloaded method as shortcut for
+isSameOrDerivedFrom(hasName(...)).
+
Matcher<CXXRecordDecl>isTemplateInstantiation
Matches template instantiations of function, class, or static
+member variable template instantiations.
+
+Given
+  template <typename T> class X {}; class A {}; X<A> x;
+or
+  template <typename T> class X {}; class A {}; template class X<A>;
+cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
+  matches the template instantiation of X<A>.
+
+But given
+  template <typename T>  class X {}; class A {};
+  template <> class X<A> {}; X<A> x;
+cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
+  does not match, as X<A> is an explicit template specialization.
+
+Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
+
Matcher<CallExpr>argumentCountIsunsigned N
Checks that a call expression or a constructor call expression has
+a specific number of arguments (including absent default arguments).
+
+Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
+  void f(int x, int y);
+  f(0, 0);
+
Matcher<CharacterLiteral>equalsValueT  Value
Matches literals that are equal to the given value.
+
+Example matches true (matcher = cxxBoolLiteral(equals(true)))
+  true
+
+Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
+           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
+
Matcher<ClassTemplateSpecializationDecl>templateArgumentCountIsunsigned N
Matches if the number of template arguments equals N.
+
+Given
+  template<typename T> struct C {};
+  C<int> c;
+classTemplateSpecializationDecl(templateArgumentCountIs(1))
+  matches C<int>.
+
Matcher<CompoundStmt>statementCountIsunsigned N
Checks that a compound statement contains a specific number of
+child statements.
+
+Example: Given
+  { for (;;) {} }
+compoundStmt(statementCountIs(0)))
+  matches '{}'
+  but does not match the outer compound statement.
+
Matcher<ConstantArrayType>hasSizeunsigned N
Matches ConstantArrayType nodes that have the specified size.
+
+Given
+  int a[42];
+  int b[2 * 21];
+  int c[41], d[43];
+constantArrayType(hasSize(42))
+  matches "int a[42]" and "int b[2 * 21]"
+
Matcher<DeclStmt>declCountIsunsigned N
Matches declaration statements that contain a specific number of
+declarations.
+
+Example: Given
+  int a, b;
+  int c;
+  int d = 2, e;
+declCountIs(2)
+  matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
+
Matcher<Decl>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
+
+Matches a node if it equals the node previously bound to ID.
+
+Given
+  class X { int a; int b; };
+cxxRecordDecl(
+    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
+    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
+  matches the class X, as a and b have the same type.
+
+Note that when multiple matches are involved via forEach* matchers,
+equalsBoundNodes acts as a filter.
+For example:
+compoundStmt(
+    forEachDescendant(varDecl().bind("d")),
+    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
+will trigger a match for each combination of variable declaration
+and reference to that variable declaration within a compound statement.
+
Matcher<Decl>hasAttrattr::Kind AttrKind
Matches declaration that has a given attribute.
+
+Given
+  __attribute__((device)) void f() { ... }
+decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
+f. If the matcher is use from clang-query, attr::Kind parameter should be
+passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
+
Matcher<Decl>isExpansionInFileMatchingstd::string RegExp
Matches AST nodes that were expanded within files whose name is
+partially matching a given regex.
+
+Example matches Y but not X
+    (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
+  #include "ASTMatcher.h"
+  class X {};
+ASTMatcher.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<Decl>isExpansionInMainFile
Matches AST nodes that were expanded within the main-file.
+
+Example matches X but not Y
+  (matcher = cxxRecordDecl(isExpansionInMainFile())
+  #include <Y.h>
+  class X {};
+Y.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<Decl>isExpansionInSystemHeader
Matches AST nodes that were expanded within system-header-files.
+
+Example matches Y but not X
+    (matcher = cxxRecordDecl(isExpansionInSystemHeader())
+  #include <SystemHeader.h>
+  class X {};
+SystemHeader.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<Decl>isImplicit
Matches a declaration that has been implicitly added
+by the compiler (eg. implicit defaultcopy constructors).
+
Matcher<Decl>isPrivate
Matches private C++ declarations.
+
+Given
+  class C {
+  public:    int a;
+  protected: int b;
+  private:   int c;
+  };
+fieldDecl(isPrivate())
+  matches 'int c;' 
+
Matcher<Decl>isProtected
Matches protected C++ declarations.
+
+Given
+  class C {
+  public:    int a;
+  protected: int b;
+  private:   int c;
+  };
+fieldDecl(isProtected())
+  matches 'int b;' 
+
Matcher<Decl>isPublic
Matches public C++ declarations.
+
+Given
+  class C {
+  public:    int a;
+  protected: int b;
+  private:   int c;
+  };
+fieldDecl(isPublic())
+  matches 'int a;' 
+
Matcher<FloatingLiteral>equalsValueT  Value
Matches literals that are equal to the given value.
+
+Example matches true (matcher = cxxBoolLiteral(equals(true)))
+  true
+
+Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
+           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
+
Matcher<FunctionDecl>hasOverloadedOperatorNameStringRef Name
Matches overloaded operator names.
+
+Matches overloaded operator names specified in strings without the
+"operator" prefix: e.g. "<<".
+
+Given:
+  class A { int operator*(); };
+  const A &operator<<(const A &a, const A &b);
+  A a;
+  a << a;   <-- This matches
+
+cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the
+specified line and
+cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
+matches the declaration of A.
+
+Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
+
Matcher<FunctionDecl>isConstexpr
Matches constexpr variable and function declarations.
+
+Given:
+  constexpr int foo = 42;
+  constexpr int bar();
+varDecl(isConstexpr())
+  matches the declaration of foo.
+functionDecl(isConstexpr())
+  matches the declaration of bar.
+
Matcher<FunctionDecl>isDefinition
Matches if a declaration has a body attached.
+
+Example matches A, va, fa
+  class A {};
+  class B;  Doesn't match, as it has no body.
+  int va;
+  extern int vb;  Doesn't match, as it doesn't define the variable.
+  void fa() {}
+  void fb();  Doesn't match, as it has no body.
+
+Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
+
Matcher<FunctionDecl>isDeleted
Matches deleted function declarations.
+
+Given:
+  void Func();
+  void DeletedFunc() = delete;
+functionDecl(isDeleted())
+  matches the declaration of DeletedFunc, but not Func.
+
Matcher<FunctionDecl>isExplicitTemplateSpecialization
Matches explicit template specializations of function, class, or
+static member variable template instantiations.
+
+Given
+  template<typename T> void A(T t) { }
+  template<> void A(int N) { }
+functionDecl(isExplicitTemplateSpecialization())
+  matches the specialization A<int>().
+
+Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
+
Matcher<FunctionDecl>isExternC
Matches extern "C" function declarations.
+
+Given:
+  extern "C" void f() {}
+  extern "C" { void g() {} }
+  void h() {}
+functionDecl(isExternC())
+  matches the declaration of f and g, but not the declaration h
+
Matcher<FunctionDecl>isInline
Matches function and namespace declarations that are marked with
+the inline keyword.
+
+Given
+  inline void f();
+  void g();
+  namespace n {
+  inline namespace m {}
+  }
+functionDecl(isInline()) will match ::f().
+namespaceDecl(isInline()) will match n::m.
+
Matcher<FunctionDecl>isTemplateInstantiation
Matches template instantiations of function, class, or static
+member variable template instantiations.
+
+Given
+  template <typename T> class X {}; class A {}; X<A> x;
+or
+  template <typename T> class X {}; class A {}; template class X<A>;
+cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
+  matches the template instantiation of X<A>.
+
+But given
+  template <typename T>  class X {}; class A {};
+  template <> class X<A> {}; X<A> x;
+cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
+  does not match, as X<A> is an explicit template specialization.
+
+Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
+
Matcher<FunctionDecl>isVariadic
Matches if a function declaration is variadic.
+
+Example matches f, but not g or h. The function i will not match, even when
+compiled in C mode.
+  void f(...);
+  void g(int);
+  template <typename... Ts> void h(Ts...);
+  void i();
+
Matcher<FunctionDecl>parameterCountIsunsigned N
Matches FunctionDecls that have a specific parameter count.
+
+Given
+  void f(int i) {}
+  void g(int i, int j) {}
+functionDecl(parameterCountIs(2))
+  matches g(int i, int j) {}
+
Matcher<IntegerLiteral>equalsValueT  Value
Matches literals that are equal to the given value.
+
+Example matches true (matcher = cxxBoolLiteral(equals(true)))
+  true
+
+Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
+           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
+
Matcher<MemberExpr>isArrow
Matches member expressions that are called with '->' as opposed
+to '.'.
+
+Member calls on the implicit this pointer match as called with '->'.
+
+Given
+  class Y {
+    void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
+    int a;
+    static int b;
+  };
+memberExpr(isArrow())
+  matches this->x, x, y.x, a, this->b
+
Matcher<NamedDecl>hasNamestd::string  Name
Matches NamedDecl nodes that have the specified name.
+
+Supports specifying enclosing namespaces or classes by prefixing the name
+with '<enclosing>::'.
+Does not match typedefs of an underlying type with the given name.
+
+Example matches X (Name == "X")
+  class X;
+
+Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
+  namespace a { namespace b { class X; } }
+
Matcher<NamedDecl>matchesNamestd::string RegExp
Matches NamedDecl nodes whose fully qualified names contain
+a substring matched by the given RegExp.
+
+Supports specifying enclosing namespaces or classes by
+prefixing the name with '<enclosing>::'.  Does not match typedefs
+of an underlying type with the given name.
+
+Example matches X (regexp == "::X")
+  class X;
+
+Example matches X (regexp is one of "::X", "^foo::.*X", among others)
+  namespace foo { namespace bar { class X; } }
+
Matcher<NamespaceDecl>isAnonymous
Matches anonymous namespace declarations.
+
+Given
+  namespace n {
+  namespace {} #1
+  }
+namespaceDecl(isAnonymous()) will match #1 but not ::n.
+
Matcher<NamespaceDecl>isInline
Matches function and namespace declarations that are marked with
+the inline keyword.
+
+Given
+  inline void f();
+  void g();
+  namespace n {
+  inline namespace m {}
+  }
+functionDecl(isInline()) will match ::f().
+namespaceDecl(isInline()) will match n::m.
+
Matcher<ObjCMessageExpr>argumentCountIsunsigned N
Checks that a call expression or a constructor call expression has
+a specific number of arguments (including absent default arguments).
+
+Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
+  void f(int x, int y);
+  f(0, 0);
+
Matcher<ObjCMessageExpr>hasKeywordSelector
Matches when the selector is a keyword selector
+
+objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
+message expression in
+
+  UIWebView *webView = ...;
+  CGRect bodyFrame = webView.frame;
+  bodyFrame.size.height = self.bodyContentHeight;
+  webView.frame = bodyFrame;
+      ^---- matches here
+
Matcher<ObjCMessageExpr>hasNullSelector
Matches when the selector is the empty selector
+
+Matches only when the selector of the objCMessageExpr is NULL. This may
+represent an error condition in the tree!
+
Matcher<ObjCMessageExpr>hasSelectorstd::string BaseName
Matches when BaseName == Selector.getAsString()
+
+ matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
+ matches the outer message expr in the code below, but NOT the message
+ invocation for self.bodyView.
+    [self.bodyView loadHTMLString:html baseURL:NULL];
+
Matcher<ObjCMessageExpr>hasUnarySelector
Matches when the selector is a Unary Selector
+
+ matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
+ matches self.bodyView in the code below, but NOT the outer message
+ invocation of "loadHTMLString:baseURL:".
+    [self.bodyView loadHTMLString:html baseURL:NULL];
+
Matcher<ObjCMessageExpr>matchesSelectorstd::string RegExp
Matches ObjC selectors whose name contains
+a substring matched by the given RegExp.
+ matcher = objCMessageExpr(matchesSelector("loadHTMLStringmatches the outer message expr in the code below, but NOT the message
+ invocation for self.bodyView.
+    [self.bodyView loadHTMLString:html baseURL:NULL];
+
Matcher<ObjCMessageExpr>numSelectorArgsunsigned N
Matches when the selector has the specified number of arguments
+
+ matcher = objCMessageExpr(numSelectorArgs(0));
+ matches self.bodyView in the code below
+
+ matcher = objCMessageExpr(numSelectorArgs(2));
+ matches the invocation of "loadHTMLString:baseURL:" but not that
+ of self.bodyView
+    [self.bodyView loadHTMLString:html baseURL:NULL];
+
Matcher<QualType>asStringstd::string Name
Matches if the matched type is represented by the given string.
+
+Given
+  class Y { public: void x(); };
+  void z() { Y* y; y->x(); }
+cxxMemberCallExpr(on(hasType(asString("class Y *"))))
+  matches y->x()
+
Matcher<QualType>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
+
+Matches a node if it equals the node previously bound to ID.
+
+Given
+  class X { int a; int b; };
+cxxRecordDecl(
+    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
+    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
+  matches the class X, as a and b have the same type.
+
+Note that when multiple matches are involved via forEach* matchers,
+equalsBoundNodes acts as a filter.
+For example:
+compoundStmt(
+    forEachDescendant(varDecl().bind("d")),
+    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
+will trigger a match for each combination of variable declaration
+and reference to that variable declaration within a compound statement.
+
Matcher<QualType>hasLocalQualifiers
Matches QualType nodes that have local CV-qualifiers attached to
+the node, not hidden within a typedef.
+
+Given
+  typedef const int const_int;
+  const_int i;
+  int *const j;
+  int *volatile k;
+  int m;
+varDecl(hasType(hasLocalQualifiers())) matches only j and k.
+i is const-qualified but the qualifier is not local.
+
Matcher<QualType>isConstQualified
Matches QualType nodes that are const-qualified, i.e., that
+include "top-level" const.
+
+Given
+  void a(int);
+  void b(int const);
+  void c(const int);
+  void d(const int*);
+  void e(int const) {};
+functionDecl(hasAnyParameter(hasType(isConstQualified())))
+  matches "void b(int const)", "void c(const int)" and
+  "void e(int const) {}". It does not match d as there
+  is no top-level const on the parameter type "const int *".
+
Matcher<QualType>isInteger
Matches QualType nodes that are of integer type.
+
+Given
+  void a(int);
+  void b(long);
+  void c(double);
+functionDecl(hasAnyParameter(hasType(isInteger())))
+matches "a(int)", "b(long)", but not "c(double)".
+
Matcher<RecordDecl>isClass
Matches RecordDecl object that are spelled with "class."
+
+Example matches C, but not S or U.
+  struct S {};
+  class C {};
+  union U {};
+
Matcher<RecordDecl>isStruct
Matches RecordDecl object that are spelled with "struct."
+
+Example matches S, but not C or U.
+  struct S {};
+  class C {};
+  union U {};
+
Matcher<RecordDecl>isUnion
Matches RecordDecl object that are spelled with "union."
+
+Example matches U, but not C or S.
+  struct S {};
+  class C {};
+  union U {};
+
Matcher<Stmt>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
+
+Matches a node if it equals the node previously bound to ID.
+
+Given
+  class X { int a; int b; };
+cxxRecordDecl(
+    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
+    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
+  matches the class X, as a and b have the same type.
+
+Note that when multiple matches are involved via forEach* matchers,
+equalsBoundNodes acts as a filter.
+For example:
+compoundStmt(
+    forEachDescendant(varDecl().bind("d")),
+    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
+will trigger a match for each combination of variable declaration
+and reference to that variable declaration within a compound statement.
+
Matcher<Stmt>isExpansionInFileMatchingstd::string RegExp
Matches AST nodes that were expanded within files whose name is
+partially matching a given regex.
+
+Example matches Y but not X
+    (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
+  #include "ASTMatcher.h"
+  class X {};
+ASTMatcher.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<Stmt>isExpansionInMainFile
Matches AST nodes that were expanded within the main-file.
+
+Example matches X but not Y
+  (matcher = cxxRecordDecl(isExpansionInMainFile())
+  #include <Y.h>
+  class X {};
+Y.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<Stmt>isExpansionInSystemHeader
Matches AST nodes that were expanded within system-header-files.
+
+Example matches Y but not X
+    (matcher = cxxRecordDecl(isExpansionInSystemHeader())
+  #include <SystemHeader.h>
+  class X {};
+SystemHeader.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<TagDecl>isDefinition
Matches if a declaration has a body attached.
+
+Example matches A, va, fa
+  class A {};
+  class B;  Doesn't match, as it has no body.
+  int va;
+  extern int vb;  Doesn't match, as it doesn't define the variable.
+  void fa() {}
+  void fb();  Doesn't match, as it has no body.
+
+Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
+
Matcher<TemplateArgument>equalsIntegralValuestd::string Value
Matches a TemplateArgument of integral type with a given value.
+
+Note that 'Value' is a string as the template argument's value is
+an arbitrary precision integer. 'Value' must be euqal to the canonical
+representation of that integral value in base 10.
+
+Given
+  template<int T> struct A {};
+  C<42> c;
+classTemplateSpecializationDecl(
+  hasAnyTemplateArgument(equalsIntegralValue("42")))
+  matches the implicit instantiation of C in C<42>.
+
Matcher<TemplateArgument>isIntegral
Matches a TemplateArgument that is an integral value.
+
+Given
+  template<int T> struct A {};
+  C<42> c;
+classTemplateSpecializationDecl(
+  hasAnyTemplateArgument(isIntegral()))
+  matches the implicit instantiation of C in C<42>
+  with isIntegral() matching 42.
+
Matcher<TemplateSpecializationType>templateArgumentCountIsunsigned N
Matches if the number of template arguments equals N.
+
+Given
+  template<typename T> struct C {};
+  C<int> c;
+classTemplateSpecializationDecl(templateArgumentCountIs(1))
+  matches C<int>.
+
Matcher<TypeLoc>isExpansionInFileMatchingstd::string RegExp
Matches AST nodes that were expanded within files whose name is
+partially matching a given regex.
+
+Example matches Y but not X
+    (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
+  #include "ASTMatcher.h"
+  class X {};
+ASTMatcher.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<TypeLoc>isExpansionInMainFile
Matches AST nodes that were expanded within the main-file.
+
+Example matches X but not Y
+  (matcher = cxxRecordDecl(isExpansionInMainFile())
+  #include <Y.h>
+  class X {};
+Y.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<TypeLoc>isExpansionInSystemHeader
Matches AST nodes that were expanded within system-header-files.
+
+Example matches Y but not X
+    (matcher = cxxRecordDecl(isExpansionInSystemHeader())
+  #include <SystemHeader.h>
+  class X {};
+SystemHeader.h:
+  class Y {};
+
+Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc>
+
Matcher<Type>equalsBoundNodestd::string ID
Matches if a node equals a previously bound node.
+
+Matches a node if it equals the node previously bound to ID.
+
+Given
+  class X { int a; int b; };
+cxxRecordDecl(
+    has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
+    has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
+  matches the class X, as a and b have the same type.
+
+Note that when multiple matches are involved via forEach* matchers,
+equalsBoundNodes acts as a filter.
+For example:
+compoundStmt(
+    forEachDescendant(varDecl().bind("d")),
+    forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
+will trigger a match for each combination of variable declaration
+and reference to that variable declaration within a compound statement.
+
Matcher<Type>voidType
Matches type void.
+
+Given
+ struct S { void func(); };
+functionDecl(returns(voidType()))
+  matches "void func();"
+
Matcher<UnaryExprOrTypeTraitExpr>ofKindUnaryExprOrTypeTrait Kind
Matches unary expressions of a certain kind.
+
+Given
+  int x;
+  int s = sizeof(x) + alignof(x)
+unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
+  matches sizeof(x)
+
Matcher<UnaryOperator>hasOperatorNamestd::string Name
Matches the operator Name of operator expressions (binary or
+unary).
+
+Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
+  !(a || b)
+
Matcher<VarDecl>hasAutomaticStorageDuration
Matches a variable declaration that has automatic storage duration.
+
+Example matches x, but not y, z, or a.
+(matcher = varDecl(hasAutomaticStorageDuration())
+void f() {
+  int x;
+  static int y;
+  thread_local int z;
+}
+int a;
+
Matcher<VarDecl>hasGlobalStorage
Matches a variable declaration that does not have local storage.
+
+Example matches y and z (matcher = varDecl(hasGlobalStorage())
+void f() {
+  int x;
+  static int y;
+}
+int z;
+
Matcher<VarDecl>hasLocalStorage
Matches a variable declaration that has function scope and is a
+non-static local variable.
+
+Example matches x (matcher = varDecl(hasLocalStorage())
+void f() {
+  int x;
+  static int y;
+}
+int z;
+
Matcher<VarDecl>hasStaticStorageDuration
Matches a variable declaration that has static storage duration.
+
+Example matches y and a, but not x or z.
+(matcher = varDecl(hasStaticStorageDuration())
+void f() {
+  int x;
+  static int y;
+  thread_local int z;
+}
+int a;
+
Matcher<VarDecl>hasThreadStorageDuration
Matches a variable declaration that has thread storage duration.
+
+Example matches z, but not x, z, or a.
+(matcher = varDecl(hasThreadStorageDuration())
+void f() {
+  int x;
+  static int y;
+  thread_local int z;
+}
+int a;
+
Matcher<VarDecl>isConstexpr
Matches constexpr variable and function declarations.
+
+Given:
+  constexpr int foo = 42;
+  constexpr int bar();
+varDecl(isConstexpr())
+  matches the declaration of foo.
+functionDecl(isConstexpr())
+  matches the declaration of bar.
+
Matcher<VarDecl>isDefinition
Matches if a declaration has a body attached.
+
+Example matches A, va, fa
+  class A {};
+  class B;  Doesn't match, as it has no body.
+  int va;
+  extern int vb;  Doesn't match, as it doesn't define the variable.
+  void fa() {}
+  void fb();  Doesn't match, as it has no body.
+
+Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
+
Matcher<VarDecl>isExceptionVariable
Matches a variable declaration that is an exception variable from
+a C++ catch block, or an Objective-C statement.
+
+Example matches x (matcher = varDecl(isExceptionVariable())
+void f(int y) {
+  try {
+  } catch (int x) {
+  }
+}
+
Matcher<VarDecl>isExplicitTemplateSpecialization
Matches explicit template specializations of function, class, or
+static member variable template instantiations.
+
+Given
+  template<typename T> void A(T t) { }
+  template<> void A(int N) { }
+functionDecl(isExplicitTemplateSpecialization())
+  matches the specialization A<int>().
+
+Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
+
Matcher<VarDecl>isTemplateInstantiation
Matches template instantiations of function, class, or static
+member variable template instantiations.
+
+Given
+  template <typename T> class X {}; class A {}; X<A> x;
+or
+  template <typename T> class X {}; class A {}; template class X<A>;
+cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
+  matches the template instantiation of X<A>.
+
+But given
+  template <typename T>  class X {}; class A {};
+  template <> class X<A> {}; X<A> x;
+cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
+  does not match, as X<A> is an explicit template specialization.
+
+Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
+
Matcher<internal::Matcher<Decl>>isInstantiated
Matches declarations that are template instantiations or are inside
+template instantiations.
+
+Given
+  template<typename T> void A(T t) { T i; }
+  A(0);
+  A(0U);
+functionDecl(isInstantiated())
+  matches 'A(int) {...};' and 'A(unsigned) {...}'.
+
Matcher<internal::Matcher<Stmt>>isInTemplateInstantiation
Matches statements inside of a template instantiation.
+
+Given
+  int j;
+  template<typename T> void A(T t) { T i; j += 42;}
+  A(0);
+  A(0U);
+declStmt(isInTemplateInstantiation())
+  matches 'int i;' and 'unsigned i'.
+unless(stmt(isInTemplateInstantiation()))
+  will NOT match j += 42; as it's shared between the template definition and
+  instantiation.
+

 
-Matcher<internal::BindableMatcher<NestedNameSpecifierLoc>>locMatcher<NestedNameSpecifier> InnerMatcher
-
Matches NestedNameSpecifierLocs for which the given inner
-NestedNameSpecifier-matcher matches.
-

+
+
AST Traversal Matchers

+
 
+
Traversal matchers specify the relationship to other nodes that are
+reachable from the current node.

 
-Matcher<internal::BindableMatcher<TypeLoc>>locMatcher<QualType> InnerMatcher
-
Matches TypeLocs for which the given inner
-QualType-matcher matches.
-

+
Note that there are special traversal matchers (has, hasDescendant, forEach and
+forEachDescendant) which work on all nodes and allow users to write more generic
+match expressions.

 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
Return typeNameParameters
Matcher<*>eachOfMatcher<*>, ..., Matcher<*>
Matches if any of the given matchers matches.
+
+Unlike anyOf, eachOf will generate a match result for each
+matching submatcher.
+
+For example, in:
+  class A { int a; int b; };
+The matcher:
+  cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
+                       has(fieldDecl(hasName("b")).bind("v"))))
+will generate two results binding "v", the first of which binds
+the field declaration of a, the second the field declaration of
+b.
+
+Usable as: Any Matcher
+
Matcher<*>forEachDescendantMatcher<*>
Matches AST nodes that have descendant AST nodes that match the
+provided matcher.
+
+Example matches X, A, B, C
+  (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X")))))
+  class X {};  Matches X, because X::X is a class of name X inside X.
+  class A { class X {}; };
+  class B { class C { class X {}; }; };
+
+DescendantT must be an AST base type.
+
+As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
+each result that matches instead of only on the first one.
+
+Note: Recursively combined ForEachDescendant can cause many matches:
+  cxxRecordDecl(forEachDescendant(cxxRecordDecl(
+    forEachDescendant(cxxRecordDecl())
+  )))
+will match 10 times (plus injected class name matches) on:
+  class A { class B { class C { class D { class E {}; }; }; }; };
+
+Usable as: Any Matcher
+
Matcher<*>forEachMatcher<*>
Matches AST nodes that have child AST nodes that match the
+provided matcher.
+
+Example matches X, Y
+  (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X")))
+  class X {};  Matches X, because X::X is a class of name X inside X.
+  class Y { class X {}; };
+  class Z { class Y { class X {}; }; };  Does not match Z.
+
+ChildT must be an AST base type.
+
+As opposed to 'has', 'forEach' will cause a match for each result that
+matches instead of only on the first one.
+
+Usable as: Any Matcher
+
Matcher<*>hasAncestorMatcher<*>
Matches AST nodes that have an ancestor that matches the provided
+matcher.
+
+Given
+void f() { if (true) { int x = 42; } }
+void g() { for (;;) { int x = 43; } }
+expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
+
+Usable as: Any Matcher
+
Matcher<*>hasDescendantMatcher<*>
Matches AST nodes that have descendant AST nodes that match the
+provided matcher.
+
+Example matches X, Y, Z
+    (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))
+  class X {};  Matches X, because X::X is a class of name X inside X.
+  class Y { class X {}; };
+  class Z { class Y { class X {}; }; };
+
+DescendantT must be an AST base type.
+
+Usable as: Any Matcher
+
Matcher<*>hasMatcher<*>
Matches AST nodes that have child AST nodes that match the
+provided matcher.
+
+Example matches X, Y
+  (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X")))
+  class X {};  Matches X, because X::X is a class of name X inside X.
+  class Y { class X {}; };
+  class Z { class Y { class X {}; }; };  Does not match Z.
+
+ChildT must be an AST base type.
+
+Usable as: Any Matcher
+
Matcher<*>hasParentMatcher<*>
Matches AST nodes that have a parent that matches the provided
+matcher.
+
+Given
+void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
+compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
+
+Usable as: Any Matcher
+
Matcher<ArraySubscriptExpr>hasBaseMatcher<Expr> InnerMatcher
Matches the base expression of an array subscript expression.
+
+Given
+  int i[5];
+  void f() { i[1] = 42; }
+arraySubscriptExpression(hasBase(implicitCastExpr(
+    hasSourceExpression(declRefExpr()))))
+  matches i[1] with the declRefExpr() matching i
+
Matcher<ArraySubscriptExpr>hasIndexMatcher<Expr> InnerMatcher
Matches the index expression of an array subscript expression.
+
+Given
+  int i[5];
+  void f() { i[1] = 42; }
+arraySubscriptExpression(hasIndex(integerLiteral()))
+  matches i[1] with the integerLiteral() matching 1
+
Matcher<ArraySubscriptExpr>hasLHSMatcher<Expr> InnerMatcher
Matches the left hand side of binary operator expressions.
+
+Example matches a (matcher = binaryOperator(hasLHS()))
+  a || b
+
Matcher<ArraySubscriptExpr>hasRHSMatcher<Expr> InnerMatcher
Matches the right hand side of binary operator expressions.
+
+Example matches b (matcher = binaryOperator(hasRHS()))
+  a || b
+
Matcher<ArrayTypeLoc>hasElementTypeLocMatcher<TypeLoc>
Matches arrays and C99 complex types that have a specific element
+type.
+
+Given
+  struct A {};
+  A a[7];
+  int b[7];
+arrayType(hasElementType(builtinType()))
+  matches "int b[7]"
+
+Usable as: Matcher<ArrayType>, Matcher<ComplexType>
+
Matcher<ArrayType>hasElementTypeMatcher<Type>
Matches arrays and C99 complex types that have a specific element
+type.
+
+Given
+  struct A {};
+  A a[7];
+  int b[7];
+arrayType(hasElementType(builtinType()))
+  matches "int b[7]"
+
+Usable as: Matcher<ArrayType>, Matcher<ComplexType>
+
Matcher<AtomicTypeLoc>hasValueTypeLocMatcher<TypeLoc>
Matches atomic types with a specific value type.
+
+Given
+  _Atomic(int) i;
+  _Atomic(float) f;
+atomicType(hasValueType(isInteger()))
+ matches "_Atomic(int) i"
+
+Usable as: Matcher<AtomicType>
+
Matcher<AtomicType>hasValueTypeMatcher<Type>
Matches atomic types with a specific value type.
+
+Given
+  _Atomic(int) i;
+  _Atomic(float) f;
+atomicType(hasValueType(isInteger()))
+ matches "_Atomic(int) i"
+
+Usable as: Matcher<AtomicType>
+
Matcher<AutoType>hasDeducedTypeMatcher<Type>
Matches AutoType nodes where the deduced type is a specific type.
+
+Note: There is no TypeLoc for the deduced type and thus no
+getDeducedLoc() matcher.
+
+Given
+  auto a = 1;
+  auto b = 2.0;
+autoType(hasDeducedType(isInteger()))
+  matches "auto a"
+
+Usable as: Matcher<AutoType>
+
Matcher<BinaryOperator>hasEitherOperandMatcher<Expr>  InnerMatcher
Matches if either the left hand side or the right hand side of a
+binary operator matches.
+
Matcher<BinaryOperator>hasLHSMatcher<Expr> InnerMatcher
Matches the left hand side of binary operator expressions.
+
+Example matches a (matcher = binaryOperator(hasLHS()))
+  a || b
+
Matcher<BinaryOperator>hasRHSMatcher<Expr> InnerMatcher
Matches the right hand side of binary operator expressions.
+
+Example matches b (matcher = binaryOperator(hasRHS()))
+  a || b
+
Matcher<BlockPointerTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<BlockPointerType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<CXXConstructExpr>hasAnyArgumentMatcher<Expr> InnerMatcher
Matches any argument of a call expression or a constructor call
+expression.
+
+Given
+  void x(int, int, int) { int y; x(1, y, 42); }
+callExpr(hasAnyArgument(declRefExpr()))
+  matches x(1, y, 42)
+with hasAnyArgument(...)
+  matching y
+
+FIXME: Currently this will ignore parentheses and implicit casts on
+the argument before applying the inner matcher. We'll want to remove
+this to allow for greater control by the user once ignoreImplicit()
+has been implemented.
+
Matcher<CXXConstructExpr>hasArgumentunsigned N, Matcher<Expr> InnerMatcher
Matches the n'th argument of a call expression or a constructor
+call expression.
+
+Example matches y in x(y)
+    (matcher = callExpr(hasArgument(0, declRefExpr())))
+  void x(int) { int y; x(y); }
+
Matcher<CXXConstructExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<CXXConstructorDecl>forEachConstructorInitializerMatcher<CXXCtorInitializer> InnerMatcher
Matches each constructor initializer in a constructor definition.
+
+Given
+  class A { A() : i(42), j(42) {} int i; int j; };
+cxxConstructorDecl(forEachConstructorInitializer(
+  forField(decl().bind("x"))
+))
+  will trigger two matches, binding for 'i' and 'j' respectively.
+
Matcher<CXXConstructorDecl>hasAnyConstructorInitializerMatcher<CXXCtorInitializer> InnerMatcher
Matches a constructor initializer.
+
+Given
+  struct Foo {
+    Foo() : foo_(1) { }
+    int foo_;
+  };
+cxxRecordDecl(has(cxxConstructorDecl(
+  hasAnyConstructorInitializer(anything())
+)))
+  record matches Foo, hasAnyConstructorInitializer matches foo_(1)
+
Matcher<CXXCtorInitializer>forFieldMatcher<FieldDecl> InnerMatcher
Matches the field declaration of a constructor initializer.
+
+Given
+  struct Foo {
+    Foo() : foo_(1) { }
+    int foo_;
+  };
+cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
+    forField(hasName("foo_"))))))
+  matches Foo
+with forField matching foo_
+
Matcher<CXXCtorInitializer>withInitializerMatcher<Expr> InnerMatcher
Matches the initializer expression of a constructor initializer.
+
+Given
+  struct Foo {
+    Foo() : foo_(1) { }
+    int foo_;
+  };
+cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
+    withInitializer(integerLiteral(equals(1)))))))
+  matches Foo
+with withInitializer matching (1)
+
Matcher<CXXForRangeStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
+a given body.
+
+Given
+  for (;;) {}
+hasBody(compoundStmt())
+  matches 'for (;;) {}'
+with compoundStmt()
+  matching '{}'
+
Matcher<CXXForRangeStmt>hasLoopVariableMatcher<VarDecl> InnerMatcher
Matches the initialization statement of a for loop.
+
+Example:
+    forStmt(hasLoopVariable(anything()))
+matches 'int x' in
+    for (int x : a) { }
+
Matcher<CXXForRangeStmt>hasRangeInitMatcher<Expr> InnerMatcher
Matches the range initialization statement of a for loop.
+
+Example:
+    forStmt(hasRangeInit(anything()))
+matches 'a' in
+    for (int x : a) { }
+
Matcher<CXXMemberCallExpr>onImplicitObjectArgumentMatcher<Expr> InnerMatcher
Matcher<CXXMemberCallExpr>onMatcher<Expr> InnerMatcher
Matches on the implicit object argument of a member call expression.
+
+Example matches y.x()
+  (matcher = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y"))))))
+  class Y { public: void x(); };
+  void z() { Y y; y.x(); }",
+
+FIXME: Overload to allow directly matching types?
+
Matcher<CXXMemberCallExpr>thisPointerTypeMatcher<Decl> InnerMatcher
Overloaded to match the type's declaration.
+
Matcher<CXXMemberCallExpr>thisPointerTypeMatcher<QualType> InnerMatcher
Matches if the expression's type either matches the specified
+matcher, or is a pointer to a type that matches the InnerMatcher.
+
Matcher<CXXMethodDecl>ofClassMatcher<CXXRecordDecl> InnerMatcher
Matches the class declaration that the given method declaration
+belongs to.
+
+FIXME: Generalize this for other kinds of declarations.
+FIXME: What other kind of declarations would we need to generalize
+this to?
+
+Example matches A() in the last line
+    (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
+        ofClass(hasName("A"))))))
+  class A {
+   public:
+    A();
+  };
+  A a = A();
+
Matcher<CXXRecordDecl>hasMethodMatcher<CXXMethodDecl> InnerMatcher
Matches the first method of a class or struct that satisfies InnerMatcher.
+
+Given:
+  class A { void func(); };
+  class B { void member(); };
+
+cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
+A but not B.
+
Matcher<CXXRecordDecl>isDerivedFromMatcher<NamedDecl> Base
Matches C++ classes that are directly or indirectly derived from
+a class matching Base.
+
+Note that a class is not considered to be derived from itself.
+
+Example matches Y, Z, C (Base == hasName("X"))
+  class X;
+  class Y : public X {};  directly derived
+  class Z : public Y {};  indirectly derived
+  typedef X A;
+  typedef A B;
+  class C : public B {};  derived from a typedef of X
+
+In the following example, Bar matches isDerivedFrom(hasName("X")):
+  class Foo;
+  typedef Foo X;
+  class Bar : public Foo {};  derived from a type that X is a typedef of
+
Matcher<CXXRecordDecl>isSameOrDerivedFromMatcher<NamedDecl> Base
Similar to isDerivedFrom(), but also matches classes that directly
+match Base.
+
Matcher<CallExpr>calleeMatcher<Decl> InnerMatcher
Matches if the call expression's callee's declaration matches the
+given matcher.
+
+Example matches y.x() (matcher = callExpr(callee(
+                                   cxxMethodDecl(hasName("x")))))
+  class Y { public: void x(); };
+  void z() { Y y; y.x(); }
+
Matcher<CallExpr>calleeMatcher<Stmt> InnerMatcher
Matches if the call expression's callee expression matches.
+
+Given
+  class Y { void x() { this->x(); x(); Y y; y.x(); } };
+  void f() { f(); }
+callExpr(callee(expr()))
+  matches this->x(), x(), y.x(), f()
+with callee(...)
+  matching this->x, x, y.x, f respectively
+
+Note: Callee cannot take the more general internal::Matcher<Expr>
+because this introduces ambiguous overloads with calls to Callee taking a
+internal::Matcher<Decl>, as the matcher hierarchy is purely
+implemented in terms of implicit casts.
+
Matcher<CallExpr>hasAnyArgumentMatcher<Expr> InnerMatcher
Matches any argument of a call expression or a constructor call
+expression.
+
+Given
+  void x(int, int, int) { int y; x(1, y, 42); }
+callExpr(hasAnyArgument(declRefExpr()))
+  matches x(1, y, 42)
+with hasAnyArgument(...)
+  matching y
+
+FIXME: Currently this will ignore parentheses and implicit casts on
+the argument before applying the inner matcher. We'll want to remove
+this to allow for greater control by the user once ignoreImplicit()
+has been implemented.
+
Matcher<CallExpr>hasArgumentunsigned N, Matcher<Expr> InnerMatcher
Matches the n'th argument of a call expression or a constructor
+call expression.
+
+Example matches y in x(y)
+    (matcher = callExpr(hasArgument(0, declRefExpr())))
+  void x(int) { int y; x(y); }
+
Matcher<CallExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<CaseStmt>hasCaseConstantMatcher<Expr> InnerMatcher
If the given case statement does not use the GNU case range
+extension, matches the constant given in the statement.
+
+Given
+  switch (1) { case 1: case 1+1: case 3 ... 4: ; }
+caseStmt(hasCaseConstant(integerLiteral()))
+  matches "case 1:"
+
Matcher<CastExpr>hasSourceExpressionMatcher<Expr> InnerMatcher
Matches if the cast's source expression matches the given matcher.
+
+Example: matches "a string" (matcher =
+                                 hasSourceExpression(cxxConstructExpr()))
+class URL { URL(string); };
+URL url = "a string";
+
Matcher<ClassTemplateSpecializationDecl>hasAnyTemplateArgumentMatcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations that have at least one
+TemplateArgument matching the given InnerMatcher.
+
+Given
+  template<typename T> class A {};
+  template<> class A<double> {};
+  A<int> a;
+classTemplateSpecializationDecl(hasAnyTemplateArgument(
+    refersToType(asString("int"))))
+  matches the specialization A<int>
+
Matcher<ClassTemplateSpecializationDecl>hasTemplateArgumentunsigned N, Matcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations where the n'th TemplateArgument
+matches the given InnerMatcher.
+
+Given
+  template<typename T, typename U> class A {};
+  A<bool, int> b;
+  A<int, bool> c;
+classTemplateSpecializationDecl(hasTemplateArgument(
+    1, refersToType(asString("int"))))
+  matches the specialization A<bool, int>
+
Matcher<ComplexTypeLoc>hasElementTypeLocMatcher<TypeLoc>
Matches arrays and C99 complex types that have a specific element
+type.
+
+Given
+  struct A {};
+  A a[7];
+  int b[7];
+arrayType(hasElementType(builtinType()))
+  matches "int b[7]"
+
+Usable as: Matcher<ArrayType>, Matcher<ComplexType>
+
Matcher<ComplexType>hasElementTypeMatcher<Type>
Matches arrays and C99 complex types that have a specific element
+type.
+
+Given
+  struct A {};
+  A a[7];
+  int b[7];
+arrayType(hasElementType(builtinType()))
+  matches "int b[7]"
+
+Usable as: Matcher<ArrayType>, Matcher<ComplexType>
+
Matcher<CompoundStmt>hasAnySubstatementMatcher<Stmt> InnerMatcher
Matches compound statements where at least one substatement matches
+a given matcher.
+
+Given
+  { {}; 1+2; }
+hasAnySubstatement(compoundStmt())
+  matches '{ {}; 1+2; }'
+with compoundStmt()
+  matching '{}'
+
Matcher<ConditionalOperator>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
+or conditional operator.
+
+Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
+  if (true) {}
+
Matcher<ConditionalOperator>hasFalseExpressionMatcher<Expr> InnerMatcher
Matches the false branch expression of a conditional operator.
+
+Example matches b
+  condition ? a : b
+
Matcher<ConditionalOperator>hasTrueExpressionMatcher<Expr> InnerMatcher
Matches the true branch expression of a conditional operator.
+
+Example matches a
+  condition ? a : b
+
Matcher<DecayedType>hasDecayedTypeMatcher<QualType> InnerType
Matches the decayed type, whos decayed type matches InnerMatcher
+
Matcher<DeclRefExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<DeclRefExpr>throughUsingDeclMatcher<UsingShadowDecl> InnerMatcher
Matches a DeclRefExpr that refers to a declaration through a
+specific using shadow declaration.
+
+Given
+  namespace a { void f() {} }
+  using a::f;
+  void g() {
+    f();     Matches this ..
+    a::f();  .. but not this.
+  }
+declRefExpr(throughUsingDecl(anything()))
+  matches f()
+
Matcher<DeclRefExpr>toMatcher<Decl> InnerMatcher
Matches a DeclRefExpr that refers to a declaration that matches the
+specified matcher.
+
+Example matches x in if(x)
+    (matcher = declRefExpr(to(varDecl(hasName("x")))))
+  bool x;
+  if (x) {}
+
Matcher<DeclStmt>containsDeclarationunsigned N, Matcher<Decl> InnerMatcher
Matches the n'th declaration of a declaration statement.
+
+Note that this does not work for global declarations because the AST
+breaks up multiple-declaration DeclStmt's into multiple single-declaration
+DeclStmt's.
+Example: Given non-global declarations
+  int a, b = 0;
+  int c;
+  int d = 2, e;
+declStmt(containsDeclaration(
+      0, varDecl(hasInitializer(anything()))))
+  matches only 'int d = 2, e;', and
+declStmt(containsDeclaration(1, varDecl()))
+  matches 'int a, b = 0' as well as 'int d = 2, e;'
+  but 'int c;' is not matched.
+
Matcher<DeclStmt>hasSingleDeclMatcher<Decl> InnerMatcher
Matches the Decl of a DeclStmt which has a single declaration.
+
+Given
+  int a, b;
+  int c;
+declStmt(hasSingleDecl(anything()))
+  matches 'int c;' but not 'int a, b;'.
+
Matcher<DeclaratorDecl>hasTypeLocMatcher<TypeLoc> Inner
Matches if the type location of the declarator decl's type matches
+the inner matcher.
+
+Given
+  int x;
+declaratorDecl(hasTypeLoc(loc(asString("int"))))
+  matches int x
+
Matcher<Decl>hasDeclContextMatcher<Decl> InnerMatcher
Matches declarations whose declaration context, interpreted as a
+Decl, matches InnerMatcher.
+
+Given
+  namespace N {
+    namespace M {
+      class D {};
+    }
+  }
+
+cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
+declaration of class D.
+
Matcher<DoStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
+a given body.
+
+Given
+  for (;;) {}
+hasBody(compoundStmt())
+  matches 'for (;;) {}'
+with compoundStmt()
+  matching '{}'
+
Matcher<DoStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
+or conditional operator.
+
+Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
+  if (true) {}
+
Matcher<ElaboratedType>hasQualifierMatcher<NestedNameSpecifier> InnerMatcher
Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
+matches InnerMatcher if the qualifier exists.
+
+Given
+  namespace N {
+    namespace M {
+      class D {};
+    }
+  }
+  N::M::D d;
+
+elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
+matches the type of the variable declaration of d.
+
Matcher<ElaboratedType>namesTypeMatcher<QualType> InnerMatcher
Matches ElaboratedTypes whose named type matches InnerMatcher.
+
+Given
+  namespace N {
+    namespace M {
+      class D {};
+    }
+  }
+  N::M::D d;
+
+elaboratedType(namesType(recordType(
+hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
+declaration of d.
+
Matcher<EnumType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<ExplicitCastExpr>hasDestinationTypeMatcher<QualType> InnerMatcher
Matches casts whose destination type matches a given matcher.
+
+(Note: Clang's AST refers to other conversions as "casts" too, and calls
+actual casts "explicit" casts.)
+
Matcher<Expr>hasTypeMatcher<Decl> InnerMatcher
Overloaded to match the declaration of the expression's or value
+declaration's type.
+
+In case of a value declaration (for example a variable declaration),
+this resolves one layer of indirection. For example, in the value
+declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
+X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
+declaration of x.
+
+Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
+            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
+ class X {};
+ void y(X &x) { x; X z; }
+
+Usable as: Matcher<Expr>, Matcher<ValueDecl>
+
Matcher<Expr>hasTypeMatcher<QualType> InnerMatcher
Matches if the expression's or declaration's type matches a type
+matcher.
+
+Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
+            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
+ class X {};
+ void y(X &x) { x; X z; }
+
Matcher<Expr>ignoringImpCastsMatcher<Expr> InnerMatcher
Matches expressions that match InnerMatcher after any implicit casts
+are stripped off.
+
+Parentheses and explicit casts are not discarded.
+Given
+  int arr[5];
+  int a = 0;
+  char b = 0;
+  const int c = a;
+  int *d = arr;
+  long e = (long) 0l;
+The matchers
+   varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
+   varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
+would match the declarations for a, b, c, and d, but not e.
+While
+   varDecl(hasInitializer(integerLiteral()))
+   varDecl(hasInitializer(declRefExpr()))
+only match the declarations for b, c, and d.
+
Matcher<Expr>ignoringParenCastsMatcher<Expr> InnerMatcher
Matches expressions that match InnerMatcher after parentheses and
+casts are stripped off.
+
+Implicit and non-C Style casts are also discarded.
+Given
+  int a = 0;
+  char b = (0);
+  void* c = reinterpret_cast<char*>(0);
+  char d = char(0);
+The matcher
+   varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
+would match the declarations for a, b, c, and d.
+while
+   varDecl(hasInitializer(integerLiteral()))
+only match the declaration for a.
+
Matcher<Expr>ignoringParenImpCastsMatcher<Expr> InnerMatcher
Matches expressions that match InnerMatcher after implicit casts and
+parentheses are stripped off.
+
+Explicit casts are not discarded.
+Given
+  int arr[5];
+  int a = 0;
+  char b = (0);
+  const int c = a;
+  int *d = (arr);
+  long e = ((long) 0l);
+The matchers
+   varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
+   varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
+would match the declarations for a, b, c, and d, but not e.
+while
+   varDecl(hasInitializer(integerLiteral()))
+   varDecl(hasInitializer(declRefExpr()))
+would only match the declaration for a.
+
Matcher<ForStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
+a given body.
+
+Given
+  for (;;) {}
+hasBody(compoundStmt())
+  matches 'for (;;) {}'
+with compoundStmt()
+  matching '{}'
+
Matcher<ForStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
+or conditional operator.
+
+Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
+  if (true) {}
+
Matcher<ForStmt>hasIncrementMatcher<Stmt> InnerMatcher
Matches the increment statement of a for loop.
+
+Example:
+    forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
+matches '++x' in
+    for (x; x < N; ++x) { }
+
Matcher<ForStmt>hasLoopInitMatcher<Stmt> InnerMatcher
Matches the initialization statement of a for loop.
+
+Example:
+    forStmt(hasLoopInit(declStmt()))
+matches 'int x = 0' in
+    for (int x = 0; x < N; ++x) { }
+
Matcher<FunctionDecl>hasAnyParameterMatcher<ParmVarDecl> InnerMatcher
Matches any parameter of a function declaration.
+
+Does not match the 'this' parameter of a method.
+
+Given
+  class X { void f(int x, int y, int z) {} };
+cxxMethodDecl(hasAnyParameter(hasName("y")))
+  matches f(int x, int y, int z) {}
+with hasAnyParameter(...)
+  matching int y
+
Matcher<FunctionDecl>hasParameterunsigned N, Matcher<ParmVarDecl> InnerMatcher
Matches the n'th parameter of a function declaration.
+
+Given
+  class X { void f(int x) {} };
+cxxMethodDecl(hasParameter(0, hasType(varDecl())))
+  matches f(int x) {}
+with hasParameter(...)
+  matching int x
+
Matcher<FunctionDecl>returnsMatcher<QualType> InnerMatcher
Matches the return type of a function declaration.
+
+Given:
+  class X { int f() { return 1; } };
+cxxMethodDecl(returns(asString("int")))
+  matches int f() { return 1; }
+
Matcher<IfStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
+or conditional operator.
+
+Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
+  if (true) {}
+
Matcher<IfStmt>hasConditionVariableStatementMatcher<DeclStmt> InnerMatcher
Matches the condition variable statement in an if statement.
+
+Given
+  if (A* a = GetAPointer()) {}
+hasConditionVariableStatement(...)
+  matches 'A* a = GetAPointer()'.
+
Matcher<IfStmt>hasElseMatcher<Stmt> InnerMatcher
Matches the else-statement of an if statement.
+
+Examples matches the if statement
+  (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true)))))
+  if (false) false; else true;
+
Matcher<IfStmt>hasThenMatcher<Stmt> InnerMatcher
Matches the then-statement of an if statement.
+
+Examples matches the if statement
+  (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true)))))
+  if (false) true; else false;
+
Matcher<ImplicitCastExpr>hasImplicitDestinationTypeMatcher<QualType> InnerMatcher
Matches implicit casts whose destination type matches a given
+matcher.
+
+FIXME: Unit test this matcher
+
Matcher<InjectedClassNameType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<LabelStmt>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<MemberExpr>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<MemberExpr>hasObjectExpressionMatcher<Expr> InnerMatcher
Matches a member expression where the object expression is
+matched by a given matcher.
+
+Given
+  struct X { int m; };
+  void f(X x) { x.m; m; }
+memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))))
+  matches "x.m" and "m"
+with hasObjectExpression(...)
+  matching "x" and the implicit object expression of "m" which has type X*.
+
Matcher<MemberExpr>memberMatcher<ValueDecl> InnerMatcher
Matches a member expression where the member is matched by a
+given matcher.
+
+Given
+  struct { int first, second; } first, second;
+  int i(second.first);
+  int j(first.second);
+memberExpr(member(hasName("first")))
+  matches second.first
+  but not first.second (because the member name there is "second").
+
Matcher<MemberPointerTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<MemberPointerType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<NestedNameSpecifierLoc>hasPrefixMatcher<NestedNameSpecifierLoc> InnerMatcher
Matches on the prefix of a NestedNameSpecifierLoc.
+
+Given
+  struct A { struct B { struct C {}; }; };
+  A::B::C c;
+nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
+  matches "A::"
+
Matcher<NestedNameSpecifierLoc>specifiesTypeLocMatcher<TypeLoc> InnerMatcher
Matches nested name specifier locs that specify a type matching the
+given TypeLoc.
+
+Given
+  struct A { struct B { struct C {}; }; };
+  A::B::C c;
+nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
+  hasDeclaration(cxxRecordDecl(hasName("A")))))))
+  matches "A::"
+
Matcher<NestedNameSpecifier>hasPrefixMatcher<NestedNameSpecifier> InnerMatcher
Matches on the prefix of a NestedNameSpecifier.
+
+Given
+  struct A { struct B { struct C {}; }; };
+  A::B::C c;
+nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
+  matches "A::"
+
Matcher<NestedNameSpecifier>specifiesNamespaceMatcher<NamespaceDecl> InnerMatcher
Matches nested name specifiers that specify a namespace matching the
+given namespace matcher.
+
+Given
+  namespace ns { struct A {}; }
+  ns::A a;
+nestedNameSpecifier(specifiesNamespace(hasName("ns")))
+  matches "ns::"
+
Matcher<NestedNameSpecifier>specifiesTypeMatcher<QualType> InnerMatcher
Matches nested name specifiers that specify a type matching the
+given QualType matcher without qualifiers.
+
+Given
+  struct A { struct B { struct C {}; }; };
+  A::B::C c;
+nestedNameSpecifier(specifiesType(
+  hasDeclaration(cxxRecordDecl(hasName("A")))
+))
+  matches "A::"
+
Matcher<ObjCMessageExpr>hasArgumentunsigned N, Matcher<Expr> InnerMatcher
Matches the n'th argument of a call expression or a constructor
+call expression.
+
+Example matches y in x(y)
+    (matcher = callExpr(hasArgument(0, declRefExpr())))
+  void x(int) { int y; x(y); }
+
Matcher<ObjCMessageExpr>hasReceiverTypeMatcher<QualType> InnerMatcher
Matches on the receiver of an ObjectiveC Message expression.
+
+Example
+matcher = objCMessageExpr(hasRecieverType(asString("UIWebView *")));
+matches the [webView ...] message invocation.
+  NSString *webViewJavaScript = ...
+  UIWebView *webView = ...
+  [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
+
Matcher<ParenType>innerTypeMatcher<Type>
Matches ParenType nodes where the inner type is a specific type.
+
+Given
+  int (*ptr_to_array)[4];
+  int (*ptr_to_func)(int);
+
+varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
+ptr_to_func but not ptr_to_array.
+
+Usable as: Matcher<ParenType>
+
Matcher<PointerTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<PointerType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<QualType>hasCanonicalTypeMatcher<QualType> InnerMatcher
Matches QualTypes whose canonical type matches InnerMatcher.
+
+Given:
+  typedef int &int_ref;
+  int a;
+  int_ref b = a;
+
+varDecl(hasType(qualType(referenceType()))))) will not match the
+declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
+
Matcher<QualType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<QualType>pointsToMatcher<Decl> InnerMatcher
Overloaded to match the pointee type's declaration.
+
Matcher<QualType>pointsToMatcher<QualType> InnerMatcher
Matches if the matched type is a pointer type and the pointee type
+matches the specified matcher.
+
+Example matches y->x()
+  (matcher = cxxMemberCallExpr(on(hasType(pointsTo
+     cxxRecordDecl(hasName("Y")))))))
+  class Y { public: void x(); };
+  void z() { Y *y; y->x(); }
+
Matcher<QualType>referencesMatcher<Decl> InnerMatcher
Overloaded to match the referenced type's declaration.
+
Matcher<QualType>referencesMatcher<QualType> InnerMatcher
Matches if the matched type is a reference type and the referenced
+type matches the specified matcher.
+
+Example matches X &x and const X &y
+    (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X"))))))
+  class X {
+    void a(X b) {
+      X &x = b;
+      const X &y = b;
+    }
+  };
+
Matcher<RecordType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<ReferenceTypeLoc>pointeeLocMatcher<TypeLoc>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<ReferenceType>pointeeMatcher<Type>
Narrows PointerType (and similar) matchers to those where the
+pointee matches a given matcher.
+
+Given
+  int *a;
+  int const *b;
+  float const *f;
+pointerType(pointee(isConstQualified(), isInteger()))
+  matches "int const *b"
+
+Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
+  Matcher<PointerType>, Matcher<ReferenceType>
+
Matcher<Stmt>alignOfExprMatcher<UnaryExprOrTypeTraitExpr>  InnerMatcher
Same as unaryExprOrTypeTraitExpr, but only matching
+alignof.
+
Matcher<Stmt>sizeOfExprMatcher<UnaryExprOrTypeTraitExpr>  InnerMatcher
Same as unaryExprOrTypeTraitExpr, but only matching
+sizeof.
+
Matcher<SwitchStmt>forEachSwitchCaseMatcher<SwitchCase> InnerMatcher
Matches each case or default statement belonging to the given switch
+statement. This matcher may produce multiple matches.
+
+Given
+  switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
+switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
+  matches four times, with "c" binding each of "case 1:", "case 2:",
+"case 3:" and "case 4:", and "s" respectively binding "switch (1)",
+"switch (1)", "switch (2)" and "switch (2)".
+
Matcher<TagType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<TemplateArgument>isExprMatcher<Expr> InnerMatcher
Matches a sugar TemplateArgument that refers to a certain expression.
+
+Given
+  template<typename T> struct A {};
+  struct B { B* next; };
+  A<&B::next> a;
+templateSpecializationType(hasAnyTemplateArgument(
+  isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
+  matches the specialization A<&B::next> with fieldDecl(...) matching
+    B::next
+
Matcher<TemplateArgument>refersToDeclarationMatcher<Decl> InnerMatcher
Matches a canonical TemplateArgument that refers to a certain
+declaration.
+
+Given
+  template<typename T> struct A {};
+  struct B { B* next; };
+  A<&B::next> a;
+classTemplateSpecializationDecl(hasAnyTemplateArgument(
+    refersToDeclaration(fieldDecl(hasName("next"))))
+  matches the specialization A<&B::next> with fieldDecl(...) matching
+    B::next
+
Matcher<TemplateArgument>refersToIntegralTypeMatcher<QualType> InnerMatcher
Matches a TemplateArgument that referes to an integral type.
+
+Given
+  template<int T> struct A {};
+  C<42> c;
+classTemplateSpecializationDecl(
+  hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
+  matches the implicit instantiation of C in C<42>.
+
Matcher<TemplateArgument>refersToTypeMatcher<QualType> InnerMatcher
Matches a TemplateArgument that refers to a certain type.
+
+Given
+  struct X {};
+  template<typename T> struct A {};
+  A<X> a;
+classTemplateSpecializationDecl(hasAnyTemplateArgument(
+    refersToType(class(hasName("X")))))
+  matches the specialization A<X>
+
Matcher<TemplateSpecializationType>hasAnyTemplateArgumentMatcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations that have at least one
+TemplateArgument matching the given InnerMatcher.
+
+Given
+  template<typename T> class A {};
+  template<> class A<double> {};
+  A<int> a;
+classTemplateSpecializationDecl(hasAnyTemplateArgument(
+    refersToType(asString("int"))))
+  matches the specialization A<int>
+
Matcher<TemplateSpecializationType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<TemplateSpecializationType>hasTemplateArgumentunsigned N, Matcher<TemplateArgument> InnerMatcher
Matches classTemplateSpecializations where the n'th TemplateArgument
+matches the given InnerMatcher.
+
+Given
+  template<typename T, typename U> class A {};
+  A<bool, int> b;
+  A<int, bool> c;
+classTemplateSpecializationDecl(hasTemplateArgument(
+    1, refersToType(asString("int"))))
+  matches the specialization A<bool, int>
+
Matcher<TemplateTypeParmType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<T>findAllMatcher<T>  Matcher
Matches if the node or any descendant matches.
+
+Generates results for each match.
+
+For example, in:
+  class A { class B {}; class C {}; };
+The matcher:
+  cxxRecordDecl(hasName("::A"),
+                findAll(cxxRecordDecl(isDefinition()).bind("m")))
+will generate results for A, B and C.
+
+Usable as: Any Matcher
+
Matcher<TypedefType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<UnaryExprOrTypeTraitExpr>hasArgumentOfTypeMatcher<QualType> InnerMatcher
Matches unary expressions that have a specific type of argument.
+
+Given
+  int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
+unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
+  matches sizeof(a) and alignof(c)
+
Matcher<UnaryOperator>hasUnaryOperandMatcher<Expr> InnerMatcher
Matches if the operand of a unary operator matches.
+
+Example matches true (matcher = hasUnaryOperand(
+                                  cxxBoolLiteral(equals(true))))
+  !true
+
Matcher<UnresolvedUsingType>hasDeclarationMatcher<Decl>  InnerMatcher
Matches a node if the declaration associated with that node
+matches the given matcher.
+
+The associated declaration is:
+- for type nodes, the declaration of the underlying type
+- for CallExpr, the declaration of the callee
+- for MemberExpr, the declaration of the referenced member
+- for CXXConstructExpr, the declaration of the constructor
+
+Also usable as Matcher<T> for any T supporting the getDecl() member
+function. e.g. various subtypes of clang::Type and various expressions.
+
+Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
+  Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
+  Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
+  Matcher<RecordType>, Matcher<TagType>,
+  Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
+  Matcher<TypedefType>, Matcher<UnresolvedUsingType>
+
Matcher<UsingDecl>hasAnyUsingShadowDeclMatcher<UsingShadowDecl> InnerMatcher
Matches any using shadow declaration.
+
+Given
+  namespace X { void b(); }
+  using X::b;
+usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
+  matches using X::b 
Matcher<UsingShadowDecl>hasTargetDeclMatcher<NamedDecl> InnerMatcher
Matches a using shadow declaration where the target declaration is
+matched by the given matcher.
+
+Given
+  namespace X { int a; void b(); }
+  using X::a;
+  using X::b;
+usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
+  matches using X::b but not using X::a 
Matcher<ValueDecl>hasTypeMatcher<Decl> InnerMatcher
Overloaded to match the declaration of the expression's or value
+declaration's type.
+
+In case of a value declaration (for example a variable declaration),
+this resolves one layer of indirection. For example, in the value
+declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
+X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
+declaration of x.
+
+Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
+            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
+ class X {};
+ void y(X &x) { x; X z; }
+
+Usable as: Matcher<Expr>, Matcher<ValueDecl>
+
Matcher<ValueDecl>hasTypeMatcher<QualType> InnerMatcher
Matches if the expression's or declaration's type matches a type
+matcher.
+
+Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
+            and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
+ class X {};
+ void y(X &x) { x; X z; }
+
Matcher<VarDecl>hasInitializerMatcher<Expr> InnerMatcher
Matches a variable declaration that has an initializer expression
+that matches the given matcher.
+
+Example matches x (matcher = varDecl(hasInitializer(callExpr())))
+  bool y() { return true; }
+  bool x = y();
+
Matcher<VariableArrayType>hasSizeExprMatcher<Expr> InnerMatcher
Matches VariableArrayType nodes that have a specific size
+expression.
+
+Given
+  void f(int b) {
+    int a[b];
+  }
+variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
+  varDecl(hasName("b")))))))
+  matches "int a[b]"
+
Matcher<WhileStmt>hasBodyMatcher<Stmt> InnerMatcher
Matches a 'for', 'while', or 'do while' statement that has
+a given body.
+
+Given
+  for (;;) {}
+hasBody(compoundStmt())
+  matches 'for (;;) {}'
+with compoundStmt()
+  matching '{}'
+
Matcher<WhileStmt>hasConditionMatcher<Expr> InnerMatcher
Matches the condition expression of an if statement, for loop,
+or conditional operator.
+
+Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
+  if (true) {}
+
Matcher<internal::BindableMatcher<NestedNameSpecifierLoc>>locMatcher<NestedNameSpecifier> InnerMatcher
Matches NestedNameSpecifierLocs for which the given inner
+NestedNameSpecifier-matcher matches.
+
Matcher<internal::BindableMatcher<TypeLoc>>locMatcher<QualType> InnerMatcher
Matches TypeLocs for which the given inner
+QualType-matcher matches.
+

 

 
diff --git a/docs/tools/dump_ast_matchers.py b/docs/tools/dump_ast_matchers.py
index 5812f86e6f..9ecff049c9 100644
--- a/docs/tools/dump_ast_matchers.py
+++ b/docs/tools/dump_ast_matchers.py
@@ -364,6 +364,6 @@ reference = re.sub(r'',
 reference = re.sub(r'',
                    '%s', reference, flags=re.S) % traversal_matcher_table
 
-with open('../LibASTMatchersReference.html', 'w') as output:
+with open('../LibASTMatchersReference.html', 'wb') as output:
   output.write(reference)
 
diff --git a/docs/tools/dump_format_style.py b/docs/tools/dump_format_style.py
index 54760529ea..b61d2017d0 100755
--- a/docs/tools/dump_format_style.py
+++ b/docs/tools/dump_format_style.py
@@ -188,6 +188,6 @@ contents = open(DOC_FILE).read()
 
 contents = substitute(contents, 'FORMAT_STYLE_OPTIONS', options_text)
 
-with open(DOC_FILE, 'w') as output:
+with open(DOC_FILE, 'wb') as output:
   output.write(contents)