granicus.if.org Git - clang/blob - 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 <p>Note that the categorization of matchers is a great help when you combine
  61 them into matcher expressions. You will usually want to form matcher expressions
  62 that read like english sentences by alternating between node matchers and
  63 narrowing or traversal matchers, like this:
  64 <pre>
  65 recordDecl(hasDescendant(
  66     ifStmt(hasTrueExpression(
  67         expr(hasDescendant(
  68             ifStmt()))))))
  69 </pre>
  70 </p>
  71
  72 <!-- ======================================================================= -->
  73 <h2 id="decl-matchers">Node Matchers</h2>
  74 <!-- ======================================================================= -->
  75
  76 <p>Node matchers are at the core of matcher expressions - they specify the type
  77 of node that is expected. Every match expression starts with a node matcher,
  78 which can then be further refined with a narrowing or traversal matcher. All
  79 traversal matchers take node matchers as their arguments.</p>
  80
  81 <p>For convenience, all node matchers take an arbitrary number of arguments
  82 and implicitly act as allOf matchers.</p>
  83
  84 <p>Node matchers are the only matchers that support the bind("id") call to
  85 bind the matched node to the given string, to be later retrieved from the
  86 match callback.</p>
  87
  88 <p>It is important to remember that the arguments to node matchers are
  89 predicates on the same node, just with additional information about the type.
  90 This is often useful to make matcher expression more readable by inlining bind
  91 calls into redundant node matchers inside another node matcher:
  92 <pre>
  93 // This binds the CXXRecordDecl to "id", as the decl() matcher will stay on
  94 // the same node.
  95 recordDecl(decl().bind("id"), hasName("::MyClass"))
  96 </pre>
  97 </p>
  98
  99 <table>
 100 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
 101 <!-- START_DECL_MATCHERS -->
 102
 103 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('cxxCtorInitializer0')"><a name="cxxCtorInitializer0Anchor">cxxCtorInitializer</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;...</td></tr>
 104 <tr><td colspan="4" class="doc" id="cxxCtorInitializer0"><pre>Matches constructor initializers.
 105
 106 Examples matches i(42).
 107   class C {
 108     C() : i(42) {}
 109     int i;
 110   };
 111 </pre></td></tr>
 112
 113
 114 <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>
 115 <tr><td colspan="4" class="doc" id="accessSpecDecl0"><pre>Matches C++ access specifier declarations.
 116
 117 Given
 118   class C {
 119   public:
 120     int a;
 121   };
 122 accessSpecDecl()
 123   matches 'public:'
 124 </pre></td></tr>
 125
 126
 127 <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>
 128 <tr><td colspan="4" class="doc" id="classTemplateDecl0"><pre>Matches C++ class template declarations.
 129
 130 Example matches Z
 131   template&lt;class T&gt; class Z {};
 132 </pre></td></tr>
 133
 134
 135 <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>
 136 <tr><td colspan="4" class="doc" id="classTemplateSpecializationDecl0"><pre>Matches C++ class template specializations.
 137
 138 Given
 139   template&lt;typename T&gt; class A {};
 140   template&lt;&gt; class A&lt;double&gt; {};
 141   A&lt;int&gt; a;
 142 classTemplateSpecializationDecl()
 143   matches the specializations A&lt;int&gt; and A&lt;double&gt;
 144 </pre></td></tr>
 145
 146
 147 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxConstructorDecl0')"><a name="cxxConstructorDecl0Anchor">cxxConstructorDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;...</td></tr>
 148 <tr><td colspan="4" class="doc" id="cxxConstructorDecl0"><pre>Matches C++ constructor declarations.
 149
 150 Example matches Foo::Foo() and Foo::Foo(int)
 151   class Foo {
 152    public:
 153     Foo();
 154     Foo(int);
 155     int DoSomething();
 156   };
 157 </pre></td></tr>
 158
 159
 160 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxConversionDecl0')"><a name="cxxConversionDecl0Anchor">cxxConversionDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConversionDecl.html">CXXConversionDecl</a>&gt;...</td></tr>
 161 <tr><td colspan="4" class="doc" id="cxxConversionDecl0"><pre>Matches conversion operator declarations.
 162
 163 Example matches the operator.
 164   class X { operator int() const; };
 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('cxxDestructorDecl0')"><a name="cxxDestructorDecl0Anchor">cxxDestructorDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDestructorDecl.html">CXXDestructorDecl</a>&gt;...</td></tr>
 169 <tr><td colspan="4" class="doc" id="cxxDestructorDecl0"><pre>Matches explicit C++ destructor declarations.
 170
 171 Example matches Foo::~Foo()
 172   class Foo {
 173    public:
 174     virtual ~Foo();
 175   };
 176 </pre></td></tr>
 177
 178
 179 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxMethodDecl0')"><a name="cxxMethodDecl0Anchor">cxxMethodDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;...</td></tr>
 180 <tr><td colspan="4" class="doc" id="cxxMethodDecl0"><pre>Matches method declarations.
 181
 182 Example matches y
 183   class X { void y(); };
 184 </pre></td></tr>
 185
 186
 187 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxRecordDecl0')"><a name="cxxRecordDecl0Anchor">cxxRecordDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;...</td></tr>
 188 <tr><td colspan="4" class="doc" id="cxxRecordDecl0"><pre>Matches C++ class declarations.
 189
 190 Example matches X, Z
 191   class X;
 192   template&lt;class T&gt; class Z {};
 193 </pre></td></tr>
 194
 195
 196 <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>
 197 <tr><td colspan="4" class="doc" id="decl0"><pre>Matches declarations.
 198
 199 Examples matches X, C, and the friend declaration inside C;
 200   void X();
 201   class C {
 202     friend X;
 203   };
 204 </pre></td></tr>
 205
 206
 207 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('declaratorDecl0')"><a name="declaratorDecl0Anchor">declaratorDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;...</td></tr>
 208 <tr><td colspan="4" class="doc" id="declaratorDecl0"><pre>Matches declarator declarations (field, variable, function
 209 and non-type template parameter declarations).
 210
 211 Given
 212   class X { int y; };
 213 declaratorDecl()
 214   matches int y.
 215 </pre></td></tr>
 216
 217
 218 <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>
 219 <tr><td colspan="4" class="doc" id="enumConstantDecl0"><pre>Matches enum constants.
 220
 221 Example matches A, B, C
 222   enum X {
 223     A, B, C
 224   };
 225 </pre></td></tr>
 226
 227
 228 <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>
 229 <tr><td colspan="4" class="doc" id="enumDecl0"><pre>Matches enum declarations.
 230
 231 Example matches X
 232   enum X {
 233     A, B, C
 234   };
 235 </pre></td></tr>
 236
 237
 238 <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>
 239 <tr><td colspan="4" class="doc" id="fieldDecl0"><pre>Matches field declarations.
 240
 241 Given
 242   class X { int m; };
 243 fieldDecl()
 244   matches 'm'.
 245 </pre></td></tr>
 246
 247
 248 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('friendDecl0')"><a name="friendDecl0Anchor">friendDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;...</td></tr>
 249 <tr><td colspan="4" class="doc" id="friendDecl0"><pre>Matches friend declarations.
 250
 251 Given
 252   class X { friend void foo(); };
 253 friendDecl()
 254   matches 'friend void foo()'.
 255 </pre></td></tr>
 256
 257
 258 <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>
 259 <tr><td colspan="4" class="doc" id="functionDecl0"><pre>Matches function declarations.
 260
 261 Example matches f
 262   void f();
 263 </pre></td></tr>
 264
 265
 266 <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>
 267 <tr><td colspan="4" class="doc" id="functionTemplateDecl0"><pre>Matches C++ function template declarations.
 268
 269 Example matches f
 270   template&lt;class T&gt; void f(T t) {}
 271 </pre></td></tr>
 272
 273
 274 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('linkageSpecDecl0')"><a name="linkageSpecDecl0Anchor">linkageSpecDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LinkageSpecDecl.html">LinkageSpecDecl</a>&gt;...</td></tr>
 275 <tr><td colspan="4" class="doc" id="linkageSpecDecl0"><pre>Matches a declaration of a linkage specification.
 276
 277 Given
 278   extern "C" {}
 279 linkageSpecDecl()
 280   matches "extern "C" {}"
 281 </pre></td></tr>
 282
 283
 284 <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>
 285 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
 286
 287 Example matches X, S, the anonymous union type, i, and U;
 288   typedef int X;
 289   struct S {
 290     union {
 291       int i;
 292     } U;
 293   };
 294 </pre></td></tr>
 295
 296
 297 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('namespaceAliasDecl0')"><a name="namespaceAliasDecl0Anchor">namespaceAliasDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamespaceAliasDecl.html">NamespaceAliasDecl</a>&gt;...</td></tr>
 298 <tr><td colspan="4" class="doc" id="namespaceAliasDecl0"><pre>Matches a declaration of a namespace alias.
 299
 300 Given
 301   namespace test {}
 302   namespace alias = ::test;
 303 namespaceAliasDecl()
 304   matches "namespace alias" but not "namespace test"
 305 </pre></td></tr>
 306
 307
 308 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('namespaceDecl0')"><a name="namespaceDecl0Anchor">namespaceDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt;...</td></tr>
 309 <tr><td colspan="4" class="doc" id="namespaceDecl0"><pre>Matches a declaration of a namespace.
 310
 311 Given
 312   namespace {}
 313   namespace test {}
 314 namespaceDecl()
 315   matches "namespace {}" and "namespace test {}"
 316 </pre></td></tr>
 317
 318
 319 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('nonTypeTemplateParmDecl0')"><a name="nonTypeTemplateParmDecl0Anchor">nonTypeTemplateParmDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NonTypeTemplateParmDecl.html">NonTypeTemplateParmDecl</a>&gt;...</td></tr>
 320 <tr><td colspan="4" class="doc" id="nonTypeTemplateParmDecl0"><pre>Matches non-type template parameter declarations.
 321
 322 Given
 323   template &lt;typename T, int N&gt; struct C {};
 324 nonTypeTemplateParmDecl()
 325   matches 'N', but not 'T'.
 326 </pre></td></tr>
 327
 328
 329 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcInterfaceDecl0')"><a name="objcInterfaceDecl0Anchor">objcInterfaceDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;...</td></tr>
 330 <tr><td colspan="4" class="doc" id="objcInterfaceDecl0"><pre>Matches Objective-C interface declarations.
 331
 332 Example matches Foo
 333   @interface Foo
 334   @end
 335 </pre></td></tr>
 336
 337
 338 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('parmVarDecl0')"><a name="parmVarDecl0Anchor">parmVarDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt;...</td></tr>
 339 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
 340
 341 Given
 342   void f(int x);
 343 parmVarDecl()
 344   matches int x.
 345 </pre></td></tr>
 346
 347
 348 <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_1RecordDecl.html">RecordDecl</a>&gt;...</td></tr>
 349 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches class, struct, and union declarations.
 350
 351 Example matches X, Z, U, and S
 352   class X;
 353   template&lt;class T&gt; class Z {};
 354   struct S {};
 355   union U {};
 356 </pre></td></tr>
 357
 358
 359 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('staticAssertDecl0')"><a name="staticAssertDecl0Anchor">staticAssertDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1StaticAssertDecl.html">StaticAssertDecl</a>&gt;...</td></tr>
 360 <tr><td colspan="4" class="doc" id="staticAssertDecl0"><pre>Matches a C++ static_assert declaration.
 361
 362 Example:
 363   staticAssertExpr()
 364 matches
 365   static_assert(sizeof(S) == sizeof(int))
 366 in
 367   struct S {
 368     int x;
 369   };
 370   static_assert(sizeof(S) == sizeof(int));
 371 </pre></td></tr>
 372
 373
 374 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('templateTypeParmDecl0')"><a name="templateTypeParmDecl0Anchor">templateTypeParmDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmDecl.html">TemplateTypeParmDecl</a>&gt;...</td></tr>
 375 <tr><td colspan="4" class="doc" id="templateTypeParmDecl0"><pre>Matches template type parameter declarations.
 376
 377 Given
 378   template &lt;typename T, int N&gt; struct C {};
 379 templateTypeParmDecl()
 380   matches 'T', but not 'N'.
 381 </pre></td></tr>
 382
 383
 384 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('translationUnitDecl0')"><a name="translationUnitDecl0Anchor">translationUnitDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TranslationUnitDecl.html">TranslationUnitDecl</a>&gt;...</td></tr>
 385 <tr><td colspan="4" class="doc" id="translationUnitDecl0"><pre>Matches the top declaration context.
 386
 387 Given
 388   int X;
 389   namespace NS {
 390   int Y;
 391   }  namespace NS
 392 decl(hasDeclContext(translationUnitDecl()))
 393   matches "int X", but not "int Y".
 394 </pre></td></tr>
 395
 396
 397 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typedefDecl0')"><a name="typedefDecl0Anchor">typedefDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefDecl.html">TypedefDecl</a>&gt;...</td></tr>
 398 <tr><td colspan="4" class="doc" id="typedefDecl0"><pre>Matches typedef declarations.
 399
 400 Given
 401   typedef int X;
 402 typedefDecl()
 403   matches "typedef int X"
 404 </pre></td></tr>
 405
 406
 407 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('unresolvedUsingTypenameDecl0')"><a name="unresolvedUsingTypenameDecl0Anchor">unresolvedUsingTypenameDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingTypenameDecl.html">UnresolvedUsingTypenameDecl</a>&gt;...</td></tr>
 408 <tr><td colspan="4" class="doc" id="unresolvedUsingTypenameDecl0"><pre>Matches unresolved using value declarations that involve the
 409 typename.
 410
 411 Given
 412   template &lt;typename T&gt;
 413   struct Base { typedef T Foo; };
 414
 415   template&lt;typename T&gt;
 416   struct S : private Base&lt;T&gt; {
 417     using typename Base&lt;T&gt;::Foo;
 418   };
 419 unresolvedUsingTypenameDecl()
 420   matches using Base&lt;T&gt;::Foo </pre></td></tr>
 421
 422
 423 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('unresolvedUsingValueDecl0')"><a name="unresolvedUsingValueDecl0Anchor">unresolvedUsingValueDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingValueDecl.html">UnresolvedUsingValueDecl</a>&gt;...</td></tr>
 424 <tr><td colspan="4" class="doc" id="unresolvedUsingValueDecl0"><pre>Matches unresolved using value declarations.
 425
 426 Given
 427   template&lt;typename X&gt;
 428   class C : private X {
 429     using X::x;
 430   };
 431 unresolvedUsingValueDecl()
 432   matches using X::x </pre></td></tr>
 433
 434
 435 <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>
 436 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
 437
 438 Given
 439   namespace X { int x; }
 440   using X::x;
 441 usingDecl()
 442   matches using X::x </pre></td></tr>
 443
 444
 445 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('usingDirectiveDecl0')"><a name="usingDirectiveDecl0Anchor">usingDirectiveDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UsingDirectiveDecl.html">UsingDirectiveDecl</a>&gt;...</td></tr>
 446 <tr><td colspan="4" class="doc" id="usingDirectiveDecl0"><pre>Matches using namespace declarations.
 447
 448 Given
 449   namespace X { int x; }
 450   using namespace X;
 451 usingDirectiveDecl()
 452   matches using namespace X </pre></td></tr>
 453
 454
 455 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('valueDecl0')"><a name="valueDecl0Anchor">valueDecl</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;...</td></tr>
 456 <tr><td colspan="4" class="doc" id="valueDecl0"><pre>Matches any value declaration.
 457
 458 Example matches A, B, C and F
 459   enum X { A, B, C };
 460   void F();
 461 </pre></td></tr>
 462
 463
 464 <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>
 465 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
 466
 467 Note: this does not match declarations of member variables, which are
 468 "field" declarations in Clang parlance.
 469
 470 Example matches a
 471   int a;
 472 </pre></td></tr>
 473
 474
 475 <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>
 476 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
 477 </pre></td></tr>
 478
 479
 480 <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>
 481 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
 482
 483 Given
 484   namespace ns {
 485     struct A { static void f(); };
 486     void A::f() {}
 487     void g() { A::f(); }
 488   }
 489   ns::A a;
 490 nestedNameSpecifier()
 491   matches "ns::" and both "A::"
 492 </pre></td></tr>
 493
 494
 495 <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>
 496 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
 497 </pre></td></tr>
 498
 499
 500 <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>
 501 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
 502
 503 Given
 504   int i = a[1];
 505 arraySubscriptExpr()
 506   matches "a[1]"
 507 </pre></td></tr>
 508
 509
 510 <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>
 511 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
 512
 513  int i = 100;
 514   __asm("mov al, 2");
 515 asmStmt()
 516   matches '__asm("mov al, 2")'
 517 </pre></td></tr>
 518
 519
 520 <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>
 521 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
 522
 523 Example matches a || b
 524   !(a || b)
 525 </pre></td></tr>
 526
 527
 528 <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>
 529 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
 530
 531 Given
 532   while (true) { break; }
 533 breakStmt()
 534   matches 'break'
 535 </pre></td></tr>
 536
 537
 538 <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>
 539 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
 540
 541 Example: Matches (int*) 2.2f in
 542   int i = (int) 2.2f;
 543 </pre></td></tr>
 544
 545
 546 <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>
 547 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
 548
 549 Example matches x.y() and y()
 550   X x;
 551   x.y();
 552   y();
 553 </pre></td></tr>
 554
 555
 556 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('caseStmt0')"><a name="caseStmt0Anchor">caseStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CaseStmt.html">CaseStmt</a>&gt;...</td></tr>
 557 <tr><td colspan="4" class="doc" id="caseStmt0"><pre>Matches case statements inside switch statements.
 558
 559 Given
 560   switch(a) { case 42: break; default: break; }
 561 caseStmt()
 562   matches 'case 42: break;'.
 563 </pre></td></tr>
 564
 565
 566 <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>
 567 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
 568
 569 Example: castExpr() matches each of the following:
 570   (int) 3;
 571   const_cast&lt;Expr *&gt;(SubExpr);
 572   char c = 0;
 573 but does not match
 574   int i = (0);
 575   int k = 0;
 576 </pre></td></tr>
 577
 578
 579 <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>
 580 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
 581
 582 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
 583 though.
 584
 585 Example matches 'a', L'a'
 586   char ch = 'a'; wchar_t chw = L'a';
 587 </pre></td></tr>
 588
 589
 590 <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>
 591 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
 592
 593 Example match: {1}, (1, 2)
 594   int array[4] = {1}; vector int myvec = (vector int)(1, 2);
 595 </pre></td></tr>
 596
 597
 598 <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>
 599 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
 600
 601 Example matches '{}' and '{{}}'in 'for (;;) {{}}'
 602   for (;;) {{}}
 603 </pre></td></tr>
 604
 605
 606 <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>
 607 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
 608
 609 Example matches a ? b : c
 610   (a ? b : c) + 42
 611 </pre></td></tr>
 612
 613
 614 <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>
 615 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
 616
 617 Given
 618   while (true) { continue; }
 619 continueStmt()
 620   matches 'continue'
 621 </pre></td></tr>
 622
 623
 624 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cudaKernelCallExpr0')"><a name="cudaKernelCallExpr0Anchor">cudaKernelCallExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CUDAKernelCallExpr.html">CUDAKernelCallExpr</a>&gt;...</td></tr>
 625 <tr><td colspan="4" class="doc" id="cudaKernelCallExpr0"><pre>Matches CUDA kernel call expression.
 626
 627 Example matches,
 628   kernel&lt;&lt;&lt;i,j&gt;&gt;&gt;();
 629 </pre></td></tr>
 630
 631
 632 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxBindTemporaryExpr0')"><a name="cxxBindTemporaryExpr0Anchor">cxxBindTemporaryExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXBindTemporaryExpr.html">CXXBindTemporaryExpr</a>&gt;...</td></tr>
 633 <tr><td colspan="4" class="doc" id="cxxBindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
 634
 635 Example matches FunctionTakesString(GetStringByValue())
 636     (matcher = cxxBindTemporaryExpr())
 637   FunctionTakesString(GetStringByValue());
 638   FunctionTakesStringByPointer(GetStringPointer());
 639 </pre></td></tr>
 640
 641
 642 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxBoolLiteral0')"><a name="cxxBoolLiteral0Anchor">cxxBoolLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;...</td></tr>
 643 <tr><td colspan="4" class="doc" id="cxxBoolLiteral0"><pre>Matches bool literals.
 644
 645 Example matches true
 646   true
 647 </pre></td></tr>
 648
 649
 650 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxCatchStmt0')"><a name="cxxCatchStmt0Anchor">cxxCatchStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>&gt;...</td></tr>
 651 <tr><td colspan="4" class="doc" id="cxxCatchStmt0"><pre>Matches catch statements.
 652
 653   try {} catch(int i) {}
 654 cxxCatchStmt()
 655   matches 'catch(int i)'
 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('cxxConstCastExpr0')"><a name="cxxConstCastExpr0Anchor">cxxConstCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstCastExpr.html">CXXConstCastExpr</a>&gt;...</td></tr>
 660 <tr><td colspan="4" class="doc" id="cxxConstCastExpr0"><pre>Matches a const_cast expression.
 661
 662 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
 663   int n = 42;
 664   const int &amp;r(n);
 665   int* p = const_cast&lt;int*&gt;(&amp;r);
 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('cxxConstructExpr0')"><a name="cxxConstructExpr0Anchor">cxxConstructExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;...</td></tr>
 670 <tr><td colspan="4" class="doc" id="cxxConstructExpr0"><pre>Matches constructor call expressions (including implicit ones).
 671
 672 Example matches string(ptr, n) and ptr within arguments of f
 673     (matcher = cxxConstructExpr())
 674   void f(const string &amp;a, const string &amp;b);
 675   char *ptr;
 676   int n;
 677   f(string(ptr, n), ptr);
 678 </pre></td></tr>
 679
 680
 681 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDefaultArgExpr0')"><a name="cxxDefaultArgExpr0Anchor">cxxDefaultArgExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDefaultArgExpr.html">CXXDefaultArgExpr</a>&gt;...</td></tr>
 682 <tr><td colspan="4" class="doc" id="cxxDefaultArgExpr0"><pre>Matches the value of a default argument at the call site.
 683
 684 Example matches the CXXDefaultArgExpr placeholder inserted for the
 685     default value of the second parameter in the call expression f(42)
 686     (matcher = cxxDefaultArgExpr())
 687   void f(int x, int y = 0);
 688   f(42);
 689 </pre></td></tr>
 690
 691
 692 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDeleteExpr0')"><a name="cxxDeleteExpr0Anchor">cxxDeleteExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDeleteExpr.html">CXXDeleteExpr</a>&gt;...</td></tr>
 693 <tr><td colspan="4" class="doc" id="cxxDeleteExpr0"><pre>Matches delete expressions.
 694
 695 Given
 696   delete X;
 697 cxxDeleteExpr()
 698   matches 'delete X'.
 699 </pre></td></tr>
 700
 701
 702 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDynamicCastExpr0')"><a name="cxxDynamicCastExpr0Anchor">cxxDynamicCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXDynamicCastExpr.html">CXXDynamicCastExpr</a>&gt;...</td></tr>
 703 <tr><td colspan="4" class="doc" id="cxxDynamicCastExpr0"><pre>Matches a dynamic_cast expression.
 704
 705 Example:
 706   cxxDynamicCastExpr()
 707 matches
 708   dynamic_cast&lt;D*&gt;(&amp;b);
 709 in
 710   struct B { virtual ~B() {} }; struct D : B {};
 711   B b;
 712   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
 713 </pre></td></tr>
 714
 715
 716 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxForRangeStmt0')"><a name="cxxForRangeStmt0Anchor">cxxForRangeStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;...</td></tr>
 717 <tr><td colspan="4" class="doc" id="cxxForRangeStmt0"><pre>Matches range-based for statements.
 718
 719 cxxForRangeStmt() matches 'for (auto a : i)'
 720   int i[] =  {1, 2, 3}; for (auto a : i);
 721   for(int j = 0; j &lt; 5; ++j);
 722 </pre></td></tr>
 723
 724
 725 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxFunctionalCastExpr0')"><a name="cxxFunctionalCastExpr0Anchor">cxxFunctionalCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;...</td></tr>
 726 <tr><td colspan="4" class="doc" id="cxxFunctionalCastExpr0"><pre>Matches functional cast expressions
 727
 728 Example: Matches Foo(bar);
 729   Foo f = bar;
 730   Foo g = (Foo) bar;
 731   Foo h = Foo(bar);
 732 </pre></td></tr>
 733
 734
 735 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxMemberCallExpr0')"><a name="cxxMemberCallExpr0Anchor">cxxMemberCallExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;...</td></tr>
 736 <tr><td colspan="4" class="doc" id="cxxMemberCallExpr0"><pre>Matches member call expressions.
 737
 738 Example matches x.y()
 739   X x;
 740   x.y();
 741 </pre></td></tr>
 742
 743
 744 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxNewExpr0')"><a name="cxxNewExpr0Anchor">cxxNewExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;...</td></tr>
 745 <tr><td colspan="4" class="doc" id="cxxNewExpr0"><pre>Matches new expressions.
 746
 747 Given
 748   new X;
 749 cxxNewExpr()
 750   matches 'new X'.
 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('cxxNullPtrLiteralExpr0')"><a name="cxxNullPtrLiteralExpr0Anchor">cxxNullPtrLiteralExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNullPtrLiteralExpr.html">CXXNullPtrLiteralExpr</a>&gt;...</td></tr>
 755 <tr><td colspan="4" class="doc" id="cxxNullPtrLiteralExpr0"><pre>Matches nullptr literal.
 756 </pre></td></tr>
 757
 758
 759 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxOperatorCallExpr0')"><a name="cxxOperatorCallExpr0Anchor">cxxOperatorCallExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;...</td></tr>
 760 <tr><td colspan="4" class="doc" id="cxxOperatorCallExpr0"><pre>Matches overloaded operator calls.
 761
 762 Note that if an operator isn't overloaded, it won't match. Instead, use
 763 binaryOperator matcher.
 764 Currently it does not match operators such as new delete.
 765 FIXME: figure out why these do not match?
 766
 767 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
 768     (matcher = cxxOperatorCallExpr())
 769   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
 770   ostream &amp;o; int b = 1, c = 1;
 771   o &lt;&lt; b &lt;&lt; c;
 772 </pre></td></tr>
 773
 774
 775 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxReinterpretCastExpr0')"><a name="cxxReinterpretCastExpr0Anchor">cxxReinterpretCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXReinterpretCastExpr.html">CXXReinterpretCastExpr</a>&gt;...</td></tr>
 776 <tr><td colspan="4" class="doc" id="cxxReinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
 777
 778 Either the source expression or the destination type can be matched
 779 using has(), but hasDestinationType() is more specific and can be
 780 more readable.
 781
 782 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
 783   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
 784 </pre></td></tr>
 785
 786
 787 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxStaticCastExpr0')"><a name="cxxStaticCastExpr0Anchor">cxxStaticCastExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXStaticCastExpr.html">CXXStaticCastExpr</a>&gt;...</td></tr>
 788 <tr><td colspan="4" class="doc" id="cxxStaticCastExpr0"><pre>Matches a C++ static_cast expression.
 789
 790 See also: hasDestinationType
 791 See also: reinterpretCast
 792
 793 Example:
 794   cxxStaticCastExpr()
 795 matches
 796   static_cast&lt;long&gt;(8)
 797 in
 798   long eight(static_cast&lt;long&gt;(8));
 799 </pre></td></tr>
 800
 801
 802 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxTemporaryObjectExpr0')"><a name="cxxTemporaryObjectExpr0Anchor">cxxTemporaryObjectExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;...</td></tr>
 803 <tr><td colspan="4" class="doc" id="cxxTemporaryObjectExpr0"><pre>Matches functional cast expressions having N != 1 arguments
 804
 805 Example: Matches Foo(bar, bar)
 806   Foo h = Foo(bar, bar);
 807 </pre></td></tr>
 808
 809
 810 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxThisExpr0')"><a name="cxxThisExpr0Anchor">cxxThisExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXThisExpr.html">CXXThisExpr</a>&gt;...</td></tr>
 811 <tr><td colspan="4" class="doc" id="cxxThisExpr0"><pre>Matches implicit and explicit this expressions.
 812
 813 Example matches the implicit this expression in "return i".
 814     (matcher = cxxThisExpr())
 815 struct foo {
 816   int i;
 817   int f() { return i; }
 818 };
 819 </pre></td></tr>
 820
 821
 822 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxThrowExpr0')"><a name="cxxThrowExpr0Anchor">cxxThrowExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXThrowExpr.html">CXXThrowExpr</a>&gt;...</td></tr>
 823 <tr><td colspan="4" class="doc" id="cxxThrowExpr0"><pre>Matches throw expressions.
 824
 825   try { throw 5; } catch(int i) {}
 826 cxxThrowExpr()
 827   matches 'throw 5'
 828 </pre></td></tr>
 829
 830
 831 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxTryStmt0')"><a name="cxxTryStmt0Anchor">cxxTryStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXTryStmt.html">CXXTryStmt</a>&gt;...</td></tr>
 832 <tr><td colspan="4" class="doc" id="cxxTryStmt0"><pre>Matches try statements.
 833
 834   try {} catch(int i) {}
 835 cxxTryStmt()
 836   matches 'try {}'
 837 </pre></td></tr>
 838
 839
 840 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxUnresolvedConstructExpr0')"><a name="cxxUnresolvedConstructExpr0Anchor">cxxUnresolvedConstructExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;...</td></tr>
 841 <tr><td colspan="4" class="doc" id="cxxUnresolvedConstructExpr0"><pre>Matches unresolved constructor call expressions.
 842
 843 Example matches T(t) in return statement of f
 844     (matcher = cxxUnresolvedConstructExpr())
 845   template &lt;typename T&gt;
 846   void f(const T&amp; t) { return T(t); }
 847 </pre></td></tr>
 848
 849
 850 <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>
 851 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
 852
 853 Example matches x in if (x)
 854   bool x;
 855   if (x) {}
 856 </pre></td></tr>
 857
 858
 859 <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>
 860 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
 861
 862 Given
 863   int a;
 864 declStmt()
 865   matches 'int a'.
 866 </pre></td></tr>
 867
 868
 869 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('defaultStmt0')"><a name="defaultStmt0Anchor">defaultStmt</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DefaultStmt.html">DefaultStmt</a>&gt;...</td></tr>
 870 <tr><td colspan="4" class="doc" id="defaultStmt0"><pre>Matches default statements inside switch statements.
 871
 872 Given
 873   switch(a) { case 42: break; default: break; }
 874 defaultStmt()
 875   matches 'default: break;'.
 876 </pre></td></tr>
 877
 878
 879 <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>
 880 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
 881
 882 Given
 883   do {} while (true);
 884 doStmt()
 885   matches 'do {} while(true)'
 886 </pre></td></tr>
 887
 888
 889 <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>
 890 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
 891
 892 Matches any cast expression written in user code, whether it be a
 893 C-style cast, a functional-style cast, or a keyword cast.
 894
 895 Does not match implicit conversions.
 896
 897 Note: the name "explicitCast" is chosen to match Clang's terminology, as
 898 Clang uses the term "cast" to apply to implicit conversions as well as to
 899 actual cast expressions.
 900
 901 See also: hasDestinationType.
 902
 903 Example: matches all five of the casts in
 904   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
 905 but does not match the implicit conversion in
 906   long ell = 42;
 907 </pre></td></tr>
 908
 909
 910 <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>
 911 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
 912
 913 Example matches x()
 914   void f() { x(); }
 915 </pre></td></tr>
 916
 917
 918 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('exprWithCleanups0')"><a name="exprWithCleanups0Anchor">exprWithCleanups</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ExprWithCleanups.html">ExprWithCleanups</a>&gt;...</td></tr>
 919 <tr><td colspan="4" class="doc" id="exprWithCleanups0"><pre>Matches expressions that introduce cleanups to be run at the end
 920 of the sub-expression's evaluation.
 921
 922 Example matches std::string()
 923   const std::string str = std::string();
 924 </pre></td></tr>
 925
 926
 927 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('floatLiteral0')"><a name="floatLiteral0Anchor">floatLiteral</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;...</td></tr>
 928 <tr><td colspan="4" class="doc" id="floatLiteral0"><pre>Matches float literals of all sizes encodings, e.g.
 929 1.0, 1.0f, 1.0L and 1e10.
 930
 931 Does not match implicit conversions such as
 932   float a = 10;
 933 </pre></td></tr>
 934
 935
 936 <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>
 937 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
 938
 939 Example matches 'for (;;) {}'
 940   for (;;) {}
 941   int i[] =  {1, 2, 3}; for (auto a : i);
 942 </pre></td></tr>
 943
 944
 945 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('gnuNullExpr0')"><a name="gnuNullExpr0Anchor">gnuNullExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1GNUNullExpr.html">GNUNullExpr</a>&gt;...</td></tr>
 946 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
 947 </pre></td></tr>
 948
 949
 950 <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>
 951 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
 952
 953 Given
 954   goto FOO;
 955   FOO: bar();
 956 gotoStmt()
 957   matches 'goto FOO'
 958 </pre></td></tr>
 959
 960
 961 <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>
 962 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
 963
 964 Example matches 'if (x) {}'
 965   if (x) {}
 966 </pre></td></tr>
 967
 968
 969 <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>
 970 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
 971
 972 This matches many different places, including function call return value
 973 eliding, as well as any type conversions.
 974 </pre></td></tr>
 975
 976
 977 <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>
 978 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
 979
 980 Given
 981   int a[] = { 1, 2 };
 982   struct B { int x, y; };
 983   B b = { 5, 6 };
 984 initListExpr()
 985   matches "{ 1, 2 }" and "{ 5, 6 }"
 986 </pre></td></tr>
 987
 988
 989 <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>
 990 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes encodings, e.g.
 991 1, 1L, 0x1 and 1U.
 992
 993 Does not match character-encoded integers such as L'a'.
 994 </pre></td></tr>
 995
 996
 997 <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>
 998 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
 999
1000 Given
1001   goto FOO;
1002   FOO: bar();
1003 labelStmt()
1004   matches 'FOO:'
1005 </pre></td></tr>
1006
1007
1008 <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>
1009 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
1010
1011 Example matches [&amp;](){return 5;}
1012   [&amp;](){return 5;}
1013 </pre></td></tr>
1014
1015
1016 <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>
1017 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
1018
1019 Example: Given
1020   struct T {void func()};
1021   T f();
1022   void g(T);
1023 materializeTemporaryExpr() matches 'f()' in these statements
1024   T u(f());
1025   g(f());
1026 but does not match
1027   f();
1028   f().func();
1029 </pre></td></tr>
1030
1031
1032 <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>
1033 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
1034
1035 Given
1036   class Y {
1037     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
1038     int a; static int b;
1039   };
1040 memberExpr()
1041   matches this-&gt;x, x, y.x, a, this-&gt;b
1042 </pre></td></tr>
1043
1044
1045 <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>
1046 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
1047
1048   foo();;
1049 nullStmt()
1050   matches the second ';'
1051 </pre></td></tr>
1052
1053
1054 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcMessageExpr0')"><a name="objcMessageExpr0Anchor">objcMessageExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;...</td></tr>
1055 <tr><td colspan="4" class="doc" id="objcMessageExpr0"><pre>Matches ObjectiveC Message invocation expressions.
1056
1057 The innermost message send invokes the "alloc" class method on the
1058 NSString class, while the outermost message send invokes the
1059 "initWithString" instance method on the object returned from
1060 NSString's "alloc". This matcher should match both message sends.
1061   [[NSString alloc] initWithString:@"Hello"]
1062 </pre></td></tr>
1063
1064
1065 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('parenExpr0')"><a name="parenExpr0Anchor">parenExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenExpr.html">ParenExpr</a>&gt;...</td></tr>
1066 <tr><td colspan="4" class="doc" id="parenExpr0"><pre>Matches parentheses used in expressions.
1067
1068 Example matches (foo() + 1)
1069   int foo() { return 1; }
1070   int a = (foo() + 1);
1071 </pre></td></tr>
1072
1073
1074 <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>
1075 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
1076
1077 Given
1078   return 1;
1079 returnStmt()
1080   matches 'return 1'
1081 </pre></td></tr>
1082
1083
1084 <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>
1085 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
1086
1087 Given
1088   { ++a; }
1089 stmt()
1090   matches both the compound statement '{ ++a; }' and '++a'.
1091 </pre></td></tr>
1092
1093
1094 <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>
1095 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
1096
1097 Example matches "abcd", L"abcd"
1098   char *s = "abcd"; wchar_t *ws = L"abcd"
1099 </pre></td></tr>
1100
1101
1102 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('substNonTypeTemplateParmExpr0')"><a name="substNonTypeTemplateParmExpr0Anchor">substNonTypeTemplateParmExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1SubstNonTypeTemplateParmExpr.html">SubstNonTypeTemplateParmExpr</a>&gt;...</td></tr>
1103 <tr><td colspan="4" class="doc" id="substNonTypeTemplateParmExpr0"><pre>Matches substitutions of non-type template parameters.
1104
1105 Given
1106   template &lt;int N&gt;
1107   struct A { static const int n = N; };
1108   struct B : public A&lt;42&gt; {};
1109 substNonTypeTemplateParmExpr()
1110   matches "N" in the right-hand side of "static const int n = N;"
1111 </pre></td></tr>
1112
1113
1114 <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>
1115 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
1116
1117 Given
1118   switch(a) { case 42: break; default: break; }
1119 switchCase()
1120   matches 'case 42: break;' and 'default: break;'.
1121 </pre></td></tr>
1122
1123
1124 <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>
1125 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
1126
1127 Given
1128   switch(a) { case 42: break; default: break; }
1129 switchStmt()
1130   matches 'switch(a)'.
1131 </pre></td></tr>
1132
1133
1134 <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>
1135 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
1136
1137 Given
1138   Foo x = bar;
1139   int y = sizeof(x) + alignof(x);
1140 unaryExprOrTypeTraitExpr()
1141   matches sizeof(x) and alignof(x)
1142 </pre></td></tr>
1143
1144
1145 <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>
1146 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
1147
1148 Example matches !a
1149   !a || b
1150 </pre></td></tr>
1151
1152
1153 <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>
1154 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
1155
1156 Example match: "foo"_suffix
1157 </pre></td></tr>
1158
1159
1160 <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>
1161 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
1162
1163 Given
1164   while (true) {}
1165 whileStmt()
1166   matches 'while (true) {}'.
1167 </pre></td></tr>
1168
1169
1170 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('templateArgument0')"><a name="templateArgument0Anchor">templateArgument</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;...</td></tr>
1171 <tr><td colspan="4" class="doc" id="templateArgument0"><pre>Matches template arguments.
1172
1173 Given
1174   template &lt;typename T&gt; struct C {};
1175   C&lt;int&gt; c;
1176 templateArgument()
1177   matches 'int' in C&lt;int&gt;.
1178 </pre></td></tr>
1179
1180
1181 <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>
1182 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
1183 </pre></td></tr>
1184
1185
1186 <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>
1187 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
1188
1189 Given
1190   int a[] = { 2, 3 };
1191   int b[4];
1192   void f() { int c[a[0]]; }
1193 arrayType()
1194   matches "int a[]", "int b[4]" and "int c[a[0]]";
1195 </pre></td></tr>
1196
1197
1198 <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>
1199 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
1200
1201 Given
1202   _Atomic(int) i;
1203 atomicType()
1204   matches "_Atomic(int) i"
1205 </pre></td></tr>
1206
1207
1208 <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>
1209 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
1210
1211 Given:
1212   auto n = 4;
1213   int v[] = { 2, 3 }
1214   for (auto i : v) { }
1215 autoType()
1216   matches "auto n" and "auto i"
1217 </pre></td></tr>
1218
1219
1220 <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>
1221 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
1222 "void (^)(int)".
1223
1224 The pointee is always required to be a FunctionType.
1225 </pre></td></tr>
1226
1227
1228 <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>
1229 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
1230
1231 Given
1232   struct A {};
1233   A a;
1234   int b;
1235   float c;
1236   bool d;
1237 builtinType()
1238   matches "int b", "float c" and "bool d"
1239 </pre></td></tr>
1240
1241
1242 <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>
1243 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
1244
1245 Given
1246   _Complex float f;
1247 complexType()
1248   matches "_Complex float f"
1249 </pre></td></tr>
1250
1251
1252 <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>
1253 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
1254
1255 Given
1256   void() {
1257     int a[2];
1258     int b[] = { 2, 3 };
1259     int c[b[0]];
1260   }
1261 constantArrayType()
1262   matches "int a[2]"
1263 </pre></td></tr>
1264
1265
1266 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('decayedType0')"><a name="decayedType0Anchor">decayedType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DecayedType.html">DecayedType</a>&gt;...</td></tr>
1267 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
1268 Example matches i[] in declaration of f.
1269     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
1270 Example matches i[1].
1271     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
1272   void f(int i[]) {
1273     i[1] = 0;
1274   }
1275 </pre></td></tr>
1276
1277
1278 <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>
1279 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
1280
1281 Given
1282   template&lt;typename T, int Size&gt;
1283   class array {
1284     T data[Size];
1285   };
1286 dependentSizedArrayType
1287   matches "T data[Size]"
1288 </pre></td></tr>
1289
1290
1291 <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>
1292 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
1293 qualified name.
1294
1295 Given
1296   namespace N {
1297     namespace M {
1298       class D {};
1299     }
1300   }
1301   class C {};
1302
1303   class C c;
1304   N::M::D d;
1305
1306 elaboratedType() matches the type of the variable declarations of both
1307 c and d.
1308 </pre></td></tr>
1309
1310
1311 <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>
1312 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
1313
1314 Given
1315   int (*f)(int);
1316   void g();
1317 functionType()
1318   matches "int (*f)(int)" and the type of "g".
1319 </pre></td></tr>
1320
1321
1322 <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>
1323 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
1324
1325 Given
1326   int a[] = { 2, 3 };
1327   int b[42];
1328   void f(int c[]) { int d[a[0]]; };
1329 incompleteArrayType()
1330   matches "int a[]" and "int c[]"
1331 </pre></td></tr>
1332
1333
1334 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('injectedClassNameType0')"><a name="injectedClassNameType0Anchor">injectedClassNameType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;...</td></tr>
1335 <tr><td colspan="4" class="doc" id="injectedClassNameType0"><pre>Matches injected class name types.
1336
1337 Example matches S s, but not S&lt;T&gt; s.
1338     (matcher = parmVarDecl(hasType(injectedClassNameType())))
1339   template &lt;typename T&gt; struct S {
1340     void f(S s);
1341     void g(S&lt;T&gt; s);
1342   };
1343 </pre></td></tr>
1344
1345
1346 <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>
1347 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
1348
1349 Given:
1350   int *a;
1351   int &amp;b = *a;
1352   int &amp;&amp;c = 1;
1353   auto &amp;d = b;
1354   auto &amp;&amp;e = c;
1355   auto &amp;&amp;f = 2;
1356   int g = 5;
1357
1358 lValueReferenceType() matches the types of b, d, and e. e is
1359 matched since the type is deduced as int&amp; by reference collapsing rules.
1360 </pre></td></tr>
1361
1362
1363 <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>
1364 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
1365 Given
1366   struct A { int i; }
1367   A::* ptr = A::i;
1368 memberPointerType()
1369   matches "A::* ptr"
1370 </pre></td></tr>
1371
1372
1373 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('objcObjectPointerType0')"><a name="objcObjectPointerType0Anchor">objcObjectPointerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCObjectPointerType.html">ObjCObjectPointerType</a>&gt;...</td></tr>
1374 <tr><td colspan="4" class="doc" id="objcObjectPointerType0"><pre>Matches an Objective-C object pointer type, which is different from
1375 a pointer type, despite being syntactically similar.
1376
1377 Given
1378   int *a;
1379
1380   @interface Foo
1381   @end
1382   Foo *f;
1383 pointerType()
1384   matches "Foo *f", but does not match "int *a".
1385 </pre></td></tr>
1386
1387
1388 <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>
1389 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
1390
1391 Given
1392   int (*ptr_to_array)[4];
1393   int *array_of_ptrs[4];
1394
1395 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
1396 array_of_ptrs.
1397 </pre></td></tr>
1398
1399
1400 <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>
1401 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
1402 types.
1403
1404 Given
1405   int *a;
1406   int &amp;b = *a;
1407   int c = 5;
1408
1409   @interface Foo
1410   @end
1411   Foo *f;
1412 pointerType()
1413   matches "int *a", but does not match "Foo *f".
1414 </pre></td></tr>
1415
1416
1417 <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>
1418 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
1419
1420 Given:
1421   int *a;
1422   int &amp;b = *a;
1423   int &amp;&amp;c = 1;
1424   auto &amp;d = b;
1425   auto &amp;&amp;e = c;
1426   auto &amp;&amp;f = 2;
1427   int g = 5;
1428
1429 rValueReferenceType() matches the types of c and f. e is not
1430 matched as it is deduced to int&amp; by reference collapsing rules.
1431 </pre></td></tr>
1432
1433
1434 <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>
1435 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
1436
1437 Given
1438   class C {};
1439   struct S {};
1440
1441   C c;
1442   S s;
1443
1444 recordType() matches the type of the variable declarations of both c
1445 and s.
1446 </pre></td></tr>
1447
1448
1449 <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>
1450 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
1451
1452 Given
1453   int *a;
1454   int &amp;b = *a;
1455   int &amp;&amp;c = 1;
1456   auto &amp;d = b;
1457   auto &amp;&amp;e = c;
1458   auto &amp;&amp;f = 2;
1459   int g = 5;
1460
1461 referenceType() matches the types of b, c, d, e, and f.
1462 </pre></td></tr>
1463
1464
1465 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('substTemplateTypeParmType0')"><a name="substTemplateTypeParmType0Anchor">substTemplateTypeParmType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1SubstTemplateTypeParmType.html">SubstTemplateTypeParmType</a>&gt;...</td></tr>
1466 <tr><td colspan="4" class="doc" id="substTemplateTypeParmType0"><pre>Matches types that represent the result of substituting a type for a
1467 template type parameter.
1468
1469 Given
1470   template &lt;typename T&gt;
1471   void F(T t) {
1472     int i = 1 + t;
1473   }
1474
1475 substTemplateTypeParmType() matches the type of 't' but not '1'
1476 </pre></td></tr>
1477
1478
1479 <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>
1480 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
1481
1482 Given
1483   template &lt;typename T&gt;
1484   class C { };
1485
1486   template class C&lt;int&gt;;  A
1487   C&lt;char&gt; var;            B
1488
1489 templateSpecializationType() matches the type of the explicit
1490 instantiation in A and the type of the variable declaration in B.
1491 </pre></td></tr>
1492
1493
1494 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('templateTypeParmType0')"><a name="templateTypeParmType0Anchor">templateTypeParmType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;...</td></tr>
1495 <tr><td colspan="4" class="doc" id="templateTypeParmType0"><pre>Matches template type parameter types.
1496
1497 Example matches T, but not int.
1498     (matcher = templateTypeParmType())
1499   template &lt;typename T&gt; void f(int i);
1500 </pre></td></tr>
1501
1502
1503 <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>
1504 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
1505 </pre></td></tr>
1506
1507
1508 <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>
1509 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
1510
1511 Given
1512   typedef int X;
1513 typedefType()
1514   matches "typedef int X"
1515 </pre></td></tr>
1516
1517
1518 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('unaryTransformType0')"><a name="unaryTransformType0Anchor">unaryTransformType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryTransformType.html">UnaryTransformType</a>&gt;...</td></tr>
1519 <tr><td colspan="4" class="doc" id="unaryTransformType0"><pre>Matches types nodes representing unary type transformations.
1520
1521 Given:
1522   typedef __underlying_type(T) type;
1523 unaryTransformType()
1524   matches "__underlying_type(T)"
1525 </pre></td></tr>
1526
1527
1528 <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>
1529 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
1530 integer-constant-expression.
1531
1532 Given
1533   void f() {
1534     int a[] = { 2, 3 }
1535     int b[42];
1536     int c[a[0]];
1537   }
1538 variableArrayType()
1539   matches "int c[a[0]]"
1540 </pre></td></tr>
1541
1542 <!--END_DECL_MATCHERS -->
1543 </table>
1544
1545 <!-- ======================================================================= -->
1546 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
1547 <!-- ======================================================================= -->
1548
1549 <p>Narrowing matchers match certain attributes on the current node, thus
1550 narrowing down the set of nodes of the current type to match on.</p>
1551
1552 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
1553 which allow users to create more powerful match expressions.</p>
1554
1555 <table>
1556 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
1557 <!-- START_NARROWING_MATCHERS -->
1558
1559 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('allOf0')"><a name="allOf0Anchor">allOf</a></td><td>Matcher&lt;*&gt;, ..., Matcher&lt;*&gt;</td></tr>
1560 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
1561
1562 Usable as: Any Matcher
1563 </pre></td></tr>
1564
1565
1566 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anyOf0')"><a name="anyOf0Anchor">anyOf</a></td><td>Matcher&lt;*&gt;, ..., Matcher&lt;*&gt;</td></tr>
1567 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
1568
1569 Usable as: Any Matcher
1570 </pre></td></tr>
1571
1572
1573 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
1574 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
1575
1576 Useful when another matcher requires a child matcher, but there's no
1577 additional constraint. This will often be used with an explicit conversion
1578 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
1579
1580 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
1581 "int* p" and "void f()" in
1582   int* p;
1583   void f();
1584
1585 Usable as: Any Matcher
1586 </pre></td></tr>
1587
1588
1589 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;</td></tr>
1590 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
1591
1592 Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
1593   class X {};
1594   class Y {};
1595
1596 Usable as: Any Matcher
1597 </pre></td></tr>
1598
1599
1600 <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>
1601 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions (binary or
1602 unary).
1603
1604 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
1605   !(a || b)
1606 </pre></td></tr>
1607
1608
1609 <tr><td>Matcher&lt;CXXBoolLiteral&gt;</td><td class="name" onclick="toggle('equals2')"><a name="equals2Anchor">equals</a></td><td>ValueT  Value</td></tr>
1610 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value.
1611
1612 Example matches true (matcher = cxxBoolLiteral(equals(true)))
1613   true
1614
1615 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1616            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;
1617 </pre></td></tr>
1618
1619
1620 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>&gt;</td><td class="name" onclick="toggle('isCatchAll0')"><a name="isCatchAll0Anchor">isCatchAll</a></td><td></td></tr>
1621 <tr><td colspan="4" class="doc" id="isCatchAll0"><pre>Matches a C++ catch statement that has a catch-all handler.
1622
1623 Given
1624   try {
1625     ...
1626   } catch (int) {
1627     ...
1628   } catch (...) {
1629     ...
1630   }
1631 endcode
1632 cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
1633 </pre></td></tr>
1634
1635
1636 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs1')"><a name="argumentCountIs1Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
1637 <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has
1638 a specific number of arguments (including absent default arguments).
1639
1640 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
1641   void f(int x, int y);
1642   f(0, 0);
1643 </pre></td></tr>
1644
1645
1646 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('isListInitialization0')"><a name="isListInitialization0Anchor">isListInitialization</a></td><td></td></tr>
1647 <tr><td colspan="4" class="doc" id="isListInitialization0"><pre>Matches a constructor call expression which uses list initialization.
1648 </pre></td></tr>
1649
1650
1651 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isCopyConstructor0')"><a name="isCopyConstructor0Anchor">isCopyConstructor</a></td><td></td></tr>
1652 <tr><td colspan="4" class="doc" id="isCopyConstructor0"><pre>Matches constructor declarations that are copy constructors.
1653
1654 Given
1655   struct S {
1656     S(); #1
1657     S(const S &amp;); #2
1658     S(S &amp;&amp;); #3
1659   };
1660 cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
1661 </pre></td></tr>
1662
1663
1664 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isDefaultConstructor0')"><a name="isDefaultConstructor0Anchor">isDefaultConstructor</a></td><td></td></tr>
1665 <tr><td colspan="4" class="doc" id="isDefaultConstructor0"><pre>Matches constructor declarations that are default constructors.
1666
1667 Given
1668   struct S {
1669     S(); #1
1670     S(const S &amp;); #2
1671     S(S &amp;&amp;); #3
1672   };
1673 cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
1674 </pre></td></tr>
1675
1676
1677 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicit0')"><a name="isExplicit0Anchor">isExplicit</a></td><td></td></tr>
1678 <tr><td colspan="4" class="doc" id="isExplicit0"><pre>Matches constructor and conversion declarations that are marked with
1679 the explicit keyword.
1680
1681 Given
1682   struct S {
1683     S(int); #1
1684     explicit S(double); #2
1685     operator int(); #3
1686     explicit operator bool(); #4
1687   };
1688 cxxConstructorDecl(isExplicit()) will match #2, but not #1.
1689 cxxConversionDecl(isExplicit()) will match #4, but not #3.
1690 </pre></td></tr>
1691
1692
1693 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isMoveConstructor0')"><a name="isMoveConstructor0Anchor">isMoveConstructor</a></td><td></td></tr>
1694 <tr><td colspan="4" class="doc" id="isMoveConstructor0"><pre>Matches constructor declarations that are move constructors.
1695
1696 Given
1697   struct S {
1698     S(); #1
1699     S(const S &amp;); #2
1700     S(S &amp;&amp;); #3
1701   };
1702 cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
1703 </pre></td></tr>
1704
1705
1706 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConversionDecl.html">CXXConversionDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicit1')"><a name="isExplicit1Anchor">isExplicit</a></td><td></td></tr>
1707 <tr><td colspan="4" class="doc" id="isExplicit1"><pre>Matches constructor and conversion declarations that are marked with
1708 the explicit keyword.
1709
1710 Given
1711   struct S {
1712     S(int); #1
1713     explicit S(double); #2
1714     operator int(); #3
1715     explicit operator bool(); #4
1716   };
1717 cxxConstructorDecl(isExplicit()) will match #2, but not #1.
1718 cxxConversionDecl(isExplicit()) will match #4, but not #3.
1719 </pre></td></tr>
1720
1721
1722 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('isBaseInitializer0')"><a name="isBaseInitializer0Anchor">isBaseInitializer</a></td><td></td></tr>
1723 <tr><td colspan="4" class="doc" id="isBaseInitializer0"><pre>Matches a constructor initializer if it is initializing a base, as
1724 opposed to a member.
1725
1726 Given
1727   struct B {};
1728   struct D : B {
1729     int I;
1730     D(int i) : I(i) {}
1731   };
1732   struct E : B {
1733     E() : B() {}
1734   };
1735 cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
1736   will match E(), but not match D(int).
1737 </pre></td></tr>
1738
1739
1740 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('isMemberInitializer0')"><a name="isMemberInitializer0Anchor">isMemberInitializer</a></td><td></td></tr>
1741 <tr><td colspan="4" class="doc" id="isMemberInitializer0"><pre>Matches a constructor initializer if it is initializing a member, as
1742 opposed to a base.
1743
1744 Given
1745   struct B {};
1746   struct D : B {
1747     int I;
1748     D(int i) : I(i) {}
1749   };
1750   struct E : B {
1751     E() : B() {}
1752   };
1753 cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
1754   will match D(int), but not match E().
1755 </pre></td></tr>
1756
1757
1758 <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>
1759 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a constructor initializer if it is explicitly written in
1760 code (as opposed to implicitly added by the compiler).
1761
1762 Given
1763   struct Foo {
1764     Foo() { }
1765     Foo(int) : foo_("A") { }
1766     string foo_;
1767   };
1768 cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
1769   will match Foo(int), but not Foo()
1770 </pre></td></tr>
1771
1772
1773 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isConst0')"><a name="isConst0Anchor">isConst</a></td><td></td></tr>
1774 <tr><td colspan="4" class="doc" id="isConst0"><pre>Matches if the given method declaration is const.
1775
1776 Given
1777 struct A {
1778   void foo() const;
1779   void bar();
1780 };
1781
1782 cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
1783 </pre></td></tr>
1784
1785
1786 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isCopyAssignmentOperator0')"><a name="isCopyAssignmentOperator0Anchor">isCopyAssignmentOperator</a></td><td></td></tr>
1787 <tr><td colspan="4" class="doc" id="isCopyAssignmentOperator0"><pre>Matches if the given method declaration declares a copy assignment
1788 operator.
1789
1790 Given
1791 struct A {
1792   A &amp;operator=(const A &amp;);
1793   A &amp;operator=(A &amp;&amp;);
1794 };
1795
1796 cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
1797 the second one.
1798 </pre></td></tr>
1799
1800
1801 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isFinal1')"><a name="isFinal1Anchor">isFinal</a></td><td></td></tr>
1802 <tr><td colspan="4" class="doc" id="isFinal1"><pre>Matches if the given method or class declaration is final.
1803
1804 Given:
1805   class A final {};
1806
1807   struct B {
1808     virtual void f();
1809   };
1810
1811   struct C : B {
1812     void f() final;
1813   };
1814 matches A and C::f, but not B, C, or B::f
1815 </pre></td></tr>
1816
1817
1818 <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>
1819 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
1820
1821 Given
1822   class A {
1823    public:
1824     virtual void x();
1825   };
1826   class B : public A {
1827    public:
1828     virtual void x();
1829   };
1830   matches B::x
1831 </pre></td></tr>
1832
1833
1834 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isPure0')"><a name="isPure0Anchor">isPure</a></td><td></td></tr>
1835 <tr><td colspan="4" class="doc" id="isPure0"><pre>Matches if the given method declaration is pure.
1836
1837 Given
1838   class A {
1839    public:
1840     virtual void x() = 0;
1841   };
1842   matches A::x
1843 </pre></td></tr>
1844
1845
1846 <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>
1847 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches if the given method declaration is virtual.
1848
1849 Given
1850   class A {
1851    public:
1852     virtual void x();
1853   };
1854   matches A::x
1855 </pre></td></tr>
1856
1857
1858 <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>
1859 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
1860
1861 Matches overloaded operator names specified in strings without the
1862 "operator" prefix: e.g. "&lt;&lt;".
1863
1864 Given:
1865   class A { int operator*(); };
1866   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
1867   A a;
1868   a &lt;&lt; a;   &lt;-- This matches
1869
1870 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
1871 specified line and
1872 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
1873 matches the declaration of A.
1874
1875 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_1FunctionDecl.html">FunctionDecl</a>&gt;
1876 </pre></td></tr>
1877
1878
1879 <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>std::string BaseName</td></tr>
1880 <tr><td colspan="4" class="doc" id="isDerivedFrom1"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
1881 </pre></td></tr>
1882
1883
1884 <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>
1885 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
1886 static member variable template instantiations.
1887
1888 Given
1889   template&lt;typename T&gt; void A(T t) { }
1890   template&lt;&gt; void A(int N) { }
1891 functionDecl(isExplicitTemplateSpecialization())
1892   matches the specialization A&lt;int&gt;().
1893
1894 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;
1895 </pre></td></tr>
1896
1897
1898 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isFinal0')"><a name="isFinal0Anchor">isFinal</a></td><td></td></tr>
1899 <tr><td colspan="4" class="doc" id="isFinal0"><pre>Matches if the given method or class declaration is final.
1900
1901 Given:
1902   class A final {};
1903
1904   struct B {
1905     virtual void f();
1906   };
1907
1908   struct C : B {
1909     void f() final;
1910   };
1911 matches A and C::f, but not B, C, or B::f
1912 </pre></td></tr>
1913
1914
1915 <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>std::string BaseName</td></tr>
1916 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom1"><pre>Overloaded method as shortcut for
1917 isSameOrDerivedFrom(hasName(...)).
1918 </pre></td></tr>
1919
1920
1921 <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>
1922 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
1923 member variable template instantiations.
1924
1925 Given
1926   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
1927 or
1928   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
1929 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
1930   matches the template instantiation of X&lt;A&gt;.
1931
1932 But given
1933   template &lt;typename T&gt;  class X {}; class A {};
1934   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
1935 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
1936   does not match, as X&lt;A&gt; is an explicit template specialization.
1937
1938 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;
1939 </pre></td></tr>
1940
1941
1942 <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>
1943 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
1944 a specific number of arguments (including absent default arguments).
1945
1946 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
1947   void f(int x, int y);
1948   f(0, 0);
1949 </pre></td></tr>
1950
1951
1952 <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>
1953 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value.
1954
1955 Example matches true (matcher = cxxBoolLiteral(equals(true)))
1956   true
1957
1958 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1959            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;
1960 </pre></td></tr>
1961
1962
1963 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('templateArgumentCountIs0')"><a name="templateArgumentCountIs0Anchor">templateArgumentCountIs</a></td><td>unsigned N</td></tr>
1964 <tr><td colspan="4" class="doc" id="templateArgumentCountIs0"><pre>Matches if the number of template arguments equals N.
1965
1966 Given
1967   template&lt;typename T&gt; struct C {};
1968   C&lt;int&gt; c;
1969 classTemplateSpecializationDecl(templateArgumentCountIs(1))
1970   matches C&lt;int&gt;.
1971 </pre></td></tr>
1972
1973
1974 <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>
1975 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
1976 child statements.
1977
1978 Example: Given
1979   { for (;;) {} }
1980 compoundStmt(statementCountIs(0)))
1981   matches '{}'
1982   but does not match the outer compound statement.
1983 </pre></td></tr>
1984
1985
1986 <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>
1987 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches ConstantArrayType nodes that have the specified size.
1988
1989 Given
1990   int a[42];
1991   int b[2 * 21];
1992   int c[41], d[43];
1993 constantArrayType(hasSize(42))
1994   matches "int a[42]" and "int b[2 * 21]"
1995 </pre></td></tr>
1996
1997
1998 <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>
1999 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
2000 declarations.
2001
2002 Example: Given
2003   int a, b;
2004   int c;
2005   int d = 2, e;
2006 declCountIs(2)
2007   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
2008 </pre></td></tr>
2009
2010
2011 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode1')"><a name="equalsBoundNode1Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
2012 <tr><td colspan="4" class="doc" id="equalsBoundNode1"><pre>Matches if a node equals a previously bound node.
2013
2014 Matches a node if it equals the node previously bound to ID.
2015
2016 Given
2017   class X { int a; int b; };
2018 cxxRecordDecl(
2019     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
2020     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
2021   matches the class X, as a and b have the same type.
2022
2023 Note that when multiple matches are involved via forEach* matchers,
2024 equalsBoundNodes acts as a filter.
2025 For example:
2026 compoundStmt(
2027     forEachDescendant(varDecl().bind("d")),
2028     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
2029 will trigger a match for each combination of variable declaration
2030 and reference to that variable declaration within a compound statement.
2031 </pre></td></tr>
2032
2033
2034 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('hasAttr0')"><a name="hasAttr0Anchor">hasAttr</a></td><td>attr::Kind AttrKind</td></tr>
2035 <tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
2036
2037 Given
2038   __attribute__((device)) void f() { ... }
2039 decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
2040 f. If the matcher is use from clang-query, attr::Kind parameter should be
2041 passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
2042 </pre></td></tr>
2043
2044
2045 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching0')"><a name="isExpansionInFileMatching0Anchor">isExpansionInFileMatching</a></td><td>std::string RegExp</td></tr>
2046 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching0"><pre>Matches AST nodes that were expanded within files whose name is
2047 partially matching a given regex.
2048
2049 Example matches Y but not X
2050     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
2051   #include "ASTMatcher.h"
2052   class X {};
2053 ASTMatcher.h:
2054   class Y {};
2055
2056 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2057 </pre></td></tr>
2058
2059
2060 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpansionInMainFile0')"><a name="isExpansionInMainFile0Anchor">isExpansionInMainFile</a></td><td></td></tr>
2061 <tr><td colspan="4" class="doc" id="isExpansionInMainFile0"><pre>Matches AST nodes that were expanded within the main-file.
2062
2063 Example matches X but not Y
2064   (matcher = cxxRecordDecl(isExpansionInMainFile())
2065   #include &lt;Y.h&gt;
2066   class X {};
2067 Y.h:
2068   class Y {};
2069
2070 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2071 </pre></td></tr>
2072
2073
2074 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpansionInSystemHeader0')"><a name="isExpansionInSystemHeader0Anchor">isExpansionInSystemHeader</a></td><td></td></tr>
2075 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader0"><pre>Matches AST nodes that were expanded within system-header-files.
2076
2077 Example matches Y but not X
2078     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
2079   #include &lt;SystemHeader.h&gt;
2080   class X {};
2081 SystemHeader.h:
2082   class Y {};
2083
2084 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2085 </pre></td></tr>
2086
2087
2088 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isImplicit0')"><a name="isImplicit0Anchor">isImplicit</a></td><td></td></tr>
2089 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches a declaration that has been implicitly added
2090 by the compiler (eg. implicit defaultcopy constructors).
2091 </pre></td></tr>
2092
2093
2094 <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>
2095 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations.
2096
2097 Given
2098   class C {
2099   public:    int a;
2100   protected: int b;
2101   private:   int c;
2102   };
2103 fieldDecl(isPrivate())
2104   matches 'int c;'
2105 </pre></td></tr>
2106
2107
2108 <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>
2109 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations.
2110
2111 Given
2112   class C {
2113   public:    int a;
2114   protected: int b;
2115   private:   int c;
2116   };
2117 fieldDecl(isProtected())
2118   matches 'int b;'
2119 </pre></td></tr>
2120
2121
2122 <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>
2123 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations.
2124
2125 Given
2126   class C {
2127   public:    int a;
2128   protected: int b;
2129   private:   int c;
2130   };
2131 fieldDecl(isPublic())
2132   matches 'int a;'
2133 </pre></td></tr>
2134
2135
2136 <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>
2137 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value.
2138
2139 Example matches true (matcher = cxxBoolLiteral(equals(true)))
2140   true
2141
2142 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
2143            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;
2144 </pre></td></tr>
2145
2146
2147 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasOverloadedOperatorName0')"><a name="hasOverloadedOperatorName0Anchor">hasOverloadedOperatorName</a></td><td>StringRef Name</td></tr>
2148 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
2149
2150 Matches overloaded operator names specified in strings without the
2151 "operator" prefix: e.g. "&lt;&lt;".
2152
2153 Given:
2154   class A { int operator*(); };
2155   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
2156   A a;
2157   a &lt;&lt; a;   &lt;-- This matches
2158
2159 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
2160 specified line and
2161 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
2162 matches the declaration of A.
2163
2164 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_1FunctionDecl.html">FunctionDecl</a>&gt;
2165 </pre></td></tr>
2166
2167
2168 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isConstexpr1')"><a name="isConstexpr1Anchor">isConstexpr</a></td><td></td></tr>
2169 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations.
2170
2171 Given:
2172   constexpr int foo = 42;
2173   constexpr int bar();
2174 varDecl(isConstexpr())
2175   matches the declaration of foo.
2176 functionDecl(isConstexpr())
2177   matches the declaration of bar.
2178 </pre></td></tr>
2179
2180
2181 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isDefaulted0')"><a name="isDefaulted0Anchor">isDefaulted</a></td><td></td></tr>
2182 <tr><td colspan="4" class="doc" id="isDefaulted0"><pre>Matches defaulted function declarations.
2183
2184 Given:
2185   class A { ~A(); };
2186   class B { ~B() = default; };
2187 functionDecl(isDefaulted())
2188   matches the declaration of ~B, but not ~A.
2189 </pre></td></tr>
2190
2191
2192 <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>
2193 <tr><td colspan="4" class="doc" id="isDefinition2"><pre>Matches if a declaration has a body attached.
2194
2195 Example matches A, va, fa
2196   class A {};
2197   class B;  Doesn't match, as it has no body.
2198   int va;
2199   extern int vb;  Doesn't match, as it doesn't define the variable.
2200   void fa() {}
2201   void fb();  Doesn't match, as it has no body.
2202
2203 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;
2204 </pre></td></tr>
2205
2206
2207 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isDeleted0')"><a name="isDeleted0Anchor">isDeleted</a></td><td></td></tr>
2208 <tr><td colspan="4" class="doc" id="isDeleted0"><pre>Matches deleted function declarations.
2209
2210 Given:
2211   void Func();
2212   void DeletedFunc() = delete;
2213 functionDecl(isDeleted())
2214   matches the declaration of DeletedFunc, but not Func.
2215 </pre></td></tr>
2216
2217
2218 <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>
2219 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization0"><pre>Matches explicit template specializations of function, class, or
2220 static member variable template instantiations.
2221
2222 Given
2223   template&lt;typename T&gt; void A(T t) { }
2224   template&lt;&gt; void A(int N) { }
2225 functionDecl(isExplicitTemplateSpecialization())
2226   matches the specialization A&lt;int&gt;().
2227
2228 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;
2229 </pre></td></tr>
2230
2231
2232 <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>
2233 <tr><td colspan="4" class="doc" id="isExternC0"><pre>Matches extern "C" function declarations.
2234
2235 Given:
2236   extern "C" void f() {}
2237   extern "C" { void g() {} }
2238   void h() {}
2239 functionDecl(isExternC())
2240   matches the declaration of f and g, but not the declaration h
2241 </pre></td></tr>
2242
2243
2244 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isInline1')"><a name="isInline1Anchor">isInline</a></td><td></td></tr>
2245 <tr><td colspan="4" class="doc" id="isInline1"><pre>Matches function and namespace declarations that are marked with
2246 the inline keyword.
2247
2248 Given
2249   inline void f();
2250   void g();
2251   namespace n {
2252   inline namespace m {}
2253   }
2254 functionDecl(isInline()) will match ::f().
2255 namespaceDecl(isInline()) will match n::m.
2256 </pre></td></tr>
2257
2258
2259 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isNoThrow0')"><a name="isNoThrow0Anchor">isNoThrow</a></td><td></td></tr>
2260 <tr><td colspan="4" class="doc" id="isNoThrow0"><pre>Matches functions that have a non-throwing exception specification.
2261
2262 Given:
2263   void f();
2264   void g() noexcept;
2265   void h() throw();
2266   void i() throw(int);
2267   void j() noexcept(false);
2268 functionDecl(isNoThrow())
2269   matches the declarations of g, and h, but not f, i or j.
2270 </pre></td></tr>
2271
2272
2273 <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>
2274 <tr><td colspan="4" class="doc" id="isTemplateInstantiation0"><pre>Matches template instantiations of function, class, or static
2275 member variable template instantiations.
2276
2277 Given
2278   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
2279 or
2280   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
2281 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2282   matches the template instantiation of X&lt;A&gt;.
2283
2284 But given
2285   template &lt;typename T&gt;  class X {}; class A {};
2286   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2287 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2288   does not match, as X&lt;A&gt; is an explicit template specialization.
2289
2290 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;
2291 </pre></td></tr>
2292
2293
2294 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isVariadic0')"><a name="isVariadic0Anchor">isVariadic</a></td><td></td></tr>
2295 <tr><td colspan="4" class="doc" id="isVariadic0"><pre>Matches if a function declaration is variadic.
2296
2297 Example matches f, but not g or h. The function i will not match, even when
2298 compiled in C mode.
2299   void f(...);
2300   void g(int);
2301   template &lt;typename... Ts&gt; void h(Ts...);
2302   void i();
2303 </pre></td></tr>
2304
2305
2306 <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>
2307 <tr><td colspan="4" class="doc" id="parameterCountIs0"><pre>Matches FunctionDecls that have a specific parameter count.
2308
2309 Given
2310   void f(int i) {}
2311   void g(int i, int j) {}
2312 functionDecl(parameterCountIs(2))
2313   matches g(int i, int j) {}
2314 </pre></td></tr>
2315
2316
2317 <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>
2318 <tr><td colspan="4" class="doc" id="equals0"><pre>Matches literals that are equal to the given value.
2319
2320 Example matches true (matcher = cxxBoolLiteral(equals(true)))
2321   true
2322
2323 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
2324            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;
2325 </pre></td></tr>
2326
2327
2328 <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>
2329 <tr><td colspan="4" class="doc" id="isArrow0"><pre>Matches member expressions that are called with '-&gt;' as opposed
2330 to '.'.
2331
2332 Member calls on the implicit this pointer match as called with '-&gt;'.
2333
2334 Given
2335   class Y {
2336     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
2337     int a;
2338     static int b;
2339   };
2340 memberExpr(isArrow())
2341   matches this-&gt;x, x, y.x, a, this-&gt;b
2342 </pre></td></tr>
2343
2344
2345 <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>
2346 <tr><td colspan="4" class="doc" id="hasName0"><pre>Matches NamedDecl nodes that have the specified name.
2347
2348 Supports specifying enclosing namespaces or classes by prefixing the name
2349 with '&lt;enclosing&gt;::'.
2350 Does not match typedefs of an underlying type with the given name.
2351
2352 Example matches X (Name == "X")
2353   class X;
2354
2355 Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
2356   namespace a { namespace b { class X; } }
2357 </pre></td></tr>
2358
2359
2360 <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>
2361 <tr><td colspan="4" class="doc" id="matchesName0"><pre>Matches NamedDecl nodes whose fully qualified names contain
2362 a substring matched by the given RegExp.
2363
2364 Supports specifying enclosing namespaces or classes by
2365 prefixing the name with '&lt;enclosing&gt;::'.  Does not match typedefs
2366 of an underlying type with the given name.
2367
2368 Example matches X (regexp == "::X")
2369   class X;
2370
2371 Example matches X (regexp is one of "::X", "^foo::.*X", among others)
2372   namespace foo { namespace bar { class X; } }
2373 </pre></td></tr>
2374
2375
2376 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt;</td><td class="name" onclick="toggle('isAnonymous0')"><a name="isAnonymous0Anchor">isAnonymous</a></td><td></td></tr>
2377 <tr><td colspan="4" class="doc" id="isAnonymous0"><pre>Matches anonymous namespace declarations.
2378
2379 Given
2380   namespace n {
2381   namespace {} #1
2382   }
2383 namespaceDecl(isAnonymous()) will match #1 but not ::n.
2384 </pre></td></tr>
2385
2386
2387 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt;</td><td class="name" onclick="toggle('isInline0')"><a name="isInline0Anchor">isInline</a></td><td></td></tr>
2388 <tr><td colspan="4" class="doc" id="isInline0"><pre>Matches function and namespace declarations that are marked with
2389 the inline keyword.
2390
2391 Given
2392   inline void f();
2393   void g();
2394   namespace n {
2395   inline namespace m {}
2396   }
2397 functionDecl(isInline()) will match ::f().
2398 namespaceDecl(isInline()) will match n::m.
2399 </pre></td></tr>
2400
2401
2402 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs2')"><a name="argumentCountIs2Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
2403 <tr><td colspan="4" class="doc" id="argumentCountIs2"><pre>Checks that a call expression or a constructor call expression has
2404 a specific number of arguments (including absent default arguments).
2405
2406 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2407   void f(int x, int y);
2408   f(0, 0);
2409 </pre></td></tr>
2410
2411
2412 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasKeywordSelector0')"><a name="hasKeywordSelector0Anchor">hasKeywordSelector</a></td><td></td></tr>
2413 <tr><td colspan="4" class="doc" id="hasKeywordSelector0"><pre>Matches when the selector is a keyword selector
2414
2415 objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
2416 message expression in
2417
2418   UIWebView *webView = ...;
2419   CGRect bodyFrame = webView.frame;
2420   bodyFrame.size.height = self.bodyContentHeight;
2421   webView.frame = bodyFrame;
2422       ^---- matches here
2423 </pre></td></tr>
2424
2425
2426 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasNullSelector0')"><a name="hasNullSelector0Anchor">hasNullSelector</a></td><td></td></tr>
2427 <tr><td colspan="4" class="doc" id="hasNullSelector0"><pre>Matches when the selector is the empty selector
2428
2429 Matches only when the selector of the objCMessageExpr is NULL. This may
2430 represent an error condition in the tree!
2431 </pre></td></tr>
2432
2433
2434 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasSelector0')"><a name="hasSelector0Anchor">hasSelector</a></td><td>std::string BaseName</td></tr>
2435 <tr><td colspan="4" class="doc" id="hasSelector0"><pre>Matches when BaseName == Selector.getAsString()
2436
2437  matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
2438  matches the outer message expr in the code below, but NOT the message
2439  invocation for self.bodyView.
2440     [self.bodyView loadHTMLString:html baseURL:NULL];
2441 </pre></td></tr>
2442
2443
2444 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasUnarySelector0')"><a name="hasUnarySelector0Anchor">hasUnarySelector</a></td><td></td></tr>
2445 <tr><td colspan="4" class="doc" id="hasUnarySelector0"><pre>Matches when the selector is a Unary Selector
2446
2447  matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
2448  matches self.bodyView in the code below, but NOT the outer message
2449  invocation of "loadHTMLString:baseURL:".
2450     [self.bodyView loadHTMLString:html baseURL:NULL];
2451 </pre></td></tr>
2452
2453
2454 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('matchesSelector0')"><a name="matchesSelector0Anchor">matchesSelector</a></td><td>std::string RegExp</td></tr>
2455 <tr><td colspan="4" class="doc" id="matchesSelector0"><pre>Matches ObjC selectors whose name contains
2456 a substring matched by the given RegExp.
2457  matcher = objCMessageExpr(matchesSelector("loadHTMLStringmatches the outer message expr in the code below, but NOT the message
2458  invocation for self.bodyView.
2459     [self.bodyView loadHTMLString:html baseURL:NULL];
2460 </pre></td></tr>
2461
2462
2463 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('numSelectorArgs0')"><a name="numSelectorArgs0Anchor">numSelectorArgs</a></td><td>unsigned N</td></tr>
2464 <tr><td colspan="4" class="doc" id="numSelectorArgs0"><pre>Matches when the selector has the specified number of arguments
2465
2466  matcher = objCMessageExpr(numSelectorArgs(0));
2467  matches self.bodyView in the code below
2468
2469  matcher = objCMessageExpr(numSelectorArgs(2));
2470  matches the invocation of "loadHTMLString:baseURL:" but not that
2471  of self.bodyView
2472     [self.bodyView loadHTMLString:html baseURL:NULL];
2473 </pre></td></tr>
2474
2475
2476 <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>
2477 <tr><td colspan="4" class="doc" id="asString0"><pre>Matches if the matched type is represented by the given string.
2478
2479 Given
2480   class Y { public: void x(); };
2481   void z() { Y* y; y-&gt;x(); }
2482 cxxMemberCallExpr(on(hasType(asString("class Y *"))))
2483   matches y-&gt;x()
2484 </pre></td></tr>
2485
2486
2487 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode3')"><a name="equalsBoundNode3Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
2488 <tr><td colspan="4" class="doc" id="equalsBoundNode3"><pre>Matches if a node equals a previously bound node.
2489
2490 Matches a node if it equals the node previously bound to ID.
2491
2492 Given
2493   class X { int a; int b; };
2494 cxxRecordDecl(
2495     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
2496     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
2497   matches the class X, as a and b have the same type.
2498
2499 Note that when multiple matches are involved via forEach* matchers,
2500 equalsBoundNodes acts as a filter.
2501 For example:
2502 compoundStmt(
2503     forEachDescendant(varDecl().bind("d")),
2504     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
2505 will trigger a match for each combination of variable declaration
2506 and reference to that variable declaration within a compound statement.
2507 </pre></td></tr>
2508
2509
2510 <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>
2511 <tr><td colspan="4" class="doc" id="hasLocalQualifiers0"><pre>Matches QualType nodes that have local CV-qualifiers attached to
2512 the node, not hidden within a typedef.
2513
2514 Given
2515   typedef const int const_int;
2516   const_int i;
2517   int *const j;
2518   int *volatile k;
2519   int m;
2520 varDecl(hasType(hasLocalQualifiers())) matches only j and k.
2521 i is const-qualified but the qualifier is not local.
2522 </pre></td></tr>
2523
2524
2525 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isAnyCharacter0')"><a name="isAnyCharacter0Anchor">isAnyCharacter</a></td><td></td></tr>
2526 <tr><td colspan="4" class="doc" id="isAnyCharacter0"><pre>Matches QualType nodes that are of character type.
2527
2528 Given
2529   void a(char);
2530   void b(wchar_t);
2531   void c(double);
2532 functionDecl(hasAnyParameter(hasType(isAnyCharacter())))
2533 matches "a(char)", "b(wchar_t)", but not "c(double)".
2534 </pre></td></tr>
2535
2536
2537 <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>
2538 <tr><td colspan="4" class="doc" id="isConstQualified0"><pre>Matches QualType nodes that are const-qualified, i.e., that
2539 include "top-level" const.
2540
2541 Given
2542   void a(int);
2543   void b(int const);
2544   void c(const int);
2545   void d(const int*);
2546   void e(int const) {};
2547 functionDecl(hasAnyParameter(hasType(isConstQualified())))
2548   matches "void b(int const)", "void c(const int)" and
2549   "void e(int const) {}". It does not match d as there
2550   is no top-level const on the parameter type "const int *".
2551 </pre></td></tr>
2552
2553
2554 <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>
2555 <tr><td colspan="4" class="doc" id="isInteger0"><pre>Matches QualType nodes that are of integer type.
2556
2557 Given
2558   void a(int);
2559   void b(long);
2560   void c(double);
2561 functionDecl(hasAnyParameter(hasType(isInteger())))
2562 matches "a(int)", "b(long)", but not "c(double)".
2563 </pre></td></tr>
2564
2565
2566 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isVolatileQualified0')"><a name="isVolatileQualified0Anchor">isVolatileQualified</a></td><td></td></tr>
2567 <tr><td colspan="4" class="doc" id="isVolatileQualified0"><pre>Matches QualType nodes that are volatile-qualified, i.e., that
2568 include "top-level" volatile.
2569
2570 Given
2571   void a(int);
2572   void b(int volatile);
2573   void c(volatile int);
2574   void d(volatile int*);
2575   void e(int volatile) {};
2576 functionDecl(hasAnyParameter(hasType(isVolatileQualified())))
2577   matches "void b(int volatile)", "void c(volatile int)" and
2578   "void e(int volatile) {}". It does not match d as there
2579   is no top-level volatile on the parameter type "volatile int *".
2580 </pre></td></tr>
2581
2582
2583 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordDecl.html">RecordDecl</a>&gt;</td><td class="name" onclick="toggle('isClass0')"><a name="isClass0Anchor">isClass</a></td><td></td></tr>
2584 <tr><td colspan="4" class="doc" id="isClass0"><pre>Matches RecordDecl object that are spelled with "class."
2585
2586 Example matches C, but not S or U.
2587   struct S {};
2588   class C {};
2589   union U {};
2590 </pre></td></tr>
2591
2592
2593 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordDecl.html">RecordDecl</a>&gt;</td><td class="name" onclick="toggle('isStruct0')"><a name="isStruct0Anchor">isStruct</a></td><td></td></tr>
2594 <tr><td colspan="4" class="doc" id="isStruct0"><pre>Matches RecordDecl object that are spelled with "struct."
2595
2596 Example matches S, but not C or U.
2597   struct S {};
2598   class C {};
2599   union U {};
2600 </pre></td></tr>
2601
2602
2603 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordDecl.html">RecordDecl</a>&gt;</td><td class="name" onclick="toggle('isUnion0')"><a name="isUnion0Anchor">isUnion</a></td><td></td></tr>
2604 <tr><td colspan="4" class="doc" id="isUnion0"><pre>Matches RecordDecl object that are spelled with "union."
2605
2606 Example matches U, but not C or S.
2607   struct S {};
2608   class C {};
2609   union U {};
2610 </pre></td></tr>
2611
2612
2613 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode0')"><a name="equalsBoundNode0Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
2614 <tr><td colspan="4" class="doc" id="equalsBoundNode0"><pre>Matches if a node equals a previously bound node.
2615
2616 Matches a node if it equals the node previously bound to ID.
2617
2618 Given
2619   class X { int a; int b; };
2620 cxxRecordDecl(
2621     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
2622     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
2623   matches the class X, as a and b have the same type.
2624
2625 Note that when multiple matches are involved via forEach* matchers,
2626 equalsBoundNodes acts as a filter.
2627 For example:
2628 compoundStmt(
2629     forEachDescendant(varDecl().bind("d")),
2630     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
2631 will trigger a match for each combination of variable declaration
2632 and reference to that variable declaration within a compound statement.
2633 </pre></td></tr>
2634
2635
2636 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching1')"><a name="isExpansionInFileMatching1Anchor">isExpansionInFileMatching</a></td><td>std::string RegExp</td></tr>
2637 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching1"><pre>Matches AST nodes that were expanded within files whose name is
2638 partially matching a given regex.
2639
2640 Example matches Y but not X
2641     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
2642   #include "ASTMatcher.h"
2643   class X {};
2644 ASTMatcher.h:
2645   class Y {};
2646
2647 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2648 </pre></td></tr>
2649
2650
2651 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInMainFile1')"><a name="isExpansionInMainFile1Anchor">isExpansionInMainFile</a></td><td></td></tr>
2652 <tr><td colspan="4" class="doc" id="isExpansionInMainFile1"><pre>Matches AST nodes that were expanded within the main-file.
2653
2654 Example matches X but not Y
2655   (matcher = cxxRecordDecl(isExpansionInMainFile())
2656   #include &lt;Y.h&gt;
2657   class X {};
2658 Y.h:
2659   class Y {};
2660
2661 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2662 </pre></td></tr>
2663
2664
2665 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInSystemHeader1')"><a name="isExpansionInSystemHeader1Anchor">isExpansionInSystemHeader</a></td><td></td></tr>
2666 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader1"><pre>Matches AST nodes that were expanded within system-header-files.
2667
2668 Example matches Y but not X
2669     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
2670   #include &lt;SystemHeader.h&gt;
2671   class X {};
2672 SystemHeader.h:
2673   class Y {};
2674
2675 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2676 </pre></td></tr>
2677
2678
2679 <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>
2680 <tr><td colspan="4" class="doc" id="isDefinition0"><pre>Matches if a declaration has a body attached.
2681
2682 Example matches A, va, fa
2683   class A {};
2684   class B;  Doesn't match, as it has no body.
2685   int va;
2686   extern int vb;  Doesn't match, as it doesn't define the variable.
2687   void fa() {}
2688   void fb();  Doesn't match, as it has no body.
2689
2690 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;
2691 </pre></td></tr>
2692
2693
2694 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('equalsIntegralValue0')"><a name="equalsIntegralValue0Anchor">equalsIntegralValue</a></td><td>std::string Value</td></tr>
2695 <tr><td colspan="4" class="doc" id="equalsIntegralValue0"><pre>Matches a TemplateArgument of integral type with a given value.
2696
2697 Note that 'Value' is a string as the template argument's value is
2698 an arbitrary precision integer. 'Value' must be euqal to the canonical
2699 representation of that integral value in base 10.
2700
2701 Given
2702   template&lt;int T&gt; struct A {};
2703   C&lt;42&gt; c;
2704 classTemplateSpecializationDecl(
2705   hasAnyTemplateArgument(equalsIntegralValue("42")))
2706   matches the implicit instantiation of C in C&lt;42&gt;.
2707 </pre></td></tr>
2708
2709
2710 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('isIntegral0')"><a name="isIntegral0Anchor">isIntegral</a></td><td></td></tr>
2711 <tr><td colspan="4" class="doc" id="isIntegral0"><pre>Matches a TemplateArgument that is an integral value.
2712
2713 Given
2714   template&lt;int T&gt; struct A {};
2715   C&lt;42&gt; c;
2716 classTemplateSpecializationDecl(
2717   hasAnyTemplateArgument(isIntegral()))
2718   matches the implicit instantiation of C in C&lt;42&gt;
2719   with isIntegral() matching 42.
2720 </pre></td></tr>
2721
2722
2723 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('templateArgumentCountIs1')"><a name="templateArgumentCountIs1Anchor">templateArgumentCountIs</a></td><td>unsigned N</td></tr>
2724 <tr><td colspan="4" class="doc" id="templateArgumentCountIs1"><pre>Matches if the number of template arguments equals N.
2725
2726 Given
2727   template&lt;typename T&gt; struct C {};
2728   C&lt;int&gt; c;
2729 classTemplateSpecializationDecl(templateArgumentCountIs(1))
2730   matches C&lt;int&gt;.
2731 </pre></td></tr>
2732
2733
2734 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching2')"><a name="isExpansionInFileMatching2Anchor">isExpansionInFileMatching</a></td><td>std::string RegExp</td></tr>
2735 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching2"><pre>Matches AST nodes that were expanded within files whose name is
2736 partially matching a given regex.
2737
2738 Example matches Y but not X
2739     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
2740   #include "ASTMatcher.h"
2741   class X {};
2742 ASTMatcher.h:
2743   class Y {};
2744
2745 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2746 </pre></td></tr>
2747
2748
2749 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpansionInMainFile2')"><a name="isExpansionInMainFile2Anchor">isExpansionInMainFile</a></td><td></td></tr>
2750 <tr><td colspan="4" class="doc" id="isExpansionInMainFile2"><pre>Matches AST nodes that were expanded within the main-file.
2751
2752 Example matches X but not Y
2753   (matcher = cxxRecordDecl(isExpansionInMainFile())
2754   #include &lt;Y.h&gt;
2755   class X {};
2756 Y.h:
2757   class Y {};
2758
2759 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2760 </pre></td></tr>
2761
2762
2763 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpansionInSystemHeader2')"><a name="isExpansionInSystemHeader2Anchor">isExpansionInSystemHeader</a></td><td></td></tr>
2764 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader2"><pre>Matches AST nodes that were expanded within system-header-files.
2765
2766 Example matches Y but not X
2767     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
2768   #include &lt;SystemHeader.h&gt;
2769   class X {};
2770 SystemHeader.h:
2771   class Y {};
2772
2773 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
2774 </pre></td></tr>
2775
2776
2777 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('booleanType0')"><a name="booleanType0Anchor">booleanType</a></td><td></td></tr>
2778 <tr><td colspan="4" class="doc" id="booleanType0"><pre>Matches type bool.
2779
2780 Given
2781  struct S { bool func(); };
2782 functionDecl(returns(booleanType()))
2783   matches "bool func();"
2784 </pre></td></tr>
2785
2786
2787 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode2')"><a name="equalsBoundNode2Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
2788 <tr><td colspan="4" class="doc" id="equalsBoundNode2"><pre>Matches if a node equals a previously bound node.
2789
2790 Matches a node if it equals the node previously bound to ID.
2791
2792 Given
2793   class X { int a; int b; };
2794 cxxRecordDecl(
2795     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
2796     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
2797   matches the class X, as a and b have the same type.
2798
2799 Note that when multiple matches are involved via forEach* matchers,
2800 equalsBoundNodes acts as a filter.
2801 For example:
2802 compoundStmt(
2803     forEachDescendant(varDecl().bind("d")),
2804     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
2805 will trigger a match for each combination of variable declaration
2806 and reference to that variable declaration within a compound statement.
2807 </pre></td></tr>
2808
2809
2810 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('voidType0')"><a name="voidType0Anchor">voidType</a></td><td></td></tr>
2811 <tr><td colspan="4" class="doc" id="voidType0"><pre>Matches type void.
2812
2813 Given
2814  struct S { void func(); };
2815 functionDecl(returns(voidType()))
2816   matches "void func();"
2817 </pre></td></tr>
2818
2819
2820 <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>
2821 <tr><td colspan="4" class="doc" id="ofKind0"><pre>Matches unary expressions of a certain kind.
2822
2823 Given
2824   int x;
2825   int s = sizeof(x) + alignof(x)
2826 unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
2827   matches sizeof(x)
2828 </pre></td></tr>
2829
2830
2831 <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>
2832 <tr><td colspan="4" class="doc" id="hasOperatorName1"><pre>Matches the operator Name of operator expressions (binary or
2833 unary).
2834
2835 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
2836   !(a || b)
2837 </pre></td></tr>
2838
2839
2840 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasAutomaticStorageDuration0')"><a name="hasAutomaticStorageDuration0Anchor">hasAutomaticStorageDuration</a></td><td></td></tr>
2841 <tr><td colspan="4" class="doc" id="hasAutomaticStorageDuration0"><pre>Matches a variable declaration that has automatic storage duration.
2842
2843 Example matches x, but not y, z, or a.
2844 (matcher = varDecl(hasAutomaticStorageDuration())
2845 void f() {
2846   int x;
2847   static int y;
2848   thread_local int z;
2849 }
2850 int a;
2851 </pre></td></tr>
2852
2853
2854 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasGlobalStorage0')"><a name="hasGlobalStorage0Anchor">hasGlobalStorage</a></td><td></td></tr>
2855 <tr><td colspan="4" class="doc" id="hasGlobalStorage0"><pre>Matches a variable declaration that does not have local storage.
2856
2857 Example matches y and z (matcher = varDecl(hasGlobalStorage())
2858 void f() {
2859   int x;
2860   static int y;
2861 }
2862 int z;
2863 </pre></td></tr>
2864
2865
2866 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasLocalStorage0')"><a name="hasLocalStorage0Anchor">hasLocalStorage</a></td><td></td></tr>
2867 <tr><td colspan="4" class="doc" id="hasLocalStorage0"><pre>Matches a variable declaration that has function scope and is a
2868 non-static local variable.
2869
2870 Example matches x (matcher = varDecl(hasLocalStorage())
2871 void f() {
2872   int x;
2873   static int y;
2874 }
2875 int z;
2876 </pre></td></tr>
2877
2878
2879 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasStaticStorageDuration0')"><a name="hasStaticStorageDuration0Anchor">hasStaticStorageDuration</a></td><td></td></tr>
2880 <tr><td colspan="4" class="doc" id="hasStaticStorageDuration0"><pre>Matches a variable declaration that has static storage duration.
2881
2882 Example matches y and a, but not x or z.
2883 (matcher = varDecl(hasStaticStorageDuration())
2884 void f() {
2885   int x;
2886   static int y;
2887   thread_local int z;
2888 }
2889 int a;
2890 </pre></td></tr>
2891
2892
2893 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasThreadStorageDuration0')"><a name="hasThreadStorageDuration0Anchor">hasThreadStorageDuration</a></td><td></td></tr>
2894 <tr><td colspan="4" class="doc" id="hasThreadStorageDuration0"><pre>Matches a variable declaration that has thread storage duration.
2895
2896 Example matches z, but not x, z, or a.
2897 (matcher = varDecl(hasThreadStorageDuration())
2898 void f() {
2899   int x;
2900   static int y;
2901   thread_local int z;
2902 }
2903 int a;
2904 </pre></td></tr>
2905
2906
2907 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isConstexpr0')"><a name="isConstexpr0Anchor">isConstexpr</a></td><td></td></tr>
2908 <tr><td colspan="4" class="doc" id="isConstexpr0"><pre>Matches constexpr variable and function declarations.
2909
2910 Given:
2911   constexpr int foo = 42;
2912   constexpr int bar();
2913 varDecl(isConstexpr())
2914   matches the declaration of foo.
2915 functionDecl(isConstexpr())
2916   matches the declaration of bar.
2917 </pre></td></tr>
2918
2919
2920 <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>
2921 <tr><td colspan="4" class="doc" id="isDefinition1"><pre>Matches if a declaration has a body attached.
2922
2923 Example matches A, va, fa
2924   class A {};
2925   class B;  Doesn't match, as it has no body.
2926   int va;
2927   extern int vb;  Doesn't match, as it doesn't define the variable.
2928   void fa() {}
2929   void fb();  Doesn't match, as it has no body.
2930
2931 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;
2932 </pre></td></tr>
2933
2934
2935 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isExceptionVariable0')"><a name="isExceptionVariable0Anchor">isExceptionVariable</a></td><td></td></tr>
2936 <tr><td colspan="4" class="doc" id="isExceptionVariable0"><pre>Matches a variable declaration that is an exception variable from
2937 a C++ catch block, or an Objective-C statement.
2938
2939 Example matches x (matcher = varDecl(isExceptionVariable())
2940 void f(int y) {
2941   try {
2942   } catch (int x) {
2943   }
2944 }
2945 </pre></td></tr>
2946
2947
2948 <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>
2949 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization1"><pre>Matches explicit template specializations of function, class, or
2950 static member variable template instantiations.
2951
2952 Given
2953   template&lt;typename T&gt; void A(T t) { }
2954   template&lt;&gt; void A(int N) { }
2955 functionDecl(isExplicitTemplateSpecialization())
2956   matches the specialization A&lt;int&gt;().
2957
2958 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;
2959 </pre></td></tr>
2960
2961
2962 <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>
2963 <tr><td colspan="4" class="doc" id="isTemplateInstantiation1"><pre>Matches template instantiations of function, class, or static
2964 member variable template instantiations.
2965
2966 Given
2967   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
2968 or
2969   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
2970 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2971   matches the template instantiation of X&lt;A&gt;.
2972
2973 But given
2974   template &lt;typename T&gt;  class X {}; class A {};
2975   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2976 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2977   does not match, as X&lt;A&gt; is an explicit template specialization.
2978
2979 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;
2980 </pre></td></tr>
2981
2982
2983 <tr><td>Matcher&lt;internal::Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;&gt;</td><td class="name" onclick="toggle('isInstantiated0')"><a name="isInstantiated0Anchor">isInstantiated</a></td><td></td></tr>
2984 <tr><td colspan="4" class="doc" id="isInstantiated0"><pre>Matches declarations that are template instantiations or are inside
2985 template instantiations.
2986
2987 Given
2988   template&lt;typename T&gt; void A(T t) { T i; }
2989   A(0);
2990   A(0U);
2991 functionDecl(isInstantiated())
2992   matches 'A(int) {...};' and 'A(unsigned) {...}'.
2993 </pre></td></tr>
2994
2995
2996 <tr><td>Matcher&lt;internal::Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;&gt;</td><td class="name" onclick="toggle('isInTemplateInstantiation0')"><a name="isInTemplateInstantiation0Anchor">isInTemplateInstantiation</a></td><td></td></tr>
2997 <tr><td colspan="4" class="doc" id="isInTemplateInstantiation0"><pre>Matches statements inside of a template instantiation.
2998
2999 Given
3000   int j;
3001   template&lt;typename T&gt; void A(T t) { T i; j += 42;}
3002   A(0);
3003   A(0U);
3004 declStmt(isInTemplateInstantiation())
3005   matches 'int i;' and 'unsigned i'.
3006 unless(stmt(isInTemplateInstantiation()))
3007   will NOT match j += 42; as it's shared between the template definition and
3008   instantiation.
3009 </pre></td></tr>
3010
3011 <!--END_NARROWING_MATCHERS -->
3012 </table>
3013
3014 <!-- ======================================================================= -->
3015 <h2 id="traversal-matchers">AST Traversal Matchers</h2>
3016 <!-- ======================================================================= -->
3017
3018 <p>Traversal matchers specify the relationship to other nodes that are
3019 reachable from the current node.</p>
3020
3021 <p>Note that there are special traversal matchers (has, hasDescendant, forEach and
3022 forEachDescendant) which work on all nodes and allow users to write more generic
3023 match expressions.</p>
3024
3025 <table>
3026 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
3027 <!-- START_TRAVERSAL_MATCHERS -->
3028
3029 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('eachOf0')"><a name="eachOf0Anchor">eachOf</a></td><td>Matcher&lt;*&gt;, ..., Matcher&lt;*&gt;</td></tr>
3030 <tr><td colspan="4" class="doc" id="eachOf0"><pre>Matches if any of the given matchers matches.
3031
3032 Unlike anyOf, eachOf will generate a match result for each
3033 matching submatcher.
3034
3035 For example, in:
3036   class A { int a; int b; };
3037 The matcher:
3038   cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
3039                        has(fieldDecl(hasName("b")).bind("v"))))
3040 will generate two results binding "v", the first of which binds
3041 the field declaration of a, the second the field declaration of
3042 b.
3043
3044 Usable as: Any Matcher
3045 </pre></td></tr>
3046
3047
3048 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEachDescendant0')"><a name="forEachDescendant0Anchor">forEachDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
3049 <tr><td colspan="4" class="doc" id="forEachDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
3050 provided matcher.
3051
3052 Example matches X, A, B, C
3053   (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X")))))
3054   class X {};  Matches X, because X::X is a class of name X inside X.
3055   class A { class X {}; };
3056   class B { class C { class X {}; }; };
3057
3058 DescendantT must be an AST base type.
3059
3060 As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
3061 each result that matches instead of only on the first one.
3062
3063 Note: Recursively combined ForEachDescendant can cause many matches:
3064   cxxRecordDecl(forEachDescendant(cxxRecordDecl(
3065     forEachDescendant(cxxRecordDecl())
3066   )))
3067 will match 10 times (plus injected class name matches) on:
3068   class A { class B { class C { class D { class E {}; }; }; }; };
3069
3070 Usable as: Any Matcher
3071 </pre></td></tr>
3072
3073
3074 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEach0')"><a name="forEach0Anchor">forEach</a></td><td>Matcher&lt;*&gt;</td></tr>
3075 <tr><td colspan="4" class="doc" id="forEach0"><pre>Matches AST nodes that have child AST nodes that match the
3076 provided matcher.
3077
3078 Example matches X, Y
3079   (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X")))
3080   class X {};  Matches X, because X::X is a class of name X inside X.
3081   class Y { class X {}; };
3082   class Z { class Y { class X {}; }; };  Does not match Z.
3083
3084 ChildT must be an AST base type.
3085
3086 As opposed to 'has', 'forEach' will cause a match for each result that
3087 matches instead of only on the first one.
3088
3089 Usable as: Any Matcher
3090 </pre></td></tr>
3091
3092
3093 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasAncestor0')"><a name="hasAncestor0Anchor">hasAncestor</a></td><td>Matcher&lt;*&gt;</td></tr>
3094 <tr><td colspan="4" class="doc" id="hasAncestor0"><pre>Matches AST nodes that have an ancestor that matches the provided
3095 matcher.
3096
3097 Given
3098 void f() { if (true) { int x = 42; } }
3099 void g() { for (;;) { int x = 43; } }
3100 expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
3101
3102 Usable as: Any Matcher
3103 </pre></td></tr>
3104
3105
3106 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasDescendant0')"><a name="hasDescendant0Anchor">hasDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
3107 <tr><td colspan="4" class="doc" id="hasDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
3108 provided matcher.
3109
3110 Example matches X, Y, Z
3111     (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))
3112   class X {};  Matches X, because X::X is a class of name X inside X.
3113   class Y { class X {}; };
3114   class Z { class Y { class X {}; }; };
3115
3116 DescendantT must be an AST base type.
3117
3118 Usable as: Any Matcher
3119 </pre></td></tr>
3120
3121
3122 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('has0')"><a name="has0Anchor">has</a></td><td>Matcher&lt;*&gt;</td></tr>
3123 <tr><td colspan="4" class="doc" id="has0"><pre>Matches AST nodes that have child AST nodes that match the
3124 provided matcher.
3125
3126 Example matches X, Y
3127   (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X")))
3128   class X {};  Matches X, because X::X is a class of name X inside X.
3129   class Y { class X {}; };
3130   class Z { class Y { class X {}; }; };  Does not match Z.
3131
3132 ChildT must be an AST base type.
3133
3134 Usable as: Any Matcher
3135 </pre></td></tr>
3136
3137
3138 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasParent0')"><a name="hasParent0Anchor">hasParent</a></td><td>Matcher&lt;*&gt;</td></tr>
3139 <tr><td colspan="4" class="doc" id="hasParent0"><pre>Matches AST nodes that have a parent that matches the provided
3140 matcher.
3141
3142 Given
3143 void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
3144 compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
3145
3146 Usable as: Any Matcher
3147 </pre></td></tr>
3148
3149
3150 <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>
3151 <tr><td colspan="4" class="doc" id="hasBase0"><pre>Matches the base expression of an array subscript expression.
3152
3153 Given
3154   int i[5];
3155   void f() { i[1] = 42; }
3156 arraySubscriptExpression(hasBase(implicitCastExpr(
3157     hasSourceExpression(declRefExpr()))))
3158   matches i[1] with the declRefExpr() matching i
3159 </pre></td></tr>
3160
3161
3162 <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>
3163 <tr><td colspan="4" class="doc" id="hasIndex0"><pre>Matches the index expression of an array subscript expression.
3164
3165 Given
3166   int i[5];
3167   void f() { i[1] = 42; }
3168 arraySubscriptExpression(hasIndex(integerLiteral()))
3169   matches i[1] with the integerLiteral() matching 1
3170 </pre></td></tr>
3171
3172
3173 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasLHS1')"><a name="hasLHS1Anchor">hasLHS</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3174 <tr><td colspan="4" class="doc" id="hasLHS1"><pre>Matches the left hand side of binary operator expressions.
3175
3176 Example matches a (matcher = binaryOperator(hasLHS()))
3177   a || b
3178 </pre></td></tr>
3179
3180
3181 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasRHS1')"><a name="hasRHS1Anchor">hasRHS</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3182 <tr><td colspan="4" class="doc" id="hasRHS1"><pre>Matches the right hand side of binary operator expressions.
3183
3184 Example matches b (matcher = binaryOperator(hasRHS()))
3185   a || b
3186 </pre></td></tr>
3187
3188
3189 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayTypeLoc.html">ArrayTypeLoc</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>
3190 <tr><td colspan="4" class="doc" id="hasElementTypeLoc0"><pre>Matches arrays and C99 complex types that have a specific element
3191 type.
3192
3193 Given
3194   struct A {};
3195   A a[7];
3196   int b[7];
3197 arrayType(hasElementType(builtinType()))
3198   matches "int b[7]"
3199
3200 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;
3201 </pre></td></tr>
3202
3203
3204 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</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>
3205 <tr><td colspan="4" class="doc" id="hasElementType0"><pre>Matches arrays and C99 complex types that have a specific element
3206 type.
3207
3208 Given
3209   struct A {};
3210   A a[7];
3211   int b[7];
3212 arrayType(hasElementType(builtinType()))
3213   matches "int b[7]"
3214
3215 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;
3216 </pre></td></tr>
3217
3218
3219 <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>
3220 <tr><td colspan="4" class="doc" id="hasValueTypeLoc0"><pre>Matches atomic types with a specific value type.
3221
3222 Given
3223   _Atomic(int) i;
3224   _Atomic(float) f;
3225 atomicType(hasValueType(isInteger()))
3226  matches "_Atomic(int) i"
3227
3228 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
3229 </pre></td></tr>
3230
3231
3232 <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>
3233 <tr><td colspan="4" class="doc" id="hasValueType0"><pre>Matches atomic types with a specific value type.
3234
3235 Given
3236   _Atomic(int) i;
3237   _Atomic(float) f;
3238 atomicType(hasValueType(isInteger()))
3239  matches "_Atomic(int) i"
3240
3241 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
3242 </pre></td></tr>
3243
3244
3245 <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>
3246 <tr><td colspan="4" class="doc" id="hasDeducedType0"><pre>Matches AutoType nodes where the deduced type is a specific type.
3247
3248 Note: There is no TypeLoc for the deduced type and thus no
3249 getDeducedLoc() matcher.
3250
3251 Given
3252   auto a = 1;
3253   auto b = 2.0;
3254 autoType(hasDeducedType(isInteger()))
3255   matches "auto a"
3256
3257 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;
3258 </pre></td></tr>
3259
3260
3261 <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>
3262 <tr><td colspan="4" class="doc" id="hasEitherOperand0"><pre>Matches if either the left hand side or the right hand side of a
3263 binary operator matches.
3264 </pre></td></tr>
3265
3266
3267 <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>
3268 <tr><td colspan="4" class="doc" id="hasLHS0"><pre>Matches the left hand side of binary operator expressions.
3269
3270 Example matches a (matcher = binaryOperator(hasLHS()))
3271   a || b
3272 </pre></td></tr>
3273
3274
3275 <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>
3276 <tr><td colspan="4" class="doc" id="hasRHS0"><pre>Matches the right hand side of binary operator expressions.
3277
3278 Example matches b (matcher = binaryOperator(hasRHS()))
3279   a || b
3280 </pre></td></tr>
3281
3282
3283 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerTypeLoc.html">BlockPointerTypeLoc</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>
3284 <tr><td colspan="4" class="doc" id="pointeeLoc0"><pre>Narrows PointerType (and similar) matchers to those where the
3285 pointee matches a given matcher.
3286
3287 Given
3288   int *a;
3289   int const *b;
3290   float const *f;
3291 pointerType(pointee(isConstQualified(), isInteger()))
3292   matches "int const *b"
3293
3294 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;,
3295   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;
3296 </pre></td></tr>
3297
3298
3299 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</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>
3300 <tr><td colspan="4" class="doc" id="pointee0"><pre>Narrows PointerType (and similar) matchers to those where the
3301 pointee matches a given matcher.
3302
3303 Given
3304   int *a;
3305   int const *b;
3306   float const *f;
3307 pointerType(pointee(isConstQualified(), isInteger()))
3308   matches "int const *b"
3309
3310 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;,
3311   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;
3312 </pre></td></tr>
3313
3314
3315 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('forEachArgumentWithParam1')"><a name="forEachArgumentWithParam1Anchor">forEachArgumentWithParam</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; ArgMatcher, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; ParamMatcher</td></tr>
3316 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam1"><pre>Matches all arguments and their respective ParmVarDecl.
3317
3318 Given
3319   void f(int i);
3320   int y;
3321   f(y);
3322 callExpr(declRefExpr(to(varDecl(hasName("y")))),
3323 parmVarDecl(hasType(isInteger())))
3324   matches f(y);
3325 with declRefExpr(...)
3326   matching int y
3327 and parmVarDecl(...)
3328   matching int i
3329 </pre></td></tr>
3330
3331
3332 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyArgument1')"><a name="hasAnyArgument1Anchor">hasAnyArgument</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3333 <tr><td colspan="4" class="doc" id="hasAnyArgument1"><pre>Matches any argument of a call expression or a constructor call
3334 expression.
3335
3336 Given
3337   void x(int, int, int) { int y; x(1, y, 42); }
3338 callExpr(hasAnyArgument(declRefExpr()))
3339   matches x(1, y, 42)
3340 with hasAnyArgument(...)
3341   matching y
3342
3343 FIXME: Currently this will ignore parentheses and implicit casts on
3344 the argument before applying the inner matcher. We'll want to remove
3345 this to allow for greater control by the user once ignoreImplicit()
3346 has been implemented.
3347 </pre></td></tr>
3348
3349
3350 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument1')"><a name="hasArgument1Anchor">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>
3351 <tr><td colspan="4" class="doc" id="hasArgument1"><pre>Matches the n'th argument of a call expression or a constructor
3352 call expression.
3353
3354 Example matches y in x(y)
3355     (matcher = callExpr(hasArgument(0, declRefExpr())))
3356   void x(int) { int y; x(y); }
3357 </pre></td></tr>
3358
3359
3360 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration12')"><a name="hasDeclaration12Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3361 <tr><td colspan="4" class="doc" id="hasDeclaration12"><pre>Matches a node if the declaration associated with that node
3362 matches the given matcher.
3363
3364 The associated declaration is:
3365 - for type nodes, the declaration of the underlying type
3366 - for CallExpr, the declaration of the callee
3367 - for MemberExpr, the declaration of the referenced member
3368 - for CXXConstructExpr, the declaration of the constructor
3369
3370 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
3371 function. e.g. various subtypes of clang::Type and various expressions.
3372
3373 Usable as: 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;,
3374   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
3375   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
3376   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
3377   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
3378   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
3379 </pre></td></tr>
3380
3381
3382 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('forEachConstructorInitializer0')"><a name="forEachConstructorInitializer0Anchor">forEachConstructorInitializer</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt; InnerMatcher</td></tr>
3383 <tr><td colspan="4" class="doc" id="forEachConstructorInitializer0"><pre>Matches each constructor initializer in a constructor definition.
3384
3385 Given
3386   class A { A() : i(42), j(42) {} int i; int j; };
3387 cxxConstructorDecl(forEachConstructorInitializer(
3388   forField(decl().bind("x"))
3389 ))
3390   will trigger two matches, binding for 'i' and 'j' respectively.
3391 </pre></td></tr>
3392
3393
3394 <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>
3395 <tr><td colspan="4" class="doc" id="hasAnyConstructorInitializer0"><pre>Matches a constructor initializer.
3396
3397 Given
3398   struct Foo {
3399     Foo() : foo_(1) { }
3400     int foo_;
3401   };
3402 cxxRecordDecl(has(cxxConstructorDecl(
3403   hasAnyConstructorInitializer(anything())
3404 )))
3405   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
3406 </pre></td></tr>
3407
3408
3409 <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>
3410 <tr><td colspan="4" class="doc" id="forField0"><pre>Matches the field declaration of a constructor initializer.
3411
3412 Given
3413   struct Foo {
3414     Foo() : foo_(1) { }
3415     int foo_;
3416   };
3417 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
3418     forField(hasName("foo_"))))))
3419   matches Foo
3420 with forField matching foo_
3421 </pre></td></tr>
3422
3423
3424 <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>
3425 <tr><td colspan="4" class="doc" id="withInitializer0"><pre>Matches the initializer expression of a constructor initializer.
3426
3427 Given
3428   struct Foo {
3429     Foo() : foo_(1) { }
3430     int foo_;
3431   };
3432 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
3433     withInitializer(integerLiteral(equals(1)))))))
3434   matches Foo
3435 with withInitializer matching (1)
3436 </pre></td></tr>
3437
3438
3439 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody3')"><a name="hasBody3Anchor">hasBody</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
3440 <tr><td colspan="4" class="doc" id="hasBody3"><pre>Matches a 'for', 'while', 'do while' statement or a function
3441 definition that has a given body.
3442
3443 Given
3444   for (;;) {}
3445 hasBody(compoundStmt())
3446   matches 'for (;;) {}'
3447 with compoundStmt()
3448   matching '{}'
3449 </pre></td></tr>
3450
3451
3452 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasLoopVariable0')"><a name="hasLoopVariable0Anchor">hasLoopVariable</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt; InnerMatcher</td></tr>
3453 <tr><td colspan="4" class="doc" id="hasLoopVariable0"><pre>Matches the initialization statement of a for loop.
3454
3455 Example:
3456     forStmt(hasLoopVariable(anything()))
3457 matches 'int x' in
3458     for (int x : a) { }
3459 </pre></td></tr>
3460
3461
3462 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasRangeInit0')"><a name="hasRangeInit0Anchor">hasRangeInit</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3463 <tr><td colspan="4" class="doc" id="hasRangeInit0"><pre>Matches the range initialization statement of a for loop.
3464
3465 Example:
3466     forStmt(hasRangeInit(anything()))
3467 matches 'a' in
3468     for (int x : a) { }
3469 </pre></td></tr>
3470
3471
3472 <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>
3473 <tr><td colspan="4" class="doc" id="onImplicitObjectArgument0"><pre></pre></td></tr>
3474
3475
3476 <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>
3477 <tr><td colspan="4" class="doc" id="on0"><pre>Matches on the implicit object argument of a member call expression.
3478
3479 Example matches y.x()
3480   (matcher = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y"))))))
3481   class Y { public: void x(); };
3482   void z() { Y y; y.x(); }",
3483
3484 FIXME: Overload to allow directly matching types?
3485 </pre></td></tr>
3486
3487
3488 <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>
3489 <tr><td colspan="4" class="doc" id="thisPointerType1"><pre>Overloaded to match the type's declaration.
3490 </pre></td></tr>
3491
3492
3493 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType0')"><a name="thisPointerType0Anchor">thisPointerType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
3494 <tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the expression's type either matches the specified
3495 matcher, or is a pointer to a type that matches the InnerMatcher.
3496 </pre></td></tr>
3497
3498
3499 <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>
3500 <tr><td colspan="4" class="doc" id="ofClass0"><pre>Matches the class declaration that the given method declaration
3501 belongs to.
3502
3503 FIXME: Generalize this for other kinds of declarations.
3504 FIXME: What other kind of declarations would we need to generalize
3505 this to?
3506
3507 Example matches A() in the last line
3508     (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
3509         ofClass(hasName("A"))))))
3510   class A {
3511    public:
3512     A();
3513   };
3514   A a = A();
3515 </pre></td></tr>
3516
3517
3518 <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>
3519 <tr><td colspan="4" class="doc" id="hasMethod0"><pre>Matches the first method of a class or struct that satisfies InnerMatcher.
3520
3521 Given:
3522   class A { void func(); };
3523   class B { void member(); };
3524
3525 cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
3526 A but not B.
3527 </pre></td></tr>
3528
3529
3530 <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>
3531 <tr><td colspan="4" class="doc" id="isDerivedFrom0"><pre>Matches C++ classes that are directly or indirectly derived from
3532 a class matching Base.
3533
3534 Note that a class is not considered to be derived from itself.
3535
3536 Example matches Y, Z, C (Base == hasName("X"))
3537   class X;
3538   class Y : public X {};  directly derived
3539   class Z : public Y {};  indirectly derived
3540   typedef X A;
3541   typedef A B;
3542   class C : public B {};  derived from a typedef of X
3543
3544 In the following example, Bar matches isDerivedFrom(hasName("X")):
3545   class Foo;
3546   typedef Foo X;
3547   class Bar : public Foo {};  derived from a type that X is a typedef of
3548 </pre></td></tr>
3549
3550
3551 <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>
3552 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom0"><pre>Similar to isDerivedFrom(), but also matches classes that directly
3553 match Base.
3554 </pre></td></tr>
3555
3556
3557 <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>
3558 <tr><td colspan="4" class="doc" id="callee1"><pre>Matches if the call expression's callee's declaration matches the
3559 given matcher.
3560
3561 Example matches y.x() (matcher = callExpr(callee(
3562                                    cxxMethodDecl(hasName("x")))))
3563   class Y { public: void x(); };
3564   void z() { Y y; y.x(); }
3565 </pre></td></tr>
3566
3567
3568 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('callee0')"><a name="callee0Anchor">callee</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
3569 <tr><td colspan="4" class="doc" id="callee0"><pre>Matches if the call expression's callee expression matches.
3570
3571 Given
3572   class Y { void x() { this-&gt;x(); x(); Y y; y.x(); } };
3573   void f() { f(); }
3574 callExpr(callee(expr()))
3575   matches this-&gt;x(), x(), y.x(), f()
3576 with callee(...)
3577   matching this-&gt;x, x, y.x, f respectively
3578
3579 Note: Callee cannot take the more general internal::Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;
3580 because this introduces ambiguous overloads with calls to Callee taking a
3581 internal::Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, as the matcher hierarchy is purely
3582 implemented in terms of implicit casts.
3583 </pre></td></tr>
3584
3585
3586 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('forEachArgumentWithParam0')"><a name="forEachArgumentWithParam0Anchor">forEachArgumentWithParam</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; ArgMatcher, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; ParamMatcher</td></tr>
3587 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam0"><pre>Matches all arguments and their respective ParmVarDecl.
3588
3589 Given
3590   void f(int i);
3591   int y;
3592   f(y);
3593 callExpr(declRefExpr(to(varDecl(hasName("y")))),
3594 parmVarDecl(hasType(isInteger())))
3595   matches f(y);
3596 with declRefExpr(...)
3597   matching int y
3598 and parmVarDecl(...)
3599   matching int i
3600 </pre></td></tr>
3601
3602
3603 <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>
3604 <tr><td colspan="4" class="doc" id="hasAnyArgument0"><pre>Matches any argument of a call expression or a constructor call
3605 expression.
3606
3607 Given
3608   void x(int, int, int) { int y; x(1, y, 42); }
3609 callExpr(hasAnyArgument(declRefExpr()))
3610   matches x(1, y, 42)
3611 with hasAnyArgument(...)
3612   matching y
3613
3614 FIXME: Currently this will ignore parentheses and implicit casts on
3615 the argument before applying the inner matcher. We'll want to remove
3616 this to allow for greater control by the user once ignoreImplicit()
3617 has been implemented.
3618 </pre></td></tr>
3619
3620
3621 <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>
3622 <tr><td colspan="4" class="doc" id="hasArgument0"><pre>Matches the n'th argument of a call expression or a constructor
3623 call expression.
3624
3625 Example matches y in x(y)
3626     (matcher = callExpr(hasArgument(0, declRefExpr())))
3627   void x(int) { int y; x(y); }
3628 </pre></td></tr>
3629
3630
3631 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration13')"><a name="hasDeclaration13Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3632 <tr><td colspan="4" class="doc" id="hasDeclaration13"><pre>Matches a node if the declaration associated with that node
3633 matches the given matcher.
3634
3635 The associated declaration is:
3636 - for type nodes, the declaration of the underlying type
3637 - for CallExpr, the declaration of the callee
3638 - for MemberExpr, the declaration of the referenced member
3639 - for CXXConstructExpr, the declaration of the constructor
3640
3641 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
3642 function. e.g. various subtypes of clang::Type and various expressions.
3643
3644 Usable as: 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;,
3645   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
3646   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
3647   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
3648   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
3649   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
3650 </pre></td></tr>
3651
3652
3653 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1CaseStmt.html">CaseStmt</a>&gt;</td><td class="name" onclick="toggle('hasCaseConstant0')"><a name="hasCaseConstant0Anchor">hasCaseConstant</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3654 <tr><td colspan="4" class="doc" id="hasCaseConstant0"><pre>If the given case statement does not use the GNU case range
3655 extension, matches the constant given in the statement.
3656
3657 Given
3658   switch (1) { case 1: case 1+1: case 3 ... 4: ; }
3659 caseStmt(hasCaseConstant(integerLiteral()))
3660   matches "case 1:"
3661 </pre></td></tr>
3662
3663
3664 <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>
3665 <tr><td colspan="4" class="doc" id="hasSourceExpression0"><pre>Matches if the cast's source expression matches the given matcher.
3666
3667 Example: matches "a string" (matcher =
3668                                  hasSourceExpression(cxxConstructExpr()))
3669 class URL { URL(string); };
3670 URL url = "a string";
3671 </pre></td></tr>
3672
3673
3674 <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>
3675 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches classTemplateSpecializations that have at least one
3676 TemplateArgument matching the given InnerMatcher.
3677
3678 Given
3679   template&lt;typename T&gt; class A {};
3680   template&lt;&gt; class A&lt;double&gt; {};
3681   A&lt;int&gt; a;
3682 classTemplateSpecializationDecl(hasAnyTemplateArgument(
3683     refersToType(asString("int"))))
3684   matches the specialization A&lt;int&gt;
3685 </pre></td></tr>
3686
3687
3688 <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>
3689 <tr><td colspan="4" class="doc" id="hasTemplateArgument0"><pre>Matches classTemplateSpecializations where the n'th TemplateArgument
3690 matches the given InnerMatcher.
3691
3692 Given
3693   template&lt;typename T, typename U&gt; class A {};
3694   A&lt;bool, int&gt; b;
3695   A&lt;int, bool&gt; c;
3696 classTemplateSpecializationDecl(hasTemplateArgument(
3697     1, refersToType(asString("int"))))
3698   matches the specialization A&lt;bool, int&gt;
3699 </pre></td></tr>
3700
3701
3702 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexTypeLoc.html">ComplexTypeLoc</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>
3703 <tr><td colspan="4" class="doc" id="hasElementTypeLoc1"><pre>Matches arrays and C99 complex types that have a specific element
3704 type.
3705
3706 Given
3707   struct A {};
3708   A a[7];
3709   int b[7];
3710 arrayType(hasElementType(builtinType()))
3711   matches "int b[7]"
3712
3713 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;
3714 </pre></td></tr>
3715
3716
3717 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</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>
3718 <tr><td colspan="4" class="doc" id="hasElementType1"><pre>Matches arrays and C99 complex types that have a specific element
3719 type.
3720
3721 Given
3722   struct A {};
3723   A a[7];
3724   int b[7];
3725 arrayType(hasElementType(builtinType()))
3726   matches "int b[7]"
3727
3728 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;
3729 </pre></td></tr>
3730
3731
3732 <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>
3733 <tr><td colspan="4" class="doc" id="hasAnySubstatement0"><pre>Matches compound statements where at least one substatement matches
3734 a given matcher.
3735
3736 Given
3737   { {}; 1+2; }
3738 hasAnySubstatement(compoundStmt())
3739   matches '{ {}; 1+2; }'
3740 with compoundStmt()
3741   matching '{}'
3742 </pre></td></tr>
3743
3744
3745 <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>
3746 <tr><td colspan="4" class="doc" id="hasCondition4"><pre>Matches the condition expression of an if statement, for loop,
3747 or conditional operator.
3748
3749 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
3750   if (true) {}
3751 </pre></td></tr>
3752
3753
3754 <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>
3755 <tr><td colspan="4" class="doc" id="hasFalseExpression0"><pre>Matches the false branch expression of a conditional operator.
3756
3757 Example matches b
3758   condition ? a : b
3759 </pre></td></tr>
3760
3761
3762 <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>
3763 <tr><td colspan="4" class="doc" id="hasTrueExpression0"><pre>Matches the true branch expression of a conditional operator.
3764
3765 Example matches a
3766   condition ? a : b
3767 </pre></td></tr>
3768
3769
3770 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DecayedType.html">DecayedType</a>&gt;</td><td class="name" onclick="toggle('hasDecayedType0')"><a name="hasDecayedType0Anchor">hasDecayedType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerType</td></tr>
3771 <tr><td colspan="4" class="doc" id="hasDecayedType0"><pre>Matches the decayed type, whos decayed type matches InnerMatcher
3772 </pre></td></tr>
3773
3774
3775 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration11')"><a name="hasDeclaration11Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3776 <tr><td colspan="4" class="doc" id="hasDeclaration11"><pre>Matches a node if the declaration associated with that node
3777 matches the given matcher.
3778
3779 The associated declaration is:
3780 - for type nodes, the declaration of the underlying type
3781 - for CallExpr, the declaration of the callee
3782 - for MemberExpr, the declaration of the referenced member
3783 - for CXXConstructExpr, the declaration of the constructor
3784
3785 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
3786 function. e.g. various subtypes of clang::Type and various expressions.
3787
3788 Usable as: 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;,
3789   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
3790   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
3791   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
3792   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
3793   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
3794 </pre></td></tr>
3795
3796
3797 <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>
3798 <tr><td colspan="4" class="doc" id="throughUsingDecl0"><pre>Matches a DeclRefExpr that refers to a declaration through a
3799 specific using shadow declaration.
3800
3801 Given
3802   namespace a { void f() {} }
3803   using a::f;
3804   void g() {
3805     f();     Matches this ..
3806     a::f();  .. but not this.
3807   }
3808 declRefExpr(throughUsingDecl(anything()))
3809   matches f()
3810 </pre></td></tr>
3811
3812
3813 <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>
3814 <tr><td colspan="4" class="doc" id="to0"><pre>Matches a DeclRefExpr that refers to a declaration that matches the
3815 specified matcher.
3816
3817 Example matches x in if(x)
3818     (matcher = declRefExpr(to(varDecl(hasName("x")))))
3819   bool x;
3820   if (x) {}
3821 </pre></td></tr>
3822
3823
3824 <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>
3825 <tr><td colspan="4" class="doc" id="containsDeclaration0"><pre>Matches the n'th declaration of a declaration statement.
3826
3827 Note that this does not work for global declarations because the AST
3828 breaks up multiple-declaration DeclStmt's into multiple single-declaration
3829 DeclStmt's.
3830 Example: Given non-global declarations
3831   int a, b = 0;
3832   int c;
3833   int d = 2, e;
3834 declStmt(containsDeclaration(
3835       0, varDecl(hasInitializer(anything()))))
3836   matches only 'int d = 2, e;', and
3837 declStmt(containsDeclaration(1, varDecl()))
3838   matches 'int a, b = 0' as well as 'int d = 2, e;'
3839   but 'int c;' is not matched.
3840 </pre></td></tr>
3841
3842
3843 <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>
3844 <tr><td colspan="4" class="doc" id="hasSingleDecl0"><pre>Matches the Decl of a DeclStmt which has a single declaration.
3845
3846 Given
3847   int a, b;
3848   int c;
3849 declStmt(hasSingleDecl(anything()))
3850   matches 'int c;' but not 'int a, b;'.
3851 </pre></td></tr>
3852
3853
3854 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc0')"><a name="hasTypeLoc0Anchor">hasTypeLoc</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
3855 <tr><td colspan="4" class="doc" id="hasTypeLoc0"><pre>Matches if the type location of the declarator decl's type matches
3856 the inner matcher.
3857
3858 Given
3859   int x;
3860 declaratorDecl(hasTypeLoc(loc(asString("int"))))
3861   matches int x
3862 </pre></td></tr>
3863
3864
3865 <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>
3866 <tr><td colspan="4" class="doc" id="hasDeclContext0"><pre>Matches declarations whose declaration context, interpreted as a
3867 Decl, matches InnerMatcher.
3868
3869 Given
3870   namespace N {
3871     namespace M {
3872       class D {};
3873     }
3874   }
3875
3876 cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
3877 declaration of class D.
3878 </pre></td></tr>
3879
3880
3881 <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>
3882 <tr><td colspan="4" class="doc" id="hasBody0"><pre>Matches a 'for', 'while', 'do while' statement or a function
3883 definition that has a given body.
3884
3885 Given
3886   for (;;) {}
3887 hasBody(compoundStmt())
3888   matches 'for (;;) {}'
3889 with compoundStmt()
3890   matching '{}'
3891 </pre></td></tr>
3892
3893
3894 <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>
3895 <tr><td colspan="4" class="doc" id="hasCondition3"><pre>Matches the condition expression of an if statement, for loop,
3896 or conditional operator.
3897
3898 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
3899   if (true) {}
3900 </pre></td></tr>
3901
3902
3903 <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>
3904 <tr><td colspan="4" class="doc" id="hasQualifier0"><pre>Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
3905 matches InnerMatcher if the qualifier exists.
3906
3907 Given
3908   namespace N {
3909     namespace M {
3910       class D {};
3911     }
3912   }
3913   N::M::D d;
3914
3915 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
3916 matches the type of the variable declaration of d.
3917 </pre></td></tr>
3918
3919
3920 <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>
3921 <tr><td colspan="4" class="doc" id="namesType0"><pre>Matches ElaboratedTypes whose named type matches InnerMatcher.
3922
3923 Given
3924   namespace N {
3925     namespace M {
3926       class D {};
3927     }
3928   }
3929   N::M::D d;
3930
3931 elaboratedType(namesType(recordType(
3932 hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
3933 declaration of d.
3934 </pre></td></tr>
3935
3936
3937 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration10')"><a name="hasDeclaration10Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
3938 <tr><td colspan="4" class="doc" id="hasDeclaration10"><pre>Matches a node if the declaration associated with that node
3939 matches the given matcher.
3940
3941 The associated declaration is:
3942 - for type nodes, the declaration of the underlying type
3943 - for CallExpr, the declaration of the callee
3944 - for MemberExpr, the declaration of the referenced member
3945 - for CXXConstructExpr, the declaration of the constructor
3946
3947 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
3948 function. e.g. various subtypes of clang::Type and various expressions.
3949
3950 Usable as: 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;,
3951   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
3952   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
3953   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
3954   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
3955   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
3956 </pre></td></tr>
3957
3958
3959 <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>
3960 <tr><td colspan="4" class="doc" id="hasDestinationType0"><pre>Matches casts whose destination type matches a given matcher.
3961
3962 (Note: Clang's AST refers to other conversions as "casts" too, and calls
3963 actual casts "explicit" casts.)
3964 </pre></td></tr>
3965
3966
3967 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</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>
3968 <tr><td colspan="4" class="doc" id="hasType2"><pre>Overloaded to match the declaration of the expression's or value
3969 declaration's type.
3970
3971 In case of a value declaration (for example a variable declaration),
3972 this resolves one layer of indirection. For example, in the value
3973 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
3974 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
3975 declaration of x.
3976
3977 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
3978             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
3979  class X {};
3980  void y(X &amp;x) { x; X z; }
3981
3982 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;
3983 </pre></td></tr>
3984
3985
3986 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('hasType0')"><a name="hasType0Anchor">hasType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
3987 <tr><td colspan="4" class="doc" id="hasType0"><pre>Matches if the expression's or declaration's type matches a type
3988 matcher.
3989
3990 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
3991             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
3992  class X {};
3993  void y(X &amp;x) { x; X z; }
3994 </pre></td></tr>
3995
3996
3997 <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>
3998 <tr><td colspan="4" class="doc" id="ignoringImpCasts0"><pre>Matches expressions that match InnerMatcher after any implicit casts
3999 are stripped off.
4000
4001 Parentheses and explicit casts are not discarded.
4002 Given
4003   int arr[5];
4004   int a = 0;
4005   char b = 0;
4006   const int c = a;
4007   int *d = arr;
4008   long e = (long) 0l;
4009 The matchers
4010    varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
4011    varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
4012 would match the declarations for a, b, c, and d, but not e.
4013 While
4014    varDecl(hasInitializer(integerLiteral()))
4015    varDecl(hasInitializer(declRefExpr()))
4016 only match the declarations for b, c, and d.
4017 </pre></td></tr>
4018
4019
4020 <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>
4021 <tr><td colspan="4" class="doc" id="ignoringParenCasts0"><pre>Matches expressions that match InnerMatcher after parentheses and
4022 casts are stripped off.
4023
4024 Implicit and non-C Style casts are also discarded.
4025 Given
4026   int a = 0;
4027   char b = (0);
4028   void* c = reinterpret_cast&lt;char*&gt;(0);
4029   char d = char(0);
4030 The matcher
4031    varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
4032 would match the declarations for a, b, c, and d.
4033 while
4034    varDecl(hasInitializer(integerLiteral()))
4035 only match the declaration for a.
4036 </pre></td></tr>
4037
4038
4039 <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>
4040 <tr><td colspan="4" class="doc" id="ignoringParenImpCasts0"><pre>Matches expressions that match InnerMatcher after implicit casts and
4041 parentheses are stripped off.
4042
4043 Explicit casts are not discarded.
4044 Given
4045   int arr[5];
4046   int a = 0;
4047   char b = (0);
4048   const int c = a;
4049   int *d = (arr);
4050   long e = ((long) 0l);
4051 The matchers
4052    varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
4053    varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
4054 would match the declarations for a, b, c, and d, but not e.
4055 while
4056    varDecl(hasInitializer(integerLiteral()))
4057    varDecl(hasInitializer(declRefExpr()))
4058 would only match the declaration for a.
4059 </pre></td></tr>
4060
4061
4062 <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>
4063 <tr><td colspan="4" class="doc" id="hasBody1"><pre>Matches a 'for', 'while', 'do while' statement or a function
4064 definition that has a given body.
4065
4066 Given
4067   for (;;) {}
4068 hasBody(compoundStmt())
4069   matches 'for (;;) {}'
4070 with compoundStmt()
4071   matching '{}'
4072 </pre></td></tr>
4073
4074
4075 <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>
4076 <tr><td colspan="4" class="doc" id="hasCondition1"><pre>Matches the condition expression of an if statement, for loop,
4077 or conditional operator.
4078
4079 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
4080   if (true) {}
4081 </pre></td></tr>
4082
4083
4084 <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>
4085 <tr><td colspan="4" class="doc" id="hasIncrement0"><pre>Matches the increment statement of a for loop.
4086
4087 Example:
4088     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
4089 matches '++x' in
4090     for (x; x &lt; N; ++x) { }
4091 </pre></td></tr>
4092
4093
4094 <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>
4095 <tr><td colspan="4" class="doc" id="hasLoopInit0"><pre>Matches the initialization statement of a for loop.
4096
4097 Example:
4098     forStmt(hasLoopInit(declStmt()))
4099 matches 'int x = 0' in
4100     for (int x = 0; x &lt; N; ++x) { }
4101 </pre></td></tr>
4102
4103
4104 <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>
4105 <tr><td colspan="4" class="doc" id="hasAnyParameter0"><pre>Matches any parameter of a function declaration.
4106
4107 Does not match the 'this' parameter of a method.
4108
4109 Given
4110   class X { void f(int x, int y, int z) {} };
4111 cxxMethodDecl(hasAnyParameter(hasName("y")))
4112   matches f(int x, int y, int z) {}
4113 with hasAnyParameter(...)
4114   matching int y
4115 </pre></td></tr>
4116
4117
4118 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasBody4')"><a name="hasBody4Anchor">hasBody</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
4119 <tr><td colspan="4" class="doc" id="hasBody4"><pre>Matches a 'for', 'while', 'do while' statement or a function
4120 definition that has a given body.
4121
4122 Given
4123   for (;;) {}
4124 hasBody(compoundStmt())
4125   matches 'for (;;) {}'
4126 with compoundStmt()
4127   matching '{}'
4128 </pre></td></tr>
4129
4130
4131 <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>
4132 <tr><td colspan="4" class="doc" id="hasParameter0"><pre>Matches the n'th parameter of a function declaration.
4133
4134 Given
4135   class X { void f(int x) {} };
4136 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
4137   matches f(int x) {}
4138 with hasParameter(...)
4139   matching int x
4140 </pre></td></tr>
4141
4142
4143 <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>
4144 <tr><td colspan="4" class="doc" id="returns0"><pre>Matches the return type of a function declaration.
4145
4146 Given:
4147   class X { int f() { return 1; } };
4148 cxxMethodDecl(returns(asString("int")))
4149   matches int f() { return 1; }
4150 </pre></td></tr>
4151
4152
4153 <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>
4154 <tr><td colspan="4" class="doc" id="hasCondition0"><pre>Matches the condition expression of an if statement, for loop,
4155 or conditional operator.
4156
4157 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
4158   if (true) {}
4159 </pre></td></tr>
4160
4161
4162 <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>
4163 <tr><td colspan="4" class="doc" id="hasConditionVariableStatement0"><pre>Matches the condition variable statement in an if statement.
4164
4165 Given
4166   if (A* a = GetAPointer()) {}
4167 hasConditionVariableStatement(...)
4168   matches 'A* a = GetAPointer()'.
4169 </pre></td></tr>
4170
4171
4172 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasElse0')"><a name="hasElse0Anchor">hasElse</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
4173 <tr><td colspan="4" class="doc" id="hasElse0"><pre>Matches the else-statement of an if statement.
4174
4175 Examples matches the if statement
4176   (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true)))))
4177   if (false) false; else true;
4178 </pre></td></tr>
4179
4180
4181 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasThen0')"><a name="hasThen0Anchor">hasThen</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
4182 <tr><td colspan="4" class="doc" id="hasThen0"><pre>Matches the then-statement of an if statement.
4183
4184 Examples matches the if statement
4185   (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true)))))
4186   if (false) true; else false;
4187 </pre></td></tr>
4188
4189
4190 <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>
4191 <tr><td colspan="4" class="doc" id="hasImplicitDestinationType0"><pre>Matches implicit casts whose destination type matches a given
4192 matcher.
4193
4194 FIXME: Unit test this matcher
4195 </pre></td></tr>
4196
4197
4198 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration9')"><a name="hasDeclaration9Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
4199 <tr><td colspan="4" class="doc" id="hasDeclaration9"><pre>Matches a node if the declaration associated with that node
4200 matches the given matcher.
4201
4202 The associated declaration is:
4203 - for type nodes, the declaration of the underlying type
4204 - for CallExpr, the declaration of the callee
4205 - for MemberExpr, the declaration of the referenced member
4206 - for CXXConstructExpr, the declaration of the constructor
4207
4208 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4209 function. e.g. various subtypes of clang::Type and various expressions.
4210
4211 Usable as: 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;,
4212   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4213   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4214   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4215   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4216   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4217 </pre></td></tr>
4218
4219
4220 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration8')"><a name="hasDeclaration8Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
4221 <tr><td colspan="4" class="doc" id="hasDeclaration8"><pre>Matches a node if the declaration associated with that node
4222 matches the given matcher.
4223
4224 The associated declaration is:
4225 - for type nodes, the declaration of the underlying type
4226 - for CallExpr, the declaration of the callee
4227 - for MemberExpr, the declaration of the referenced member
4228 - for CXXConstructExpr, the declaration of the constructor
4229
4230 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4231 function. e.g. various subtypes of clang::Type and various expressions.
4232
4233 Usable as: 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;,
4234   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4235   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4236   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4237   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4238   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4239 </pre></td></tr>
4240
4241
4242 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration7')"><a name="hasDeclaration7Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
4243 <tr><td colspan="4" class="doc" id="hasDeclaration7"><pre>Matches a node if the declaration associated with that node
4244 matches the given matcher.
4245
4246 The associated declaration is:
4247 - for type nodes, the declaration of the underlying type
4248 - for CallExpr, the declaration of the callee
4249 - for MemberExpr, the declaration of the referenced member
4250 - for CXXConstructExpr, the declaration of the constructor
4251
4252 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4253 function. e.g. various subtypes of clang::Type and various expressions.
4254
4255 Usable as: 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;,
4256   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4257   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4258   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4259   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4260   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4261 </pre></td></tr>
4262
4263
4264 <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>
4265 <tr><td colspan="4" class="doc" id="hasObjectExpression0"><pre>Matches a member expression where the object expression is
4266 matched by a given matcher.
4267
4268 Given
4269   struct X { int m; };
4270   void f(X x) { x.m; m; }
4271 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))))
4272   matches "x.m" and "m"
4273 with hasObjectExpression(...)
4274   matching "x" and the implicit object expression of "m" which has type X*.
4275 </pre></td></tr>
4276
4277
4278 <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>
4279 <tr><td colspan="4" class="doc" id="member0"><pre>Matches a member expression where the member is matched by a
4280 given matcher.
4281
4282 Given
4283   struct { int first, second; } first, second;
4284   int i(second.first);
4285   int j(first.second);
4286 memberExpr(member(hasName("first")))
4287   matches second.first
4288   but not first.second (because the member name there is "second").
4289 </pre></td></tr>
4290
4291
4292 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerTypeLoc.html">MemberPointerTypeLoc</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>
4293 <tr><td colspan="4" class="doc" id="pointeeLoc1"><pre>Narrows PointerType (and similar) matchers to those where the
4294 pointee matches a given matcher.
4295
4296 Given
4297   int *a;
4298   int const *b;
4299   float const *f;
4300 pointerType(pointee(isConstQualified(), isInteger()))
4301   matches "int const *b"
4302
4303 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;,
4304   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;
4305 </pre></td></tr>
4306
4307
4308 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</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>
4309 <tr><td colspan="4" class="doc" id="pointee1"><pre>Narrows PointerType (and similar) matchers to those where the
4310 pointee matches a given matcher.
4311
4312 Given
4313   int *a;
4314   int const *b;
4315   float const *f;
4316 pointerType(pointee(isConstQualified(), isInteger()))
4317   matches "int const *b"
4318
4319 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;,
4320   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;
4321 </pre></td></tr>
4322
4323
4324 <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>
4325 <tr><td colspan="4" class="doc" id="hasPrefix1"><pre>Matches on the prefix of a NestedNameSpecifierLoc.
4326
4327 Given
4328   struct A { struct B { struct C {}; }; };
4329   A::B::C c;
4330 nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
4331   matches "A::"
4332 </pre></td></tr>
4333
4334
4335 <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>
4336 <tr><td colspan="4" class="doc" id="specifiesTypeLoc0"><pre>Matches nested name specifier locs that specify a type matching the
4337 given TypeLoc.
4338
4339 Given
4340   struct A { struct B { struct C {}; }; };
4341   A::B::C c;
4342 nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
4343   hasDeclaration(cxxRecordDecl(hasName("A")))))))
4344   matches "A::"
4345 </pre></td></tr>
4346
4347
4348 <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>
4349 <tr><td colspan="4" class="doc" id="hasPrefix0"><pre>Matches on the prefix of a NestedNameSpecifier.
4350
4351 Given
4352   struct A { struct B { struct C {}; }; };
4353   A::B::C c;
4354 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
4355   matches "A::"
4356 </pre></td></tr>
4357
4358
4359 <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>
4360 <tr><td colspan="4" class="doc" id="specifiesNamespace0"><pre>Matches nested name specifiers that specify a namespace matching the
4361 given namespace matcher.
4362
4363 Given
4364   namespace ns { struct A {}; }
4365   ns::A a;
4366 nestedNameSpecifier(specifiesNamespace(hasName("ns")))
4367   matches "ns::"
4368 </pre></td></tr>
4369
4370
4371 <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>
4372 <tr><td colspan="4" class="doc" id="specifiesType0"><pre>Matches nested name specifiers that specify a type matching the
4373 given QualType matcher without qualifiers.
4374
4375 Given
4376   struct A { struct B { struct C {}; }; };
4377   A::B::C c;
4378 nestedNameSpecifier(specifiesType(
4379   hasDeclaration(cxxRecordDecl(hasName("A")))
4380 ))
4381   matches "A::"
4382 </pre></td></tr>
4383
4384
4385 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument2')"><a name="hasArgument2Anchor">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>
4386 <tr><td colspan="4" class="doc" id="hasArgument2"><pre>Matches the n'th argument of a call expression or a constructor
4387 call expression.
4388
4389 Example matches y in x(y)
4390     (matcher = callExpr(hasArgument(0, declRefExpr())))
4391   void x(int) { int y; x(y); }
4392 </pre></td></tr>
4393
4394
4395 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasReceiverType0')"><a name="hasReceiverType0Anchor">hasReceiverType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
4396 <tr><td colspan="4" class="doc" id="hasReceiverType0"><pre>Matches on the receiver of an ObjectiveC Message expression.
4397
4398 Example
4399 matcher = objCMessageExpr(hasRecieverType(asString("UIWebView *")));
4400 matches the [webView ...] message invocation.
4401   NSString *webViewJavaScript = ...
4402   UIWebView *webView = ...
4403   [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
4404 </pre></td></tr>
4405
4406
4407 <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>
4408 <tr><td colspan="4" class="doc" id="innerType0"><pre>Matches ParenType nodes where the inner type is a specific type.
4409
4410 Given
4411   int (*ptr_to_array)[4];
4412   int (*ptr_to_func)(int);
4413
4414 varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
4415 ptr_to_func but not ptr_to_array.
4416
4417 Usable as: Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;
4418 </pre></td></tr>
4419
4420
4421 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerTypeLoc.html">PointerTypeLoc</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>
4422 <tr><td colspan="4" class="doc" id="pointeeLoc2"><pre>Narrows PointerType (and similar) matchers to those where the
4423 pointee matches a given matcher.
4424
4425 Given
4426   int *a;
4427   int const *b;
4428   float const *f;
4429 pointerType(pointee(isConstQualified(), isInteger()))
4430   matches "int const *b"
4431
4432 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;,
4433   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;
4434 </pre></td></tr>
4435
4436
4437 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</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>
4438 <tr><td colspan="4" class="doc" id="pointee2"><pre>Narrows PointerType (and similar) matchers to those where the
4439 pointee matches a given matcher.
4440
4441 Given
4442   int *a;
4443   int const *b;
4444   float const *f;
4445 pointerType(pointee(isConstQualified(), isInteger()))
4446   matches "int const *b"
4447
4448 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;,
4449   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;
4450 </pre></td></tr>
4451
4452
4453 <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>
4454 <tr><td colspan="4" class="doc" id="hasCanonicalType0"><pre>Matches QualTypes whose canonical type matches InnerMatcher.
4455
4456 Given:
4457   typedef int &amp;int_ref;
4458   int a;
4459   int_ref b = a;
4460
4461 varDecl(hasType(qualType(referenceType()))))) will not match the
4462 declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
4463 </pre></td></tr>
4464
4465
4466 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration6')"><a name="hasDeclaration6Anchor">hasDeclaration</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
4467 <tr><td colspan="4" class="doc" id="hasDeclaration6"><pre>Matches a node if the declaration associated with that node
4468 matches the given matcher.
4469
4470 The associated declaration is:
4471 - for type nodes, the declaration of the underlying type
4472 - for CallExpr, the declaration of the callee
4473 - for MemberExpr, the declaration of the referenced member
4474 - for CXXConstructExpr, the declaration of the constructor
4475
4476 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4477 function. e.g. various subtypes of clang::Type and various expressions.
4478
4479 Usable as: 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;,
4480   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4481   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4482   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4483   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4484   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4485 </pre></td></tr>
4486
4487
4488 <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>
4489 <tr><td colspan="4" class="doc" id="pointsTo1"><pre>Overloaded to match the pointee type's declaration.
4490 </pre></td></tr>
4491
4492
4493 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('pointsTo0')"><a name="pointsTo0Anchor">pointsTo</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
4494 <tr><td colspan="4" class="doc" id="pointsTo0"><pre>Matches if the matched type is a pointer type and the pointee type
4495 matches the specified matcher.
4496
4497 Example matches y-&gt;x()
4498   (matcher = cxxMemberCallExpr(on(hasType(pointsTo
4499      cxxRecordDecl(hasName("Y")))))))
4500   class Y { public: void x(); };
4501   void z() { Y *y; y-&gt;x(); }
4502 </pre></td></tr>
4503
4504
4505 <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>
4506 <tr><td colspan="4" class="doc" id="references1"><pre>Overloaded to match the referenced type's declaration.
4507 </pre></td></tr>
4508
4509
4510 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('references0')"><a name="references0Anchor">references</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
4511 <tr><td colspan="4" class="doc" id="references0"><pre>Matches if the matched type is a reference type and the referenced
4512 type matches the specified matcher.
4513
4514 Example matches X &amp;x and const X &amp;y
4515     (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X"))))))
4516   class X {
4517     void a(X b) {
4518       X &amp;x = b;
4519       const X &amp;y = b;
4520     }
4521   };
4522 </pre></td></tr>
4523
4524
4525 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</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>
4526 <tr><td colspan="4" class="doc" id="hasDeclaration5"><pre>Matches a node if the declaration associated with that node
4527 matches the given matcher.
4528
4529 The associated declaration is:
4530 - for type nodes, the declaration of the underlying type
4531 - for CallExpr, the declaration of the callee
4532 - for MemberExpr, the declaration of the referenced member
4533 - for CXXConstructExpr, the declaration of the constructor
4534
4535 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4536 function. e.g. various subtypes of clang::Type and various expressions.
4537
4538 Usable as: 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;,
4539   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4540   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4541   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4542   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4543   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4544 </pre></td></tr>
4545
4546
4547 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceTypeLoc.html">ReferenceTypeLoc</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>
4548 <tr><td colspan="4" class="doc" id="pointeeLoc3"><pre>Narrows PointerType (and similar) matchers to those where the
4549 pointee matches a given matcher.
4550
4551 Given
4552   int *a;
4553   int const *b;
4554   float const *f;
4555 pointerType(pointee(isConstQualified(), isInteger()))
4556   matches "int const *b"
4557
4558 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;,
4559   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;
4560 </pre></td></tr>
4561
4562
4563 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</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>
4564 <tr><td colspan="4" class="doc" id="pointee3"><pre>Narrows PointerType (and similar) matchers to those where the
4565 pointee matches a given matcher.
4566
4567 Given
4568   int *a;
4569   int const *b;
4570   float const *f;
4571 pointerType(pointee(isConstQualified(), isInteger()))
4572   matches "int const *b"
4573
4574 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;,
4575   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;
4576 </pre></td></tr>
4577
4578
4579 <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>
4580 <tr><td colspan="4" class="doc" id="alignOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
4581 alignof.
4582 </pre></td></tr>
4583
4584
4585 <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>
4586 <tr><td colspan="4" class="doc" id="sizeOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
4587 sizeof.
4588 </pre></td></tr>
4589
4590
4591 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;</td><td class="name" onclick="toggle('forEachSwitchCase0')"><a name="forEachSwitchCase0Anchor">forEachSwitchCase</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1SwitchCase.html">SwitchCase</a>&gt; InnerMatcher</td></tr>
4592 <tr><td colspan="4" class="doc" id="forEachSwitchCase0"><pre>Matches each case or default statement belonging to the given switch
4593 statement. This matcher may produce multiple matches.
4594
4595 Given
4596   switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
4597 switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
4598   matches four times, with "c" binding each of "case 1:", "case 2:",
4599 "case 3:" and "case 4:", and "s" respectively binding "switch (1)",
4600 "switch (1)", "switch (2)" and "switch (2)".
4601 </pre></td></tr>
4602
4603
4604 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</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>
4605 <tr><td colspan="4" class="doc" id="hasDeclaration4"><pre>Matches a node if the declaration associated with that node
4606 matches the given matcher.
4607
4608 The associated declaration is:
4609 - for type nodes, the declaration of the underlying type
4610 - for CallExpr, the declaration of the callee
4611 - for MemberExpr, the declaration of the referenced member
4612 - for CXXConstructExpr, the declaration of the constructor
4613
4614 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4615 function. e.g. various subtypes of clang::Type and various expressions.
4616
4617 Usable as: 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;,
4618   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4619   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4620   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4621   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4622   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4623 </pre></td></tr>
4624
4625
4626 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('isExpr0')"><a name="isExpr0Anchor">isExpr</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
4627 <tr><td colspan="4" class="doc" id="isExpr0"><pre>Matches a sugar TemplateArgument that refers to a certain expression.
4628
4629 Given
4630   template&lt;typename T&gt; struct A {};
4631   struct B { B* next; };
4632   A&lt;&amp;B::next&gt; a;
4633 templateSpecializationType(hasAnyTemplateArgument(
4634   isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
4635   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
4636     B::next
4637 </pre></td></tr>
4638
4639
4640 <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>
4641 <tr><td colspan="4" class="doc" id="refersToDeclaration0"><pre>Matches a canonical TemplateArgument that refers to a certain
4642 declaration.
4643
4644 Given
4645   template&lt;typename T&gt; struct A {};
4646   struct B { B* next; };
4647   A&lt;&amp;B::next&gt; a;
4648 classTemplateSpecializationDecl(hasAnyTemplateArgument(
4649     refersToDeclaration(fieldDecl(hasName("next"))))
4650   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
4651     B::next
4652 </pre></td></tr>
4653
4654
4655 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToIntegralType0')"><a name="refersToIntegralType0Anchor">refersToIntegralType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
4656 <tr><td colspan="4" class="doc" id="refersToIntegralType0"><pre>Matches a TemplateArgument that referes to an integral type.
4657
4658 Given
4659   template&lt;int T&gt; struct A {};
4660   C&lt;42&gt; c;
4661 classTemplateSpecializationDecl(
4662   hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
4663   matches the implicit instantiation of C in C&lt;42&gt;.
4664 </pre></td></tr>
4665
4666
4667 <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>
4668 <tr><td colspan="4" class="doc" id="refersToType0"><pre>Matches a TemplateArgument that refers to a certain type.
4669
4670 Given
4671   struct X {};
4672   template&lt;typename T&gt; struct A {};
4673   A&lt;X&gt; a;
4674 classTemplateSpecializationDecl(hasAnyTemplateArgument(
4675     refersToType(class(hasName("X")))))
4676   matches the specialization A&lt;X&gt;
4677 </pre></td></tr>
4678
4679
4680 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument1')"><a name="hasAnyTemplateArgument1Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
4681 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument1"><pre>Matches classTemplateSpecializations that have at least one
4682 TemplateArgument matching the given InnerMatcher.
4683
4684 Given
4685   template&lt;typename T&gt; class A {};
4686   template&lt;&gt; class A&lt;double&gt; {};
4687   A&lt;int&gt; a;
4688 classTemplateSpecializationDecl(hasAnyTemplateArgument(
4689     refersToType(asString("int"))))
4690   matches the specialization A&lt;int&gt;
4691 </pre></td></tr>
4692
4693
4694 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</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>
4695 <tr><td colspan="4" class="doc" id="hasDeclaration3"><pre>Matches a node if the declaration associated with that node
4696 matches the given matcher.
4697
4698 The associated declaration is:
4699 - for type nodes, the declaration of the underlying type
4700 - for CallExpr, the declaration of the callee
4701 - for MemberExpr, the declaration of the referenced member
4702 - for CXXConstructExpr, the declaration of the constructor
4703
4704 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4705 function. e.g. various subtypes of clang::Type and various expressions.
4706
4707 Usable as: 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;,
4708   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4709   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4710   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4711   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4712   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4713 </pre></td></tr>
4714
4715
4716 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument1')"><a name="hasTemplateArgument1Anchor">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>
4717 <tr><td colspan="4" class="doc" id="hasTemplateArgument1"><pre>Matches classTemplateSpecializations where the n'th TemplateArgument
4718 matches the given InnerMatcher.
4719
4720 Given
4721   template&lt;typename T, typename U&gt; class A {};
4722   A&lt;bool, int&gt; b;
4723   A&lt;int, bool&gt; c;
4724 classTemplateSpecializationDecl(hasTemplateArgument(
4725     1, refersToType(asString("int"))))
4726   matches the specialization A&lt;bool, int&gt;
4727 </pre></td></tr>
4728
4729
4730 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</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>
4731 <tr><td colspan="4" class="doc" id="hasDeclaration2"><pre>Matches a node if the declaration associated with that node
4732 matches the given matcher.
4733
4734 The associated declaration is:
4735 - for type nodes, the declaration of the underlying type
4736 - for CallExpr, the declaration of the callee
4737 - for MemberExpr, the declaration of the referenced member
4738 - for CXXConstructExpr, the declaration of the constructor
4739
4740 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4741 function. e.g. various subtypes of clang::Type and various expressions.
4742
4743 Usable as: 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;,
4744   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4745   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4746   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4747   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4748   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4749 </pre></td></tr>
4750
4751
4752 <tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('findAll0')"><a name="findAll0Anchor">findAll</a></td><td>Matcher&lt;T&gt;  Matcher</td></tr>
4753 <tr><td colspan="4" class="doc" id="findAll0"><pre>Matches if the node or any descendant matches.
4754
4755 Generates results for each match.
4756
4757 For example, in:
4758   class A { class B {}; class C {}; };
4759 The matcher:
4760   cxxRecordDecl(hasName("::A"),
4761                 findAll(cxxRecordDecl(isDefinition()).bind("m")))
4762 will generate results for A, B and C.
4763
4764 Usable as: Any Matcher
4765 </pre></td></tr>
4766
4767
4768 <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>
4769 <tr><td colspan="4" class="doc" id="hasDeclaration1"><pre>Matches a node if the declaration associated with that node
4770 matches the given matcher.
4771
4772 The associated declaration is:
4773 - for type nodes, the declaration of the underlying type
4774 - for CallExpr, the declaration of the callee
4775 - for MemberExpr, the declaration of the referenced member
4776 - for CXXConstructExpr, the declaration of the constructor
4777
4778 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4779 function. e.g. various subtypes of clang::Type and various expressions.
4780
4781 Usable as: 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;,
4782   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4783   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4784   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4785   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4786   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4787 </pre></td></tr>
4788
4789
4790 <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>
4791 <tr><td colspan="4" class="doc" id="hasArgumentOfType0"><pre>Matches unary expressions that have a specific type of argument.
4792
4793 Given
4794   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
4795 unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
4796   matches sizeof(a) and alignof(c)
4797 </pre></td></tr>
4798
4799
4800 <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>
4801 <tr><td colspan="4" class="doc" id="hasUnaryOperand0"><pre>Matches if the operand of a unary operator matches.
4802
4803 Example matches true (matcher = hasUnaryOperand(
4804                                   cxxBoolLiteral(equals(true))))
4805   !true
4806 </pre></td></tr>
4807
4808
4809 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</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>
4810 <tr><td colspan="4" class="doc" id="hasDeclaration0"><pre>Matches a node if the declaration associated with that node
4811 matches the given matcher.
4812
4813 The associated declaration is:
4814 - for type nodes, the declaration of the underlying type
4815 - for CallExpr, the declaration of the callee
4816 - for MemberExpr, the declaration of the referenced member
4817 - for CXXConstructExpr, the declaration of the constructor
4818
4819 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4820 function. e.g. various subtypes of clang::Type and various expressions.
4821
4822 Usable as: 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;,
4823   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;,
4824   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;, 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_1QualType.html">QualType</a>&gt;,
4825   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4826   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;,
4827   Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;, Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
4828 </pre></td></tr>
4829
4830
4831 <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>
4832 <tr><td colspan="4" class="doc" id="hasAnyUsingShadowDecl0"><pre>Matches any using shadow declaration.
4833
4834 Given
4835   namespace X { void b(); }
4836   using X::b;
4837 usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
4838   matches using X::b </pre></td></tr>
4839
4840
4841 <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>
4842 <tr><td colspan="4" class="doc" id="hasTargetDecl0"><pre>Matches a using shadow declaration where the target declaration is
4843 matched by the given matcher.
4844
4845 Given
4846   namespace X { int a; void b(); }
4847   using X::a;
4848   using X::b;
4849 usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
4850   matches using X::b but not using X::a </pre></td></tr>
4851
4852
4853 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</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>
4854 <tr><td colspan="4" class="doc" id="hasType3"><pre>Overloaded to match the declaration of the expression's or value
4855 declaration's type.
4856
4857 In case of a value declaration (for example a variable declaration),
4858 this resolves one layer of indirection. For example, in the value
4859 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
4860 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
4861 declaration of x.
4862
4863 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
4864             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
4865  class X {};
4866  void y(X &amp;x) { x; X z; }
4867
4868 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;
4869 </pre></td></tr>
4870
4871
4872 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;</td><td class="name" onclick="toggle('hasType1')"><a name="hasType1Anchor">hasType</a></td><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
4873 <tr><td colspan="4" class="doc" id="hasType1"><pre>Matches if the expression's or declaration's type matches a type
4874 matcher.
4875
4876 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
4877             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
4878  class X {};
4879  void y(X &amp;x) { x; X z; }
4880 </pre></td></tr>
4881
4882
4883 <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>
4884 <tr><td colspan="4" class="doc" id="hasInitializer0"><pre>Matches a variable declaration that has an initializer expression
4885 that matches the given matcher.
4886
4887 Example matches x (matcher = varDecl(hasInitializer(callExpr())))
4888   bool y() { return true; }
4889   bool x = y();
4890 </pre></td></tr>
4891
4892
4893 <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>
4894 <tr><td colspan="4" class="doc" id="hasSizeExpr0"><pre>Matches VariableArrayType nodes that have a specific size
4895 expression.
4896
4897 Given
4898   void f(int b) {
4899     int a[b];
4900   }
4901 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
4902   varDecl(hasName("b")))))))
4903   matches "int a[b]"
4904 </pre></td></tr>
4905
4906
4907 <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>
4908 <tr><td colspan="4" class="doc" id="hasBody2"><pre>Matches a 'for', 'while', 'do while' statement or a function
4909 definition that has a given body.
4910
4911 Given
4912   for (;;) {}
4913 hasBody(compoundStmt())
4914   matches 'for (;;) {}'
4915 with compoundStmt()
4916   matching '{}'
4917 </pre></td></tr>
4918
4919
4920 <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>
4921 <tr><td colspan="4" class="doc" id="hasCondition2"><pre>Matches the condition expression of an if statement, for loop,
4922 or conditional operator.
4923
4924 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
4925   if (true) {}
4926 </pre></td></tr>
4927
4928
4929 <tr><td>Matcher&lt;internal::BindableMatcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;&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>
4930 <tr><td colspan="4" class="doc" id="loc1"><pre>Matches NestedNameSpecifierLocs for which the given inner
4931 NestedNameSpecifier-matcher matches.
4932 </pre></td></tr>
4933
4934
4935 <tr><td>Matcher&lt;internal::BindableMatcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;&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>
4936 <tr><td colspan="4" class="doc" id="loc0"><pre>Matches TypeLocs for which the given inner
4937 QualType-matcher matches.
4938 </pre></td></tr>
4939
4940 <!--END_TRAVERSAL_MATCHERS -->
4941 </table>
4942
4943 </div>
4944 </body>
4945 </html>
4946
4947