AST Matcher Reference

Matches C++ access specifier declarations.

Given
  class C {
  public:
    int a;
  };
accessSpecDecl()
  matches 'public:'

Matches C++ class template declarations.

Example matches Z
  template<class T> class Z {};

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>

Matches C++ constructor declarations.

Example matches Foo::Foo() and Foo::Foo(int)
  class Foo {
   public:
    Foo();
    Foo(int);
    int DoSomething();
  };

Matches declarations.

Examples matches X, C, and the friend declaration inside C;
  void X();
  class C {
    friend X;
  };

Matches explicit C++ destructor declarations.

Example matches Foo::~Foo()
  class Foo {
   public:
    virtual ~Foo();
  };

Matches enum constants.

Example matches A, B, C
  enum X {
    A, B, C
  };

Matches enum declarations.

Example matches X
  enum X {
    A, B, C
  };

Matches field declarations.

Given
  class X { int m; };
fieldDecl()
  matches 'm'.

Matches function declarations.

Example matches f
  void f();

Matches C++ function template declarations.

Example matches f
  template<class T> void f(T t) {}

Matches method declarations.

Example matches y
  class X { void y() };

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;
  };

Matches C++ class declarations.

Example matches X, Z
  class X;
  template<class T> class Z {};

Matches using declarations.

Given
  namespace X { int x; }
  using X::x;
usingDecl()
  matches using X::x 

Matches variable declarations.

Note: this does not match declarations of member variables, which are
"field" declarations in Clang parlance.

Example matches a
  int a;

Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.

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::"

Matches QualTypes in the clang AST.

Matches array subscript expressions.

Given
  int i = a[1];
arraySubscriptExpr()
  matches "a[1]"

Matches asm statements.

 int i = 100;
  __asm("mov al, 2");
asmStmt()
  matches '__asm("mov al, 2")'

Matches binary operator expressions.

Example matches a || b
  !(a || b)

Matches nodes where temporaries are created.

Example matches FunctionTakesString(GetStringByValue())
    (matcher = bindTemporaryExpr())
  FunctionTakesString(GetStringByValue());
  FunctionTakesStringByPointer(GetStringPointer());

Matches bool literals.

Example matches true
  true

Matches break statements.

Given
  while (true) { break; }
breakStmt()
  matches 'break'

Matches a C-style cast expression.

Example: Matches (int*) 2.2f in
  int i = (int) 2.2f;

Matches call expressions.

Example matches x.y() and y()
  X x;
  x.y();
  y();

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;

Matches catch statements.

  try {} catch(int i) {}
catchStmt()
  matches 'catch(int i)'

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';

Matches compound (i.e. non-scalar) literals

Example match: {1}, (1, 2)
  int array[4] = {1}; vector int myvec = (vector int)(1, 2);

Matches compound statements.

Example matches '{}' and '{{}}'in 'for (;;) {{}}'
  for (;;) {{}}

Matches conditional operator expressions.

Example matches a ? b : c
  (a ? b : c) + 42

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);

Matches constructor call expressions (including implicit ones).

Example matches string(ptr, n) and ptr within arguments of f
    (matcher = constructExpr())
  void f(const string &a, const string &b);
  char *ptr;
  int n;
  f(string(ptr, n), ptr);

Matches continue statements.

Given
  while (true) { continue; }
continueStmt()
  matches 'continue'

Matches expressions that refer to declarations.

Example matches x in if (x)
  bool x;
  if (x) {}

Matches declaration statements.

Given
  int a;
declStmt()
  matches 'int a'.

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 = defaultArgExpr())
  void f(int x, int y = 0);
  f(42);

Matches delete expressions.

Given
  delete X;
deleteExpr()
  matches 'delete X'.

Matches do statements.

Given
  do {} while (true);
doStmt()
  matches 'do {} while(true)'

Matches a dynamic_cast expression.

Example:
  dynamicCastExpr()
matches
  dynamic_cast<D*>(&b);
in
  struct B { virtual ~B() {} }; struct D : B {};
  B b;
  D* p = dynamic_cast<D*>(&b);

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;

Matches expressions.

Example matches x()
  void f() { x(); }

Matches range-based for statements.

forRangeStmt() matches 'for (auto a : i)'
  int i[] =  {1, 2, 3}; for (auto a : i);
  for(int j = 0; j < 5; ++j);

Matches for statements.

Example matches 'for (;;) {}'
  for (;;) {}
  int i[] =  {1, 2, 3}; for (auto a : i);

Matches functional cast expressions

Example: Matches Foo(bar);
  Foo f = bar;
  Foo g = (Foo) bar;
  Foo h = Foo(bar);

Matches goto statements.

Given
  goto FOO;
  FOO: bar();
gotoStmt()
  matches 'goto FOO'

Matches if statements.

Example matches 'if (x) {}'
  if (x) {}

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.

Matches init list expressions.

Given
  int a[] = { 1, 2 };
  struct B { int x, y; };
  B b = { 5, 6 };
initList()
  matches "{ 1, 2 }" and "{ 5, 6 }"

Matches integer literals of all sizes encodings.

Not matching character-encoded integers such as L'a'.

Example matches 1, 1L, 0x1, 1U

Matches label statements.

Given
  goto FOO;
  FOO: bar();
labelStmt()
  matches 'FOO:'

Matches lambda expressions.

Example matches [&](){return 5;}
  [&](){return 5;}

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();

Matches member call expressions.

Example matches x.y()
  X x;
  x.y();

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

Matches new expressions.

Given
  new X;
newExpr()
  matches 'new X'.

Matches nullptr literal.

Matches null statements.

  foo();;
nullStmt()
  matches the second ';'

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 = operatorCallExpr())
  ostream &operator<< (ostream &out, int i) { };
  ostream &o; int b = 1, c = 1;
  o << b << c;

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);

Matches return statements.

Given
  return 1;
returnStmt()
  matches 'return 1'

Matches a C++ static_cast expression.

hasDestinationType
reinterpretCast

Example:
  staticCastExpr()
matches
  static_cast<long>(8)
in
  long eight(static_cast<long>(8));

Matches statements.

Given
  { ++a; }
stmt()
  matches both the compound statement '{ ++a; }' and '++a'.

Matches string literals (also matches wide string literals).

Example matches "abcd", L"abcd"
  char *s = "abcd"; wchar_t *ws = L"abcd"

Matches case and default statements inside switch statements.

Given
  switch(a) { case 42: break; default: break; }
switchCase()
  matches 'case 42: break;' and 'default: break;'.

Matches switch statements.

Given
  switch(a) { case 42: break; default: break; }
switchStmt()
  matches 'switch(a)'.

Matches implicit and explicit this expressions.

Example matches the implicit this expression in "return i".
    (matcher = thisExpr())
struct foo {
  int i;
  int f() { return i; }
};

Matches throw expressions.

  try { throw 5; } catch(int i) {}
throwExpr()
  matches 'throw 5'

Matches try statements.

  try {} catch(int i) {}
tryStmt()
  matches 'try {}'

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)

Matches unary operator expressions.

Example matches !a
  !a || b

Matches user defined literal operator call.

Example match: "foo"_suffix

Matches while statements.

Given
  while (true) {}
whileStmt()
  matches 'while (true) {}'.

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]]";

Matches atomic types.

Given
  _Atomic(int) i;
atomicType()
  matches "_Atomic(int) i"

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"

Matches block pointer types, i.e. types syntactically represented as
"void (^)(int)".

The pointee is always required to be a FunctionType.

Matches builtin Types.

Given
  struct A {};
  A a;
  int b;
  float c;
  bool d;
builtinType()
  matches "int b", "float c" and "bool d"

Matches C99 complex types.

Given
  _Complex float f;
complexType()
  matches "_Complex float f"

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]"

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]"

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.

Matches FunctionType nodes.

Given
  int (*f)(int);
  void g();
functionType()
  matches "int (*f)(int)" and the type of "g".

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[]"

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.

Matches member pointer types.
Given
  struct A { int i; }
  A::* ptr = A::i;
memberPointerType()
  matches "A::* ptr"

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.

Matches pointer types.

Given
  int *a;
  int &b = *a;
  int c = 5;
pointerType()
  matches "int *a"

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.

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.

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.

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.

Matches TypeLocs in the clang AST.

Matches typedef types.

Given
  typedef int X;
typedefType()
  matches "typedef int X"

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]]"

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]]";

Matches atomic types.

Given
  _Atomic(int) i;
atomicType()
  matches "_Atomic(int) i"

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"

Matches block pointer types, i.e. types syntactically represented as
"void (^)(int)".

The pointee is always required to be a FunctionType.

Matches builtin Types.

Given
  struct A {};
  A a;
  int b;
  float c;
  bool d;
builtinType()
  matches "int b", "float c" and "bool d"

Matches C99 complex types.

Given
  _Complex float f;
complexType()
  matches "_Complex float f"

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]"

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]"

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.

Matches FunctionType nodes.

Given
  int (*f)(int);
  void g();
functionType()
  matches "int (*f)(int)" and the type of "g".

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[]"

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.

Matches member pointer types.
Given
  struct A { int i; }
  A::* ptr = A::i;
memberPointerType()
  matches "A::* ptr"

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.

Matches pointer types.

Given
  int *a;
  int &b = *a;
  int c = 5;
pointerType()
  matches "int *a"

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.

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.

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.

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.

Matches Types in the clang AST.

Matches typedef types.

Given
  typedef int X;
typedefType()
  matches "typedef int X"

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]]"

Matches if all given matchers match.

Usable as: Any Matcher

Matches if any of the given matchers matches.

Usable as: Any Matcher

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

Matches if the provided matcher does not match.

Example matches Y (matcher = recordDecl(unless(hasName("X"))))
  class X {};
  class Y {};

Usable as: Any Matcher

Matches the operator Name of operator expressions (binary or
unary).

Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
  !(a || b)

Matches literals that are equal to the given value.

Example matches true (matcher = boolLiteral(equals(true)))
  true

Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>

Matches a constructor declaration that has been implicitly added
by the compiler (eg. implicit defaultcopy constructors).

Matches a contructor 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_;
  };
constructorDecl(hasAnyConstructorInitializer(isWritten()))
  will match Foo(int), but not Foo()

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

operatorCallExpr(hasOverloadedOperatorName("<<"))) matches the specified
line and recordDecl(hasMethod(hasOverloadedOperatorName("*"))) matches
the declaration of A.

Usable as: Matcher<CXXOperatorCallExpr>, Matcher<CXXMethodDecl>

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

Matches if the given method declaration is virtual.

Given
  class A {
   public:
    virtual void x();
  };
  matches A::x

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

operatorCallExpr(hasOverloadedOperatorName("<<"))) matches the specified
line and recordDecl(hasMethod(hasOverloadedOperatorName("*"))) matches
the declaration of A.

Usable as: Matcher<CXXOperatorCallExpr>, Matcher<CXXMethodDecl>

Overloaded method as shortcut for isDerivedFrom(hasName(...)).

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>

Overloaded method as shortcut for
isSameOrDerivedFrom(hasName(...)).

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>;
recordDecl(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;
recordDecl(hasName("::X"), isTemplateInstantiation())
  does not match, as X<A> is an explicit template specialization.

Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>

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);

Matches literals that are equal to the given value.

Example matches true (matcher = boolLiteral(equals(true)))
  true

Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>

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.

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]"

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;'.

Matches if a node equals another node.

Decl has pointer identity in the AST.

Matches private C++ declarations.

Given
  class C {
  public:    int a;
  protected: int b;
  private:   int c;
  };
fieldDecl(isPrivate())
  matches 'int c;' 

Matches protected C++ declarations.

Given
  class C {
  public:    int a;
  protected: int b;
  private:   int c;
  };
fieldDecl(isProtected())
  matches 'int b;' 

Matches public C++ declarations.

Given
  class C {
  public:    int a;
  protected: int b;
  private:   int c;
  };
fieldDecl(isPublic())
  matches 'int a;' 

Matches literals that are equal to the given value.

Example matches true (matcher = boolLiteral(equals(true)))
  true

Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>

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>

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>

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

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>;
recordDecl(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;
recordDecl(hasName("::X"), isTemplateInstantiation())
  does not match, as X<A> is an explicit template specialization.

Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>

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) {}

Matches literals that are equal to the given value.

Example matches true (matcher = boolLiteral(equals(true)))
  true

Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
           Matcher<FloatingLiteral>, Matcher<IntegerLiteral>

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

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; } }

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; } }

Matches if the matched type is represented by the given string.

Given
  class Y { public: void x(); };
  void z() { Y* y; y->x(); }
callExpr(on(hasType(asString("class Y *"))))
  matches y->x()

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.

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 *".

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)".

Matches if a node equals another node.

Stmt has pointer identity in the AST.

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>

Matches unary expressions of a certain kind.

Given
  int x;
  int s = sizeof(x) + alignof(x)
unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
  matches sizeof(x)

Matches the operator Name of operator expressions (binary or
unary).

Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
  !(a || b)

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>

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>

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>;
recordDecl(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;
recordDecl(hasName("::X"), isTemplateInstantiation())
  does not match, as X<A> is an explicit template specialization.

Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>

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:
  recordDecl(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

Matches if the node or any descendant matches.

Generates results for each match.

For example, in:
  class A { class B {}; class C {}; };
The matcher:
  recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("m")))
will generate results for A, B and C.

Usable as: Any Matcher

Matches AST nodes that have child AST nodes that match the
provided matcher.

Example matches X, Y (matcher = recordDecl(forEach(recordDecl(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

Matches AST nodes that have descendant AST nodes that match the
provided matcher.

Example matches X, A, B, C
    (matcher = recordDecl(forEachDescendant(recordDecl(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:
  recordDecl(forEachDescendant(recordDecl(forEachDescendant(recordDecl()))))
will match 10 times (plus injected class name matches) on:
  class A { class B { class C { class D { class E {}; }; }; }; };

Usable as: Any Matcher

Matches AST nodes that have child AST nodes that match the
provided matcher.

Example matches X, Y (matcher = recordDecl(has(recordDecl(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

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

Matches AST nodes that have descendant AST nodes that match the
provided matcher.

Example matches X, Y, Z
    (matcher = recordDecl(hasDescendant(recordDecl(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

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

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

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

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>

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>

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>

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>

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>

Matches if either the left hand side or the right hand side of a
binary operator matches.

Matches the left hand side of binary operator expressions.

Example matches a (matcher = binaryOperator(hasLHS()))
  a || b

Matches the right hand side of binary operator expressions.

Example matches b (matcher = binaryOperator(hasRHS()))
  a || b

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>

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>

Matches a type if the declaration of the type matches the given
matcher.

In addition to being usable as Matcher<TypedefType>, also usable as
Matcher<T> for any T supporting the getDecl() member function. e.g. various
subtypes of clang::Type.

Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>,
  Matcher<MemberExpr>, Matcher<TypedefType>,
  Matcher<TemplateSpecializationType>

Matches a constructor initializer.

Given
  struct Foo {
    Foo() : foo_(1) { }
    int foo_;
  };
recordDecl(has(constructorDecl(hasAnyConstructorInitializer(anything()))))
  record matches Foo, hasAnyConstructorInitializer matches foo_(1)

Matches the field declaration of a constructor initializer.

Given
  struct Foo {
    Foo() : foo_(1) { }
    int foo_;
  };
recordDecl(has(constructorDecl(hasAnyConstructorInitializer(
    forField(hasName("foo_"))))))
  matches Foo
with forField matching foo_

Matches the initializer expression of a constructor initializer.

Given
  struct Foo {
    Foo() : foo_(1) { }
    int foo_;
  };
recordDecl(has(constructorDecl(hasAnyConstructorInitializer(
    withInitializer(integerLiteral(equals(1)))))))
  matches Foo
with withInitializer matching (1)

Matches on the implicit object argument of a member call expression.

Example matches y.x() (matcher = callExpr(on(hasType(recordDecl(hasName("Y"))))))
  class Y { public: void x(); };
  void z() { Y y; y.x(); }",

FIXME: Overload to allow directly matching types?

Overloaded to match the type's declaration.

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 = constructExpr(hasDeclaration(methodDecl(
        ofClass(hasName("A"))))))
  class A {
   public:
    A();
  };
  A a = A();

Matches the first method of a class or struct that satisfies InnerMatcher.

Given:
  class A { void func(); };
  class B { void member(); };

recordDecl(hasMethod(hasName("func"))) matches the declaration of A
but not B.

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

Similar to isDerivedFrom(), but also matches classes that directly
match Base.

Matches if the call expression's callee's declaration matches the
given matcher.

Example matches y.x() (matcher = callExpr(callee(methodDecl(hasName("x")))))
  class Y { public: void x(); };
  void z() { Y y; y.x();

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

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); }

Matches a type if the declaration of the type matches the given
matcher.

In addition to being usable as Matcher<TypedefType>, also usable as
Matcher<T> for any T supporting the getDecl() member function. e.g. various
subtypes of clang::Type.

Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>,
  Matcher<MemberExpr>, Matcher<TypedefType>,
  Matcher<TemplateSpecializationType>

Matches if the cast's source expression matches the given matcher.

Example: matches "a string" (matcher =
                                 hasSourceExpression(constructExpr()))
class URL { URL(string); };
URL url = "a string";

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>

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>

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>

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>

Matches compound statements where at least one substatement matches
a given matcher.

Given
  { {}; 1+2; }
hasAnySubstatement(compoundStmt())
  matches '{ {}; 1+2; }'
with compoundStmt()
  matching '{}'

Matches the condition expression of an if statement, for loop,
or conditional operator.

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

Matches the false branch expression of a conditional operator.

Example matches b
  condition ? a : b

Matches the true branch expression of a conditional operator.

Example matches a
  condition ? a : b

Matches a DeclRefExpr that refers to a declaration through a
specific using shadow declaration.

FIXME: This currently only works for functions. Fix.

Given
  namespace a { void f() {} }
  using a::f;
  void g() {
    f();     Matches this ..
    a::f();  .. but not this.
  }
declRefExpr(throughUsingDeclaration(anything()))
  matches f()

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) {}

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.

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;'.

Matches declarations whose declaration context, interpreted as a
Decl, matches InnerMatcher.

Given
  namespace N {
    namespace M {
      class D {};
    }
  }

recordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
declaration of class D.

Matches a 'for', 'while', or 'do while' statement that has
a given body.

Given
  for (;;) {}
hasBody(compoundStmt())
  matches 'for (;;) {}'
with compoundStmt()
  matching '{}'

Matches the condition expression of an if statement, for loop,
or conditional operator.

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

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.

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.

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.)

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;", recordDecl(hasName("X")) matches the declaration of X,
while varDecl(hasType(recordDecl(hasName("X")))) matches the declaration
of x."

Example matches x (matcher = expr(hasType(recordDecl(hasName("X")))))
            and z (matcher = varDecl(hasType(recordDecl(hasName("X")))))
 class X {};
 void y(X &x) { x; X z; }

Usable as: Matcher<Expr>, Matcher<ValueDecl>

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.

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.

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.

Matches a 'for', 'while', or 'do while' statement that has
a given body.

Given
  for (;;) {}
hasBody(compoundStmt())
  matches 'for (;;) {}'
with compoundStmt()
  matching '{}'

Matches the condition expression of an if statement, for loop,
or conditional operator.

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

Matches the increment statement of a for loop.

Example:
    forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
matches '++x' in
    for (x; x < N; ++x) { }

Matches the initialization statement of a for loop.

Example:
    forStmt(hasLoopInit(declStmt()))
matches 'int x = 0' in
    for (int x = 0; x < N; ++x) { }

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) {} };
methodDecl(hasAnyParameter(hasName("y")))
  matches f(int x, int y, int z) {}
with hasAnyParameter(...)
  matching int y

Matches the n'th parameter of a function declaration.

Given
  class X { void f(int x) {} };
methodDecl(hasParameter(0, hasType(varDecl())))
  matches f(int x) {}
with hasParameter(...)
  matching int x

Matches the return type of a function declaration.

Given:
  class X { int f() { return 1; } };
methodDecl(returns(asString("int")))
  matches int f() { return 1; }

Matches the condition expression of an if statement, for loop,
or conditional operator.

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

Matches the condition variable statement in an if statement.

Given
  if (A* a = GetAPointer()) {}
hasConditionVariableStatment(...)
  matches 'A* a = GetAPointer()'.

Matches implicit casts whose destination type matches a given
matcher.

FIXME: Unit test this matcher

Matches a type if the declaration of the type matches the given
matcher.

In addition to being usable as Matcher<TypedefType>, also usable as
Matcher<T> for any T supporting the getDecl() member function. e.g. various
subtypes of clang::Type.

Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>,
  Matcher<MemberExpr>, Matcher<TypedefType>,
  Matcher<TemplateSpecializationType>

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(recordDecl(hasName("X")))))))
  matches "x.m" and "m"
with hasObjectExpression(...)
  matching "x" and the implicit object expression of "m" which has type X*.

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").

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>

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>

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::"

Matches NestedNameSpecifierLocs for which the given inner
NestedNameSpecifier-matcher matches.

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(recordDecl(hasName("A")))))))
  matches "A::"

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::"

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::"

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(recordDecl(hasName("A")))))
  matches "A::"

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>

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>

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>

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.

Matches a type if the declaration of the type matches the given
matcher.

In addition to being usable as Matcher<TypedefType>, also usable as
Matcher<T> for any T supporting the getDecl() member function. e.g. various
subtypes of clang::Type.

Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>,
  Matcher<MemberExpr>, Matcher<TypedefType>,
  Matcher<TemplateSpecializationType>

Overloaded to match the pointee type's declaration.

Overloaded to match the referenced type's declaration.

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>

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>

Same as unaryExprOrTypeTraitExpr, but only matching
alignof.

Same as unaryExprOrTypeTraitExpr, but only matching
sizeof.

Matches a 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

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>

Matches a type if the declaration of the type matches the given
matcher.

In addition to being usable as Matcher<TypedefType>, also usable as
Matcher<T> for any T supporting the getDecl() member function. e.g. various
subtypes of clang::Type.

Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>,
  Matcher<MemberExpr>, Matcher<TypedefType>,
  Matcher<TemplateSpecializationType>

Matches TypeLocs for which the given inner
QualType-matcher matches.

Matches a type if the declaration of the type matches the given
matcher.

In addition to being usable as Matcher<TypedefType>, also usable as
Matcher<T> for any T supporting the getDecl() member function. e.g. various
subtypes of clang::Type.

Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>,
  Matcher<MemberExpr>, Matcher<TypedefType>,
  Matcher<TemplateSpecializationType>

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)

Matches if the operand of a unary operator matches.

Example matches true (matcher = hasUnaryOperand(boolLiteral(equals(true))))
  !true

Matches any using shadow declaration.

Given
  namespace X { void b(); }
  using X::b;
usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
  matches using X::b 

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 

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;", recordDecl(hasName("X")) matches the declaration of X,
while varDecl(hasType(recordDecl(hasName("X")))) matches the declaration
of x."

Example matches x (matcher = expr(hasType(recordDecl(hasName("X")))))
            and z (matcher = varDecl(hasType(recordDecl(hasName("X")))))
 class X {};
 void y(X &x) { x; X z; }

Usable as: Matcher<Expr>, Matcher<ValueDecl>

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();

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]"

Matches a 'for', 'while', or 'do while' statement that has
a given body.

Given
  for (;;) {}
hasBody(compoundStmt())
  matches 'for (;;) {}'
with compoundStmt()
  matching '{}'

Matches the condition expression of an if statement, for loop,
or conditional operator.

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