docs/LibASTMatchersReference.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
   2           "http://www.w3.org/TR/html4/strict.dtd">
   3 <html>
   4 <head>
   5 <title>AST Matcher Reference</title>
   6 <link type="text/css" rel="stylesheet" href="../menu.css" />
   7 <link type="text/css" rel="stylesheet" href="../content.css" />
   8 <style type="text/css">
   9 td {
  10   padding: .33em;
  11 }
  12 td.doc {
  13   display: none;
  14   border-bottom: 1px solid black;
  15 }
  16 td.name:hover {
  17   color: blue;
  18   cursor: pointer;
  19 }
  20 </style>
  21 <script type="text/javascript">
  22 function toggle(id) {
  23   if (!id) return;
  24   row = document.getElementById(id);
  25   if (row.style.display != 'table-cell')
  26     row.style.display = 'table-cell';
  27   else
  28     row.style.display = 'none';
  29 }
  30 </script>
  31 </head>
  32 <body onLoad="toggle(location.hash.substring(1, location.hash.length - 6))">
  33
  34 <!--#include virtual="../menu.html.incl"-->
  35
  36 <div id="content">
  37
  38 <h1>AST Matcher Reference</h1>
  39
  40 <p>This document shows all currently implemented matchers. The matchers are grouped
  41 by category and node type they match. You can click on matcher names to show the
  42 matcher's source documentation.</p>
  43
  44 <p>There are three different basic categories of matchers:
  45 <ul>
  46 <li><a href="#decl-matchers">Node Matchers:</a> Matchers that match a specific type of AST node.</li>
  47 <li><a href="#narrowing-matchers">Narrowing Matchers:</a> Matchers that match attributes on AST nodes.</li>
  48 <li><a href="#traversal-matchers">Traversal Matchers:</a> Matchers that allow traversal between AST nodes.</li>
  49 </ul>
  50 </p>
  51
  52 <p>Within each category the matchers are ordered by node type they match on.
  53 Note that if a matcher can match multiple node types, it will it will appear
  54 multiple times. This means that by searching for Matcher&lt;Stmt&gt; you can
  55 find all matchers that can be used to match on Stmt nodes.</p>
  56
  57 <p>The exception to that rule are matchers that can match on any node. Those
  58 are marked with a * and are listed in the beginning of each category.</p>
  59
  60 <!-- ======================================================================= -->
  61 <h2 id="decl-matchers">Node Matchers</h2>
  62 <!-- ======================================================================= -->
  63
  64 <p>Node matchers are at the core of matcher expressions - they specify the type
  65 of node that is expected. Every match expression starts with a node matcher,
  66 which can then be further refined with a narrowing or traversal matcher. All
  67 traversal matchers take node matchers as their arguments.</p>
  68
  69 <p>For convenience, all node matchers take an arbitrary number of arguments
  70 and implicitly act as allOf matchers.</p>
  71
  72 <p>Node matchers are the only matchers that support the bind("id") call to
  73 bind the matched node to the given string, to be later retrieved from the
  74 match callback.</p>
  75
  76 <table>
  77 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
  78 <!-- START_DECL_MATCHERS -->
  79
  80 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('accessSpecDecl0')"><a name="accessSpecDecl0Anchor">accessSpecDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AccessSpecDecl.html">AccessSpecDecl</a>&gt;...</td></tr>
  81 <tr><td colspan="4" class="doc" id="accessSpecDecl0"><pre>Matches C++ access specifier declarations.
  82
  83 Given
  84   class C {
  85   public:
  86     int a;
  87   };
  88 accessSpecDecl()
  89   matches 'public:'
  90 </pre></td></tr>
  91
  92
  93 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('classTemplateDecl0')"><a name="classTemplateDecl0Anchor">classTemplateDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ClassTemplateDecl.html">ClassTemplateDecl</a>&gt;...</td></tr>
  94 <tr><td colspan="4" class="doc" id="classTemplateDecl0"><pre>Matches C++ class template declarations.
  95
  96 Example matches Z
  97   template&lt;class T&gt; class Z {};
  98 </pre></td></tr>
  99
 100
 101 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('classTemplateSpecializationDecl0')"><a name="classTemplateSpecializationDecl0Anchor">classTemplateSpecializationDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;...</td></tr>
 102 <tr><td colspan="4" class="doc" id="classTemplateSpecializationDecl0"><pre>Matches C++ class template specializations.
 103
 104 Given
 105   template&lt;typename T&gt; class A {};
 106   template&lt;&gt; class A&lt;double&gt; {};
 107   A&lt;int&gt; a;
 108 classTemplateSpecializationDecl()
 109   matches the specializations A&lt;int&gt; and A&lt;double&gt;
 110 </pre></td></tr>
 111
 112
 113 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('constructorDecl0')"><a name="constructorDecl0Anchor">constructorDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;...</td></tr>
 114 <tr><td colspan="4" class="doc" id="constructorDecl0"><pre>Matches C++ constructor declarations.
 115
 116 Example matches Foo::Foo() and Foo::Foo(int)
 117   class Foo {
 118    public:
 119     Foo();
 120     Foo(int);
 121     int DoSomething();
 122   };
 123 </pre></td></tr>
 124
 125
 126 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('decl0')"><a name="decl0Anchor">decl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;...</td></tr>
 127 <tr><td colspan="4" class="doc" id="decl0"><pre>Matches declarations.
 128
 129 Examples matches X, C, and the friend declaration inside C;
 130   void X();
 131   class C {
 132     friend X;
 133   };
 134 </pre></td></tr>
 135
 136
 137 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('destructorDecl0')"><a name="destructorDecl0Anchor">destructorDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDestructorDecl.html">CXXDestructorDecl</a>&gt;...</td></tr>
 138 <tr><td colspan="4" class="doc" id="destructorDecl0"><pre>Matches explicit C++ destructor declarations.
 139
 140 Example matches Foo::~Foo()
 141   class Foo {
 142    public:
 143     virtual ~Foo();
 144   };
 145 </pre></td></tr>
 146
 147
 148 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('enumConstantDecl0')"><a name="enumConstantDecl0Anchor">enumConstantDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumConstantDecl.html">EnumConstantDecl</a>&gt;...</td></tr>
 149 <tr><td colspan="4" class="doc" id="enumConstantDecl0"><pre>Matches enum constants.
 150
 151 Example matches A, B, C
 152   enum X {
 153     A, B, C
 154   };
 155 </pre></td></tr>
 156
 157
 158 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('enumDecl0')"><a name="enumDecl0Anchor">enumDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumDecl.html">EnumDecl</a>&gt;...</td></tr>
 159 <tr><td colspan="4" class="doc" id="enumDecl0"><pre>Matches enum declarations.
 160
 161 Example matches X
 162   enum X {
 163     A, B, C
 164   };
 165 </pre></td></tr>
 166
 167
 168 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('fieldDecl0')"><a name="fieldDecl0Anchor">fieldDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;...</td></tr>
 169 <tr><td colspan="4" class="doc" id="fieldDecl0"><pre>Matches field declarations.
 170
 171 Given
 172   class X { int m; };
 173 fieldDecl()
 174   matches 'm'.
 175 </pre></td></tr>
 176
 177
 178 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('functionDecl0')"><a name="functionDecl0Anchor">functionDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;...</td></tr>
 179 <tr><td colspan="4" class="doc" id="functionDecl0"><pre>Matches function declarations.
 180
 181 Example matches f
 182   void f();
 183 </pre></td></tr>
 184
 185
 186 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('functionTemplateDecl0')"><a name="functionTemplateDecl0Anchor">functionTemplateDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionTemplateDecl.html">FunctionTemplateDecl</a>&gt;...</td></tr>
 187 <tr><td colspan="4" class="doc" id="functionTemplateDecl0"><pre>Matches C++ function template declarations.
 188
 189 Example matches f
 190   template&lt;class T&gt; void f(T t) {}
 191 </pre></td></tr>
 192
 193
 194 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('methodDecl0')"><a name="methodDecl0Anchor">methodDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;...</td></tr>
 195 <tr><td colspan="4" class="doc" id="methodDecl0"><pre>Matches method declarations.
 196
 197 Example matches y
 198   class X { void y() };
 199 </pre></td></tr>
 200
 201
 202 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('namedDecl0')"><a name="namedDecl0Anchor">namedDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;...</td></tr>
 203 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
 204
 205 Example matches X, S, the anonymous union type, i, and U;
 206   typedef int X;
 207   struct S {
 208     union {
 209       int i;
 210     } U;
 211   };
 212 </pre></td></tr>
 213
 214
 215 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('recordDecl0')"><a name="recordDecl0Anchor">recordDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;...</td></tr>
 216 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches C++ class declarations.
 217
 218 Example matches X, Z
 219   class X;
 220   template&lt;class T&gt; class Z {};
 221 </pre></td></tr>
 222
 223
 224 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('usingDecl0')"><a name="usingDecl0Anchor">usingDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UsingDecl.html">UsingDecl</a>&gt;...</td></tr>
 225 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
 226
 227 Given
 228   namespace X { int x; }
 229   using X::x;
 230 usingDecl()
 231   matches using X::x </pre></td></tr>
 232
 233
 234 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('varDecl0')"><a name="varDecl0Anchor">varDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;...</td></tr>
 235 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
 236
 237 Note: this does not match declarations of member variables, which are
 238 "field" declarations in Clang parlance.
 239
 240 Example matches a
 241   int a;
 242 </pre></td></tr>
 243
 244
 245 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('nestedNameSpecifierLoc0')"><a name="nestedNameSpecifierLoc0Anchor">nestedNameSpecifierLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;...</td></tr>
 246 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
 247 </pre></td></tr>
 248
 249
 250 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('nestedNameSpecifier0')"><a name="nestedNameSpecifier0Anchor">nestedNameSpecifier</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;...</td></tr>
 251 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
 252
 253 Given
 254   namespace ns {
 255     struct A { static void f(); };
 256     void A::f() {}
 257     void g() { A::f(); }
 258   }
 259   ns::A a;
 260 nestedNameSpecifier()
 261   matches "ns::" and both "A::"
 262 </pre></td></tr>
 263
 264
 265 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('qualType0')"><a name="qualType0Anchor">qualType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;...</td></tr>
 266 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
 267 </pre></td></tr>
 268
 269
 270 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('arraySubscriptExpr0')"><a name="arraySubscriptExpr0Anchor">arraySubscriptExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;...</td></tr>
 271 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
 272
 273 Given
 274   int i = a[1];
 275 arraySubscriptExpr()
 276   matches "a[1]"
 277 </pre></td></tr>
 278
 279
 280 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('asmStmt0')"><a name="asmStmt0Anchor">asmStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AsmStmt.html">AsmStmt</a>&gt;...</td></tr>
 281 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
 282
 283  int i = 100;
 284   __asm("mov al, 2");
 285 asmStmt()
 286   matches '__asm("mov al, 2")'
 287 </pre></td></tr>
 288
 289
 290 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('binaryOperator0')"><a name="binaryOperator0Anchor">binaryOperator</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;...</td></tr>
 291 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
 292
 293 Example matches a || b
 294   !(a || b)
 295 </pre></td></tr>
 296
 297
 298 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('bindTemporaryExpr0')"><a name="bindTemporaryExpr0Anchor">bindTemporaryExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXBindTemporaryExpr.html">CXXBindTemporaryExpr</a>&gt;...</td></tr>
 299 <tr><td colspan="4" class="doc" id="bindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
 300
 301 Example matches FunctionTakesString(GetStringByValue())
 302     (matcher = bindTemporaryExpr())
 303   FunctionTakesString(GetStringByValue());
 304   FunctionTakesStringByPointer(GetStringPointer());
 305 </pre></td></tr>
 306
 307
 308 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('boolLiteral0')"><a name="boolLiteral0Anchor">boolLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;...</td></tr>
 309 <tr><td colspan="4" class="doc" id="boolLiteral0"><pre>Matches bool literals.
 310
 311 Example matches true
 312   true
 313 </pre></td></tr>
 314
 315
 316 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('breakStmt0')"><a name="breakStmt0Anchor">breakStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BreakStmt.html">BreakStmt</a>&gt;...</td></tr>
 317 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
 318
 319 Given
 320   while (true) { break; }
 321 breakStmt()
 322   matches 'break'
 323 </pre></td></tr>
 324
 325
 326 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cStyleCastExpr0')"><a name="cStyleCastExpr0Anchor">cStyleCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CStyleCastExpr.html">CStyleCastExpr</a>&gt;...</td></tr>
 327 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
 328
 329 Example: Matches (int*) 2.2f in
 330   int i = (int) 2.2f;
 331 </pre></td></tr>
 332
 333
 334 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('callExpr0')"><a name="callExpr0Anchor">callExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;...</td></tr>
 335 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
 336
 337 Example matches x.y() and y()
 338   X x;
 339   x.y();
 340   y();
 341 </pre></td></tr>
 342
 343
 344 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('castExpr0')"><a name="castExpr0Anchor">castExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;...</td></tr>
 345 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
 346
 347 Example: castExpr() matches each of the following:
 348   (int) 3;
 349   const_cast&lt;Expr *&gt;(SubExpr);
 350   char c = 0;
 351 but does not match
 352   int i = (0);
 353   int k = 0;
 354 </pre></td></tr>
 355
 356
 357 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('catchStmt0')"><a name="catchStmt0Anchor">catchStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>&gt;...</td></tr>
 358 <tr><td colspan="4" class="doc" id="catchStmt0"><pre>Matches catch statements.
 359
 360   try {} catch(int i) {}
 361 catchStmt()
 362   matches 'catch(int i)'
 363 </pre></td></tr>
 364
 365
 366 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('characterLiteral0')"><a name="characterLiteral0Anchor">characterLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;...</td></tr>
 367 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
 368
 369 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
 370 though.
 371
 372 Example matches 'a', L'a'
 373   char ch = 'a'; wchar_t chw = L'a';
 374 </pre></td></tr>
 375
 376
 377 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('compoundLiteralExpr0')"><a name="compoundLiteralExpr0Anchor">compoundLiteralExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;...</td></tr>
 378 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
 379
 380 Example match: {1}, (1, 2)
 381   int array[4] = {1}; vector int myvec = (vector int)(1, 2);
 382 </pre></td></tr>
 383
 384
 385 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('compoundStmt0')"><a name="compoundStmt0Anchor">compoundStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;...</td></tr>
 386 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
 387
 388 Example matches '{}' and '{{}}'in 'for (;;) {{}}'
 389   for (;;) {{}}
 390 </pre></td></tr>
 391
 392
 393 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('conditionalOperator0')"><a name="conditionalOperator0Anchor">conditionalOperator</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConditionalOperator.html">ConditionalOperator</a>&gt;...</td></tr>
 394 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
 395
 396 Example matches a ? b : c
 397   (a ? b : c) + 42
 398 </pre></td></tr>
 399
 400
 401 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('constCastExpr0')"><a name="constCastExpr0Anchor">constCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstCastExpr.html">CXXConstCastExpr</a>&gt;...</td></tr>
 402 <tr><td colspan="4" class="doc" id="constCastExpr0"><pre>Matches a const_cast expression.
 403
 404 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
 405   int n = 42;
 406   const int &amp;r(n);
 407   int* p = const_cast&lt;int*&gt;(&amp;r);
 408 </pre></td></tr>
 409
 410
 411 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('constructExpr0')"><a name="constructExpr0Anchor">constructExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;...</td></tr>
 412 <tr><td colspan="4" class="doc" id="constructExpr0"><pre>Matches constructor call expressions (including implicit ones).
 413
 414 Example matches string(ptr, n) and ptr within arguments of f
 415     (matcher = constructExpr())
 416   void f(const string &amp;a, const string &amp;b);
 417   char *ptr;
 418   int n;
 419   f(string(ptr, n), ptr);
 420 </pre></td></tr>
 421
 422
 423 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('continueStmt0')"><a name="continueStmt0Anchor">continueStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ContinueStmt.html">ContinueStmt</a>&gt;...</td></tr>
 424 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
 425
 426 Given
 427   while (true) { continue; }
 428 continueStmt()
 429   matches 'continue'
 430 </pre></td></tr>
 431
 432
 433 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('declRefExpr0')"><a name="declRefExpr0Anchor">declRefExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;...</td></tr>
 434 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
 435
 436 Example matches x in if (x)
 437   bool x;
 438   if (x) {}
 439 </pre></td></tr>
 440
 441
 442 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('declStmt0')"><a name="declStmt0Anchor">declStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;...</td></tr>
 443 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
 444
 445 Given
 446   int a;
 447 declStmt()
 448   matches 'int a'.
 449 </pre></td></tr>
 450
 451
 452 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('defaultArgExpr0')"><a name="defaultArgExpr0Anchor">defaultArgExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDefaultArgExpr.html">CXXDefaultArgExpr</a>&gt;...</td></tr>
 453 <tr><td colspan="4" class="doc" id="defaultArgExpr0"><pre>Matches the value of a default argument at the call site.
 454
 455 Example matches the CXXDefaultArgExpr placeholder inserted for the
 456     default value of the second parameter in the call expression f(42)
 457     (matcher = defaultArgExpr())
 458   void f(int x, int y = 0);
 459   f(42);
 460 </pre></td></tr>
 461
 462
 463 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('deleteExpr0')"><a name="deleteExpr0Anchor">deleteExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDeleteExpr.html">CXXDeleteExpr</a>&gt;...</td></tr>
 464 <tr><td colspan="4" class="doc" id="deleteExpr0"><pre>Matches delete expressions.
 465
 466 Given
 467   delete X;
 468 deleteExpr()
 469   matches 'delete X'.
 470 </pre></td></tr>
 471
 472
 473 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('doStmt0')"><a name="doStmt0Anchor">doStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;...</td></tr>
 474 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
 475
 476 Given
 477   do {} while (true);
 478 doStmt()
 479   matches 'do {} while(true)'
 480 </pre></td></tr>
 481
 482
 483 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('dynamicCastExpr0')"><a name="dynamicCastExpr0Anchor">dynamicCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDynamicCastExpr.html">CXXDynamicCastExpr</a>&gt;...</td></tr>
 484 <tr><td colspan="4" class="doc" id="dynamicCastExpr0"><pre>Matches a dynamic_cast expression.
 485
 486 Example:
 487   dynamicCastExpr()
 488 matches
 489   dynamic_cast&lt;D*&gt;(&amp;b);
 490 in
 491   struct B { virtual ~B() {} }; struct D : B {};
 492   B b;
 493   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
 494 </pre></td></tr>
 495
 496
 497 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('explicitCastExpr0')"><a name="explicitCastExpr0Anchor">explicitCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;...</td></tr>
 498 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
 499
 500 Matches any cast expression written in user code, whether it be a
 501 C-style cast, a functional-style cast, or a keyword cast.
 502
 503 Does not match implicit conversions.
 504
 505 Note: the name "explicitCast" is chosen to match Clang's terminology, as
 506 Clang uses the term "cast" to apply to implicit conversions as well as to
 507 actual cast expressions.
 508
 509 hasDestinationType.
 510
 511 Example: matches all five of the casts in
 512   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
 513 but does not match the implicit conversion in
 514   long ell = 42;
 515 </pre></td></tr>
 516
 517
 518 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('expr0')"><a name="expr0Anchor">expr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;...</td></tr>
 519 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
 520
 521 Example matches x()
 522   void f() { x(); }
 523 </pre></td></tr>
 524
 525
 526 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forRangeStmt0')"><a name="forRangeStmt0Anchor">forRangeStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;...</td></tr>
 527 <tr><td colspan="4" class="doc" id="forRangeStmt0"><pre>Matches range-based for statements.
 528
 529 forRangeStmt() matches 'for (auto a : i)'
 530   int i[] =  {1, 2, 3}; for (auto a : i);
 531   for(int j = 0; j &lt; 5; ++j);
 532 </pre></td></tr>
 533
 534
 535 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forStmt0')"><a name="forStmt0Anchor">forStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;...</td></tr>
 536 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
 537
 538 Example matches 'for (;;) {}'
 539   for (;;) {}
 540   int i[] =  {1, 2, 3}; for (auto a : i);
 541 </pre></td></tr>
 542
 543
 544 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('functionalCastExpr0')"><a name="functionalCastExpr0Anchor">functionalCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;...</td></tr>
 545 <tr><td colspan="4" class="doc" id="functionalCastExpr0"><pre>Matches functional cast expressions
 546
 547 Example: Matches Foo(bar);
 548   Foo f = bar;
 549   Foo g = (Foo) bar;
 550   Foo h = Foo(bar);
 551 </pre></td></tr>
 552
 553
 554 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('gotoStmt0')"><a name="gotoStmt0Anchor">gotoStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1GotoStmt.html">GotoStmt</a>&gt;...</td></tr>
 555 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
 556
 557 Given
 558   goto FOO;
 559   FOO: bar();
 560 gotoStmt()
 561   matches 'goto FOO'
 562 </pre></td></tr>
 563
 564
 565 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('ifStmt0')"><a name="ifStmt0Anchor">ifStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;...</td></tr>
 566 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
 567
 568 Example matches 'if (x) {}'
 569   if (x) {}
 570 </pre></td></tr>
 571
 572
 573 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('implicitCastExpr0')"><a name="implicitCastExpr0Anchor">implicitCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ImplicitCastExpr.html">ImplicitCastExpr</a>&gt;...</td></tr>
 574 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
 575
 576 This matches many different places, including function call return value
 577 eliding, as well as any type conversions.
 578 </pre></td></tr>
 579
 580
 581 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('initListExpr0')"><a name="initListExpr0Anchor">initListExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;...</td></tr>
 582 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
 583
 584 Given
 585   int a[] = { 1, 2 };
 586   struct B { int x, y; };
 587   B b = { 5, 6 };
 588 initList()
 589   matches "{ 1, 2 }" and "{ 5, 6 }"
 590 </pre></td></tr>
 591
 592
 593 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('integerLiteral0')"><a name="integerLiteral0Anchor">integerLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;...</td></tr>
 594 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes encodings.
 595
 596 Not matching character-encoded integers such as L'a'.
 597
 598 Example matches 1, 1L, 0x1, 1U
 599 </pre></td></tr>
 600
 601
 602 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('labelStmt0')"><a name="labelStmt0Anchor">labelStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;...</td></tr>
 603 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
 604
 605 Given
 606   goto FOO;
 607   FOO: bar();
 608 labelStmt()
 609   matches 'FOO:'
 610 </pre></td></tr>
 611
 612
 613 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('lambdaExpr0')"><a name="lambdaExpr0Anchor">lambdaExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LambdaExpr.html">LambdaExpr</a>&gt;...</td></tr>
 614 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
 615
 616 Example matches [&amp;](){return 5;}
 617   [&amp;](){return 5;}
 618 </pre></td></tr>
 619
 620
 621 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('materializeTemporaryExpr0')"><a name="materializeTemporaryExpr0Anchor">materializeTemporaryExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MaterializeTemporaryExpr.html">MaterializeTemporaryExpr</a>&gt;...</td></tr>
 622 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
 623
 624 Example: Given
 625   struct T {void func()};
 626   T f();
 627   void g(T);
 628 materializeTemporaryExpr() matches 'f()' in these statements
 629   T u(f());
 630   g(f());
 631 but does not match
 632   f();
 633   f().func();
 634 </pre></td></tr>
 635
 636
 637 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('memberCallExpr0')"><a name="memberCallExpr0Anchor">memberCallExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;...</td></tr>
 638 <tr><td colspan="4" class="doc" id="memberCallExpr0"><pre>Matches member call expressions.
 639
 640 Example matches x.y()
 641   X x;
 642   x.y();
 643 </pre></td></tr>
 644
 645
 646 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('memberExpr0')"><a name="memberExpr0Anchor">memberExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;...</td></tr>
 647 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
 648
 649 Given
 650   class Y {
 651     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
 652     int a; static int b;
 653   };
 654 memberExpr()
 655   matches this-&gt;x, x, y.x, a, this-&gt;b
 656 </pre></td></tr>
 657
 658
 659 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('newExpr0')"><a name="newExpr0Anchor">newExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;...</td></tr>
 660 <tr><td colspan="4" class="doc" id="newExpr0"><pre>Matches new expressions.
 661
 662 Given
 663   new X;
 664 newExpr()
 665   matches 'new X'.
 666 </pre></td></tr>
 667
 668
 669 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('nullPtrLiteralExpr0')"><a name="nullPtrLiteralExpr0Anchor">nullPtrLiteralExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNullPtrLiteralExpr.html">CXXNullPtrLiteralExpr</a>&gt;...</td></tr>
 670 <tr><td colspan="4" class="doc" id="nullPtrLiteralExpr0"><pre>Matches nullptr literal.
 671 </pre></td></tr>
 672
 673
 674 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('nullStmt0')"><a name="nullStmt0Anchor">nullStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NullStmt.html">NullStmt</a>&gt;...</td></tr>
 675 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
 676
 677   foo();;
 678 nullStmt()
 679   matches the second ';'
 680 </pre></td></tr>
 681
 682
 683 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('operatorCallExpr0')"><a name="operatorCallExpr0Anchor">operatorCallExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;...</td></tr>
 684 <tr><td colspan="4" class="doc" id="operatorCallExpr0"><pre>Matches overloaded operator calls.
 685
 686 Note that if an operator isn't overloaded, it won't match. Instead, use
 687 binaryOperator matcher.
 688 Currently it does not match operators such as new delete.
 689 FIXME: figure out why these do not match?
 690
 691 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
 692     (matcher = operatorCallExpr())
 693   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
 694   ostream &amp;o; int b = 1, c = 1;
 695   o &lt;&lt; b &lt;&lt; c;
 696 </pre></td></tr>
 697
 698
 699 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('reinterpretCastExpr0')"><a name="reinterpretCastExpr0Anchor">reinterpretCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXReinterpretCastExpr.html">CXXReinterpretCastExpr</a>&gt;...</td></tr>
 700 <tr><td colspan="4" class="doc" id="reinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
 701
 702 Either the source expression or the destination type can be matched
 703 using has(), but hasDestinationType() is more specific and can be
 704 more readable.
 705
 706 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
 707   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
 708 </pre></td></tr>
 709
 710
 711 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('returnStmt0')"><a name="returnStmt0Anchor">returnStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReturnStmt.html">ReturnStmt</a>&gt;...</td></tr>
 712 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
 713
 714 Given
 715   return 1;
 716 returnStmt()
 717   matches 'return 1'
 718 </pre></td></tr>
 719
 720
 721 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('staticCastExpr0')"><a name="staticCastExpr0Anchor">staticCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXStaticCastExpr.html">CXXStaticCastExpr</a>&gt;...</td></tr>
 722 <tr><td colspan="4" class="doc" id="staticCastExpr0"><pre>Matches a C++ static_cast expression.
 723
 724 hasDestinationType
 725 reinterpretCast
 726
 727 Example:
 728   staticCastExpr()
 729 matches
 730   static_cast&lt;long&gt;(8)
 731 in
 732   long eight(static_cast&lt;long&gt;(8));
 733 </pre></td></tr>
 734
 735
 736 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stmt0')"><a name="stmt0Anchor">stmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;...</td></tr>
 737 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
 738
 739 Given
 740   { ++a; }
 741 stmt()
 742   matches both the compound statement '{ ++a; }' and '++a'.
 743 </pre></td></tr>
 744
 745
 746 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stringLiteral0')"><a name="stringLiteral0Anchor">stringLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1StringLiteral.html">StringLiteral</a>&gt;...</td></tr>
 747 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
 748
 749 Example matches "abcd", L"abcd"
 750   char *s = "abcd"; wchar_t *ws = L"abcd"
 751 </pre></td></tr>
 752
 753
 754 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('switchCase0')"><a name="switchCase0Anchor">switchCase</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1SwitchCase.html">SwitchCase</a>&gt;...</td></tr>
 755 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
 756
 757 Given
 758   switch(a) { case 42: break; default: break; }
 759 switchCase()
 760   matches 'case 42: break;' and 'default: break;'.
 761 </pre></td></tr>
 762
 763
 764 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('switchStmt0')"><a name="switchStmt0Anchor">switchStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;...</td></tr>
 765 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
 766
 767 Given
 768   switch(a) { case 42: break; default: break; }
 769 switchStmt()
 770   matches 'switch(a)'.
 771 </pre></td></tr>
 772
 773
 774 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('thisExpr0')"><a name="thisExpr0Anchor">thisExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXThisExpr.html">CXXThisExpr</a>&gt;...</td></tr>
 775 <tr><td colspan="4" class="doc" id="thisExpr0"><pre>Matches implicit and explicit this expressions.
 776
 777 Example matches the implicit this expression in "return i".
 778     (matcher = thisExpr())
 779 struct foo {
 780   int i;
 781   int f() { return i; }
 782 };
 783 </pre></td></tr>
 784
 785
 786 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('throwExpr0')"><a name="throwExpr0Anchor">throwExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXThrowExpr.html">CXXThrowExpr</a>&gt;...</td></tr>
 787 <tr><td colspan="4" class="doc" id="throwExpr0"><pre>Matches throw expressions.
 788
 789   try { throw 5; } catch(int i) {}
 790 throwExpr()
 791   matches 'throw 5'
 792 </pre></td></tr>
 793
 794
 795 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('tryStmt0')"><a name="tryStmt0Anchor">tryStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXTryStmt.html">CXXTryStmt</a>&gt;...</td></tr>
 796 <tr><td colspan="4" class="doc" id="tryStmt0"><pre>Matches try statements.
 797
 798   try {} catch(int i) {}
 799 tryStmt()
 800   matches 'try {}'
 801 </pre></td></tr>
 802
 803
 804 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unaryExprOrTypeTraitExpr0')"><a name="unaryExprOrTypeTraitExpr0Anchor">unaryExprOrTypeTraitExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;...</td></tr>
 805 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
 806
 807 Given
 808   Foo x = bar;
 809   int y = sizeof(x) + alignof(x);
 810 unaryExprOrTypeTraitExpr()
 811   matches sizeof(x) and alignof(x)
 812 </pre></td></tr>
 813
 814
 815 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unaryOperator0')"><a name="unaryOperator0Anchor">unaryOperator</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;...</td></tr>
 816 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
 817
 818 Example matches !a
 819   !a || b
 820 </pre></td></tr>
 821
 822
 823 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('userDefinedLiteral0')"><a name="userDefinedLiteral0Anchor">userDefinedLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UserDefinedLiteral.html">UserDefinedLiteral</a>&gt;...</td></tr>
 824 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
 825
 826 Example match: "foo"_suffix
 827 </pre></td></tr>
 828
 829
 830 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('whileStmt0')"><a name="whileStmt0Anchor">whileStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;...</td></tr>
 831 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
 832
 833 Given
 834   while (true) {}
 835 whileStmt()
 836   matches 'while (true) {}'.
 837 </pre></td></tr>
 838
 839
 840 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('arrayTypeLoc0')"><a name="arrayTypeLoc0Anchor">arrayTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayTypeLoc.html">ArrayTypeLoc</a>&gt;...</td></tr>
 841 <tr><td colspan="4" class="doc" id="arrayTypeLoc0"><pre>Matches all kinds of arrays.
 842
 843 Given
 844   int a[] = { 2, 3 };
 845   int b[4];
 846   void f() { int c[a[0]]; }
 847 arrayType()
 848   matches "int a[]", "int b[4]" and "int c[a[0]]";
 849 </pre></td></tr>
 850
 851
 852 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('atomicTypeLoc0')"><a name="atomicTypeLoc0Anchor">atomicTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicTypeLoc.html">AtomicTypeLoc</a>&gt;...</td></tr>
 853 <tr><td colspan="4" class="doc" id="atomicTypeLoc0"><pre>Matches atomic types.
 854
 855 Given
 856   _Atomic(int) i;
 857 atomicType()
 858   matches "_Atomic(int) i"
 859 </pre></td></tr>
 860
 861
 862 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('autoTypeLoc0')"><a name="autoTypeLoc0Anchor">autoTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AutoTypeLoc.html">AutoTypeLoc</a>&gt;...</td></tr>
 863 <tr><td colspan="4" class="doc" id="autoTypeLoc0"><pre>Matches types nodes representing C++11 auto types.
 864
 865 Given:
 866   auto n = 4;
 867   int v[] = { 2, 3 }
 868   for (auto i : v) { }
 869 autoType()
 870   matches "auto n" and "auto i"
 871 </pre></td></tr>
 872
 873
 874 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('blockPointerTypeLoc0')"><a name="blockPointerTypeLoc0Anchor">blockPointerTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerTypeLoc.html">BlockPointerTypeLoc</a>&gt;...</td></tr>
 875 <tr><td colspan="4" class="doc" id="blockPointerTypeLoc0"><pre>Matches block pointer types, i.e. types syntactically represented as
 876 "void (^)(int)".
 877
 878 The pointee is always required to be a FunctionType.
 879 </pre></td></tr>
 880
 881
 882 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('builtinTypeLoc0')"><a name="builtinTypeLoc0Anchor">builtinTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BuiltinTypeLoc.html">BuiltinTypeLoc</a>&gt;...</td></tr>
 883 <tr><td colspan="4" class="doc" id="builtinTypeLoc0"><pre>Matches builtin Types.
 884
 885 Given
 886   struct A {};
 887   A a;
 888   int b;
 889   float c;
 890   bool d;
 891 builtinType()
 892   matches "int b", "float c" and "bool d"
 893 </pre></td></tr>
 894
 895
 896 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('complexTypeLoc0')"><a name="complexTypeLoc0Anchor">complexTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexTypeLoc.html">ComplexTypeLoc</a>&gt;...</td></tr>
 897 <tr><td colspan="4" class="doc" id="complexTypeLoc0"><pre>Matches C99 complex types.
 898
 899 Given
 900   _Complex float f;
 901 complexType()
 902   matches "_Complex float f"
 903 </pre></td></tr>
 904
 905
 906 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('constantArrayTypeLoc0')"><a name="constantArrayTypeLoc0Anchor">constantArrayTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConstantArrayTypeLoc.html">ConstantArrayTypeLoc</a>&gt;...</td></tr>
 907 <tr><td colspan="4" class="doc" id="constantArrayTypeLoc0"><pre>Matches C arrays with a specified constant size.
 908
 909 Given
 910   void() {
 911     int a[2];
 912     int b[] = { 2, 3 };
 913     int c[b[0]];
 914   }
 915 constantArrayType()
 916   matches "int a[2]"
 917 </pre></td></tr>
 918
 919
 920 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('dependentSizedArrayTypeLoc0')"><a name="dependentSizedArrayTypeLoc0Anchor">dependentSizedArrayTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DependentSizedArrayTypeLoc.html">DependentSizedArrayTypeLoc</a>&gt;...</td></tr>
 921 <tr><td colspan="4" class="doc" id="dependentSizedArrayTypeLoc0"><pre>Matches C++ arrays whose size is a value-dependent expression.
 922
 923 Given
 924   template&lt;typename T, int Size&gt;
 925   class array {
 926     T data[Size];
 927   };
 928 dependentSizedArrayType
 929   matches "T data[Size]"
 930 </pre></td></tr>
 931
 932
 933 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('elaboratedTypeLoc0')"><a name="elaboratedTypeLoc0Anchor">elaboratedTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ElaboratedTypeLoc.html">ElaboratedTypeLoc</a>&gt;...</td></tr>
 934 <tr><td colspan="4" class="doc" id="elaboratedTypeLoc0"><pre>Matches types specified with an elaborated type keyword or with a
 935 qualified name.
 936
 937 Given
 938   namespace N {
 939     namespace M {
 940       class D {};
 941     }
 942   }
 943   class C {};
 944
 945   class C c;
 946   N::M::D d;
 947
 948 elaboratedType() matches the type of the variable declarations of both
 949 c and d.
 950 </pre></td></tr>
 951
 952
 953 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('functionTypeLoc0')"><a name="functionTypeLoc0Anchor">functionTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionTypeLoc.html">FunctionTypeLoc</a>&gt;...</td></tr>
 954 <tr><td colspan="4" class="doc" id="functionTypeLoc0"><pre>Matches FunctionType nodes.
 955
 956 Given
 957   int (*f)(int);
 958   void g();
 959 functionType()
 960   matches "int (*f)(int)" and the type of "g".
 961 </pre></td></tr>
 962
 963
 964 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('incompleteArrayTypeLoc0')"><a name="incompleteArrayTypeLoc0Anchor">incompleteArrayTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IncompleteArrayTypeLoc.html">IncompleteArrayTypeLoc</a>&gt;...</td></tr>
 965 <tr><td colspan="4" class="doc" id="incompleteArrayTypeLoc0"><pre>Matches C arrays with unspecified size.
 966
 967 Given
 968   int a[] = { 2, 3 };
 969   int b[42];
 970   void f(int c[]) { int d[a[0]]; };
 971 incompleteArrayType()
 972   matches "int a[]" and "int c[]"
 973 </pre></td></tr>
 974
 975
 976 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('lValueReferenceTypeLoc0')"><a name="lValueReferenceTypeLoc0Anchor">lValueReferenceTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LValueReferenceTypeLoc.html">LValueReferenceTypeLoc</a>&gt;...</td></tr>
 977 <tr><td colspan="4" class="doc" id="lValueReferenceTypeLoc0"><pre>Matches lvalue reference types.
 978
 979 Given:
 980   int *a;
 981   int &amp;b = *a;
 982   int &amp;&amp;c = 1;
 983   auto &amp;d = b;
 984   auto &amp;&amp;e = c;
 985   auto &amp;&amp;f = 2;
 986   int g = 5;
 987
 988 lValueReferenceType() matches the types of b, d, and e. e is
 989 matched since the type is deduced as int&amp; by reference collapsing rules.
 990 </pre></td></tr>
 991
 992
 993 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('memberPointerTypeLoc0')"><a name="memberPointerTypeLoc0Anchor">memberPointerTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerTypeLoc.html">MemberPointerTypeLoc</a>&gt;...</td></tr>
 994 <tr><td colspan="4" class="doc" id="memberPointerTypeLoc0"><pre>Matches member pointer types.
 995 Given
 996   struct A { int i; }
 997   A::* ptr = A::i;
 998 memberPointerType()
 999   matches "A::* ptr"
1000 </pre></td></tr>
1001
1002
1003 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('parenTypeLoc0')"><a name="parenTypeLoc0Anchor">parenTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenTypeLoc.html">ParenTypeLoc</a>&gt;...</td></tr>
1004 <tr><td colspan="4" class="doc" id="parenTypeLoc0"><pre>Matches ParenType nodes.
1005
1006 Given
1007   int (*ptr_to_array)[4];
1008   int *array_of_ptrs[4];
1009
1010 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
1011 array_of_ptrs.
1012 </pre></td></tr>
1013
1014
1015 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('pointerTypeLoc0')"><a name="pointerTypeLoc0Anchor">pointerTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerTypeLoc.html">PointerTypeLoc</a>&gt;...</td></tr>
1016 <tr><td colspan="4" class="doc" id="pointerTypeLoc0"><pre>Matches pointer types.
1017
1018 Given
1019   int *a;
1020   int &amp;b = *a;
1021   int c = 5;
1022 pointerType()
1023   matches "int *a"
1024 </pre></td></tr>
1025
1026
1027 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('rValueReferenceTypeLoc0')"><a name="rValueReferenceTypeLoc0Anchor">rValueReferenceTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RValueReferenceTypeLoc.html">RValueReferenceTypeLoc</a>&gt;...</td></tr>
1028 <tr><td colspan="4" class="doc" id="rValueReferenceTypeLoc0"><pre>Matches rvalue reference types.
1029
1030 Given:
1031   int *a;
1032   int &amp;b = *a;
1033   int &amp;&amp;c = 1;
1034   auto &amp;d = b;
1035   auto &amp;&amp;e = c;
1036   auto &amp;&amp;f = 2;
1037   int g = 5;
1038
1039 rValueReferenceType() matches the types of c and f. e is not
1040 matched as it is deduced to int&amp; by reference collapsing rules.
1041 </pre></td></tr>
1042
1043
1044 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('recordTypeLoc0')"><a name="recordTypeLoc0Anchor">recordTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordTypeLoc.html">RecordTypeLoc</a>&gt;...</td></tr>
1045 <tr><td colspan="4" class="doc" id="recordTypeLoc0"><pre>Matches record types (e.g. structs, classes).
1046
1047 Given
1048   class C {};
1049   struct S {};
1050
1051   C c;
1052   S s;
1053
1054 recordType() matches the type of the variable declarations of both c
1055 and s.
1056 </pre></td></tr>
1057
1058
1059 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('referenceTypeLoc0')"><a name="referenceTypeLoc0Anchor">referenceTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceTypeLoc.html">ReferenceTypeLoc</a>&gt;...</td></tr>
1060 <tr><td colspan="4" class="doc" id="referenceTypeLoc0"><pre>Matches both lvalue and rvalue reference types.
1061
1062 Given
1063   int *a;
1064   int &amp;b = *a;
1065   int &amp;&amp;c = 1;
1066   auto &amp;d = b;
1067   auto &amp;&amp;e = c;
1068   auto &amp;&amp;f = 2;
1069   int g = 5;
1070
1071 referenceType() matches the types of b, c, d, e, and f.
1072 </pre></td></tr>
1073
1074
1075 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('templateSpecializationTypeLoc0')"><a name="templateSpecializationTypeLoc0Anchor">templateSpecializationTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationTypeLoc.html">TemplateSpecializationTypeLoc</a>&gt;...</td></tr>
1076 <tr><td colspan="4" class="doc" id="templateSpecializationTypeLoc0"><pre>Matches template specialization types.
1077
1078 Given
1079   template &lt;typename T&gt;
1080   class C { };
1081
1082   template class C&lt;int&gt;;  A
1083   C&lt;char&gt; var;            B
1084
1085 templateSpecializationType() matches the type of the explicit
1086 instantiation in A and the type of the variable declaration in B.
1087 </pre></td></tr>
1088
1089
1090 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('typeLoc0')"><a name="typeLoc0Anchor">typeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;...</td></tr>
1091 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
1092 </pre></td></tr>
1093
1094
1095 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('typedefTypeLoc0')"><a name="typedefTypeLoc0Anchor">typedefTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefTypeLoc.html">TypedefTypeLoc</a>&gt;...</td></tr>
1096 <tr><td colspan="4" class="doc" id="typedefTypeLoc0"><pre>Matches typedef types.
1097
1098 Given
1099   typedef int X;
1100 typedefType()
1101   matches "typedef int X"
1102 </pre></td></tr>
1103
1104
1105 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('variableArrayTypeLoc0')"><a name="variableArrayTypeLoc0Anchor">variableArrayTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VariableArrayTypeLoc.html">VariableArrayTypeLoc</a>&gt;...</td></tr>
1106 <tr><td colspan="4" class="doc" id="variableArrayTypeLoc0"><pre>Matches C arrays with a specified size that is not an
1107 integer-constant-expression.
1108
1109 Given
1110   void f() {
1111     int a[] = { 2, 3 }
1112     int b[42];
1113     int c[a[0]];
1114 variableArrayType()
1115   matches "int c[a[0]]"
1116 </pre></td></tr>
1117
1118
1119 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('arrayType0')"><a name="arrayType0Anchor">arrayType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;...</td></tr>
1120 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
1121
1122 Given
1123   int a[] = { 2, 3 };
1124   int b[4];
1125   void f() { int c[a[0]]; }
1126 arrayType()
1127   matches "int a[]", "int b[4]" and "int c[a[0]]";
1128 </pre></td></tr>
1129
1130
1131 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('atomicType0')"><a name="atomicType0Anchor">atomicType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;...</td></tr>
1132 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
1133
1134 Given
1135   _Atomic(int) i;
1136 atomicType()
1137   matches "_Atomic(int) i"
1138 </pre></td></tr>
1139
1140
1141 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('autoType0')"><a name="autoType0Anchor">autoType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;...</td></tr>
1142 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
1143
1144 Given:
1145   auto n = 4;
1146   int v[] = { 2, 3 }
1147   for (auto i : v) { }
1148 autoType()
1149   matches "auto n" and "auto i"
1150 </pre></td></tr>
1151
1152
1153 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('blockPointerType0')"><a name="blockPointerType0Anchor">blockPointerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;...</td></tr>
1154 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
1155 "void (^)(int)".
1156
1157 The pointee is always required to be a FunctionType.
1158 </pre></td></tr>
1159
1160
1161 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('builtinType0')"><a name="builtinType0Anchor">builtinType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BuiltinType.html">BuiltinType</a>&gt;...</td></tr>
1162 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
1163
1164 Given
1165   struct A {};
1166   A a;
1167   int b;
1168   float c;
1169   bool d;
1170 builtinType()
1171   matches "int b", "float c" and "bool d"
1172 </pre></td></tr>
1173
1174
1175 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('complexType0')"><a name="complexType0Anchor">complexType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;...</td></tr>
1176 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
1177
1178 Given
1179   _Complex float f;
1180 complexType()
1181   matches "_Complex float f"
1182 </pre></td></tr>
1183
1184
1185 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('constantArrayType0')"><a name="constantArrayType0Anchor">constantArrayType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConstantArrayType.html">ConstantArrayType</a>&gt;...</td></tr>
1186 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
1187
1188 Given
1189   void() {
1190     int a[2];
1191     int b[] = { 2, 3 };
1192     int c[b[0]];
1193   }
1194 constantArrayType()
1195   matches "int a[2]"
1196 </pre></td></tr>
1197
1198
1199 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentSizedArrayType0')"><a name="dependentSizedArrayType0Anchor">dependentSizedArrayType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DependentSizedArrayType.html">DependentSizedArrayType</a>&gt;...</td></tr>
1200 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
1201
1202 Given
1203   template&lt;typename T, int Size&gt;
1204   class array {
1205     T data[Size];
1206   };
1207 dependentSizedArrayType
1208   matches "T data[Size]"
1209 </pre></td></tr>
1210
1211
1212 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('elaboratedType0')"><a name="elaboratedType0Anchor">elaboratedType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;...</td></tr>
1213 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
1214 qualified name.
1215
1216 Given
1217   namespace N {
1218     namespace M {
1219       class D {};
1220     }
1221   }
1222   class C {};
1223
1224   class C c;
1225   N::M::D d;
1226
1227 elaboratedType() matches the type of the variable declarations of both
1228 c and d.
1229 </pre></td></tr>
1230
1231
1232 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('functionType0')"><a name="functionType0Anchor">functionType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionType.html">FunctionType</a>&gt;...</td></tr>
1233 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
1234
1235 Given
1236   int (*f)(int);
1237   void g();
1238 functionType()
1239   matches "int (*f)(int)" and the type of "g".
1240 </pre></td></tr>
1241
1242
1243 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('incompleteArrayType0')"><a name="incompleteArrayType0Anchor">incompleteArrayType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IncompleteArrayType.html">IncompleteArrayType</a>&gt;...</td></tr>
1244 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
1245
1246 Given
1247   int a[] = { 2, 3 };
1248   int b[42];
1249   void f(int c[]) { int d[a[0]]; };
1250 incompleteArrayType()
1251   matches "int a[]" and "int c[]"
1252 </pre></td></tr>
1253
1254
1255 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('lValueReferenceType0')"><a name="lValueReferenceType0Anchor">lValueReferenceType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LValueReferenceType.html">LValueReferenceType</a>&gt;...</td></tr>
1256 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
1257
1258 Given:
1259   int *a;
1260   int &amp;b = *a;
1261   int &amp;&amp;c = 1;
1262   auto &amp;d = b;
1263   auto &amp;&amp;e = c;
1264   auto &amp;&amp;f = 2;
1265   int g = 5;
1266
1267 lValueReferenceType() matches the types of b, d, and e. e is
1268 matched since the type is deduced as int&amp; by reference collapsing rules.
1269 </pre></td></tr>
1270
1271
1272 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('memberPointerType0')"><a name="memberPointerType0Anchor">memberPointerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;...</td></tr>
1273 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
1274 Given
1275   struct A { int i; }
1276   A::* ptr = A::i;
1277 memberPointerType()
1278   matches "A::* ptr"
1279 </pre></td></tr>
1280
1281
1282 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('parenType0')"><a name="parenType0Anchor">parenType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;...</td></tr>
1283 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
1284
1285 Given
1286   int (*ptr_to_array)[4];
1287   int *array_of_ptrs[4];
1288
1289 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
1290 array_of_ptrs.
1291 </pre></td></tr>
1292
1293
1294 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('pointerType0')"><a name="pointerType0Anchor">pointerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;...</td></tr>
1295 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types.
1296
1297 Given
1298   int *a;
1299   int &amp;b = *a;
1300   int c = 5;
1301 pointerType()
1302   matches "int *a"
1303 </pre></td></tr>
1304
1305
1306 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('rValueReferenceType0')"><a name="rValueReferenceType0Anchor">rValueReferenceType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RValueReferenceType.html">RValueReferenceType</a>&gt;...</td></tr>
1307 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
1308
1309 Given:
1310   int *a;
1311   int &amp;b = *a;
1312   int &amp;&amp;c = 1;
1313   auto &amp;d = b;
1314   auto &amp;&amp;e = c;
1315   auto &amp;&amp;f = 2;
1316   int g = 5;
1317
1318 rValueReferenceType() matches the types of c and f. e is not
1319 matched as it is deduced to int&amp; by reference collapsing rules.
1320 </pre></td></tr>
1321
1322
1323 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('recordType0')"><a name="recordType0Anchor">recordType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;...</td></tr>
1324 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
1325
1326 Given
1327   class C {};
1328   struct S {};
1329
1330   C c;
1331   S s;
1332
1333 recordType() matches the type of the variable declarations of both c
1334 and s.
1335 </pre></td></tr>
1336
1337
1338 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('referenceType0')"><a name="referenceType0Anchor">referenceType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;...</td></tr>
1339 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
1340
1341 Given
1342   int *a;
1343   int &amp;b = *a;
1344   int &amp;&amp;c = 1;
1345   auto &amp;d = b;
1346   auto &amp;&amp;e = c;
1347   auto &amp;&amp;f = 2;
1348   int g = 5;
1349
1350 referenceType() matches the types of b, c, d, e, and f.
1351 </pre></td></tr>
1352
1353
1354 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('templateSpecializationType0')"><a name="templateSpecializationType0Anchor">templateSpecializationType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;...</td></tr>
1355 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
1356
1357 Given
1358   template &lt;typename T&gt;
1359   class C { };
1360
1361   template class C&lt;int&gt;;  A
1362   C&lt;char&gt; var;            B
1363
1364 templateSpecializationType() matches the type of the explicit
1365 instantiation in A and the type of the variable declaration in B.
1366 </pre></td></tr>
1367
1368
1369 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('type0')"><a name="type0Anchor">type</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;...</td></tr>
1370 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
1371 </pre></td></tr>
1372
1373
1374 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('typedefType0')"><a name="typedefType0Anchor">typedefType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;...</td></tr>
1375 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
1376
1377 Given
1378   typedef int X;
1379 typedefType()
1380   matches "typedef int X"
1381 </pre></td></tr>
1382
1383
1384 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('variableArrayType0')"><a name="variableArrayType0Anchor">variableArrayType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VariableArrayType.html">VariableArrayType</a>&gt;...</td></tr>
1385 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
1386 integer-constant-expression.
1387
1388 Given
1389   void f() {
1390     int a[] = { 2, 3 }
1391     int b[42];
1392     int c[a[0]];
1393 variableArrayType()
1394   matches "int c[a[0]]"
1395 </pre></td></tr>
1396
1397 <!--END_DECL_MATCHERS -->
1398 </table>
1399
1400 <!-- ======================================================================= -->
1401 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
1402 <!-- ======================================================================= -->
1403
1404 <p>Narrowing matchers match certain attributes on the current node, thus
1405 narrowing down the set of nodes of the current type to match on.</p>
1406
1407 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
1408 which allow users to create more powerful match expressions.</p>
1409
1410 <table>
1411 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
1412 <!-- START_NARROWING_MATCHERS -->
1413
1414 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('allOf0')"><a name="allOf0Anchor">allOf</a></td><td>Matcher&lt;*&gt;  P1, Matcher&lt;*&gt;  P2</td></tr>
1415 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
1416
1417 Usable as: Any Matcher
1418 </pre></td></tr>
1419
1420
1421 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anyOf0')"><a name="anyOf0Anchor">anyOf</a></td><td>Matcher&lt;*&gt;  P1, Matcher&lt;*&gt;  P2</td></tr>
1422 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
1423
1424 Usable as: Any Matcher
1425 </pre></td></tr>
1426
1427
1428 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
1429 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
1430
1431 Useful when another matcher requires a child matcher, but there's no
1432 additional constraint. This will often be used with an explicit conversion
1433 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
1434
1435 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
1436 "int* p" and "void f()" in
1437   int* p;
1438   void f();
1439
1440 Usable as: Any Matcher
1441 </pre></td></tr>
1442
1443
1444 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;  InnerMatcher</td></tr>
1445 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
1446
1447 Example matches Y (matcher = recordDecl(unless(hasName("X"))))
1448   class X {};
1449   class Y {};
1450
1451 Usable as: Any Matcher
1452 </pre></td></tr>
1453
1454
1455 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName0')"><a name="hasOperatorName0Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
1456 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions (binary or
1457 unary).
1458
1459 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
1460   !(a || b)
1461 </pre></td></tr>
1462
1463
1464 <tr><td>Matcher&lt;CXXBoolLiteral&gt;</td><td class="name" onclick="toggle('equals2')"><a name="equals2Anchor">equals</a></td><td>ValueT  Value</td></tr>
1465 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value.
1466
1467 Example matches true (matcher = boolLiteral(equals(true)))
1468   true
1469
1470 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1471            Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
1472 </pre></td></tr>
1473
1474
1475 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isImplicit0')"><a name="isImplicit0Anchor">isImplicit</a></td><td></td></tr>
1476 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches a constructor declaration that has been implicitly added
1477 by the compiler (eg. implicit defaultcopy constructors).
1478 </pre></td></tr>
1479
1480
1481 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('isWritten0')"><a name="isWritten0Anchor">isWritten</a></td><td></td></tr>
1482 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a contructor initializer if it is explicitly written in
1483 code (as opposed to implicitly added by the compiler).
1484
1485 Given
1486   struct Foo {
1487     Foo() { }
1488     Foo(int) : foo_("A") { }
1489     string foo_;
1490   };
1491 constructorDecl(hasAnyConstructorInitializer(isWritten()))
1492   will match Foo(int), but not Foo()
1493 </pre></td></tr>
1494
1495
1496 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('hasOverloadedOperatorName0')"><a name="hasOverloadedOperatorName0Anchor">hasOverloadedOperatorName</a></td><td>StringRef Name</td></tr>
1497 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
1498
1499 Matches overloaded operator names specified in strings without the
1500 "operator" prefix: e.g. "&lt;&lt;".
1501
1502 Given:
1503   class A { int operator*(); };
1504   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
1505   A a;
1506   a &lt;&lt; a;   &lt;-- This matches
1507
1508 operatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the specified
1509 line and recordDecl(hasMethod(hasOverloadedOperatorName("*"))) matches
1510 the declaration of A.
1511
1512 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;
1513 </pre></td></tr>
1514
1515
1516 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isOverride0')"><a name="isOverride0Anchor">isOverride</a></td><td></td></tr>
1517 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
1518
1519 Given
1520   class A {
1521    public:
1522     virtual void x();
1523   };
1524   class B : public A {
1525    public:
1526     virtual void x();
1527   };
1528   matches B::x
1529 </pre></td></tr>
1530
1531
1532 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isVirtual0')"><a name="isVirtual0Anchor">isVirtual</a></td><td></td></tr>
1533 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches if the given method declaration is virtual.
1534
1535 Given
1536   class A {
1537    public:
1538     virtual void x();
1539   };
1540   matches A::x
1541 </pre></td></tr>
1542
1543
1544 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasOverloadedOperatorName1')"><a name="hasOverloadedOperatorName1Anchor">hasOverloadedOperatorName</a></td><td>StringRef Name</td></tr>
1545 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
1546
1547 Matches overloaded operator names specified in strings without the
1548 "operator" prefix: e.g. "&lt;&lt;".
1549
1550 Given:
1551   class A { int operator*(); };
1552   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
1553   A a;
1554   a &lt;&lt; a;   &lt;-- This matches
1555
1556 operatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the specified
1557 line and recordDecl(hasMethod(hasOverloadedOperatorName("*"))) matches
1558 the declaration of A.
1559
1560 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;
1561 </pre></td></tr>
1562
1563
1564 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom1')"><a name="isDerivedFrom1Anchor">isDerivedFrom</a></td><td>StringRef BaseName</td></tr>
1565 <tr><td colspan="4" class="doc" id="isDerivedFrom1"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
1566 </pre></td></tr>
1567
1568
1569 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicitTemplateSpecialization2')"><a name="isExplicitTemplateSpecialization2Anchor">isExplicitTemplateSpecialization</a></td><td></td></tr>
1570 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
1571 static member variable template instantiations.
1572
1573 Given
1574   template&lt;typename T&gt; void A(T t) { }
1575   template&lt;&gt; void A(int N) { }
1576 functionDecl(isExplicitTemplateSpecialization())
1577   matches the specialization A&lt;int&gt;().
1578
1579 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
1580 </pre></td></tr>
1581
1582
1583 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom1')"><a name="isSameOrDerivedFrom1Anchor">isSameOrDerivedFrom</a></td><td>StringRef BaseName</td></tr>
1584 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom1"><pre>Overloaded method as shortcut for
1585 isSameOrDerivedFrom(hasName(...)).
1586 </pre></td></tr>
1587
1588
1589 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isTemplateInstantiation2')"><a name="isTemplateInstantiation2Anchor">isTemplateInstantiation</a></td><td></td></tr>
1590 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
1591 member variable template instantiations.
1592
1593 Given
1594   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
1595 or
1596   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
1597 recordDecl(hasName("::X"), isTemplateInstantiation())
1598   matches the template instantiation of X&lt;A&gt;.
1599
1600 But given
1601   template &lt;typename T&gt;  class X {}; class A {};
1602   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
1603 recordDecl(hasName("::X"), isTemplateInstantiation())
1604   does not match, as X&lt;A&gt; is an explicit template specialization.
1605
1606 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
1607 </pre></td></tr>
1608
1609
1610 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs0')"><a name="argumentCountIs0Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
1611 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
1612 a specific number of arguments (including absent default arguments).
1613
1614 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
1615   void f(int x, int y);
1616   f(0, 0);
1617 </pre></td></tr>
1618
1619
1620 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals3')"><a name="equals3Anchor">equals</a></td><td>ValueT  Value</td></tr>
1621 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value.
1622
1623 Example matches true (matcher = boolLiteral(equals(true)))
1624   true
1625
1626 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1627            Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
1628 </pre></td></tr>
1629
1630
1631 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;</td><td class="name" onclick="toggle('statementCountIs0')"><a name="statementCountIs0Anchor">statementCountIs</a></td><td>unsigned N</td></tr>
1632 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
1633 child statements.
1634
1635 Example: Given
1636   { for (;;) {} }
1637 compoundStmt(statementCountIs(0)))
1638   matches '{}'
1639   but does not match the outer compound statement.
1640 </pre></td></tr>
1641
1642
1643 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConstantArrayType.html">ConstantArrayType</a>&gt;</td><td class="name" onclick="toggle('hasSize0')"><a name="hasSize0Anchor">hasSize</a></td><td>unsigned N</td></tr>
1644 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches ConstantArrayType nodes that have the specified size.
1645
1646 Given
1647   int a[42];
1648   int b[2 * 21];
1649   int c[41], d[43];
1650 constantArrayType(hasSize(42))
1651   matches "int a[42]" and "int b[2 * 21]"
1652 </pre></td></tr>
1653
1654
1655 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;</td><td class="name" onclick="toggle('declCountIs0')"><a name="declCountIs0Anchor">declCountIs</a></td><td>unsigned N</td></tr>
1656 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
1657 declarations.
1658
1659 Example: Given
1660   int a, b;
1661   int c;
1662   int d = 2, e;
1663 declCountIs(2)
1664   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
1665 </pre></td></tr>
1666
1667
1668 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('equalsNode0')"><a name="equalsNode0Anchor">equalsNode</a></td><td>Decl* Other</td></tr>
1669 <tr><td colspan="4" class="doc" id="equalsNode0"><pre>Matches if a node equals another node.
1670
1671 Decl has pointer identity in the AST.
1672 </pre></td></tr>
1673
1674
1675 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isPrivate0')"><a name="isPrivate0Anchor">isPrivate</a></td><td></td></tr>
1676 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations.
1677
1678 Given
1679   class C {
1680   public:    int a;
1681   protected: int b;
1682   private:   int c;
1683   };
1684 fieldDecl(isPrivate())
1685   matches 'int c;'
1686 </pre></td></tr>
1687
1688
1689 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isProtected0')"><a name="isProtected0Anchor">isProtected</a></td><td></td></tr>
1690 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations.
1691
1692 Given
1693   class C {
1694   public:    int a;
1695   protected: int b;
1696   private:   int c;
1697   };
1698 fieldDecl(isProtected())
1699   matches 'int b;'
1700 </pre></td></tr>
1701
1702
1703 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isPublic0')"><a name="isPublic0Anchor">isPublic</a></td><td></td></tr>
1704 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations.
1705
1706 Given
1707   class C {
1708   public:    int a;
1709   protected: int b;
1710   private:   int c;
1711   };
1712 fieldDecl(isPublic())
1713   matches 'int a;'
1714 </pre></td></tr>
1715
1716
1717 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;</td><td class="name" onclick="toggle('equals1')"><a name="equals1Anchor">equals</a></td><td>ValueT  Value</td></tr>
1718 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value.
1719
1720 Example matches true (matcher = boolLiteral(equals(true)))
1721   true
1722
1723 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1724            Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
1725 </pre></td></tr>
1726
1727
1728 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition2')"><a name="isDefinition2Anchor">isDefinition</a></td><td></td></tr>
1729 <tr><td colspan="4" class="doc" id="isDefinition2"><pre>Matches if a declaration has a body attached.
1730
1731 Example matches A, va, fa
1732   class A {};
1733   class B;  Doesn't match, as it has no body.
1734   int va;
1735   extern int vb;  Doesn't match, as it doesn't define the variable.
1736   void fa() {}
1737   void fb();  Doesn't match, as it has no body.
1738
1739 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
1740 </pre></td></tr>
1741
1742
1743 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicitTemplateSpecialization0')"><a name="isExplicitTemplateSpecialization0Anchor">isExplicitTemplateSpecialization</a></td><td></td></tr>
1744 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization0"><pre>Matches explicit template specializations of function, class, or
1745 static member variable template instantiations.
1746
1747 Given
1748   template&lt;typename T&gt; void A(T t) { }
1749   template&lt;&gt; void A(int N) { }
1750 functionDecl(isExplicitTemplateSpecialization())
1751   matches the specialization A&lt;int&gt;().
1752
1753 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
1754 </pre></td></tr>
1755
1756
1757 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isExternC0')"><a name="isExternC0Anchor">isExternC</a></td><td></td></tr>
1758 <tr><td colspan="4" class="doc" id="isExternC0"><pre>Matches extern "C" function declarations.
1759
1760 Given:
1761   extern "C" void f() {}
1762   extern "C" { void g() {} }
1763   void h() {}
1764 functionDecl(isExternC())
1765   matches the declaration of f and g, but not the declaration h
1766 </pre></td></tr>
1767
1768
1769 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isTemplateInstantiation0')"><a name="isTemplateInstantiation0Anchor">isTemplateInstantiation</a></td><td></td></tr>
1770 <tr><td colspan="4" class="doc" id="isTemplateInstantiation0"><pre>Matches template instantiations of function, class, or static
1771 member variable template instantiations.
1772
1773 Given
1774   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
1775 or
1776   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
1777 recordDecl(hasName("::X"), isTemplateInstantiation())
1778   matches the template instantiation of X&lt;A&gt;.
1779
1780 But given
1781   template &lt;typename T&gt;  class X {}; class A {};
1782   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
1783 recordDecl(hasName("::X"), isTemplateInstantiation())
1784   does not match, as X&lt;A&gt; is an explicit template specialization.
1785
1786 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
1787 </pre></td></tr>
1788
1789
1790 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('parameterCountIs0')"><a name="parameterCountIs0Anchor">parameterCountIs</a></td><td>unsigned N</td></tr>
1791 <tr><td colspan="4" class="doc" id="parameterCountIs0"><pre>Matches FunctionDecls that have a specific parameter count.
1792
1793 Given
1794   void f(int i) {}
1795   void g(int i, int j) {}
1796 functionDecl(parameterCountIs(2))
1797   matches g(int i, int j) {}
1798 </pre></td></tr>
1799
1800
1801 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;</td><td class="name" onclick="toggle('equals0')"><a name="equals0Anchor">equals</a></td><td>ValueT  Value</td></tr>
1802 <tr><td colspan="4" class="doc" id="equals0"><pre>Matches literals that are equal to the given value.
1803
1804 Example matches true (matcher = boolLiteral(equals(true)))
1805   true
1806
1807 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1808            Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
1809 </pre></td></tr>
1810
1811
1812 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('isArrow0')"><a name="isArrow0Anchor">isArrow</a></td><td></td></tr>
1813 <tr><td colspan="4" class="doc" id="isArrow0"><pre>Matches member expressions that are called with '-&gt;' as opposed
1814 to '.'.
1815
1816 Member calls on the implicit this pointer match as called with '-&gt;'.
1817
1818 Given
1819   class Y {
1820     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
1821     int a;
1822     static int b;
1823   };
1824 memberExpr(isArrow())
1825   matches this-&gt;x, x, y.x, a, this-&gt;b
1826 </pre></td></tr>
1827
1828
1829 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasName0')"><a name="hasName0Anchor">hasName</a></td><td>std::string Name</td></tr>
1830 <tr><td colspan="4" class="doc" id="hasName0"><pre>Matches NamedDecl nodes that have the specified name.
1831
1832 Supports specifying enclosing namespaces or classes by prefixing the name
1833 with '&lt;enclosing&gt;::'.
1834 Does not match typedefs of an underlying type with the given name.
1835
1836 Example matches X (Name == "X")
1837   class X;
1838
1839 Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
1840   namespace a { namespace b { class X; } }
1841 </pre></td></tr>
1842
1843
1844 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('matchesName0')"><a name="matchesName0Anchor">matchesName</a></td><td>std::string RegExp</td></tr>
1845 <tr><td colspan="4" class="doc" id="matchesName0"><pre>Matches NamedDecl nodes whose fully qualified names contain
1846 a substring matched by the given RegExp.
1847
1848 Supports specifying enclosing namespaces or classes by
1849 prefixing the name with '&lt;enclosing&gt;::'.  Does not match typedefs
1850 of an underlying type with the given name.
1851
1852 Example matches X (regexp == "::X")
1853   class X;
1854
1855 Example matches X (regexp is one of "::X", "^foo::.*X", among others)
1856   namespace foo { namespace bar { class X; } }
1857 </pre></td></tr>
1858
1859
1860 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('asString0')"><a name="asString0Anchor">asString</a></td><td>std::string Name</td></tr>
1861 <tr><td colspan="4" class="doc" id="asString0"><pre>Matches if the matched type is represented by the given string.
1862
1863 Given
1864   class Y { public: void x(); };
1865   void z() { Y* y; y-&gt;x(); }
1866 callExpr(on(hasType(asString("class Y *"))))
1867   matches y-&gt;x()
1868 </pre></td></tr>
1869
1870
1871 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasLocalQualifiers0')"><a name="hasLocalQualifiers0Anchor">hasLocalQualifiers</a></td><td></td></tr>
1872 <tr><td colspan="4" class="doc" id="hasLocalQualifiers0"><pre>Matches QualType nodes that have local CV-qualifiers attached to
1873 the node, not hidden within a typedef.
1874
1875 Given
1876   typedef const int const_int;
1877   const_int i;
1878   int *const j;
1879   int *volatile k;
1880   int m;
1881 varDecl(hasType(hasLocalQualifiers())) matches only j and k.
1882 i is const-qualified but the qualifier is not local.
1883 </pre></td></tr>
1884
1885
1886 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isConstQualified0')"><a name="isConstQualified0Anchor">isConstQualified</a></td><td></td></tr>
1887 <tr><td colspan="4" class="doc" id="isConstQualified0"><pre>Matches QualType nodes that are const-qualified, i.e., that
1888 include "top-level" const.
1889
1890 Given
1891   void a(int);
1892   void b(int const);
1893   void c(const int);
1894   void d(const int*);
1895   void e(int const) {};
1896 functionDecl(hasAnyParameter(hasType(isConstQualified())))
1897   matches "void b(int const)", "void c(const int)" and
1898   "void e(int const) {}". It does not match d as there
1899   is no top-level const on the parameter type "const int *".
1900 </pre></td></tr>
1901
1902
1903 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isInteger0')"><a name="isInteger0Anchor">isInteger</a></td><td></td></tr>
1904 <tr><td colspan="4" class="doc" id="isInteger0"><pre>Matches QualType nodes that are of integer type.
1905
1906 Given
1907   void a(int);
1908   void b(long);
1909   void c(double);
1910 functionDecl(hasAnyParameter(hasType(isInteger())))
1911 matches "a(int)", "b(long)", but not "c(double)".
1912 </pre></td></tr>
1913
1914
1915 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('equalsNode1')"><a name="equalsNode1Anchor">equalsNode</a></td><td>Stmt* Other</td></tr>
1916 <tr><td colspan="4" class="doc" id="equalsNode1"><pre>Matches if a node equals another node.
1917
1918 Stmt has pointer identity in the AST.
1919
1920 </pre></td></tr>
1921
1922
1923 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition0')"><a name="isDefinition0Anchor">isDefinition</a></td><td></td></tr>
1924 <tr><td colspan="4" class="doc" id="isDefinition0"><pre>Matches if a declaration has a body attached.
1925
1926 Example matches A, va, fa
1927   class A {};
1928   class B;  Doesn't match, as it has no body.
1929   int va;
1930   extern int vb;  Doesn't match, as it doesn't define the variable.
1931   void fa() {}
1932   void fb();  Doesn't match, as it has no body.
1933
1934 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
1935 </pre></td></tr>
1936
1937
1938 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;</td><td class="name" onclick="toggle('ofKind0')"><a name="ofKind0Anchor">ofKind</a></td><td>UnaryExprOrTypeTrait Kind</td></tr>
1939 <tr><td colspan="4" class="doc" id="ofKind0"><pre>Matches unary expressions of a certain kind.
1940
1941 Given
1942   int x;
1943   int s = sizeof(x) + alignof(x)
1944 unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
1945   matches sizeof(x)
1946 </pre></td></tr>
1947
1948
1949 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName1')"><a name="hasOperatorName1Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
1950 <tr><td colspan="4" class="doc" id="hasOperatorName1"><pre>Matches the operator Name of operator expressions (binary or
1951 unary).
1952
1953 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
1954   !(a || b)
1955 </pre></td></tr>
1956
1957
1958 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition1')"><a name="isDefinition1Anchor">isDefinition</a></td><td></td></tr>
1959 <tr><td colspan="4" class="doc" id="isDefinition1"><pre>Matches if a declaration has a body attached.
1960
1961 Example matches A, va, fa
1962   class A {};
1963   class B;  Doesn't match, as it has no body.
1964   int va;
1965   extern int vb;  Doesn't match, as it doesn't define the variable.
1966   void fa() {}
1967   void fb();  Doesn't match, as it has no body.
1968
1969 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
1970 </pre></td></tr>
1971
1972
1973 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicitTemplateSpecialization1')"><a name="isExplicitTemplateSpecialization1Anchor">isExplicitTemplateSpecialization</a></td><td></td></tr>
1974 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization1"><pre>Matches explicit template specializations of function, class, or
1975 static member variable template instantiations.
1976
1977 Given
1978   template&lt;typename T&gt; void A(T t) { }
1979   template&lt;&gt; void A(int N) { }
1980 functionDecl(isExplicitTemplateSpecialization())
1981   matches the specialization A&lt;int&gt;().
1982
1983 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
1984 </pre></td></tr>
1985
1986
1987 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isTemplateInstantiation1')"><a name="isTemplateInstantiation1Anchor">isTemplateInstantiation</a></td><td></td></tr>
1988 <tr><td colspan="4" class="doc" id="isTemplateInstantiation1"><pre>Matches template instantiations of function, class, or static
1989 member variable template instantiations.
1990
1991 Given
1992   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
1993 or
1994   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
1995 recordDecl(hasName("::X"), isTemplateInstantiation())
1996   matches the template instantiation of X&lt;A&gt;.
1997
1998 But given
1999   template &lt;typename T&gt;  class X {}; class A {};
2000   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2001 recordDecl(hasName("::X"), isTemplateInstantiation())
2002   does not match, as X&lt;A&gt; is an explicit template specialization.
2003
2004 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
2005 </pre></td></tr>
2006
2007 <!--END_NARROWING_MATCHERS -->
2008 </table>
2009
2010 <!-- ======================================================================= -->
2011 <h2 id="traversal-matchers">AST Traversal Matchers</h2>
2012 <!-- ======================================================================= -->
2013
2014 <p>Traversal matchers specify the relationship to other nodes that are
2015 reachable from the current node.</p>
2016
2017 <p>Note that there are special traversal matchers (has, hasDescendant, forEach and
2018 forEachDescendant) which work on all nodes and allow users to write more generic
2019 match expressions.</p>
2020
2021 <table>
2022 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
2023 <!-- START_TRAVERSAL_MATCHERS -->
2024
2025 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('eachOf0')"><a name="eachOf0Anchor">eachOf</a></td><td>Matcher&lt;*&gt;  P1, Matcher&lt;*&gt;  P2</td></tr>
2026 <tr><td colspan="4" class="doc" id="eachOf0"><pre>Matches if any of the given matchers matches.
2027
2028 Unlike anyOf, eachOf will generate a match result for each
2029 matching submatcher.
2030
2031 For example, in:
2032   class A { int a; int b; };
2033 The matcher:
2034   recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
2035                     has(fieldDecl(hasName("b")).bind("v"))))
2036 will generate two results binding "v", the first of which binds
2037 the field declaration of a, the second the field declaration of
2038 b.
2039
2040 Usable as: Any Matcher
2041 </pre></td></tr>
2042
2043
2044 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('findAll0')"><a name="findAll0Anchor">findAll</a></td><td>Matcher&lt;T&gt;  Matcher</td></tr>
2045 <tr><td colspan="4" class="doc" id="findAll0"><pre>Matches if the node or any descendant matches.
2046
2047 Generates results for each match.
2048
2049 For example, in:
2050   class A { class B {}; class C {}; };
2051 The matcher:
2052   recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("m")))
2053 will generate results for A, B and C.
2054
2055 Usable as: Any Matcher
2056 </pre></td></tr>
2057
2058
2059 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEach0')"><a name="forEach0Anchor">forEach</a></td><td>Matcher&lt;ChildT&gt;  ChildMatcher</td></tr>
2060 <tr><td colspan="4" class="doc" id="forEach0"><pre>Matches AST nodes that have child AST nodes that match the
2061 provided matcher.
2062
2063 Example matches X, Y (matcher = recordDecl(forEach(recordDecl(hasName("X")))
2064   class X {};  Matches X, because X::X is a class of name X inside X.
2065   class Y { class X {}; };
2066   class Z { class Y { class X {}; }; };  Does not match Z.
2067
2068 ChildT must be an AST base type.
2069
2070 As opposed to 'has', 'forEach' will cause a match for each result that
2071 matches instead of only on the first one.
2072
2073 Usable as: Any Matcher
2074 </pre></td></tr>
2075
2076
2077 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEachDescendant0')"><a name="forEachDescendant0Anchor">forEachDescendant</a></td><td>Matcher&lt;DescendantT&gt;  DescendantMatcher</td></tr>
2078 <tr><td colspan="4" class="doc" id="forEachDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
2079 provided matcher.
2080
2081 Example matches X, A, B, C
2082     (matcher = recordDecl(forEachDescendant(recordDecl(hasName("X")))))
2083   class X {};  Matches X, because X::X is a class of name X inside X.
2084   class A { class X {}; };
2085   class B { class C { class X {}; }; };
2086
2087 DescendantT must be an AST base type.
2088
2089 As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
2090 each result that matches instead of only on the first one.
2091
2092 Note: Recursively combined ForEachDescendant can cause many matches:
2093   recordDecl(forEachDescendant(recordDecl(forEachDescendant(recordDecl()))))
2094 will match 10 times (plus injected class name matches) on:
2095   class A { class B { class C { class D { class E {}; }; }; }; };
2096
2097 Usable as: Any Matcher
2098 </pre></td></tr>
2099
2100
2101 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('has0')"><a name="has0Anchor">has</a></td><td>Matcher&lt;ChildT&gt;  ChildMatcher</td></tr>
2102 <tr><td colspan="4" class="doc" id="has0"><pre>Matches AST nodes that have child AST nodes that match the
2103 provided matcher.
2104
2105 Example matches X, Y (matcher = recordDecl(has(recordDecl(hasName("X")))
2106   class X {};  Matches X, because X::X is a class of name X inside X.
2107   class Y { class X {}; };
2108   class Z { class Y { class X {}; }; };  Does not match Z.
2109
2110 ChildT must be an AST base type.
2111
2112 Usable as: Any Matcher
2113 </pre></td></tr>
2114
2115
2116 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasAncestor0')"><a name="hasAncestor0Anchor">hasAncestor</a></td><td>Matcher&lt;AncestorT&gt;  AncestorMatcher</td></tr>
2117 <tr><td colspan="4" class="doc" id="hasAncestor0"><pre>Matches AST nodes that have an ancestor that matches the provided
2118 matcher.
2119
2120 Given
2121 void f() { if (true) { int x = 42; } }
2122 void g() { for (;;) { int x = 43; } }
2123 expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
2124
2125 Usable as: Any Matcher
2126 </pre></td></tr>
2127
2128
2129 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasDescendant0')"><a name="hasDescendant0Anchor">hasDescendant</a></td><td>Matcher&lt;DescendantT&gt;  DescendantMatcher</td></tr>
2130 <tr><td colspan="4" class="doc" id="hasDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
2131 provided matcher.
2132
2133 Example matches X, Y, Z
2134     (matcher = recordDecl(hasDescendant(recordDecl(hasName("X")))))
2135   class X {};  Matches X, because X::X is a class of name X inside X.
2136   class Y { class X {}; };
2137   class Z { class Y { class X {}; }; };
2138
2139 DescendantT must be an AST base type.
2140
2141 Usable as: Any Matcher
2142 </pre></td></tr>
2143
2144
2145 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasParent0')"><a name="hasParent0Anchor">hasParent</a></td><td>Matcher&lt;ParentT&gt;  ParentMatcher</td></tr>
2146 <tr><td colspan="4" class="doc" id="hasParent0"><pre>Matches AST nodes that have a parent that matches the provided
2147 matcher.
2148
2149 Given
2150 void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
2151 compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
2152
2153 Usable as: Any Matcher
2154 </pre></td></tr>
2155
2156
2157 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasBase0')"><a name="hasBase0Anchor">hasBase</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2158 <tr><td colspan="4" class="doc" id="hasBase0"><pre>Matches the base expression of an array subscript expression.
2159
2160 Given
2161   int i[5];
2162   void f() { i[1] = 42; }
2163 arraySubscriptExpression(hasBase(implicitCastExpr(
2164     hasSourceExpression(declRefExpr()))))
2165   matches i[1] with the declRefExpr() matching i
2166 </pre></td></tr>
2167
2168
2169 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasIndex0')"><a name="hasIndex0Anchor">hasIndex</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2170 <tr><td colspan="4" class="doc" id="hasIndex0"><pre>Matches the index expression of an array subscript expression.
2171
2172 Given
2173   int i[5];
2174   void f() { i[1] = 42; }
2175 arraySubscriptExpression(hasIndex(integerLiteral()))
2176   matches i[1] with the integerLiteral() matching 1
2177 </pre></td></tr>
2178
2179
2180 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayTypeLoc.html">ArrayTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasElementTypeLoc1')"><a name="hasElementTypeLoc1Anchor">hasElementTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
2181 <tr><td colspan="4" class="doc" id="hasElementTypeLoc1"><pre>Matches arrays and C99 complex types that have a specific element
2182 type.
2183
2184 Given
2185   struct A {};
2186   A a[7];
2187   int b[7];
2188 arrayType(hasElementType(builtinType()))
2189   matches "int b[7]"
2190
2191 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;
2192 </pre></td></tr>
2193
2194
2195 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;</td><td class="name" onclick="toggle('hasElementType1')"><a name="hasElementType1Anchor">hasElementType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
2196 <tr><td colspan="4" class="doc" id="hasElementType1"><pre>Matches arrays and C99 complex types that have a specific element
2197 type.
2198
2199 Given
2200   struct A {};
2201   A a[7];
2202   int b[7];
2203 arrayType(hasElementType(builtinType()))
2204   matches "int b[7]"
2205
2206 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;
2207 </pre></td></tr>
2208
2209
2210 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicTypeLoc.html">AtomicTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasValueTypeLoc0')"><a name="hasValueTypeLoc0Anchor">hasValueTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
2211 <tr><td colspan="4" class="doc" id="hasValueTypeLoc0"><pre>Matches atomic types with a specific value type.
2212
2213 Given
2214   _Atomic(int) i;
2215   _Atomic(float) f;
2216 atomicType(hasValueType(isInteger()))
2217  matches "_Atomic(int) i"
2218
2219 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
2220 </pre></td></tr>
2221
2222
2223 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;</td><td class="name" onclick="toggle('hasValueType0')"><a name="hasValueType0Anchor">hasValueType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
2224 <tr><td colspan="4" class="doc" id="hasValueType0"><pre>Matches atomic types with a specific value type.
2225
2226 Given
2227   _Atomic(int) i;
2228   _Atomic(float) f;
2229 atomicType(hasValueType(isInteger()))
2230  matches "_Atomic(int) i"
2231
2232 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
2233 </pre></td></tr>
2234
2235
2236 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;</td><td class="name" onclick="toggle('hasDeducedType0')"><a name="hasDeducedType0Anchor">hasDeducedType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
2237 <tr><td colspan="4" class="doc" id="hasDeducedType0"><pre>Matches AutoType nodes where the deduced type is a specific type.
2238
2239 Note: There is no TypeLoc for the deduced type and thus no
2240 getDeducedLoc() matcher.
2241
2242 Given
2243   auto a = 1;
2244   auto b = 2.0;
2245 autoType(hasDeducedType(isInteger()))
2246   matches "auto a"
2247
2248 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;
2249 </pre></td></tr>
2250
2251
2252 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasEitherOperand0')"><a name="hasEitherOperand0Anchor">hasEitherOperand</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;  InnerMatcher</td></tr>
2253 <tr><td colspan="4" class="doc" id="hasEitherOperand0"><pre>Matches if either the left hand side or the right hand side of a
2254 binary operator matches.
2255 </pre></td></tr>
2256
2257
2258 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasLHS0')"><a name="hasLHS0Anchor">hasLHS</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2259 <tr><td colspan="4" class="doc" id="hasLHS0"><pre>Matches the left hand side of binary operator expressions.
2260
2261 Example matches a (matcher = binaryOperator(hasLHS()))
2262   a || b
2263 </pre></td></tr>
2264
2265
2266 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasRHS0')"><a name="hasRHS0Anchor">hasRHS</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2267 <tr><td colspan="4" class="doc" id="hasRHS0"><pre>Matches the right hand side of binary operator expressions.
2268
2269 Example matches b (matcher = binaryOperator(hasRHS()))
2270   a || b
2271 </pre></td></tr>
2272
2273
2274 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerTypeLoc.html">BlockPointerTypeLoc</a>&gt;</td><td class="name" onclick="toggle('pointeeLoc3')"><a name="pointeeLoc3Anchor">pointeeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
2275 <tr><td colspan="4" class="doc" id="pointeeLoc3"><pre>Narrows PointerType (and similar) matchers to those where the
2276 pointee matches a given matcher.
2277
2278 Given
2279   int *a;
2280   int const *b;
2281   float const *f;
2282 pointerType(pointee(isConstQualified(), isInteger()))
2283   matches "int const *b"
2284
2285 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
2286   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
2287 </pre></td></tr>
2288
2289
2290 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;</td><td class="name" onclick="toggle('pointee3')"><a name="pointee3Anchor">pointee</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
2291 <tr><td colspan="4" class="doc" id="pointee3"><pre>Narrows PointerType (and similar) matchers to those where the
2292 pointee matches a given matcher.
2293
2294 Given
2295   int *a;
2296   int const *b;
2297   float const *f;
2298 pointerType(pointee(isConstQualified(), isInteger()))
2299   matches "int const *b"
2300
2301 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
2302   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
2303 </pre></td></tr>
2304
2305
2306 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration3')"><a name="hasDeclaration3Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
2307 <tr><td colspan="4" class="doc" id="hasDeclaration3"><pre>Matches a type if the declaration of the type matches the given
2308 matcher.
2309
2310 In addition to being usable as Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, also usable as
2311 Matcher&lt;T&gt; for any T supporting the getDecl() member function. e.g. various
2312 subtypes of clang::Type.
2313
2314 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;,
2315   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
2316   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;
2317 </pre></td></tr>
2318
2319
2320 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyConstructorInitializer0')"><a name="hasAnyConstructorInitializer0Anchor">hasAnyConstructorInitializer</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt; InnerMatcher</td></tr>
2321 <tr><td colspan="4" class="doc" id="hasAnyConstructorInitializer0"><pre>Matches a constructor initializer.
2322
2323 Given
2324   struct Foo {
2325     Foo() : foo_(1) { }
2326     int foo_;
2327   };
2328 recordDecl(has(constructorDecl(hasAnyConstructorInitializer(anything()))))
2329   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
2330 </pre></td></tr>
2331
2332
2333 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('forField0')"><a name="forField0Anchor">forField</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt; InnerMatcher</td></tr>
2334 <tr><td colspan="4" class="doc" id="forField0"><pre>Matches the field declaration of a constructor initializer.
2335
2336 Given
2337   struct Foo {
2338     Foo() : foo_(1) { }
2339     int foo_;
2340   };
2341 recordDecl(has(constructorDecl(hasAnyConstructorInitializer(
2342     forField(hasName("foo_"))))))
2343   matches Foo
2344 with forField matching foo_
2345 </pre></td></tr>
2346
2347
2348 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('withInitializer0')"><a name="withInitializer0Anchor">withInitializer</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2349 <tr><td colspan="4" class="doc" id="withInitializer0"><pre>Matches the initializer expression of a constructor initializer.
2350
2351 Given
2352   struct Foo {
2353     Foo() : foo_(1) { }
2354     int foo_;
2355   };
2356 recordDecl(has(constructorDecl(hasAnyConstructorInitializer(
2357     withInitializer(integerLiteral(equals(1)))))))
2358   matches Foo
2359 with withInitializer matching (1)
2360 </pre></td></tr>
2361
2362
2363 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('on0')"><a name="on0Anchor">on</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2364 <tr><td colspan="4" class="doc" id="on0"><pre>Matches on the implicit object argument of a member call expression.
2365
2366 Example matches y.x() (matcher = callExpr(on(hasType(recordDecl(hasName("Y"))))))
2367   class Y { public: void x(); };
2368   void z() { Y y; y.x(); }",
2369
2370 FIXME: Overload to allow directly matching types?
2371 </pre></td></tr>
2372
2373
2374 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('onImplicitObjectArgument0')"><a name="onImplicitObjectArgument0Anchor">onImplicitObjectArgument</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2375 <tr><td colspan="4" class="doc" id="onImplicitObjectArgument0"><pre></pre></td></tr>
2376
2377
2378 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType1')"><a name="thisPointerType1Anchor">thisPointerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
2379 <tr><td colspan="4" class="doc" id="thisPointerType1"><pre>Overloaded to match the type's declaration.
2380 </pre></td></tr>
2381
2382
2383 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('ofClass0')"><a name="ofClass0Anchor">ofClass</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt; InnerMatcher</td></tr>
2384 <tr><td colspan="4" class="doc" id="ofClass0"><pre>Matches the class declaration that the given method declaration
2385 belongs to.
2386
2387 FIXME: Generalize this for other kinds of declarations.
2388 FIXME: What other kind of declarations would we need to generalize
2389 this to?
2390
2391 Example matches A() in the last line
2392     (matcher = constructExpr(hasDeclaration(methodDecl(
2393         ofClass(hasName("A"))))))
2394   class A {
2395    public:
2396     A();
2397   };
2398   A a = A();
2399 </pre></td></tr>
2400
2401
2402 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasMethod0')"><a name="hasMethod0Anchor">hasMethod</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
2403 <tr><td colspan="4" class="doc" id="hasMethod0"><pre>Matches the first method of a class or struct that satisfies InnerMatcher.
2404
2405 Given:
2406   class A { void func(); };
2407   class B { void member(); };
2408
2409 recordDecl(hasMethod(hasName("func"))) matches the declaration of A
2410 but not B.
2411 </pre></td></tr>
2412
2413
2414 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom0')"><a name="isDerivedFrom0Anchor">isDerivedFrom</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
2415 <tr><td colspan="4" class="doc" id="isDerivedFrom0"><pre>Matches C++ classes that are directly or indirectly derived from
2416 a class matching Base.
2417
2418 Note that a class is not considered to be derived from itself.
2419
2420 Example matches Y, Z, C (Base == hasName("X"))
2421   class X;
2422   class Y : public X {};  directly derived
2423   class Z : public Y {};  indirectly derived
2424   typedef X A;
2425   typedef A B;
2426   class C : public B {};  derived from a typedef of X
2427
2428 In the following example, Bar matches isDerivedFrom(hasName("X")):
2429   class Foo;
2430   typedef Foo X;
2431   class Bar : public Foo {};  derived from a type that X is a typedef of
2432 </pre></td></tr>
2433
2434
2435 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom0')"><a name="isSameOrDerivedFrom0Anchor">isSameOrDerivedFrom</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
2436 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom0"><pre>Similar to isDerivedFrom(), but also matches classes that directly
2437 match Base.
2438 </pre></td></tr>
2439
2440
2441 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('callee1')"><a name="callee1Anchor">callee</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
2442 <tr><td colspan="4" class="doc" id="callee1"><pre>Matches if the call expression's callee's declaration matches the
2443 given matcher.
2444
2445 Example matches y.x() (matcher = callExpr(callee(methodDecl(hasName("x")))))
2446   class Y { public: void x(); };
2447   void z() { Y y; y.x();
2448 </pre></td></tr>
2449
2450
2451 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyArgument0')"><a name="hasAnyArgument0Anchor">hasAnyArgument</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2452 <tr><td colspan="4" class="doc" id="hasAnyArgument0"><pre>Matches any argument of a call expression or a constructor call
2453 expression.
2454
2455 Given
2456   void x(int, int, int) { int y; x(1, y, 42); }
2457 callExpr(hasAnyArgument(declRefExpr()))
2458   matches x(1, y, 42)
2459 with hasAnyArgument(...)
2460   matching y
2461 </pre></td></tr>
2462
2463
2464 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument0')"><a name="hasArgument0Anchor">hasArgument</a></td><td>unsigned N, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2465 <tr><td colspan="4" class="doc" id="hasArgument0"><pre>Matches the n'th argument of a call expression or a constructor
2466 call expression.
2467
2468 Example matches y in x(y)
2469     (matcher = callExpr(hasArgument(0, declRefExpr())))
2470   void x(int) { int y; x(y); }
2471 </pre></td></tr>
2472
2473
2474 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration4')"><a name="hasDeclaration4Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
2475 <tr><td colspan="4" class="doc" id="hasDeclaration4"><pre>Matches a type if the declaration of the type matches the given
2476 matcher.
2477
2478 In addition to being usable as Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, also usable as
2479 Matcher&lt;T&gt; for any T supporting the getDecl() member function. e.g. various
2480 subtypes of clang::Type.
2481
2482 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;,
2483   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
2484   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;
2485 </pre></td></tr>
2486
2487
2488 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;</td><td class="name" onclick="toggle('hasSourceExpression0')"><a name="hasSourceExpression0Anchor">hasSourceExpression</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2489 <tr><td colspan="4" class="doc" id="hasSourceExpression0"><pre>Matches if the cast's source expression matches the given matcher.
2490
2491 Example: matches "a string" (matcher =
2492                                  hasSourceExpression(constructExpr()))
2493 class URL { URL(string); };
2494 URL url = "a string";
2495 </pre></td></tr>
2496
2497
2498 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument0')"><a name="hasAnyTemplateArgument0Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
2499 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches classTemplateSpecializations that have at least one
2500 TemplateArgument matching the given InnerMatcher.
2501
2502 Given
2503   template&lt;typename T&gt; class A {};
2504   template&lt;&gt; class A&lt;double&gt; {};
2505   A&lt;int&gt; a;
2506 classTemplateSpecializationDecl(hasAnyTemplateArgument(
2507     refersToType(asString("int"))))
2508   matches the specialization A&lt;int&gt;
2509 </pre></td></tr>
2510
2511
2512 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument0')"><a name="hasTemplateArgument0Anchor">hasTemplateArgument</a></td><td>unsigned N, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
2513 <tr><td colspan="4" class="doc" id="hasTemplateArgument0"><pre>Matches classTemplateSpecializations where the n'th TemplateArgument
2514 matches the given InnerMatcher.
2515
2516 Given
2517   template&lt;typename T, typename U&gt; class A {};
2518   A&lt;bool, int&gt; b;
2519   A&lt;int, bool&gt; c;
2520 classTemplateSpecializationDecl(hasTemplateArgument(
2521     1, refersToType(asString("int"))))
2522   matches the specialization A&lt;bool, int&gt;
2523 </pre></td></tr>
2524
2525
2526 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexTypeLoc.html">ComplexTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasElementTypeLoc0')"><a name="hasElementTypeLoc0Anchor">hasElementTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
2527 <tr><td colspan="4" class="doc" id="hasElementTypeLoc0"><pre>Matches arrays and C99 complex types that have a specific element
2528 type.
2529
2530 Given
2531   struct A {};
2532   A a[7];
2533   int b[7];
2534 arrayType(hasElementType(builtinType()))
2535   matches "int b[7]"
2536
2537 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;
2538 </pre></td></tr>
2539
2540
2541 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;</td><td class="name" onclick="toggle('hasElementType0')"><a name="hasElementType0Anchor">hasElementType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
2542 <tr><td colspan="4" class="doc" id="hasElementType0"><pre>Matches arrays and C99 complex types that have a specific element
2543 type.
2544
2545 Given
2546   struct A {};
2547   A a[7];
2548   int b[7];
2549 arrayType(hasElementType(builtinType()))
2550   matches "int b[7]"
2551
2552 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;
2553 </pre></td></tr>
2554
2555
2556 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;</td><td class="name" onclick="toggle('hasAnySubstatement0')"><a name="hasAnySubstatement0Anchor">hasAnySubstatement</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
2557 <tr><td colspan="4" class="doc" id="hasAnySubstatement0"><pre>Matches compound statements where at least one substatement matches
2558 a given matcher.
2559
2560 Given
2561   { {}; 1+2; }
2562 hasAnySubstatement(compoundStmt())
2563   matches '{ {}; 1+2; }'
2564 with compoundStmt()
2565   matching '{}'
2566 </pre></td></tr>
2567
2568
2569 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConditionalOperator.html">ConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasCondition4')"><a name="hasCondition4Anchor">hasCondition</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2570 <tr><td colspan="4" class="doc" id="hasCondition4"><pre>Matches the condition expression of an if statement, for loop,
2571 or conditional operator.
2572
2573 Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
2574   if (true) {}
2575 </pre></td></tr>
2576
2577
2578 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConditionalOperator.html">ConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasFalseExpression0')"><a name="hasFalseExpression0Anchor">hasFalseExpression</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2579 <tr><td colspan="4" class="doc" id="hasFalseExpression0"><pre>Matches the false branch expression of a conditional operator.
2580
2581 Example matches b
2582   condition ? a : b
2583 </pre></td></tr>
2584
2585
2586 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ConditionalOperator.html">ConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasTrueExpression0')"><a name="hasTrueExpression0Anchor">hasTrueExpression</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2587 <tr><td colspan="4" class="doc" id="hasTrueExpression0"><pre>Matches the true branch expression of a conditional operator.
2588
2589 Example matches a
2590   condition ? a : b
2591 </pre></td></tr>
2592
2593
2594 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('throughUsingDecl0')"><a name="throughUsingDecl0Anchor">throughUsingDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt; InnerMatcher</td></tr>
2595 <tr><td colspan="4" class="doc" id="throughUsingDecl0"><pre>Matches a DeclRefExpr that refers to a declaration through a
2596 specific using shadow declaration.
2597
2598 FIXME: This currently only works for functions. Fix.
2599
2600 Given
2601   namespace a { void f() {} }
2602   using a::f;
2603   void g() {
2604     f();     Matches this ..
2605     a::f();  .. but not this.
2606   }
2607 declRefExpr(throughUsingDeclaration(anything()))
2608   matches f()
2609 </pre></td></tr>
2610
2611
2612 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('to0')"><a name="to0Anchor">to</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
2613 <tr><td colspan="4" class="doc" id="to0"><pre>Matches a DeclRefExpr that refers to a declaration that matches the
2614 specified matcher.
2615
2616 Example matches x in if(x)
2617     (matcher = declRefExpr(to(varDecl(hasName("x")))))
2618   bool x;
2619   if (x) {}
2620 </pre></td></tr>
2621
2622
2623 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;</td><td class="name" onclick="toggle('containsDeclaration0')"><a name="containsDeclaration0Anchor">containsDeclaration</a></td><td>unsigned N, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
2624 <tr><td colspan="4" class="doc" id="containsDeclaration0"><pre>Matches the n'th declaration of a declaration statement.
2625
2626 Note that this does not work for global declarations because the AST
2627 breaks up multiple-declaration DeclStmt's into multiple single-declaration
2628 DeclStmt's.
2629 Example: Given non-global declarations
2630   int a, b = 0;
2631   int c;
2632   int d = 2, e;
2633 declStmt(containsDeclaration(
2634       0, varDecl(hasInitializer(anything()))))
2635   matches only 'int d = 2, e;', and
2636 declStmt(containsDeclaration(1, varDecl()))
2637   matches 'int a, b = 0' as well as 'int d = 2, e;'
2638   but 'int c;' is not matched.
2639 </pre></td></tr>
2640
2641
2642 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;</td><td class="name" onclick="toggle('hasSingleDecl0')"><a name="hasSingleDecl0Anchor">hasSingleDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
2643 <tr><td colspan="4" class="doc" id="hasSingleDecl0"><pre>Matches the Decl of a DeclStmt which has a single declaration.
2644
2645 Given
2646   int a, b;
2647   int c;
2648 declStmt(hasSingleDecl(anything()))
2649   matches 'int c;' but not 'int a, b;'.
2650 </pre></td></tr>
2651
2652
2653 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('hasDeclContext0')"><a name="hasDeclContext0Anchor">hasDeclContext</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
2654 <tr><td colspan="4" class="doc" id="hasDeclContext0"><pre>Matches declarations whose declaration context, interpreted as a
2655 Decl, matches InnerMatcher.
2656
2657 Given
2658   namespace N {
2659     namespace M {
2660       class D {};
2661     }
2662   }
2663
2664 recordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
2665 declaration of class D.
2666 </pre></td></tr>
2667
2668
2669 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody0')"><a name="hasBody0Anchor">hasBody</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
2670 <tr><td colspan="4" class="doc" id="hasBody0"><pre>Matches a 'for', 'while', or 'do while' statement that has
2671 a given body.
2672
2673 Given
2674   for (;;) {}
2675 hasBody(compoundStmt())
2676   matches 'for (;;) {}'
2677 with compoundStmt()
2678   matching '{}'
2679 </pre></td></tr>
2680
2681
2682 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition3')"><a name="hasCondition3Anchor">hasCondition</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2683 <tr><td colspan="4" class="doc" id="hasCondition3"><pre>Matches the condition expression of an if statement, for loop,
2684 or conditional operator.
2685
2686 Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
2687   if (true) {}
2688 </pre></td></tr>
2689
2690
2691 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;</td><td class="name" onclick="toggle('hasQualifier0')"><a name="hasQualifier0Anchor">hasQualifier</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt; InnerMatcher</td></tr>
2692 <tr><td colspan="4" class="doc" id="hasQualifier0"><pre>Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
2693 matches InnerMatcher if the qualifier exists.
2694
2695 Given
2696   namespace N {
2697     namespace M {
2698       class D {};
2699     }
2700   }
2701   N::M::D d;
2702
2703 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
2704 matches the type of the variable declaration of d.
2705 </pre></td></tr>
2706
2707
2708 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;</td><td class="name" onclick="toggle('namesType0')"><a name="namesType0Anchor">namesType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
2709 <tr><td colspan="4" class="doc" id="namesType0"><pre>Matches ElaboratedTypes whose named type matches InnerMatcher.
2710
2711 Given
2712   namespace N {
2713     namespace M {
2714       class D {};
2715     }
2716   }
2717   N::M::D d;
2718
2719 elaboratedType(namesType(recordType(
2720 hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
2721 declaration of d.
2722 </pre></td></tr>
2723
2724
2725 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasDestinationType0')"><a name="hasDestinationType0Anchor">hasDestinationType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
2726 <tr><td colspan="4" class="doc" id="hasDestinationType0"><pre>Matches casts whose destination type matches a given matcher.
2727
2728 (Note: Clang's AST refers to other conversions as "casts" too, and calls
2729 actual casts "explicit" casts.)
2730 </pre></td></tr>
2731
2732
2733 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('hasType3')"><a name="hasType3Anchor">hasType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
2734 <tr><td colspan="4" class="doc" id="hasType3"><pre>Overloaded to match the declaration of the expression's or value
2735 declaration's type.
2736
2737 In case of a value declaration (for example a variable declaration),
2738 this resolves one layer of indirection. For example, in the value
2739 declaration "X x;", recordDecl(hasName("X")) matches the declaration of X,
2740 while varDecl(hasType(recordDecl(hasName("X")))) matches the declaration
2741 of x."
2742
2743 Example matches x (matcher = expr(hasType(recordDecl(hasName("X")))))
2744             and z (matcher = varDecl(hasType(recordDecl(hasName("X")))))
2745  class X {};
2746  void y(X &amp;x) { x; X z; }
2747
2748 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;
2749 </pre></td></tr>
2750
2751
2752 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringImpCasts0')"><a name="ignoringImpCasts0Anchor">ignoringImpCasts</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2753 <tr><td colspan="4" class="doc" id="ignoringImpCasts0"><pre>Matches expressions that match InnerMatcher after any implicit casts
2754 are stripped off.
2755
2756 Parentheses and explicit casts are not discarded.
2757 Given
2758   int arr[5];
2759   int a = 0;
2760   char b = 0;
2761   const int c = a;
2762   int *d = arr;
2763   long e = (long) 0l;
2764 The matchers
2765    varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
2766    varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
2767 would match the declarations for a, b, c, and d, but not e.
2768 While
2769    varDecl(hasInitializer(integerLiteral()))
2770    varDecl(hasInitializer(declRefExpr()))
2771 only match the declarations for b, c, and d.
2772 </pre></td></tr>
2773
2774
2775 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringParenCasts0')"><a name="ignoringParenCasts0Anchor">ignoringParenCasts</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2776 <tr><td colspan="4" class="doc" id="ignoringParenCasts0"><pre>Matches expressions that match InnerMatcher after parentheses and
2777 casts are stripped off.
2778
2779 Implicit and non-C Style casts are also discarded.
2780 Given
2781   int a = 0;
2782   char b = (0);
2783   void* c = reinterpret_cast&lt;char*&gt;(0);
2784   char d = char(0);
2785 The matcher
2786    varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
2787 would match the declarations for a, b, c, and d.
2788 while
2789    varDecl(hasInitializer(integerLiteral()))
2790 only match the declaration for a.
2791 </pre></td></tr>
2792
2793
2794 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringParenImpCasts0')"><a name="ignoringParenImpCasts0Anchor">ignoringParenImpCasts</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2795 <tr><td colspan="4" class="doc" id="ignoringParenImpCasts0"><pre>Matches expressions that match InnerMatcher after implicit casts and
2796 parentheses are stripped off.
2797
2798 Explicit casts are not discarded.
2799 Given
2800   int arr[5];
2801   int a = 0;
2802   char b = (0);
2803   const int c = a;
2804   int *d = (arr);
2805   long e = ((long) 0l);
2806 The matchers
2807    varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
2808    varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
2809 would match the declarations for a, b, c, and d, but not e.
2810 while
2811    varDecl(hasInitializer(integerLiteral()))
2812    varDecl(hasInitializer(declRefExpr()))
2813 would only match the declaration for a.
2814 </pre></td></tr>
2815
2816
2817 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody1')"><a name="hasBody1Anchor">hasBody</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
2818 <tr><td colspan="4" class="doc" id="hasBody1"><pre>Matches a 'for', 'while', or 'do while' statement that has
2819 a given body.
2820
2821 Given
2822   for (;;) {}
2823 hasBody(compoundStmt())
2824   matches 'for (;;) {}'
2825 with compoundStmt()
2826   matching '{}'
2827 </pre></td></tr>
2828
2829
2830 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition1')"><a name="hasCondition1Anchor">hasCondition</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2831 <tr><td colspan="4" class="doc" id="hasCondition1"><pre>Matches the condition expression of an if statement, for loop,
2832 or conditional operator.
2833
2834 Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
2835   if (true) {}
2836 </pre></td></tr>
2837
2838
2839 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasIncrement0')"><a name="hasIncrement0Anchor">hasIncrement</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
2840 <tr><td colspan="4" class="doc" id="hasIncrement0"><pre>Matches the increment statement of a for loop.
2841
2842 Example:
2843     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
2844 matches '++x' in
2845     for (x; x &lt; N; ++x) { }
2846 </pre></td></tr>
2847
2848
2849 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasLoopInit0')"><a name="hasLoopInit0Anchor">hasLoopInit</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
2850 <tr><td colspan="4" class="doc" id="hasLoopInit0"><pre>Matches the initialization statement of a for loop.
2851
2852 Example:
2853     forStmt(hasLoopInit(declStmt()))
2854 matches 'int x = 0' in
2855     for (int x = 0; x &lt; N; ++x) { }
2856 </pre></td></tr>
2857
2858
2859 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyParameter0')"><a name="hasAnyParameter0Anchor">hasAnyParameter</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
2860 <tr><td colspan="4" class="doc" id="hasAnyParameter0"><pre>Matches any parameter of a function declaration.
2861
2862 Does not match the 'this' parameter of a method.
2863
2864 Given
2865   class X { void f(int x, int y, int z) {} };
2866 methodDecl(hasAnyParameter(hasName("y")))
2867   matches f(int x, int y, int z) {}
2868 with hasAnyParameter(...)
2869   matching int y
2870 </pre></td></tr>
2871
2872
2873 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasParameter0')"><a name="hasParameter0Anchor">hasParameter</a></td><td>unsigned N, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
2874 <tr><td colspan="4" class="doc" id="hasParameter0"><pre>Matches the n'th parameter of a function declaration.
2875
2876 Given
2877   class X { void f(int x) {} };
2878 methodDecl(hasParameter(0, hasType(varDecl())))
2879   matches f(int x) {}
2880 with hasParameter(...)
2881   matching int x
2882 </pre></td></tr>
2883
2884
2885 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('returns0')"><a name="returns0Anchor">returns</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
2886 <tr><td colspan="4" class="doc" id="returns0"><pre>Matches the return type of a function declaration.
2887
2888 Given:
2889   class X { int f() { return 1; } };
2890 methodDecl(returns(asString("int")))
2891   matches int f() { return 1; }
2892 </pre></td></tr>
2893
2894
2895 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition0')"><a name="hasCondition0Anchor">hasCondition</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2896 <tr><td colspan="4" class="doc" id="hasCondition0"><pre>Matches the condition expression of an if statement, for loop,
2897 or conditional operator.
2898
2899 Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
2900   if (true) {}
2901 </pre></td></tr>
2902
2903
2904 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasConditionVariableStatement0')"><a name="hasConditionVariableStatement0Anchor">hasConditionVariableStatement</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt; InnerMatcher</td></tr>
2905 <tr><td colspan="4" class="doc" id="hasConditionVariableStatement0"><pre>Matches the condition variable statement in an if statement.
2906
2907 Given
2908   if (A* a = GetAPointer()) {}
2909 hasConditionVariableStatment(...)
2910   matches 'A* a = GetAPointer()'.
2911 </pre></td></tr>
2912
2913
2914 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ImplicitCastExpr.html">ImplicitCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasImplicitDestinationType0')"><a name="hasImplicitDestinationType0Anchor">hasImplicitDestinationType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
2915 <tr><td colspan="4" class="doc" id="hasImplicitDestinationType0"><pre>Matches implicit casts whose destination type matches a given
2916 matcher.
2917
2918 FIXME: Unit test this matcher
2919 </pre></td></tr>
2920
2921
2922 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration2')"><a name="hasDeclaration2Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
2923 <tr><td colspan="4" class="doc" id="hasDeclaration2"><pre>Matches a type if the declaration of the type matches the given
2924 matcher.
2925
2926 In addition to being usable as Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, also usable as
2927 Matcher&lt;T&gt; for any T supporting the getDecl() member function. e.g. various
2928 subtypes of clang::Type.
2929
2930 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;,
2931   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
2932   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;
2933 </pre></td></tr>
2934
2935
2936 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasObjectExpression0')"><a name="hasObjectExpression0Anchor">hasObjectExpression</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
2937 <tr><td colspan="4" class="doc" id="hasObjectExpression0"><pre>Matches a member expression where the object expression is
2938 matched by a given matcher.
2939
2940 Given
2941   struct X { int m; };
2942   void f(X x) { x.m; m; }
2943 memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))))
2944   matches "x.m" and "m"
2945 with hasObjectExpression(...)
2946   matching "x" and the implicit object expression of "m" which has type X*.
2947 </pre></td></tr>
2948
2949
2950 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('member0')"><a name="member0Anchor">member</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt; InnerMatcher</td></tr>
2951 <tr><td colspan="4" class="doc" id="member0"><pre>Matches a member expression where the member is matched by a
2952 given matcher.
2953
2954 Given
2955   struct { int first, second; } first, second;
2956   int i(second.first);
2957   int j(first.second);
2958 memberExpr(member(hasName("first")))
2959   matches second.first
2960   but not first.second (because the member name there is "second").
2961 </pre></td></tr>
2962
2963
2964 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerTypeLoc.html">MemberPointerTypeLoc</a>&gt;</td><td class="name" onclick="toggle('pointeeLoc2')"><a name="pointeeLoc2Anchor">pointeeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
2965 <tr><td colspan="4" class="doc" id="pointeeLoc2"><pre>Narrows PointerType (and similar) matchers to those where the
2966 pointee matches a given matcher.
2967
2968 Given
2969   int *a;
2970   int const *b;
2971   float const *f;
2972 pointerType(pointee(isConstQualified(), isInteger()))
2973   matches "int const *b"
2974
2975 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
2976   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
2977 </pre></td></tr>
2978
2979
2980 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;</td><td class="name" onclick="toggle('pointee2')"><a name="pointee2Anchor">pointee</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
2981 <tr><td colspan="4" class="doc" id="pointee2"><pre>Narrows PointerType (and similar) matchers to those where the
2982 pointee matches a given matcher.
2983
2984 Given
2985   int *a;
2986   int const *b;
2987   float const *f;
2988 pointerType(pointee(isConstQualified(), isInteger()))
2989   matches "int const *b"
2990
2991 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
2992   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
2993 </pre></td></tr>
2994
2995
2996 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('hasPrefix1')"><a name="hasPrefix1Anchor">hasPrefix</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt; InnerMatcher</td></tr>
2997 <tr><td colspan="4" class="doc" id="hasPrefix1"><pre>Matches on the prefix of a NestedNameSpecifierLoc.
2998
2999 Given
3000   struct A { struct B { struct C {}; }; };
3001   A::B::C c;
3002 nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
3003   matches "A::"
3004 </pre></td></tr>
3005
3006
3007 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('loc1')"><a name="loc1Anchor">loc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;  InnerMatcher</td></tr>
3008 <tr><td colspan="4" class="doc" id="loc1"><pre>Matches NestedNameSpecifierLocs for which the given inner
3009 NestedNameSpecifier-matcher matches.
3010 </pre></td></tr>
3011
3012
3013 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('specifiesTypeLoc0')"><a name="specifiesTypeLoc0Anchor">specifiesTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; InnerMatcher</td></tr>
3014 <tr><td colspan="4" class="doc" id="specifiesTypeLoc0"><pre>Matches nested name specifier locs that specify a type matching the
3015 given TypeLoc.
3016
3017 Given
3018   struct A { struct B { struct C {}; }; };
3019   A::B::C c;
3020 nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
3021   hasDeclaration(recordDecl(hasName("A")))))))
3022   matches "A::"
3023 </pre></td></tr>
3024
3025
3026 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('hasPrefix0')"><a name="hasPrefix0Anchor">hasPrefix</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt; InnerMatcher</td></tr>
3027 <tr><td colspan="4" class="doc" id="hasPrefix0"><pre>Matches on the prefix of a NestedNameSpecifier.
3028
3029 Given
3030   struct A { struct B { struct C {}; }; };
3031   A::B::C c;
3032 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
3033   matches "A::"
3034 </pre></td></tr>
3035
3036
3037 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('specifiesNamespace0')"><a name="specifiesNamespace0Anchor">specifiesNamespace</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt; InnerMatcher</td></tr>
3038 <tr><td colspan="4" class="doc" id="specifiesNamespace0"><pre>Matches nested name specifiers that specify a namespace matching the
3039 given namespace matcher.
3040
3041 Given
3042   namespace ns { struct A {}; }
3043   ns::A a;
3044 nestedNameSpecifier(specifiesNamespace(hasName("ns")))
3045   matches "ns::"
3046 </pre></td></tr>
3047
3048
3049 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('specifiesType0')"><a name="specifiesType0Anchor">specifiesType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
3050 <tr><td colspan="4" class="doc" id="specifiesType0"><pre>Matches nested name specifiers that specify a type matching the
3051 given QualType matcher without qualifiers.
3052
3053 Given
3054   struct A { struct B { struct C {}; }; };
3055   A::B::C c;
3056 nestedNameSpecifier(specifiesType(hasDeclaration(recordDecl(hasName("A")))))
3057   matches "A::"
3058 </pre></td></tr>
3059
3060
3061 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;</td><td class="name" onclick="toggle('innerType0')"><a name="innerType0Anchor">innerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
3062 <tr><td colspan="4" class="doc" id="innerType0"><pre>Matches ParenType nodes where the inner type is a specific type.
3063
3064 Given
3065   int (*ptr_to_array)[4];
3066   int (*ptr_to_func)(int);
3067
3068 varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
3069 ptr_to_func but not ptr_to_array.
3070
3071 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;
3072 </pre></td></tr>
3073
3074
3075 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerTypeLoc.html">PointerTypeLoc</a>&gt;</td><td class="name" onclick="toggle('pointeeLoc1')"><a name="pointeeLoc1Anchor">pointeeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
3076 <tr><td colspan="4" class="doc" id="pointeeLoc1"><pre>Narrows PointerType (and similar) matchers to those where the
3077 pointee matches a given matcher.
3078
3079 Given
3080   int *a;
3081   int const *b;
3082   float const *f;
3083 pointerType(pointee(isConstQualified(), isInteger()))
3084   matches "int const *b"
3085
3086 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
3087   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
3088 </pre></td></tr>
3089
3090
3091 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;</td><td class="name" onclick="toggle('pointee1')"><a name="pointee1Anchor">pointee</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
3092 <tr><td colspan="4" class="doc" id="pointee1"><pre>Narrows PointerType (and similar) matchers to those where the
3093 pointee matches a given matcher.
3094
3095 Given
3096   int *a;
3097   int const *b;
3098   float const *f;
3099 pointerType(pointee(isConstQualified(), isInteger()))
3100   matches "int const *b"
3101
3102 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
3103   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
3104 </pre></td></tr>
3105
3106
3107 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasCanonicalType0')"><a name="hasCanonicalType0Anchor">hasCanonicalType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
3108 <tr><td colspan="4" class="doc" id="hasCanonicalType0"><pre>Matches QualTypes whose canonical type matches InnerMatcher.
3109
3110 Given:
3111   typedef int &amp;int_ref;
3112   int a;
3113   int_ref b = a;
3114
3115 varDecl(hasType(qualType(referenceType()))))) will not match the
3116 declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
3117 </pre></td></tr>
3118
3119
3120 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration5')"><a name="hasDeclaration5Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3121 <tr><td colspan="4" class="doc" id="hasDeclaration5"><pre>Matches a type if the declaration of the type matches the given
3122 matcher.
3123
3124 In addition to being usable as Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, also usable as
3125 Matcher&lt;T&gt; for any T supporting the getDecl() member function. e.g. various
3126 subtypes of clang::Type.
3127
3128 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;,
3129   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
3130   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;
3131 </pre></td></tr>
3132
3133
3134 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('pointsTo1')"><a name="pointsTo1Anchor">pointsTo</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3135 <tr><td colspan="4" class="doc" id="pointsTo1"><pre>Overloaded to match the pointee type's declaration.
3136 </pre></td></tr>
3137
3138
3139 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('references1')"><a name="references1Anchor">references</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3140 <tr><td colspan="4" class="doc" id="references1"><pre>Overloaded to match the referenced type's declaration.
3141 </pre></td></tr>
3142
3143
3144 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceTypeLoc.html">ReferenceTypeLoc</a>&gt;</td><td class="name" onclick="toggle('pointeeLoc0')"><a name="pointeeLoc0Anchor">pointeeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td></tr>
3145 <tr><td colspan="4" class="doc" id="pointeeLoc0"><pre>Narrows PointerType (and similar) matchers to those where the
3146 pointee matches a given matcher.
3147
3148 Given
3149   int *a;
3150   int const *b;
3151   float const *f;
3152 pointerType(pointee(isConstQualified(), isInteger()))
3153   matches "int const *b"
3154
3155 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
3156   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
3157 </pre></td></tr>
3158
3159
3160 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;</td><td class="name" onclick="toggle('pointee0')"><a name="pointee0Anchor">pointee</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
3161 <tr><td colspan="4" class="doc" id="pointee0"><pre>Narrows PointerType (and similar) matchers to those where the
3162 pointee matches a given matcher.
3163
3164 Given
3165   int *a;
3166   int const *b;
3167   float const *f;
3168 pointerType(pointee(isConstQualified(), isInteger()))
3169   matches "int const *b"
3170
3171 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
3172   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
3173 </pre></td></tr>
3174
3175
3176 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('alignOfExpr0')"><a name="alignOfExpr0Anchor">alignOfExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;  InnerMatcher</td></tr>
3177 <tr><td colspan="4" class="doc" id="alignOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
3178 alignof.
3179 </pre></td></tr>
3180
3181
3182 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('sizeOfExpr0')"><a name="sizeOfExpr0Anchor">sizeOfExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;  InnerMatcher</td></tr>
3183 <tr><td colspan="4" class="doc" id="sizeOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
3184 sizeof.
3185 </pre></td></tr>
3186
3187
3188 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToDeclaration0')"><a name="refersToDeclaration0Anchor">refersToDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
3189 <tr><td colspan="4" class="doc" id="refersToDeclaration0"><pre>Matches a TemplateArgument that refers to a certain declaration.
3190
3191 Given
3192   template&lt;typename T&gt; struct A {};
3193   struct B { B* next; };
3194   A&lt;&amp;B::next&gt; a;
3195 classTemplateSpecializationDecl(hasAnyTemplateArgument(
3196     refersToDeclaration(fieldDecl(hasName("next"))))
3197   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
3198     B::next
3199 </pre></td></tr>
3200
3201
3202 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToType0')"><a name="refersToType0Anchor">refersToType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
3203 <tr><td colspan="4" class="doc" id="refersToType0"><pre>Matches a TemplateArgument that refers to a certain type.
3204
3205 Given
3206   struct X {};
3207   template&lt;typename T&gt; struct A {};
3208   A&lt;X&gt; a;
3209 classTemplateSpecializationDecl(hasAnyTemplateArgument(
3210     refersToType(class(hasName("X")))))
3211   matches the specialization A&lt;X&gt;
3212 </pre></td></tr>
3213
3214
3215 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration0')"><a name="hasDeclaration0Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3216 <tr><td colspan="4" class="doc" id="hasDeclaration0"><pre>Matches a type if the declaration of the type matches the given
3217 matcher.
3218
3219 In addition to being usable as Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, also usable as
3220 Matcher&lt;T&gt; for any T supporting the getDecl() member function. e.g. various
3221 subtypes of clang::Type.
3222
3223 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;,
3224   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
3225   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;
3226 </pre></td></tr>
3227
3228
3229 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('loc0')"><a name="loc0Anchor">loc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;  InnerMatcher</td></tr>
3230 <tr><td colspan="4" class="doc" id="loc0"><pre>Matches TypeLocs for which the given inner
3231 QualType-matcher matches.
3232 </pre></td></tr>
3233
3234
3235 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration1')"><a name="hasDeclaration1Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3236 <tr><td colspan="4" class="doc" id="hasDeclaration1"><pre>Matches a type if the declaration of the type matches the given
3237 matcher.
3238
3239 In addition to being usable as Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, also usable as
3240 Matcher&lt;T&gt; for any T supporting the getDecl() member function. e.g. various
3241 subtypes of clang::Type.
3242
3243 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;,
3244   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
3245   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;
3246 </pre></td></tr>
3247
3248
3249 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgumentOfType0')"><a name="hasArgumentOfType0Anchor">hasArgumentOfType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
3250 <tr><td colspan="4" class="doc" id="hasArgumentOfType0"><pre>Matches unary expressions that have a specific type of argument.
3251
3252 Given
3253   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
3254 unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
3255   matches sizeof(a) and alignof(c)
3256 </pre></td></tr>
3257
3258
3259 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasUnaryOperand0')"><a name="hasUnaryOperand0Anchor">hasUnaryOperand</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3260 <tr><td colspan="4" class="doc" id="hasUnaryOperand0"><pre>Matches if the operand of a unary operator matches.
3261
3262 Example matches true (matcher = hasUnaryOperand(boolLiteral(equals(true))))
3263   !true
3264 </pre></td></tr>
3265
3266
3267 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UsingDecl.html">UsingDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyUsingShadowDecl0')"><a name="hasAnyUsingShadowDecl0Anchor">hasAnyUsingShadowDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt; InnerMatcher</td></tr>
3268 <tr><td colspan="4" class="doc" id="hasAnyUsingShadowDecl0"><pre>Matches any using shadow declaration.
3269
3270 Given
3271   namespace X { void b(); }
3272   using X::b;
3273 usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
3274   matches using X::b </pre></td></tr>
3275
3276
3277 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt;</td><td class="name" onclick="toggle('hasTargetDecl0')"><a name="hasTargetDecl0Anchor">hasTargetDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; InnerMatcher</td></tr>
3278 <tr><td colspan="4" class="doc" id="hasTargetDecl0"><pre>Matches a using shadow declaration where the target declaration is
3279 matched by the given matcher.
3280
3281 Given
3282   namespace X { int a; void b(); }
3283   using X::a;
3284   using X::b;
3285 usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
3286   matches using X::b but not using X::a </pre></td></tr>
3287
3288
3289 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;</td><td class="name" onclick="toggle('hasType2')"><a name="hasType2Anchor">hasType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3290 <tr><td colspan="4" class="doc" id="hasType2"><pre>Overloaded to match the declaration of the expression's or value
3291 declaration's type.
3292
3293 In case of a value declaration (for example a variable declaration),
3294 this resolves one layer of indirection. For example, in the value
3295 declaration "X x;", recordDecl(hasName("X")) matches the declaration of X,
3296 while varDecl(hasType(recordDecl(hasName("X")))) matches the declaration
3297 of x."
3298
3299 Example matches x (matcher = expr(hasType(recordDecl(hasName("X")))))
3300             and z (matcher = varDecl(hasType(recordDecl(hasName("X")))))
3301  class X {};
3302  void y(X &amp;x) { x; X z; }
3303
3304 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;
3305 </pre></td></tr>
3306
3307
3308 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasInitializer0')"><a name="hasInitializer0Anchor">hasInitializer</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3309 <tr><td colspan="4" class="doc" id="hasInitializer0"><pre>Matches a variable declaration that has an initializer expression
3310 that matches the given matcher.
3311
3312 Example matches x (matcher = varDecl(hasInitializer(callExpr())))
3313   bool y() { return true; }
3314   bool x = y();
3315 </pre></td></tr>
3316
3317
3318 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VariableArrayType.html">VariableArrayType</a>&gt;</td><td class="name" onclick="toggle('hasSizeExpr0')"><a name="hasSizeExpr0Anchor">hasSizeExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3319 <tr><td colspan="4" class="doc" id="hasSizeExpr0"><pre>Matches VariableArrayType nodes that have a specific size
3320 expression.
3321
3322 Given
3323   void f(int b) {
3324     int a[b];
3325   }
3326 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
3327   varDecl(hasName("b")))))))
3328   matches "int a[b]"
3329 </pre></td></tr>
3330
3331
3332 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody2')"><a name="hasBody2Anchor">hasBody</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
3333 <tr><td colspan="4" class="doc" id="hasBody2"><pre>Matches a 'for', 'while', or 'do while' statement that has
3334 a given body.
3335
3336 Given
3337   for (;;) {}
3338 hasBody(compoundStmt())
3339   matches 'for (;;) {}'
3340 with compoundStmt()
3341   matching '{}'
3342 </pre></td></tr>
3343
3344
3345 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition2')"><a name="hasCondition2Anchor">hasCondition</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3346 <tr><td colspan="4" class="doc" id="hasCondition2"><pre>Matches the condition expression of an if statement, for loop,
3347 or conditional operator.
3348
3349 Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
3350   if (true) {}
3351 </pre></td></tr>
3352
3353 <!--END_TRAVERSAL_MATCHERS -->
3354 </table>
3355
3356 </div>
3357 </body>
3358 </html>
3359
3360