# AST Matcher Reference

This document shows all currently implemented matchers. The matchers are grouped by category and node type they match. You can click on matcher names to show the matcher's source documentation.

There are three different basic categories of matchers:

- Node Matchers: Matchers that match a specific type of AST node.
- Narrowing Matchers: Matchers that match attributes on AST nodes.
- Traversal Matchers: Matchers that allow traversal between AST nodes.

Within each category the matchers are ordered by node type they match on. Note that if a matcher can match multiple node types, it will it will appear multiple times. This means that by searching for Matcher<Stmt> you can find all matchers that can be used to match on Stmt nodes.

The exception to that rule are matchers that can match on any node. Those are marked with a * and are listed in the beginning of each category.

## Node Matchers

Node matchers are at the core of matcher expressions - they specify the type of node that is expected. Every match expression starts with a node matcher, which can then be further refined with a narrowing or traversal matcher. All traversal matchers take node matchers as their arguments.

For convenience, all node matchers take an arbitrary number of arguments and implicitly act as allOf matchers.

Node matchers are the only matchers that support the bind("id") call to bind the matched node to the given string, to be later retrieved from the match callback.

Return type | Name | Parameters
--- | --- | ---
Matcher<Decl> | classTemplateDecl | Matcher<ClassTemplateDecl>...

    Matches C++ class template declarations.

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

Matcher<Decl> | classTemplateSpecializationDecl | Matcher<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> | constructorDecl | Matcher<CXXConstructorDecl>...

    Matches C++ constructor declarations.

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

Matcher<Decl> | decl | Matcher<Decl>...

    Matches declarations.

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

Matcher<Decl> | destructorDecl | Matcher<CXXDestructorDecl>...

    Matches explicit C++ destructor declarations.

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

Matcher<Decl> | enumConstantDecl | Matcher<EnumConstantDecl>...

    Matches enum constants.

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

Matcher<Decl> | enumDecl | Matcher<EnumDecl>...

    Matches enum declarations.

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

Matcher<Decl> | fieldDecl | Matcher<FieldDecl>...

    Matches field declarations.

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

Matcher<Decl> | functionDecl | Matcher<FunctionDecl>...

    Matches function declarations.

    Example matches f
      void f();

Matcher<Decl> | functionTemplateDecl | Matcher<FunctionTemplateDecl>...

    Matches C++ function template declarations.

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

Matcher<Decl> | methodDecl | Matcher<CXXMethodDecl>...

    Matches method declarations.

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

Matcher<Decl> | namedDecl | Matcher<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> | recordDecl | Matcher<CXXRecordDecl>...

    Matches C++ class declarations.

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

Matcher<Decl> | usingDecl | Matcher<UsingDecl>...

    Matches using declarations.

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

Matcher<Decl> | varDecl | Matcher<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<Expr> | boolLiteral | Matcher<CXXBoolLiteralExpr>...

    Matches bool literals.

    Example matches true
      true

Matcher<Expr> | castExpr | Matcher<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<Expr> | characterLiteral | Matcher<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<Expr> | constCastExpr | Matcher<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<Expr> | dynamicCastExpr | Matcher<CXXDynamicCastExpr>...

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

Matcher<Expr> | explicitCastExpr | Matcher<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<Expr> | functionalCastExpr | Matcher<CXXFunctionalCastExpr>...

    Matches functional cast expressions

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

Matcher<Expr> | implicitCastExpr | Matcher<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<Expr> | integerLiteral | Matcher<IntegerLiteral>...

    Matches integer literals of all sizes encodings.

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

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

Matcher<Expr> | reinterpretCastExpr | Matcher<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<Expr> | staticCastExpr | Matcher<CXXStaticCastExpr>...

    Matches a C++ static_cast expression.

    hasDestinationType
    reinterpretCast

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

Matcher<Expr> | stringLiteral | Matcher<StringLiteral>...

    Matches string literals (also matches wide string literals).

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

Matcher<Stmt> | arraySubscriptExpr | Matcher<ArraySubscriptExpr>...

    Matches array subscript expressions.

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

Matcher<Stmt> | binaryOperator | Matcher<BinaryOperator>...

    Matches binary operator expressions.

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

Matcher<Stmt> | bindTemporaryExpr | Matcher<CXXBindTemporaryExpr>...

    Matches nodes where temporaries are created.

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

Matcher<Stmt> | callExpr | Matcher<CallExpr>...

    Matches call expressions.

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

Matcher<Stmt> | compoundStmt | Matcher<CompoundStmt>...

    Matches compound statements.

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

Matcher<Stmt> | conditionalOperator | Matcher<ConditionalOperator>...

    Matches conditional operator expressions.

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

Matcher<Stmt> | constructExpr | Matcher<CXXConstructExpr>...

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

Matcher<Stmt> | declRefExpr | Matcher<DeclRefExpr>...

    Matches expressions that refer to declarations.

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

Matcher<Stmt> | declStmt | Matcher<DeclStmt>...

    Matches declaration statements.

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

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

Matcher<Stmt> | deleteExpr | Matcher<CXXDeleteExpr>...

    Matches delete expressions.

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

Matcher<Stmt> | doStmt | Matcher<DoStmt>...

    Matches do statements.

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

Matcher<Stmt> | expr | Matcher<Expr>...

    Matches expressions.

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

Matcher<Stmt> | forStmt | Matcher<ForStmt>...

    Matches for statements.

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

Matcher<Stmt> | ifStmt | Matcher<IfStmt>...

    Matches if statements.

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

Matcher<Stmt> | initListExpr | Matcher<InitListExpr>...

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

Matcher<Stmt> | materializeTemporaryExpr | Matcher<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> | memberCallExpr | Matcher<CXXMemberCallExpr>...

    Matches member call expressions.

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

Matcher<Stmt> | memberExpr | Matcher<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> | newExpr | Matcher<CXXNewExpr>...

    Matches new expressions.

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

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

Matcher<Stmt> | stmt | Matcher<Stmt>...

    Matches statements.

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

Matcher<Stmt> | switchCase | Matcher<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> | unaryExprOrTypeTraitExpr | Matcher<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> | unaryOperator | Matcher<UnaryOperator>...

    Matches unary operator expressions.

    Example matches !a
      !a || b

Matcher<Stmt> | whileStmt | Matcher<WhileStmt>...

    Matches while statements.

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

## 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 type | Name | Parameters
--- | --- | ---
Matcher<*> | allOf | Matcher<*> P1, Matcher<*> P2

    Matches if all given matchers match.

    Usable as: Any Matcher

Matcher<*> | anyOf | Matcher<*> P1, Matcher<*> P2

    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<*> | unless | Matcher<*> InnerMatcher

    Matches if the provided matcher does not match.

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

    Usable as: Any Matcher

Matcher<BinaryOperator> | hasOperatorName | std::string Name

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

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

Matcher<CXXBoolLiteral> | equals | ValueT Value

    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>

Matcher<CXXConstructorDecl> | isImplicit |

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

Matcher<CXXCtorInitializer> | isWritten |

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

Matcher<CXXOperatorCallExpr> | hasOverloadedOperatorName | std::string Name

    Matches overloaded operator names.

    Matches overloaded operator names specified in strings without the
    "operator" prefix, such as "<<", for OverloadedOperatorCall's.

    Example matches a << b
        (matcher == operatorCallExpr(hasOverloadedOperatorName("<<")))
      a << b;
      c && d;  assuming both operator<<
               and operator&& are overloaded somewhere.

Matcher<CXXRecordDecl> | isA | StringRef BaseName

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

Matcher<CXXRecordDecl> | isDerivedFrom | StringRef 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> | 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>;
    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>

Matcher<CallExpr> | argumentCountIs | unsigned 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> | equals | ValueT Value

    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>

Matcher<CompoundStmt> | statementCountIs | unsigned 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<DeclStmt> | declCountIs | unsigned 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<FloatingLiteral> | equals | ValueT Value

    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>

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

Matcher<IntegerLiteral> | equals | ValueT Value

    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>

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> | hasName | std::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> | matchesName | std::string RegExp

    Matches NamedDecl nodes whose full names partially match 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<QualType> | asString | std::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(); }
    callExpr(on(hasType(asString("class Y *"))))
      matches y->x()

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<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<UnaryExprOrTypeTraitExpr> | ofKind | UnaryExprOrTypeTrait 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> | hasOperatorName | std::string Name

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

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

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

## 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 type | Name | Parameters
--- | --- | ---
Matcher<*> | forEach | Matcher<ChildT> ChildMatcher

    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

Matcher<*> | forEachDescendant | Matcher<DescendantT> DescendantMatcher

    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

Matcher<*> | has | Matcher<ChildT> ChildMatcher

    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

Matcher<*> | hasAncestor | Matcher<AncestorT> AncestorMatcher

    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(hasAncsestor(ifStmt()))) matches 42, but not 43.

    Usable as: Any Matcher

Matcher<*> | hasDescendant | Matcher<DescendantT> DescendantMatcher

    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

Matcher<ArraySubscriptExpr> | hasBase | Matcher<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> | hasIndex | Matcher<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<BinaryOperator> | hasEitherOperand | Matcher<Expr> InnerMatcher

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

Matcher<BinaryOperator> | hasLHS | Matcher<Expr> InnerMatcher

    Matches the left hand side of binary operator expressions.

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

Matcher<BinaryOperator> | hasRHS | Matcher<Expr> InnerMatcher

    Matches the right hand side of binary operator expressions.

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

Matcher<CXXConstructExpr> | hasDeclaration | Matcher<Decl> InnerMatcher

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

    Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>

Matcher<CXXConstructorDecl> | hasAnyConstructorInitializer | Matcher<CXXCtorInitializer> InnerMatcher

    Matches a constructor initializer.

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

Matcher<CXXCtorInitializer> | forField | Matcher<FieldDecl> InnerMatcher

    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_

Matcher<CXXCtorInitializer> | withInitializer | Matcher<Expr> InnerMatcher

    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)

Matcher<CXXMemberCallExpr> | on | Matcher<Expr> InnerMatcher

    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?

Matcher<CXXMemberCallExpr> | onImplicitObjectArgument | Matcher<Expr> InnerMatcher

Matcher<CXXMemberCallExpr> | thisPointerType | Matcher<Decl> InnerMatcher

    Overloaded to match the type's declaration.

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

Matcher<CXXRecordDecl> | isA | Matcher<NamedDecl> Base

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

Matcher<CXXRecordDecl> | isDerivedFrom | Matcher<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<CallExpr> | callee | Matcher<Decl> InnerMatcher

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

Matcher<CallExpr> | hasAnyArgument | Matcher<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

Matcher<CallExpr> | hasArgument | unsigned 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> | hasDeclaration | Matcher<Decl> InnerMatcher

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

    Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>

Matcher<CastExpr> | hasSourceExpression | Matcher<Expr> InnerMatcher

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

Matcher<ClassTemplateSpecializationDecl> | hasAnyTemplateArgument | Matcher<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> | hasTemplateArgument | unsigned 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<CompoundStmt> | hasAnySubstatement | Matcher<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> | hasCondition | Matcher<Expr> InnerMatcher

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

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

Matcher<ConditionalOperator> | hasFalseExpression | Matcher<Expr> InnerMatcher

    Matches the false branch expression of a conditional operator.

    Example matches b
      condition ? a : b

Matcher<ConditionalOperator> | hasTrueExpression | Matcher<Expr> InnerMatcher

    Matches the true branch expression of a conditional operator.

    Example matches a
      condition ? a : b

Matcher<DeclRefExpr> | throughUsingDecl | Matcher<UsingShadowDecl> InnerMatcher

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

Matcher<DeclRefExpr> | to | Matcher<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> | containsDeclaration | unsigned 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> | hasSingleDecl | Matcher<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<DoStmt> | hasBody | Matcher<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> | hasCondition | Matcher<Expr> InnerMatcher

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

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

Matcher<ExplicitCastExpr> | hasDestinationType | Matcher<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> | hasType | Matcher<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;", 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>

Matcher<Expr> | ignoringImpCasts | Matcher<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> | ignoringParenCasts | Matcher<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> | ignoringParenImpCasts | Matcher<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> | hasBody | Matcher<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> | hasCondition | Matcher<Expr> InnerMatcher

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

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

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

Matcher<FunctionDecl> | hasParameter | unsigned N, Matcher<ParmVarDecl> InnerMatcher

    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

Matcher<FunctionDecl> | returns | Matcher<QualType> InnerMatcher

    Matches the return type of a function declaration.

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

Matcher<IfStmt> | hasCondition | Matcher<Expr> InnerMatcher

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

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

Matcher<IfStmt> | hasConditionVariableStatement | Matcher<DeclStmt> InnerMatcher

    Matches the condition variable statement in an if statement.

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

Matcher<ImplicitCastExpr> | hasImplicitDestinationType | Matcher<QualType> InnerMatcher

    Matches implicit casts whose destination type matches a given
    matcher.

    FIXME: Unit test this matcher

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

Matcher<MemberExpr> | member | Matcher<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<QualType> | hasDeclaration | Matcher<Decl> InnerMatcher

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

    Usable as: Matcher<QualType>, Matcher<CallExpr>, Matcher<CXXConstructExpr>

Matcher<QualType> | pointsTo | Matcher<Decl> InnerMatcher

    Overloaded to match the pointee type's declaration.

Matcher<QualType> | references | Matcher<Decl> InnerMatcher

    Overloaded to match the referenced type's declaration.

Matcher<Stmt> | alignOfExpr | Matcher<UnaryExprOrTypeTraitExpr> InnerMatcher

    Same as unaryExprOrTypeTraitExpr, but only matching
    alignof.

Matcher<Stmt> | sizeOfExpr | Matcher<UnaryExprOrTypeTraitExpr> InnerMatcher

    Same as unaryExprOrTypeTraitExpr, but only matching
    sizeof.

Matcher<TemplateArgument> | refersToDeclaration | Matcher<Decl> InnerMatcher

    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

Matcher<TemplateArgument> | refersToType | Matcher<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<UnaryExprOrTypeTraitExpr> | hasArgumentOfType | Matcher<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> | hasUnaryOperand | Matcher<Expr> InnerMatcher

    Matches if the operand of a unary operator matches.

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

Matcher<UsingDecl> | hasAnyUsingShadowDecl | Matcher<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> | hasTargetDecl | Matcher<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> | hasType | Matcher<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;", 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>

Matcher<VarDecl> | hasInitializer | Matcher<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<WhileStmt> | hasBody | Matcher<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> | hasCondition | Matcher<Expr> InnerMatcher

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

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