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('labelDecl0')"><a name="labelDecl0Anchor">labelDecl</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelDecl.html">LabelDecl</a>&gt;...</td></tr>
 275 <tr><td colspan="4" class="doc" id="labelDecl0"><pre>Matches a declaration of label.
 276
 277 Given
 278   goto FOO;
 279   FOO: bar();
 280 labelDecl()
 281   matches 'FOO:'
 282 </pre></td></tr>
 283
 284
 285 <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>
 286 <tr><td colspan="4" class="doc" id="linkageSpecDecl0"><pre>Matches a declaration of a linkage specification.
 287
 288 Given
 289   extern "C" {}
 290 linkageSpecDecl()
 291   matches "extern "C" {}"
 292 </pre></td></tr>
 293
 294
 295 <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>
 296 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
 297
 298 Example matches X, S, the anonymous union type, i, and U;
 299   typedef int X;
 300   struct S {
 301     union {
 302       int i;
 303     } U;
 304   };
 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('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>
 309 <tr><td colspan="4" class="doc" id="namespaceAliasDecl0"><pre>Matches a declaration of a namespace alias.
 310
 311 Given
 312   namespace test {}
 313   namespace alias = ::test;
 314 namespaceAliasDecl()
 315   matches "namespace alias" but not "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('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>
 320 <tr><td colspan="4" class="doc" id="namespaceDecl0"><pre>Matches a declaration of a namespace.
 321
 322 Given
 323   namespace {}
 324   namespace test {}
 325 namespaceDecl()
 326   matches "namespace {}" and "namespace test {}"
 327 </pre></td></tr>
 328
 329
 330 <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>
 331 <tr><td colspan="4" class="doc" id="nonTypeTemplateParmDecl0"><pre>Matches non-type template parameter declarations.
 332
 333 Given
 334   template &lt;typename T, int N&gt; struct C {};
 335 nonTypeTemplateParmDecl()
 336   matches 'N', but not 'T'.
 337 </pre></td></tr>
 338
 339
 340 <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>
 341 <tr><td colspan="4" class="doc" id="objcInterfaceDecl0"><pre>Matches Objective-C interface declarations.
 342
 343 Example matches Foo
 344   @interface Foo
 345   @end
 346 </pre></td></tr>
 347
 348
 349 <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>
 350 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
 351
 352 Given
 353   void f(int x);
 354 parmVarDecl()
 355   matches int x.
 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('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>
 360 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches class, struct, and union declarations.
 361
 362 Example matches X, Z, U, and S
 363   class X;
 364   template&lt;class T&gt; class Z {};
 365   struct S {};
 366   union U {};
 367 </pre></td></tr>
 368
 369
 370 <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>
 371 <tr><td colspan="4" class="doc" id="staticAssertDecl0"><pre>Matches a C++ static_assert declaration.
 372
 373 Example:
 374   staticAssertExpr()
 375 matches
 376   static_assert(sizeof(S) == sizeof(int))
 377 in
 378   struct S {
 379     int x;
 380   };
 381   static_assert(sizeof(S) == sizeof(int));
 382 </pre></td></tr>
 383
 384
 385 <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>
 386 <tr><td colspan="4" class="doc" id="templateTypeParmDecl0"><pre>Matches template type parameter declarations.
 387
 388 Given
 389   template &lt;typename T, int N&gt; struct C {};
 390 templateTypeParmDecl()
 391   matches 'T', but not 'N'.
 392 </pre></td></tr>
 393
 394
 395 <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>
 396 <tr><td colspan="4" class="doc" id="translationUnitDecl0"><pre>Matches the top declaration context.
 397
 398 Given
 399   int X;
 400   namespace NS {
 401   int Y;
 402   }  namespace NS
 403 decl(hasDeclContext(translationUnitDecl()))
 404   matches "int X", but not "int Y".
 405 </pre></td></tr>
 406
 407
 408 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typeAliasDecl0')"><a name="typeAliasDecl0Anchor">typeAliasDecl</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TypeAliasDecl.html">TypeAliasDecl</a>&gt;...</td></tr>
 409 <tr><td colspan="4" class="doc" id="typeAliasDecl0"><pre>Matches type alias declarations.
 410
 411 Given
 412   typedef int X;
 413   using Y = int;
 414 typeAliasDecl()
 415   matches "using Y = int", but not "typedef int X"
 416 </pre></td></tr>
 417
 418
 419 <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>
 420 <tr><td colspan="4" class="doc" id="typedefDecl0"><pre>Matches typedef declarations.
 421
 422 Given
 423   typedef int X;
 424   using Y = int;
 425 typedefDecl()
 426   matches "typedef int X", but not "using Y = int"
 427 </pre></td></tr>
 428
 429
 430 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typedefNameDecl0')"><a name="typedefNameDecl0Anchor">typedefNameDecl</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;...</td></tr>
 431 <tr><td colspan="4" class="doc" id="typedefNameDecl0"><pre>Matches typedef name declarations.
 432
 433 Given
 434   typedef int X;
 435   using Y = int;
 436 typedefNameDecl()
 437   matches "typedef int X" and "using Y = int"
 438 </pre></td></tr>
 439
 440
 441 <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>
 442 <tr><td colspan="4" class="doc" id="unresolvedUsingTypenameDecl0"><pre>Matches unresolved using value declarations that involve the
 443 typename.
 444
 445 Given
 446   template &lt;typename T&gt;
 447   struct Base { typedef T Foo; };
 448
 449   template&lt;typename T&gt;
 450   struct S : private Base&lt;T&gt; {
 451     using typename Base&lt;T&gt;::Foo;
 452   };
 453 unresolvedUsingTypenameDecl()
 454   matches using Base&lt;T&gt;::Foo </pre></td></tr>
 455
 456
 457 <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>
 458 <tr><td colspan="4" class="doc" id="unresolvedUsingValueDecl0"><pre>Matches unresolved using value declarations.
 459
 460 Given
 461   template&lt;typename X&gt;
 462   class C : private X {
 463     using X::x;
 464   };
 465 unresolvedUsingValueDecl()
 466   matches using X::x </pre></td></tr>
 467
 468
 469 <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>
 470 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
 471
 472 Given
 473   namespace X { int x; }
 474   using X::x;
 475 usingDecl()
 476   matches using X::x </pre></td></tr>
 477
 478
 479 <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>
 480 <tr><td colspan="4" class="doc" id="usingDirectiveDecl0"><pre>Matches using namespace declarations.
 481
 482 Given
 483   namespace X { int x; }
 484   using namespace X;
 485 usingDirectiveDecl()
 486   matches using namespace X </pre></td></tr>
 487
 488
 489 <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>
 490 <tr><td colspan="4" class="doc" id="valueDecl0"><pre>Matches any value declaration.
 491
 492 Example matches A, B, C and F
 493   enum X { A, B, C };
 494   void F();
 495 </pre></td></tr>
 496
 497
 498 <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>
 499 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
 500
 501 Note: this does not match declarations of member variables, which are
 502 "field" declarations in Clang parlance.
 503
 504 Example matches a
 505   int a;
 506 </pre></td></tr>
 507
 508
 509 <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>
 510 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
 511 </pre></td></tr>
 512
 513
 514 <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>
 515 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
 516
 517 Given
 518   namespace ns {
 519     struct A { static void f(); };
 520     void A::f() {}
 521     void g() { A::f(); }
 522   }
 523   ns::A a;
 524 nestedNameSpecifier()
 525   matches "ns::" and both "A::"
 526 </pre></td></tr>
 527
 528
 529 <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>
 530 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
 531 </pre></td></tr>
 532
 533
 534 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('addrLabelExpr0')"><a name="addrLabelExpr0Anchor">addrLabelExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;...</td></tr>
 535 <tr><td colspan="4" class="doc" id="addrLabelExpr0"><pre>Matches address of label statements (GNU extension).
 536
 537 Given
 538   FOO: bar();
 539   void *ptr = &amp;&amp;FOO;
 540   goto *bar;
 541 addrLabelExpr()
 542   matches '&amp;&amp;FOO'
 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('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>
 547 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
 548
 549 Given
 550   int i = a[1];
 551 arraySubscriptExpr()
 552   matches "a[1]"
 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('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>
 557 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
 558
 559  int i = 100;
 560   __asm("mov al, 2");
 561 asmStmt()
 562   matches '__asm("mov al, 2")'
 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('atomicExpr0')"><a name="atomicExpr0Anchor">atomicExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicExpr.html">AtomicExpr</a>&gt;...</td></tr>
 567 <tr><td colspan="4" class="doc" id="atomicExpr0"><pre>Matches atomic builtins.
 568 Example matches __atomic_load_n(ptr, 1)
 569   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
 570 </pre></td></tr>
 571
 572
 573 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('binaryConditionalOperator0')"><a name="binaryConditionalOperator0Anchor">binaryConditionalOperator</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1BinaryConditionalOperator.html">BinaryConditionalOperator</a>&gt;...</td></tr>
 574 <tr><td colspan="4" class="doc" id="binaryConditionalOperator0"><pre>Matches binary conditional operator expressions (GNU extension).
 575
 576 Example matches a ?: b
 577   (a ?: b) + 42;
 578 </pre></td></tr>
 579
 580
 581 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('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>
 582 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
 583
 584 Example matches a || b
 585   !(a || b)
 586 </pre></td></tr>
 587
 588
 589 <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>
 590 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
 591
 592 Given
 593   while (true) { break; }
 594 breakStmt()
 595   matches 'break'
 596 </pre></td></tr>
 597
 598
 599 <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>
 600 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
 601
 602 Example: Matches (int*) 2.2f in
 603   int i = (int) 2.2f;
 604 </pre></td></tr>
 605
 606
 607 <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>
 608 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
 609
 610 Example matches x.y() and y()
 611   X x;
 612   x.y();
 613   y();
 614 </pre></td></tr>
 615
 616
 617 <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>
 618 <tr><td colspan="4" class="doc" id="caseStmt0"><pre>Matches case statements inside switch statements.
 619
 620 Given
 621   switch(a) { case 42: break; default: break; }
 622 caseStmt()
 623   matches 'case 42: break;'.
 624 </pre></td></tr>
 625
 626
 627 <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>
 628 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
 629
 630 Example: castExpr() matches each of the following:
 631   (int) 3;
 632   const_cast&lt;Expr *&gt;(SubExpr);
 633   char c = 0;
 634 but does not match
 635   int i = (0);
 636   int k = 0;
 637 </pre></td></tr>
 638
 639
 640 <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>
 641 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
 642
 643 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
 644 though.
 645
 646 Example matches 'a', L'a'
 647   char ch = 'a';
 648   wchar_t chw = L'a';
 649 </pre></td></tr>
 650
 651
 652 <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>
 653 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
 654
 655 Example match: {1}, (1, 2)
 656   int array[4] = {1};
 657   vector int myvec = (vector int)(1, 2);
 658 </pre></td></tr>
 659
 660
 661 <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>
 662 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
 663
 664 Example matches '{}' and '{{}}'in 'for (;;) {{}}'
 665   for (;;) {{}}
 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('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>
 670 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
 671
 672 Example matches a ? b : c
 673   (a ? b : c) + 42
 674 </pre></td></tr>
 675
 676
 677 <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>
 678 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
 679
 680 Given
 681   while (true) { continue; }
 682 continueStmt()
 683   matches 'continue'
 684 </pre></td></tr>
 685
 686
 687 <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>
 688 <tr><td colspan="4" class="doc" id="cudaKernelCallExpr0"><pre>Matches CUDA kernel call expression.
 689
 690 Example matches,
 691   kernel&lt;&lt;&lt;i,j&gt;&gt;&gt;();
 692 </pre></td></tr>
 693
 694
 695 <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>
 696 <tr><td colspan="4" class="doc" id="cxxBindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
 697
 698 Example matches FunctionTakesString(GetStringByValue())
 699     (matcher = cxxBindTemporaryExpr())
 700   FunctionTakesString(GetStringByValue());
 701   FunctionTakesStringByPointer(GetStringPointer());
 702 </pre></td></tr>
 703
 704
 705 <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>
 706 <tr><td colspan="4" class="doc" id="cxxBoolLiteral0"><pre>Matches bool literals.
 707
 708 Example matches true
 709   true
 710 </pre></td></tr>
 711
 712
 713 <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>
 714 <tr><td colspan="4" class="doc" id="cxxCatchStmt0"><pre>Matches catch statements.
 715
 716   try {} catch(int i) {}
 717 cxxCatchStmt()
 718   matches 'catch(int i)'
 719 </pre></td></tr>
 720
 721
 722 <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>
 723 <tr><td colspan="4" class="doc" id="cxxConstCastExpr0"><pre>Matches a const_cast expression.
 724
 725 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
 726   int n = 42;
 727   const int &amp;r(n);
 728   int* p = const_cast&lt;int*&gt;(&amp;r);
 729 </pre></td></tr>
 730
 731
 732 <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>
 733 <tr><td colspan="4" class="doc" id="cxxConstructExpr0"><pre>Matches constructor call expressions (including implicit ones).
 734
 735 Example matches string(ptr, n) and ptr within arguments of f
 736     (matcher = cxxConstructExpr())
 737   void f(const string &amp;a, const string &amp;b);
 738   char *ptr;
 739   int n;
 740   f(string(ptr, n), ptr);
 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('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>
 745 <tr><td colspan="4" class="doc" id="cxxDefaultArgExpr0"><pre>Matches the value of a default argument at the call site.
 746
 747 Example matches the CXXDefaultArgExpr placeholder inserted for the
 748     default value of the second parameter in the call expression f(42)
 749     (matcher = cxxDefaultArgExpr())
 750   void f(int x, int y = 0);
 751   f(42);
 752 </pre></td></tr>
 753
 754
 755 <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>
 756 <tr><td colspan="4" class="doc" id="cxxDeleteExpr0"><pre>Matches delete expressions.
 757
 758 Given
 759   delete X;
 760 cxxDeleteExpr()
 761   matches 'delete X'.
 762 </pre></td></tr>
 763
 764
 765 <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>
 766 <tr><td colspan="4" class="doc" id="cxxDynamicCastExpr0"><pre>Matches a dynamic_cast expression.
 767
 768 Example:
 769   cxxDynamicCastExpr()
 770 matches
 771   dynamic_cast&lt;D*&gt;(&amp;b);
 772 in
 773   struct B { virtual ~B() {} }; struct D : B {};
 774   B b;
 775   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
 776 </pre></td></tr>
 777
 778
 779 <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>
 780 <tr><td colspan="4" class="doc" id="cxxForRangeStmt0"><pre>Matches range-based for statements.
 781
 782 cxxForRangeStmt() matches 'for (auto a : i)'
 783   int i[] =  {1, 2, 3}; for (auto a : i);
 784   for(int j = 0; j &lt; 5; ++j);
 785 </pre></td></tr>
 786
 787
 788 <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>
 789 <tr><td colspan="4" class="doc" id="cxxFunctionalCastExpr0"><pre>Matches functional cast expressions
 790
 791 Example: Matches Foo(bar);
 792   Foo f = bar;
 793   Foo g = (Foo) bar;
 794   Foo h = Foo(bar);
 795 </pre></td></tr>
 796
 797
 798 <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>
 799 <tr><td colspan="4" class="doc" id="cxxMemberCallExpr0"><pre>Matches member call expressions.
 800
 801 Example matches x.y()
 802   X x;
 803   x.y();
 804 </pre></td></tr>
 805
 806
 807 <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>
 808 <tr><td colspan="4" class="doc" id="cxxNewExpr0"><pre>Matches new expressions.
 809
 810 Given
 811   new X;
 812 cxxNewExpr()
 813   matches 'new X'.
 814 </pre></td></tr>
 815
 816
 817 <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>
 818 <tr><td colspan="4" class="doc" id="cxxNullPtrLiteralExpr0"><pre>Matches nullptr literal.
 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('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>
 823 <tr><td colspan="4" class="doc" id="cxxOperatorCallExpr0"><pre>Matches overloaded operator calls.
 824
 825 Note that if an operator isn't overloaded, it won't match. Instead, use
 826 binaryOperator matcher.
 827 Currently it does not match operators such as new delete.
 828 FIXME: figure out why these do not match?
 829
 830 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
 831     (matcher = cxxOperatorCallExpr())
 832   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
 833   ostream &amp;o; int b = 1, c = 1;
 834   o &lt;&lt; b &lt;&lt; c;
 835 </pre></td></tr>
 836
 837
 838 <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>
 839 <tr><td colspan="4" class="doc" id="cxxReinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
 840
 841 Either the source expression or the destination type can be matched
 842 using has(), but hasDestinationType() is more specific and can be
 843 more readable.
 844
 845 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
 846   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
 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('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>
 851 <tr><td colspan="4" class="doc" id="cxxStaticCastExpr0"><pre>Matches a C++ static_cast expression.
 852
 853 See also: hasDestinationType
 854 See also: reinterpretCast
 855
 856 Example:
 857   cxxStaticCastExpr()
 858 matches
 859   static_cast&lt;long&gt;(8)
 860 in
 861   long eight(static_cast&lt;long&gt;(8));
 862 </pre></td></tr>
 863
 864
 865 <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>
 866 <tr><td colspan="4" class="doc" id="cxxTemporaryObjectExpr0"><pre>Matches functional cast expressions having N != 1 arguments
 867
 868 Example: Matches Foo(bar, bar)
 869   Foo h = Foo(bar, bar);
 870 </pre></td></tr>
 871
 872
 873 <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>
 874 <tr><td colspan="4" class="doc" id="cxxThisExpr0"><pre>Matches implicit and explicit this expressions.
 875
 876 Example matches the implicit this expression in "return i".
 877     (matcher = cxxThisExpr())
 878 struct foo {
 879   int i;
 880   int f() { return i; }
 881 };
 882 </pre></td></tr>
 883
 884
 885 <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>
 886 <tr><td colspan="4" class="doc" id="cxxThrowExpr0"><pre>Matches throw expressions.
 887
 888   try { throw 5; } catch(int i) {}
 889 cxxThrowExpr()
 890   matches 'throw 5'
 891 </pre></td></tr>
 892
 893
 894 <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>
 895 <tr><td colspan="4" class="doc" id="cxxTryStmt0"><pre>Matches try statements.
 896
 897   try {} catch(int i) {}
 898 cxxTryStmt()
 899   matches 'try {}'
 900 </pre></td></tr>
 901
 902
 903 <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>
 904 <tr><td colspan="4" class="doc" id="cxxUnresolvedConstructExpr0"><pre>Matches unresolved constructor call expressions.
 905
 906 Example matches T(t) in return statement of f
 907     (matcher = cxxUnresolvedConstructExpr())
 908   template &lt;typename T&gt;
 909   void f(const T&amp; t) { return T(t); }
 910 </pre></td></tr>
 911
 912
 913 <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>
 914 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
 915
 916 Example matches x in if (x)
 917   bool x;
 918   if (x) {}
 919 </pre></td></tr>
 920
 921
 922 <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>
 923 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
 924
 925 Given
 926   int a;
 927 declStmt()
 928   matches 'int a'.
 929 </pre></td></tr>
 930
 931
 932 <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>
 933 <tr><td colspan="4" class="doc" id="defaultStmt0"><pre>Matches default statements inside switch statements.
 934
 935 Given
 936   switch(a) { case 42: break; default: break; }
 937 defaultStmt()
 938   matches 'default: break;'.
 939 </pre></td></tr>
 940
 941
 942 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('designatedInitExpr0')"><a name="designatedInitExpr0Anchor">designatedInitExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;...</td></tr>
 943 <tr><td colspan="4" class="doc" id="designatedInitExpr0"><pre>Matches C99 designated initializer expressions [C99 6.7.8].
 944
 945 Example: Matches { [2].y = 1.0, [0].x = 1.0 }
 946   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
 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('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>
 951 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
 952
 953 Given
 954   do {} while (true);
 955 doStmt()
 956   matches 'do {} while(true)'
 957 </pre></td></tr>
 958
 959
 960 <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>
 961 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
 962
 963 Matches any cast expression written in user code, whether it be a
 964 C-style cast, a functional-style cast, or a keyword cast.
 965
 966 Does not match implicit conversions.
 967
 968 Note: the name "explicitCast" is chosen to match Clang's terminology, as
 969 Clang uses the term "cast" to apply to implicit conversions as well as to
 970 actual cast expressions.
 971
 972 See also: hasDestinationType.
 973
 974 Example: matches all five of the casts in
 975   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
 976 but does not match the implicit conversion in
 977   long ell = 42;
 978 </pre></td></tr>
 979
 980
 981 <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>
 982 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
 983
 984 Example matches x()
 985   void f() { x(); }
 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('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>
 990 <tr><td colspan="4" class="doc" id="exprWithCleanups0"><pre>Matches expressions that introduce cleanups to be run at the end
 991 of the sub-expression's evaluation.
 992
 993 Example matches std::string()
 994   const std::string str = std::string();
 995 </pre></td></tr>
 996
 997
 998 <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>
 999 <tr><td colspan="4" class="doc" id="floatLiteral0"><pre>Matches float literals of all sizes encodings, e.g.
1000 1.0, 1.0f, 1.0L and 1e10.
1001
1002 Does not match implicit conversions such as
1003   float a = 10;
1004 </pre></td></tr>
1005
1006
1007 <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>
1008 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
1009
1010 Example matches 'for (;;) {}'
1011   for (;;) {}
1012   int i[] =  {1, 2, 3}; for (auto a : i);
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('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>
1017 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
1018 </pre></td></tr>
1019
1020
1021 <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>
1022 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
1023
1024 Given
1025   goto FOO;
1026   FOO: bar();
1027 gotoStmt()
1028   matches 'goto FOO'
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('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>
1033 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
1034
1035 Example matches 'if (x) {}'
1036   if (x) {}
1037 </pre></td></tr>
1038
1039
1040 <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>
1041 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
1042
1043 This matches many different places, including function call return value
1044 eliding, as well as any type conversions.
1045 </pre></td></tr>
1046
1047
1048 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('implicitValueInitExpr0')"><a name="implicitValueInitExpr0Anchor">implicitValueInitExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ImplicitValueInitExpr.html">ImplicitValueInitExpr</a>&gt;...</td></tr>
1049 <tr><td colspan="4" class="doc" id="implicitValueInitExpr0"><pre>Matches implicit initializers of init list expressions.
1050
1051 Given
1052   point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
1053 implicitValueInitExpr()
1054   matches "[0].y" (implicitly)
1055 </pre></td></tr>
1056
1057
1058 <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>
1059 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
1060
1061 Given
1062   int a[] = { 1, 2 };
1063   struct B { int x, y; };
1064   B b = { 5, 6 };
1065 initListExpr()
1066   matches "{ 1, 2 }" and "{ 5, 6 }"
1067 </pre></td></tr>
1068
1069
1070 <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>
1071 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes encodings, e.g.
1072 1, 1L, 0x1 and 1U.
1073
1074 Does not match character-encoded integers such as L'a'.
1075 </pre></td></tr>
1076
1077
1078 <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>
1079 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
1080
1081 Given
1082   goto FOO;
1083   FOO: bar();
1084 labelStmt()
1085   matches 'FOO:'
1086 </pre></td></tr>
1087
1088
1089 <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>
1090 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
1091
1092 Example matches [&amp;](){return 5;}
1093   [&amp;](){return 5;}
1094 </pre></td></tr>
1095
1096
1097 <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>
1098 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
1099
1100 Example: Given
1101   struct T {void func()};
1102   T f();
1103   void g(T);
1104 materializeTemporaryExpr() matches 'f()' in these statements
1105   T u(f());
1106   g(f());
1107 but does not match
1108   f();
1109   f().func();
1110 </pre></td></tr>
1111
1112
1113 <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>
1114 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
1115
1116 Given
1117   class Y {
1118     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
1119     int a; static int b;
1120   };
1121 memberExpr()
1122   matches this-&gt;x, x, y.x, a, this-&gt;b
1123 </pre></td></tr>
1124
1125
1126 <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>
1127 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
1128
1129   foo();;
1130 nullStmt()
1131   matches the second ';'
1132 </pre></td></tr>
1133
1134
1135 <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>
1136 <tr><td colspan="4" class="doc" id="objcMessageExpr0"><pre>Matches ObjectiveC Message invocation expressions.
1137
1138 The innermost message send invokes the "alloc" class method on the
1139 NSString class, while the outermost message send invokes the
1140 "initWithString" instance method on the object returned from
1141 NSString's "alloc". This matcher should match both message sends.
1142   [[NSString alloc] initWithString:@"Hello"]
1143 </pre></td></tr>
1144
1145
1146 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('opaqueValueExpr0')"><a name="opaqueValueExpr0Anchor">opaqueValueExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1OpaqueValueExpr.html">OpaqueValueExpr</a>&gt;...</td></tr>
1147 <tr><td colspan="4" class="doc" id="opaqueValueExpr0"><pre>Matches opaque value expressions. They are used as helpers
1148 to reference another expressions and can be met
1149 in BinaryConditionalOperators, for example.
1150
1151 Example matches 'a'
1152   (a ?: c) + 42;
1153 </pre></td></tr>
1154
1155
1156 <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>
1157 <tr><td colspan="4" class="doc" id="parenExpr0"><pre>Matches parentheses used in expressions.
1158
1159 Example matches (foo() + 1)
1160   int foo() { return 1; }
1161   int a = (foo() + 1);
1162 </pre></td></tr>
1163
1164
1165 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('parenListExpr0')"><a name="parenListExpr0Anchor">parenListExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenListExpr.html">ParenListExpr</a>&gt;...</td></tr>
1166 <tr><td colspan="4" class="doc" id="parenListExpr0"><pre>Matches paren list expressions.
1167 ParenListExprs don't have a predefined type and are used for late parsing.
1168 In the final AST, they can be met in template declarations.
1169
1170 Given
1171   template&lt;typename T&gt; class X {
1172     void f() {
1173       X x(*this);
1174       int a = 0, b = 1; int i = (a, b);
1175     }
1176   };
1177 parenListExpr() matches "*this" but NOT matches (a, b) because (a, b)
1178 has a predefined type and is a ParenExpr, not a ParenListExpr.
1179 </pre></td></tr>
1180
1181
1182 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('predefinedExpr0')"><a name="predefinedExpr0Anchor">predefinedExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1PredefinedExpr.html">PredefinedExpr</a>&gt;...</td></tr>
1183 <tr><td colspan="4" class="doc" id="predefinedExpr0"><pre>Matches predefined identifier expressions [C99 6.4.2.2].
1184
1185 Example: Matches __func__
1186   printf("%s", __func__);
1187 </pre></td></tr>
1188
1189
1190 <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>
1191 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
1192
1193 Given
1194   return 1;
1195 returnStmt()
1196   matches 'return 1'
1197 </pre></td></tr>
1198
1199
1200 <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>
1201 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
1202
1203 Given
1204   { ++a; }
1205 stmt()
1206   matches both the compound statement '{ ++a; }' and '++a'.
1207 </pre></td></tr>
1208
1209
1210 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stmtExpr0')"><a name="stmtExpr0Anchor">stmtExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1StmtExpr.html">StmtExpr</a>&gt;...</td></tr>
1211 <tr><td colspan="4" class="doc" id="stmtExpr0"><pre>Matches statement expression (GNU extension).
1212
1213 Example match: ({ int X = 4; X; })
1214   int C = ({ int X = 4; X; });
1215 </pre></td></tr>
1216
1217
1218 <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>
1219 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
1220
1221 Example matches "abcd", L"abcd"
1222   char *s = "abcd";
1223   wchar_t *ws = L"abcd";
1224 </pre></td></tr>
1225
1226
1227 <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>
1228 <tr><td colspan="4" class="doc" id="substNonTypeTemplateParmExpr0"><pre>Matches substitutions of non-type template parameters.
1229
1230 Given
1231   template &lt;int N&gt;
1232   struct A { static const int n = N; };
1233   struct B : public A&lt;42&gt; {};
1234 substNonTypeTemplateParmExpr()
1235   matches "N" in the right-hand side of "static const int n = N;"
1236 </pre></td></tr>
1237
1238
1239 <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>
1240 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
1241
1242 Given
1243   switch(a) { case 42: break; default: break; }
1244 switchCase()
1245   matches 'case 42: break;' and 'default: break;'.
1246 </pre></td></tr>
1247
1248
1249 <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>
1250 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
1251
1252 Given
1253   switch(a) { case 42: break; default: break; }
1254 switchStmt()
1255   matches 'switch(a)'.
1256 </pre></td></tr>
1257
1258
1259 <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>
1260 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
1261
1262 Given
1263   Foo x = bar;
1264   int y = sizeof(x) + alignof(x);
1265 unaryExprOrTypeTraitExpr()
1266   matches sizeof(x) and alignof(x)
1267 </pre></td></tr>
1268
1269
1270 <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>
1271 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
1272
1273 Example matches !a
1274   !a || b
1275 </pre></td></tr>
1276
1277
1278 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unresolvedLookupExpr0')"><a name="unresolvedLookupExpr0Anchor">unresolvedLookupExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedLookupExpr.html">UnresolvedLookupExpr</a>&gt;...</td></tr>
1279 <tr><td colspan="4" class="doc" id="unresolvedLookupExpr0"><pre>Matches reference to a name that can be looked up during parsing
1280 but could not be resolved to a specific declaration.
1281
1282 Given
1283   template&lt;typename T&gt;
1284   T foo() { T a; return a; }
1285   template&lt;typename T&gt;
1286   void bar() {
1287     foo&lt;T&gt;();
1288   }
1289 unresolvedLookupExpr()
1290   matches foo&lt;T&gt;() </pre></td></tr>
1291
1292
1293 <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>
1294 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
1295
1296 Example match: "foo"_suffix
1297 </pre></td></tr>
1298
1299
1300 <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>
1301 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
1302
1303 Given
1304   while (true) {}
1305 whileStmt()
1306   matches 'while (true) {}'.
1307 </pre></td></tr>
1308
1309
1310 <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>
1311 <tr><td colspan="4" class="doc" id="templateArgument0"><pre>Matches template arguments.
1312
1313 Given
1314   template &lt;typename T&gt; struct C {};
1315   C&lt;int&gt; c;
1316 templateArgument()
1317   matches 'int' in C&lt;int&gt;.
1318 </pre></td></tr>
1319
1320
1321 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt;</td><td class="name" onclick="toggle('templateName0')"><a name="templateName0Anchor">templateName</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt;...</td></tr>
1322 <tr><td colspan="4" class="doc" id="templateName0"><pre>Matches template name.
1323
1324 Given
1325   template &lt;typename T&gt; class X { };
1326   X&lt;int&gt; xi;
1327 templateName()
1328   matches 'X' in X&lt;int&gt;.
1329 </pre></td></tr>
1330
1331
1332 <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>
1333 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
1334 </pre></td></tr>
1335
1336
1337 <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>
1338 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
1339
1340 Given
1341   int a[] = { 2, 3 };
1342   int b[4];
1343   void f() { int c[a[0]]; }
1344 arrayType()
1345   matches "int a[]", "int b[4]" and "int c[a[0]]";
1346 </pre></td></tr>
1347
1348
1349 <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>
1350 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
1351
1352 Given
1353   _Atomic(int) i;
1354 atomicType()
1355   matches "_Atomic(int) i"
1356 </pre></td></tr>
1357
1358
1359 <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>
1360 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
1361
1362 Given:
1363   auto n = 4;
1364   int v[] = { 2, 3 }
1365   for (auto i : v) { }
1366 autoType()
1367   matches "auto n" and "auto i"
1368 </pre></td></tr>
1369
1370
1371 <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>
1372 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
1373 "void (^)(int)".
1374
1375 The pointee is always required to be a FunctionType.
1376 </pre></td></tr>
1377
1378
1379 <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>
1380 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
1381
1382 Given
1383   struct A {};
1384   A a;
1385   int b;
1386   float c;
1387   bool d;
1388 builtinType()
1389   matches "int b", "float c" and "bool d"
1390 </pre></td></tr>
1391
1392
1393 <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>
1394 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
1395
1396 Given
1397   _Complex float f;
1398 complexType()
1399   matches "_Complex float f"
1400 </pre></td></tr>
1401
1402
1403 <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>
1404 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
1405
1406 Given
1407   void() {
1408     int a[2];
1409     int b[] = { 2, 3 };
1410     int c[b[0]];
1411   }
1412 constantArrayType()
1413   matches "int a[2]"
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('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>
1418 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
1419 Example matches i[] in declaration of f.
1420     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
1421 Example matches i[1].
1422     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
1423   void f(int i[]) {
1424     i[1] = 0;
1425   }
1426 </pre></td></tr>
1427
1428
1429 <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>
1430 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
1431
1432 Given
1433   template&lt;typename T, int Size&gt;
1434   class array {
1435     T data[Size];
1436   };
1437 dependentSizedArrayType
1438   matches "T data[Size]"
1439 </pre></td></tr>
1440
1441
1442 <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>
1443 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
1444 qualified name.
1445
1446 Given
1447   namespace N {
1448     namespace M {
1449       class D {};
1450     }
1451   }
1452   class C {};
1453
1454   class C c;
1455   N::M::D d;
1456
1457 elaboratedType() matches the type of the variable declarations of both
1458 c and d.
1459 </pre></td></tr>
1460
1461
1462 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('enumType0')"><a name="enumType0Anchor">enumType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;...</td></tr>
1463 <tr><td colspan="4" class="doc" id="enumType0"><pre>Matches enum types.
1464
1465 Given
1466   enum C { Green };
1467   enum class S { Red };
1468
1469   C c;
1470   S s;
1471
1472 enumType() matches the type of the variable declarations of both c and
1473 s.
1474 </pre></td></tr>
1475
1476
1477 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('functionProtoType0')"><a name="functionProtoType0Anchor">functionProtoType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;...</td></tr>
1478 <tr><td colspan="4" class="doc" id="functionProtoType0"><pre>Matches FunctionProtoType nodes.
1479
1480 Given
1481   int (*f)(int);
1482   void g();
1483 functionProtoType()
1484   matches "int (*f)(int)" and the type of "g" in C++ mode.
1485   In C mode, "g" is not matched because it does not contain a prototype.
1486 </pre></td></tr>
1487
1488
1489 <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>
1490 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
1491
1492 Given
1493   int (*f)(int);
1494   void g();
1495 functionType()
1496   matches "int (*f)(int)" and the type of "g".
1497 </pre></td></tr>
1498
1499
1500 <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>
1501 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
1502
1503 Given
1504   int a[] = { 2, 3 };
1505   int b[42];
1506   void f(int c[]) { int d[a[0]]; };
1507 incompleteArrayType()
1508   matches "int a[]" and "int c[]"
1509 </pre></td></tr>
1510
1511
1512 <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>
1513 <tr><td colspan="4" class="doc" id="injectedClassNameType0"><pre>Matches injected class name types.
1514
1515 Example matches S s, but not S&lt;T&gt; s.
1516     (matcher = parmVarDecl(hasType(injectedClassNameType())))
1517   template &lt;typename T&gt; struct S {
1518     void f(S s);
1519     void g(S&lt;T&gt; s);
1520   };
1521 </pre></td></tr>
1522
1523
1524 <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>
1525 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
1526
1527 Given:
1528   int *a;
1529   int &amp;b = *a;
1530   int &amp;&amp;c = 1;
1531   auto &amp;d = b;
1532   auto &amp;&amp;e = c;
1533   auto &amp;&amp;f = 2;
1534   int g = 5;
1535
1536 lValueReferenceType() matches the types of b, d, and e. e is
1537 matched since the type is deduced as int&amp; by reference collapsing rules.
1538 </pre></td></tr>
1539
1540
1541 <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>
1542 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
1543 Given
1544   struct A { int i; }
1545   A::* ptr = A::i;
1546 memberPointerType()
1547   matches "A::* ptr"
1548 </pre></td></tr>
1549
1550
1551 <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>
1552 <tr><td colspan="4" class="doc" id="objcObjectPointerType0"><pre>Matches an Objective-C object pointer type, which is different from
1553 a pointer type, despite being syntactically similar.
1554
1555 Given
1556   int *a;
1557
1558   @interface Foo
1559   @end
1560   Foo *f;
1561 pointerType()
1562   matches "Foo *f", but does not match "int *a".
1563 </pre></td></tr>
1564
1565
1566 <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>
1567 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
1568
1569 Given
1570   int (*ptr_to_array)[4];
1571   int *array_of_ptrs[4];
1572
1573 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
1574 array_of_ptrs.
1575 </pre></td></tr>
1576
1577
1578 <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>
1579 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
1580 types.
1581
1582 Given
1583   int *a;
1584   int &amp;b = *a;
1585   int c = 5;
1586
1587   @interface Foo
1588   @end
1589   Foo *f;
1590 pointerType()
1591   matches "int *a", but does not match "Foo *f".
1592 </pre></td></tr>
1593
1594
1595 <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>
1596 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
1597
1598 Given:
1599   int *a;
1600   int &amp;b = *a;
1601   int &amp;&amp;c = 1;
1602   auto &amp;d = b;
1603   auto &amp;&amp;e = c;
1604   auto &amp;&amp;f = 2;
1605   int g = 5;
1606
1607 rValueReferenceType() matches the types of c and f. e is not
1608 matched as it is deduced to int&amp; by reference collapsing rules.
1609 </pre></td></tr>
1610
1611
1612 <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>
1613 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
1614
1615 Given
1616   class C {};
1617   struct S {};
1618
1619   C c;
1620   S s;
1621
1622 recordType() matches the type of the variable declarations of both c
1623 and s.
1624 </pre></td></tr>
1625
1626
1627 <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>
1628 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
1629
1630 Given
1631   int *a;
1632   int &amp;b = *a;
1633   int &amp;&amp;c = 1;
1634   auto &amp;d = b;
1635   auto &amp;&amp;e = c;
1636   auto &amp;&amp;f = 2;
1637   int g = 5;
1638
1639 referenceType() matches the types of b, c, d, e, and f.
1640 </pre></td></tr>
1641
1642
1643 <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>
1644 <tr><td colspan="4" class="doc" id="substTemplateTypeParmType0"><pre>Matches types that represent the result of substituting a type for a
1645 template type parameter.
1646
1647 Given
1648   template &lt;typename T&gt;
1649   void F(T t) {
1650     int i = 1 + t;
1651   }
1652
1653 substTemplateTypeParmType() matches the type of 't' but not '1'
1654 </pre></td></tr>
1655
1656
1657 <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>
1658 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
1659
1660 Given
1661   template &lt;typename T&gt;
1662   class C { };
1663
1664   template class C&lt;int&gt;;  A
1665   C&lt;char&gt; var;            B
1666
1667 templateSpecializationType() matches the type of the explicit
1668 instantiation in A and the type of the variable declaration in B.
1669 </pre></td></tr>
1670
1671
1672 <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>
1673 <tr><td colspan="4" class="doc" id="templateTypeParmType0"><pre>Matches template type parameter types.
1674
1675 Example matches T, but not int.
1676     (matcher = templateTypeParmType())
1677   template &lt;typename T&gt; void f(int i);
1678 </pre></td></tr>
1679
1680
1681 <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>
1682 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
1683 </pre></td></tr>
1684
1685
1686 <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>
1687 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
1688
1689 Given
1690   typedef int X;
1691 typedefType()
1692   matches "typedef int X"
1693 </pre></td></tr>
1694
1695
1696 <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>
1697 <tr><td colspan="4" class="doc" id="unaryTransformType0"><pre>Matches types nodes representing unary type transformations.
1698
1699 Given:
1700   typedef __underlying_type(T) type;
1701 unaryTransformType()
1702   matches "__underlying_type(T)"
1703 </pre></td></tr>
1704
1705
1706 <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>
1707 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
1708 integer-constant-expression.
1709
1710 Given
1711   void f() {
1712     int a[] = { 2, 3 }
1713     int b[42];
1714     int c[a[0]];
1715   }
1716 variableArrayType()
1717   matches "int c[a[0]]"
1718 </pre></td></tr>
1719
1720 <!--END_DECL_MATCHERS -->
1721 </table>
1722
1723 <!-- ======================================================================= -->
1724 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
1725 <!-- ======================================================================= -->
1726
1727 <p>Narrowing matchers match certain attributes on the current node, thus
1728 narrowing down the set of nodes of the current type to match on.</p>
1729
1730 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
1731 which allow users to create more powerful match expressions.</p>
1732
1733 <table>
1734 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
1735 <!-- START_NARROWING_MATCHERS -->
1736
1737 <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>
1738 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
1739
1740 Usable as: Any Matcher
1741 </pre></td></tr>
1742
1743
1744 <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>
1745 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
1746
1747 Usable as: Any Matcher
1748 </pre></td></tr>
1749
1750
1751 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
1752 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
1753
1754 Useful when another matcher requires a child matcher, but there's no
1755 additional constraint. This will often be used with an explicit conversion
1756 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
1757
1758 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
1759 "int* p" and "void f()" in
1760   int* p;
1761   void f();
1762
1763 Usable as: Any Matcher
1764 </pre></td></tr>
1765
1766
1767 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;</td></tr>
1768 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
1769
1770 Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
1771   class X {};
1772   class Y {};
1773
1774 Usable as: Any Matcher
1775 </pre></td></tr>
1776
1777
1778 <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>
1779 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions (binary or
1780 unary).
1781
1782 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
1783   !(a || b)
1784 </pre></td></tr>
1785
1786
1787 <tr><td>Matcher&lt;CXXBoolLiteral&gt;</td><td class="name" onclick="toggle('equals2')"><a name="equals2Anchor">equals</a></td><td>ValueT  Value</td></tr>
1788 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value.
1789
1790 Example matches true (matcher = cxxBoolLiteral(equals(true)))
1791   true
1792
1793 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
1794            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;
1795 </pre></td></tr>
1796
1797
1798 <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>
1799 <tr><td colspan="4" class="doc" id="isCatchAll0"><pre>Matches a C++ catch statement that has a catch-all handler.
1800
1801 Given
1802   try {
1803     ...
1804   } catch (int) {
1805     ...
1806   } catch (...) {
1807     ...
1808   }
1809 endcode
1810 cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
1811 </pre></td></tr>
1812
1813
1814 <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>
1815 <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has
1816 a specific number of arguments (including absent default arguments).
1817
1818 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
1819   void f(int x, int y);
1820   f(0, 0);
1821 </pre></td></tr>
1822
1823
1824 <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>
1825 <tr><td colspan="4" class="doc" id="isListInitialization0"><pre>Matches a constructor call expression which uses list initialization.
1826 </pre></td></tr>
1827
1828
1829 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('requiresZeroInitialization0')"><a name="requiresZeroInitialization0Anchor">requiresZeroInitialization</a></td><td></td></tr>
1830 <tr><td colspan="4" class="doc" id="requiresZeroInitialization0"><pre>Matches a constructor call expression which requires
1831 zero initialization.
1832
1833 Given
1834 void foo() {
1835   struct point { double x; double y; };
1836   point pt[2] = { { 1.0, 2.0 } };
1837 }
1838 initListExpr(has(cxxConstructExpr(requiresZeroInitialization()))
1839 will match the implicit array filler for pt[1].
1840 </pre></td></tr>
1841
1842
1843 <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>
1844 <tr><td colspan="4" class="doc" id="isCopyConstructor0"><pre>Matches constructor declarations that are copy constructors.
1845
1846 Given
1847   struct S {
1848     S(); #1
1849     S(const S &amp;); #2
1850     S(S &amp;&amp;); #3
1851   };
1852 cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
1853 </pre></td></tr>
1854
1855
1856 <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>
1857 <tr><td colspan="4" class="doc" id="isDefaultConstructor0"><pre>Matches constructor declarations that are default constructors.
1858
1859 Given
1860   struct S {
1861     S(); #1
1862     S(const S &amp;); #2
1863     S(S &amp;&amp;); #3
1864   };
1865 cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
1866 </pre></td></tr>
1867
1868
1869 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isDelegatingConstructor0')"><a name="isDelegatingConstructor0Anchor">isDelegatingConstructor</a></td><td></td></tr>
1870 <tr><td colspan="4" class="doc" id="isDelegatingConstructor0"><pre>Matches constructors that delegate to another constructor.
1871
1872 Given
1873   struct S {
1874     S(); #1
1875     S(int) {} #2
1876     S(S &amp;&amp;) : S() {} #3
1877   };
1878   S::S() : S(0) {} #4
1879 cxxConstructorDecl(isDelegatingConstructor()) will match #3 and #4, but not
1880 #1 or #2.
1881 </pre></td></tr>
1882
1883
1884 <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>
1885 <tr><td colspan="4" class="doc" id="isExplicit0"><pre>Matches constructor and conversion declarations that are marked with
1886 the explicit keyword.
1887
1888 Given
1889   struct S {
1890     S(int); #1
1891     explicit S(double); #2
1892     operator int(); #3
1893     explicit operator bool(); #4
1894   };
1895 cxxConstructorDecl(isExplicit()) will match #2, but not #1.
1896 cxxConversionDecl(isExplicit()) will match #4, but not #3.
1897 </pre></td></tr>
1898
1899
1900 <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>
1901 <tr><td colspan="4" class="doc" id="isMoveConstructor0"><pre>Matches constructor declarations that are move constructors.
1902
1903 Given
1904   struct S {
1905     S(); #1
1906     S(const S &amp;); #2
1907     S(S &amp;&amp;); #3
1908   };
1909 cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
1910 </pre></td></tr>
1911
1912
1913 <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>
1914 <tr><td colspan="4" class="doc" id="isExplicit1"><pre>Matches constructor and conversion declarations that are marked with
1915 the explicit keyword.
1916
1917 Given
1918   struct S {
1919     S(int); #1
1920     explicit S(double); #2
1921     operator int(); #3
1922     explicit operator bool(); #4
1923   };
1924 cxxConstructorDecl(isExplicit()) will match #2, but not #1.
1925 cxxConversionDecl(isExplicit()) will match #4, but not #3.
1926 </pre></td></tr>
1927
1928
1929 <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>
1930 <tr><td colspan="4" class="doc" id="isBaseInitializer0"><pre>Matches a constructor initializer if it is initializing a base, as
1931 opposed to a member.
1932
1933 Given
1934   struct B {};
1935   struct D : B {
1936     int I;
1937     D(int i) : I(i) {}
1938   };
1939   struct E : B {
1940     E() : B() {}
1941   };
1942 cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
1943   will match E(), but not match D(int).
1944 </pre></td></tr>
1945
1946
1947 <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>
1948 <tr><td colspan="4" class="doc" id="isMemberInitializer0"><pre>Matches a constructor initializer if it is initializing a member, as
1949 opposed to a base.
1950
1951 Given
1952   struct B {};
1953   struct D : B {
1954     int I;
1955     D(int i) : I(i) {}
1956   };
1957   struct E : B {
1958     E() : B() {}
1959   };
1960 cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
1961   will match D(int), but not match E().
1962 </pre></td></tr>
1963
1964
1965 <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>
1966 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a constructor initializer if it is explicitly written in
1967 code (as opposed to implicitly added by the compiler).
1968
1969 Given
1970   struct Foo {
1971     Foo() { }
1972     Foo(int) : foo_("A") { }
1973     string foo_;
1974   };
1975 cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
1976   will match Foo(int), but not Foo()
1977 </pre></td></tr>
1978
1979
1980 <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>
1981 <tr><td colspan="4" class="doc" id="isConst0"><pre>Matches if the given method declaration is const.
1982
1983 Given
1984 struct A {
1985   void foo() const;
1986   void bar();
1987 };
1988
1989 cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
1990 </pre></td></tr>
1991
1992
1993 <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>
1994 <tr><td colspan="4" class="doc" id="isCopyAssignmentOperator0"><pre>Matches if the given method declaration declares a copy assignment
1995 operator.
1996
1997 Given
1998 struct A {
1999   A &amp;operator=(const A &amp;);
2000   A &amp;operator=(A &amp;&amp;);
2001 };
2002
2003 cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
2004 the second one.
2005 </pre></td></tr>
2006
2007
2008 <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>
2009 <tr><td colspan="4" class="doc" id="isFinal1"><pre>Matches if the given method or class declaration is final.
2010
2011 Given:
2012   class A final {};
2013
2014   struct B {
2015     virtual void f();
2016   };
2017
2018   struct C : B {
2019     void f() final;
2020   };
2021 matches A and C::f, but not B, C, or B::f
2022 </pre></td></tr>
2023
2024
2025 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isMoveAssignmentOperator0')"><a name="isMoveAssignmentOperator0Anchor">isMoveAssignmentOperator</a></td><td></td></tr>
2026 <tr><td colspan="4" class="doc" id="isMoveAssignmentOperator0"><pre>Matches if the given method declaration declares a move assignment
2027 operator.
2028
2029 Given
2030 struct A {
2031   A &amp;operator=(const A &amp;);
2032   A &amp;operator=(A &amp;&amp;);
2033 };
2034
2035 cxxMethodDecl(isMoveAssignmentOperator()) matches the second method but not
2036 the first one.
2037 </pre></td></tr>
2038
2039
2040 <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>
2041 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
2042
2043 Given
2044   class A {
2045    public:
2046     virtual void x();
2047   };
2048   class B : public A {
2049    public:
2050     virtual void x();
2051   };
2052   matches B::x
2053 </pre></td></tr>
2054
2055
2056 <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>
2057 <tr><td colspan="4" class="doc" id="isPure0"><pre>Matches if the given method declaration is pure.
2058
2059 Given
2060   class A {
2061    public:
2062     virtual void x() = 0;
2063   };
2064   matches A::x
2065 </pre></td></tr>
2066
2067
2068 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isUserProvided0')"><a name="isUserProvided0Anchor">isUserProvided</a></td><td></td></tr>
2069 <tr><td colspan="4" class="doc" id="isUserProvided0"><pre>Matches method declarations that are user-provided.
2070
2071 Given
2072   struct S {
2073     S(); #1
2074     S(const S &amp;) = default; #2
2075     S(S &amp;&amp;) = delete; #3
2076   };
2077 cxxConstructorDecl(isUserProvided()) will match #1, but not #2 or #3.
2078 </pre></td></tr>
2079
2080
2081 <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>
2082 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches if the given method declaration is virtual.
2083
2084 Given
2085   class A {
2086    public:
2087     virtual void x();
2088   };
2089   matches A::x
2090 </pre></td></tr>
2091
2092
2093 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isVirtualAsWritten0')"><a name="isVirtualAsWritten0Anchor">isVirtualAsWritten</a></td><td></td></tr>
2094 <tr><td colspan="4" class="doc" id="isVirtualAsWritten0"><pre>Matches if the given method declaration has an explicit "virtual".
2095
2096 Given
2097   class A {
2098    public:
2099     virtual void x();
2100   };
2101   class B : public A {
2102    public:
2103     void x();
2104   };
2105   matches A::x but not B::x
2106 </pre></td></tr>
2107
2108
2109 <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>
2110 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
2111
2112 Matches overloaded operator names specified in strings without the
2113 "operator" prefix: e.g. "&lt;&lt;".
2114
2115 Given:
2116   class A { int operator*(); };
2117   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
2118   A a;
2119   a &lt;&lt; a;   &lt;-- This matches
2120
2121 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
2122 specified line and
2123 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
2124 matches the declaration of A.
2125
2126 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;
2127 </pre></td></tr>
2128
2129
2130 <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>
2131 <tr><td colspan="4" class="doc" id="isDerivedFrom1"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
2132 </pre></td></tr>
2133
2134
2135 <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>
2136 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
2137 static member variable template instantiations.
2138
2139 Given
2140   template&lt;typename T&gt; void A(T t) { }
2141   template&lt;&gt; void A(int N) { }
2142 functionDecl(isExplicitTemplateSpecialization())
2143   matches the specialization A&lt;int&gt;().
2144
2145 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;
2146 </pre></td></tr>
2147
2148
2149 <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>
2150 <tr><td colspan="4" class="doc" id="isFinal0"><pre>Matches if the given method or class declaration is final.
2151
2152 Given:
2153   class A final {};
2154
2155   struct B {
2156     virtual void f();
2157   };
2158
2159   struct C : B {
2160     void f() final;
2161   };
2162 matches A and C::f, but not B, C, or B::f
2163 </pre></td></tr>
2164
2165
2166 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isLambda0')"><a name="isLambda0Anchor">isLambda</a></td><td></td></tr>
2167 <tr><td colspan="4" class="doc" id="isLambda0"><pre>Matches the generated class of lambda expressions.
2168
2169 Given:
2170   auto x = []{};
2171
2172 cxxRecordDecl(isLambda()) matches the implicit class declaration of
2173 decltype(x)
2174 </pre></td></tr>
2175
2176
2177 <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>
2178 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom1"><pre>Overloaded method as shortcut for
2179 isSameOrDerivedFrom(hasName(...)).
2180 </pre></td></tr>
2181
2182
2183 <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>
2184 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
2185 member variable template instantiations.
2186
2187 Given
2188   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
2189 or
2190   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
2191 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2192   matches the template instantiation of X&lt;A&gt;.
2193
2194 But given
2195   template &lt;typename T&gt;  class X {}; class A {};
2196   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2197 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2198   does not match, as X&lt;A&gt; is an explicit template specialization.
2199
2200 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;
2201 </pre></td></tr>
2202
2203
2204 <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>
2205 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
2206 a specific number of arguments (including absent default arguments).
2207
2208 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2209   void f(int x, int y);
2210   f(0, 0);
2211 </pre></td></tr>
2212
2213
2214 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;</td><td class="name" onclick="toggle('hasCastKind0')"><a name="hasCastKind0Anchor">hasCastKind</a></td><td>CastKind Kind</td></tr>
2215 <tr><td colspan="4" class="doc" id="hasCastKind0"><pre>Matches casts that has a given cast kind.
2216
2217 Example: matches the implicit cast around 0
2218 (matcher = castExpr(hasCastKind(CK_NullToPointer)))
2219   int *p = 0;
2220 </pre></td></tr>
2221
2222
2223 <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>
2224 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value.
2225
2226 Example matches true (matcher = cxxBoolLiteral(equals(true)))
2227   true
2228
2229 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
2230            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;
2231 </pre></td></tr>
2232
2233
2234 <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>
2235 <tr><td colspan="4" class="doc" id="templateArgumentCountIs0"><pre>Matches if the number of template arguments equals N.
2236
2237 Given
2238   template&lt;typename T&gt; struct C {};
2239   C&lt;int&gt; c;
2240 classTemplateSpecializationDecl(templateArgumentCountIs(1))
2241   matches C&lt;int&gt;.
2242 </pre></td></tr>
2243
2244
2245 <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>
2246 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
2247 child statements.
2248
2249 Example: Given
2250   { for (;;) {} }
2251 compoundStmt(statementCountIs(0)))
2252   matches '{}'
2253   but does not match the outer compound statement.
2254 </pre></td></tr>
2255
2256
2257 <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>
2258 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches nodes that have the specified size.
2259
2260 Given
2261   int a[42];
2262   int b[2 * 21];
2263   int c[41], d[43];
2264   char *s = "abcd";
2265   wchar_t *ws = L"abcd";
2266   char *w = "a";
2267 constantArrayType(hasSize(42))
2268   matches "int a[42]" and "int b[2 * 21]"
2269 stringLiteral(hasSize(4))
2270   matches "abcd", L"abcd"
2271 </pre></td></tr>
2272
2273
2274 <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>
2275 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
2276 declarations.
2277
2278 Example: Given
2279   int a, b;
2280   int c;
2281   int d = 2, e;
2282 declCountIs(2)
2283   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
2284 </pre></td></tr>
2285
2286
2287 <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>
2288 <tr><td colspan="4" class="doc" id="equalsBoundNode1"><pre>Matches if a node equals a previously bound node.
2289
2290 Matches a node if it equals the node previously bound to ID.
2291
2292 Given
2293   class X { int a; int b; };
2294 cxxRecordDecl(
2295     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
2296     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
2297   matches the class X, as a and b have the same type.
2298
2299 Note that when multiple matches are involved via forEach* matchers,
2300 equalsBoundNodes acts as a filter.
2301 For example:
2302 compoundStmt(
2303     forEachDescendant(varDecl().bind("d")),
2304     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
2305 will trigger a match for each combination of variable declaration
2306 and reference to that variable declaration within a compound statement.
2307 </pre></td></tr>
2308
2309
2310 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('equalsNode0')"><a name="equalsNode0Anchor">equalsNode</a></td><td>const Decl* Other</td></tr>
2311 <tr><td colspan="4" class="doc" id="equalsNode0"><pre>Matches if a node equals another node.
2312
2313 Decl has pointer identity in the AST.
2314 </pre></td></tr>
2315
2316
2317 <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>
2318 <tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
2319
2320 Given
2321   __attribute__((device)) void f() { ... }
2322 decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
2323 f. If the matcher is use from clang-query, attr::Kind parameter should be
2324 passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
2325 </pre></td></tr>
2326
2327
2328 <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>
2329 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching0"><pre>Matches AST nodes that were expanded within files whose name is
2330 partially matching a given regex.
2331
2332 Example matches Y but not X
2333     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
2334   #include "ASTMatcher.h"
2335   class X {};
2336 ASTMatcher.h:
2337   class Y {};
2338
2339 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;
2340 </pre></td></tr>
2341
2342
2343 <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>
2344 <tr><td colspan="4" class="doc" id="isExpansionInMainFile0"><pre>Matches AST nodes that were expanded within the main-file.
2345
2346 Example matches X but not Y
2347   (matcher = cxxRecordDecl(isExpansionInMainFile())
2348   #include &lt;Y.h&gt;
2349   class X {};
2350 Y.h:
2351   class Y {};
2352
2353 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;
2354 </pre></td></tr>
2355
2356
2357 <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>
2358 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader0"><pre>Matches AST nodes that were expanded within system-header-files.
2359
2360 Example matches Y but not X
2361     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
2362   #include &lt;SystemHeader.h&gt;
2363   class X {};
2364 SystemHeader.h:
2365   class Y {};
2366
2367 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;
2368 </pre></td></tr>
2369
2370
2371 <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>
2372 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches a declaration that has been implicitly added
2373 by the compiler (eg. implicit defaultcopy constructors).
2374 </pre></td></tr>
2375
2376
2377 <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>
2378 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations.
2379
2380 Given
2381   class C {
2382   public:    int a;
2383   protected: int b;
2384   private:   int c;
2385   };
2386 fieldDecl(isPrivate())
2387   matches 'int c;'
2388 </pre></td></tr>
2389
2390
2391 <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>
2392 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations.
2393
2394 Given
2395   class C {
2396   public:    int a;
2397   protected: int b;
2398   private:   int c;
2399   };
2400 fieldDecl(isProtected())
2401   matches 'int b;'
2402 </pre></td></tr>
2403
2404
2405 <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>
2406 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations.
2407
2408 Given
2409   class C {
2410   public:    int a;
2411   protected: int b;
2412   private:   int c;
2413   };
2414 fieldDecl(isPublic())
2415   matches 'int a;'
2416 </pre></td></tr>
2417
2418
2419 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;</td><td class="name" onclick="toggle('designatorCountIs0')"><a name="designatorCountIs0Anchor">designatorCountIs</a></td><td>unsigned N</td></tr>
2420 <tr><td colspan="4" class="doc" id="designatorCountIs0"><pre>Matches designated initializer expressions that contain
2421 a specific number of designators.
2422
2423 Example: Given
2424   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
2425   point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 };
2426 designatorCountIs(2)
2427   matches '{ [2].y = 1.0, [0].x = 1.0 }',
2428   but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'.
2429 </pre></td></tr>
2430
2431
2432 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('hasBitWidth0')"><a name="hasBitWidth0Anchor">hasBitWidth</a></td><td>unsigned Width</td></tr>
2433 <tr><td colspan="4" class="doc" id="hasBitWidth0"><pre>Matches non-static data members that are bit-fields.
2434
2435 Given
2436   class C {
2437     int a : 2;
2438     int b : 4;
2439     int c : 2;
2440   };
2441 fieldDecl(isBitField())
2442   matches 'int a;' and 'int c;' but not 'int b;'.
2443 </pre></td></tr>
2444
2445
2446 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('isBitField0')"><a name="isBitField0Anchor">isBitField</a></td><td></td></tr>
2447 <tr><td colspan="4" class="doc" id="isBitField0"><pre>Matches non-static data members that are bit-fields.
2448
2449 Given
2450   class C {
2451     int a : 2;
2452     int b;
2453   };
2454 fieldDecl(isBitField())
2455   matches 'int a;' but not 'int b;'.
2456 </pre></td></tr>
2457
2458
2459 <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>
2460 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value.
2461
2462 Example matches true (matcher = cxxBoolLiteral(equals(true)))
2463   true
2464
2465 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
2466            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;
2467 </pre></td></tr>
2468
2469
2470 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasDynamicExceptionSpec0')"><a name="hasDynamicExceptionSpec0Anchor">hasDynamicExceptionSpec</a></td><td></td></tr>
2471 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec0"><pre>Matches functions that have a dynamic exception specification.
2472
2473 Given:
2474   void f();
2475   void g() noexcept;
2476   void h() noexcept(true);
2477   void i() noexcept(false);
2478   void j() throw();
2479   void k() throw(int);
2480   void l() throw(...);
2481 functionDecl(hasDynamicExceptionSpec()) and
2482   functionProtoType(hasDynamicExceptionSpec())
2483   match the declarations of j, k, and l, but not f, g, h, or i.
2484 </pre></td></tr>
2485
2486
2487 <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>
2488 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
2489
2490 Matches overloaded operator names specified in strings without the
2491 "operator" prefix: e.g. "&lt;&lt;".
2492
2493 Given:
2494   class A { int operator*(); };
2495   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
2496   A a;
2497   a &lt;&lt; a;   &lt;-- This matches
2498
2499 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
2500 specified line and
2501 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
2502 matches the declaration of A.
2503
2504 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;
2505 </pre></td></tr>
2506
2507
2508 <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>
2509 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations.
2510
2511 Given:
2512   constexpr int foo = 42;
2513   constexpr int bar();
2514 varDecl(isConstexpr())
2515   matches the declaration of foo.
2516 functionDecl(isConstexpr())
2517   matches the declaration of bar.
2518 </pre></td></tr>
2519
2520
2521 <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>
2522 <tr><td colspan="4" class="doc" id="isDefaulted0"><pre>Matches defaulted function declarations.
2523
2524 Given:
2525   class A { ~A(); };
2526   class B { ~B() = default; };
2527 functionDecl(isDefaulted())
2528   matches the declaration of ~B, but not ~A.
2529 </pre></td></tr>
2530
2531
2532 <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>
2533 <tr><td colspan="4" class="doc" id="isDefinition2"><pre>Matches if a declaration has a body attached.
2534
2535 Example matches A, va, fa
2536   class A {};
2537   class B;  Doesn't match, as it has no body.
2538   int va;
2539   extern int vb;  Doesn't match, as it doesn't define the variable.
2540   void fa() {}
2541   void fb();  Doesn't match, as it has no body.
2542
2543 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;
2544 </pre></td></tr>
2545
2546
2547 <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>
2548 <tr><td colspan="4" class="doc" id="isDeleted0"><pre>Matches deleted function declarations.
2549
2550 Given:
2551   void Func();
2552   void DeletedFunc() = delete;
2553 functionDecl(isDeleted())
2554   matches the declaration of DeletedFunc, but not Func.
2555 </pre></td></tr>
2556
2557
2558 <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>
2559 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization0"><pre>Matches explicit template specializations of function, class, or
2560 static member variable template instantiations.
2561
2562 Given
2563   template&lt;typename T&gt; void A(T t) { }
2564   template&lt;&gt; void A(int N) { }
2565 functionDecl(isExplicitTemplateSpecialization())
2566   matches the specialization A&lt;int&gt;().
2567
2568 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;
2569 </pre></td></tr>
2570
2571
2572 <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>
2573 <tr><td colspan="4" class="doc" id="isExternC0"><pre>Matches extern "C" function declarations.
2574
2575 Given:
2576   extern "C" void f() {}
2577   extern "C" { void g() {} }
2578   void h() {}
2579 functionDecl(isExternC())
2580   matches the declaration of f and g, but not the declaration h
2581 </pre></td></tr>
2582
2583
2584 <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>
2585 <tr><td colspan="4" class="doc" id="isInline1"><pre>Matches function and namespace declarations that are marked with
2586 the inline keyword.
2587
2588 Given
2589   inline void f();
2590   void g();
2591   namespace n {
2592   inline namespace m {}
2593   }
2594 functionDecl(isInline()) will match ::f().
2595 namespaceDecl(isInline()) will match n::m.
2596 </pre></td></tr>
2597
2598
2599 <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>
2600 <tr><td colspan="4" class="doc" id="isNoThrow0"><pre>Matches functions that have a non-throwing exception specification.
2601
2602 Given:
2603   void f();
2604   void g() noexcept;
2605   void h() throw();
2606   void i() throw(int);
2607   void j() noexcept(false);
2608 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
2609   match the declarations of g, and h, but not f, i or j.
2610 </pre></td></tr>
2611
2612
2613 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isStaticStorageClass0')"><a name="isStaticStorageClass0Anchor">isStaticStorageClass</a></td><td></td></tr>
2614 <tr><td colspan="4" class="doc" id="isStaticStorageClass0"><pre>Matches variablefunction declarations that have "static" storage
2615 class specifier ("static" keyword) written in the source.
2616
2617 Given:
2618   static void f() {}
2619   static int i = 0;
2620   extern int j;
2621   int k;
2622 functionDecl(isStaticStorageClass())
2623   matches the function declaration f.
2624 varDecl(isStaticStorageClass())
2625   matches the variable declaration i.
2626 </pre></td></tr>
2627
2628
2629 <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>
2630 <tr><td colspan="4" class="doc" id="isTemplateInstantiation0"><pre>Matches template instantiations of function, class, or static
2631 member variable template instantiations.
2632
2633 Given
2634   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
2635 or
2636   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
2637 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2638   matches the template instantiation of X&lt;A&gt;.
2639
2640 But given
2641   template &lt;typename T&gt;  class X {}; class A {};
2642   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2643 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2644   does not match, as X&lt;A&gt; is an explicit template specialization.
2645
2646 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;
2647 </pre></td></tr>
2648
2649
2650 <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>
2651 <tr><td colspan="4" class="doc" id="isVariadic0"><pre>Matches if a function declaration is variadic.
2652
2653 Example matches f, but not g or h. The function i will not match, even when
2654 compiled in C mode.
2655   void f(...);
2656   void g(int);
2657   template &lt;typename... Ts&gt; void h(Ts...);
2658   void i();
2659 </pre></td></tr>
2660
2661
2662 <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>
2663 <tr><td colspan="4" class="doc" id="parameterCountIs0"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
2664 specific parameter count.
2665
2666 Given
2667   void f(int i) {}
2668   void g(int i, int j) {}
2669   void h(int i, int j);
2670   void j(int i);
2671   void k(int x, int y, int z, ...);
2672 functionDecl(parameterCountIs(2))
2673   matches void g(int i, int j) {}
2674 functionProtoType(parameterCountIs(2))
2675   matches void h(int i, int j)
2676 functionProtoType(parameterCountIs(3))
2677   matches void k(int x, int y, int z, ...);
2678 </pre></td></tr>
2679
2680
2681 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;</td><td class="name" onclick="toggle('hasDynamicExceptionSpec1')"><a name="hasDynamicExceptionSpec1Anchor">hasDynamicExceptionSpec</a></td><td></td></tr>
2682 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec1"><pre>Matches functions that have a dynamic exception specification.
2683
2684 Given:
2685   void f();
2686   void g() noexcept;
2687   void h() noexcept(true);
2688   void i() noexcept(false);
2689   void j() throw();
2690   void k() throw(int);
2691   void l() throw(...);
2692 functionDecl(hasDynamicExceptionSpec()) and
2693   functionProtoType(hasDynamicExceptionSpec())
2694   match the declarations of j, k, and l, but not f, g, h, or i.
2695 </pre></td></tr>
2696
2697
2698 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;</td><td class="name" onclick="toggle('isNoThrow1')"><a name="isNoThrow1Anchor">isNoThrow</a></td><td></td></tr>
2699 <tr><td colspan="4" class="doc" id="isNoThrow1"><pre>Matches functions that have a non-throwing exception specification.
2700
2701 Given:
2702   void f();
2703   void g() noexcept;
2704   void h() throw();
2705   void i() throw(int);
2706   void j() noexcept(false);
2707 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
2708   match the declarations of g, and h, but not f, i or j.
2709 </pre></td></tr>
2710
2711
2712 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;</td><td class="name" onclick="toggle('parameterCountIs1')"><a name="parameterCountIs1Anchor">parameterCountIs</a></td><td>unsigned N</td></tr>
2713 <tr><td colspan="4" class="doc" id="parameterCountIs1"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
2714 specific parameter count.
2715
2716 Given
2717   void f(int i) {}
2718   void g(int i, int j) {}
2719   void h(int i, int j);
2720   void j(int i);
2721   void k(int x, int y, int z, ...);
2722 functionDecl(parameterCountIs(2))
2723   matches void g(int i, int j) {}
2724 functionProtoType(parameterCountIs(2))
2725   matches void h(int i, int j)
2726 functionProtoType(parameterCountIs(3))
2727   matches void k(int x, int y, int z, ...);
2728 </pre></td></tr>
2729
2730
2731 <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>
2732 <tr><td colspan="4" class="doc" id="equals0"><pre>Matches literals that are equal to the given value.
2733
2734 Example matches true (matcher = cxxBoolLiteral(equals(true)))
2735   true
2736
2737 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;CXXBoolLiteral&gt;,
2738            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;
2739 </pre></td></tr>
2740
2741
2742 <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>
2743 <tr><td colspan="4" class="doc" id="isArrow0"><pre>Matches member expressions that are called with '-&gt;' as opposed
2744 to '.'.
2745
2746 Member calls on the implicit this pointer match as called with '-&gt;'.
2747
2748 Given
2749   class Y {
2750     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
2751     int a;
2752     static int b;
2753   };
2754 memberExpr(isArrow())
2755   matches this-&gt;x, x, y.x, a, this-&gt;b
2756 </pre></td></tr>
2757
2758
2759 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasExternalFormalLinkage0')"><a name="hasExternalFormalLinkage0Anchor">hasExternalFormalLinkage</a></td><td></td></tr>
2760 <tr><td colspan="4" class="doc" id="hasExternalFormalLinkage0"><pre>Matches a declaration that has external formal linkage.
2761
2762 Example matches only z (matcher = varDecl(hasExternalFormalLinkage()))
2763 void f() {
2764   int x;
2765   static int y;
2766 }
2767 int z;
2768
2769 Example matches f() because it has external formal linkage despite being
2770 unique to the translation unit as though it has internal likage
2771 (matcher = functionDecl(hasExternalFormalLinkage()))
2772
2773 namespace {
2774 void f() {}
2775 }
2776 </pre></td></tr>
2777
2778
2779 <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>
2780 <tr><td colspan="4" class="doc" id="hasName0"><pre>Matches NamedDecl nodes that have the specified name.
2781
2782 Supports specifying enclosing namespaces or classes by prefixing the name
2783 with '&lt;enclosing&gt;::'.
2784 Does not match typedefs of an underlying type with the given name.
2785
2786 Example matches X (Name == "X")
2787   class X;
2788
2789 Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
2790   namespace a { namespace b { class X; } }
2791 </pre></td></tr>
2792
2793
2794 <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>
2795 <tr><td colspan="4" class="doc" id="matchesName0"><pre>Matches NamedDecl nodes whose fully qualified names contain
2796 a substring matched by the given RegExp.
2797
2798 Supports specifying enclosing namespaces or classes by
2799 prefixing the name with '&lt;enclosing&gt;::'.  Does not match typedefs
2800 of an underlying type with the given name.
2801
2802 Example matches X (regexp == "::X")
2803   class X;
2804
2805 Example matches X (regexp is one of "::X", "^foo::.*X", among others)
2806   namespace foo { namespace bar { class X; } }
2807 </pre></td></tr>
2808
2809
2810 <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>
2811 <tr><td colspan="4" class="doc" id="isAnonymous0"><pre>Matches anonymous namespace declarations.
2812
2813 Given
2814   namespace n {
2815   namespace {} #1
2816   }
2817 namespaceDecl(isAnonymous()) will match #1 but not ::n.
2818 </pre></td></tr>
2819
2820
2821 <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>
2822 <tr><td colspan="4" class="doc" id="isInline0"><pre>Matches function and namespace declarations that are marked with
2823 the inline keyword.
2824
2825 Given
2826   inline void f();
2827   void g();
2828   namespace n {
2829   inline namespace m {}
2830   }
2831 functionDecl(isInline()) will match ::f().
2832 namespaceDecl(isInline()) will match n::m.
2833 </pre></td></tr>
2834
2835
2836 <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>
2837 <tr><td colspan="4" class="doc" id="argumentCountIs2"><pre>Checks that a call expression or a constructor call expression has
2838 a specific number of arguments (including absent default arguments).
2839
2840 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2841   void f(int x, int y);
2842   f(0, 0);
2843 </pre></td></tr>
2844
2845
2846 <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>
2847 <tr><td colspan="4" class="doc" id="hasKeywordSelector0"><pre>Matches when the selector is a keyword selector
2848
2849 objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
2850 message expression in
2851
2852   UIWebView *webView = ...;
2853   CGRect bodyFrame = webView.frame;
2854   bodyFrame.size.height = self.bodyContentHeight;
2855   webView.frame = bodyFrame;
2856       ^---- matches here
2857 </pre></td></tr>
2858
2859
2860 <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>
2861 <tr><td colspan="4" class="doc" id="hasNullSelector0"><pre>Matches when the selector is the empty selector
2862
2863 Matches only when the selector of the objCMessageExpr is NULL. This may
2864 represent an error condition in the tree!
2865 </pre></td></tr>
2866
2867
2868 <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>
2869 <tr><td colspan="4" class="doc" id="hasSelector0"><pre>Matches when BaseName == Selector.getAsString()
2870
2871  matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
2872  matches the outer message expr in the code below, but NOT the message
2873  invocation for self.bodyView.
2874     [self.bodyView loadHTMLString:html baseURL:NULL];
2875 </pre></td></tr>
2876
2877
2878 <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>
2879 <tr><td colspan="4" class="doc" id="hasUnarySelector0"><pre>Matches when the selector is a Unary Selector
2880
2881  matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
2882  matches self.bodyView in the code below, but NOT the outer message
2883  invocation of "loadHTMLString:baseURL:".
2884     [self.bodyView loadHTMLString:html baseURL:NULL];
2885 </pre></td></tr>
2886
2887
2888 <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>
2889 <tr><td colspan="4" class="doc" id="matchesSelector0"><pre>Matches ObjC selectors whose name contains
2890 a substring matched by the given RegExp.
2891  matcher = objCMessageExpr(matchesSelector("loadHTMLStringmatches the outer message expr in the code below, but NOT the message
2892  invocation for self.bodyView.
2893     [self.bodyView loadHTMLString:html baseURL:NULL];
2894 </pre></td></tr>
2895
2896
2897 <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>
2898 <tr><td colspan="4" class="doc" id="numSelectorArgs0"><pre>Matches when the selector has the specified number of arguments
2899
2900  matcher = objCMessageExpr(numSelectorArgs(0));
2901  matches self.bodyView in the code below
2902
2903  matcher = objCMessageExpr(numSelectorArgs(2));
2904  matches the invocation of "loadHTMLString:baseURL:" but not that
2905  of self.bodyView
2906     [self.bodyView loadHTMLString:html baseURL:NULL];
2907 </pre></td></tr>
2908
2909
2910 <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>
2911 <tr><td colspan="4" class="doc" id="asString0"><pre>Matches if the matched type is represented by the given string.
2912
2913 Given
2914   class Y { public: void x(); };
2915   void z() { Y* y; y-&gt;x(); }
2916 cxxMemberCallExpr(on(hasType(asString("class Y *"))))
2917   matches y-&gt;x()
2918 </pre></td></tr>
2919
2920
2921 <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>
2922 <tr><td colspan="4" class="doc" id="equalsBoundNode3"><pre>Matches if a node equals a previously bound node.
2923
2924 Matches a node if it equals the node previously bound to ID.
2925
2926 Given
2927   class X { int a; int b; };
2928 cxxRecordDecl(
2929     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
2930     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
2931   matches the class X, as a and b have the same type.
2932
2933 Note that when multiple matches are involved via forEach* matchers,
2934 equalsBoundNodes acts as a filter.
2935 For example:
2936 compoundStmt(
2937     forEachDescendant(varDecl().bind("d")),
2938     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
2939 will trigger a match for each combination of variable declaration
2940 and reference to that variable declaration within a compound statement.
2941 </pre></td></tr>
2942
2943
2944 <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>
2945 <tr><td colspan="4" class="doc" id="hasLocalQualifiers0"><pre>Matches QualType nodes that have local CV-qualifiers attached to
2946 the node, not hidden within a typedef.
2947
2948 Given
2949   typedef const int const_int;
2950   const_int i;
2951   int *const j;
2952   int *volatile k;
2953   int m;
2954 varDecl(hasType(hasLocalQualifiers())) matches only j and k.
2955 i is const-qualified but the qualifier is not local.
2956 </pre></td></tr>
2957
2958
2959 <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>
2960 <tr><td colspan="4" class="doc" id="isAnyCharacter0"><pre>Matches QualType nodes that are of character type.
2961
2962 Given
2963   void a(char);
2964   void b(wchar_t);
2965   void c(double);
2966 functionDecl(hasAnyParameter(hasType(isAnyCharacter())))
2967 matches "a(char)", "b(wchar_t)", but not "c(double)".
2968 </pre></td></tr>
2969
2970
2971 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isAnyPointer0')"><a name="isAnyPointer0Anchor">isAnyPointer</a></td><td></td></tr>
2972 <tr><td colspan="4" class="doc" id="isAnyPointer0"><pre>Matches QualType nodes that are of any pointer type; this includes
2973 the Objective-C object pointer type, which is different despite being
2974 syntactically similar.
2975
2976 Given
2977   int *i = nullptr;
2978
2979   @interface Foo
2980   @end
2981   Foo *f;
2982
2983   int j;
2984 varDecl(hasType(isAnyPointer()))
2985   matches "int *i" and "Foo *f", but not "int j".
2986 </pre></td></tr>
2987
2988
2989 <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>
2990 <tr><td colspan="4" class="doc" id="isConstQualified0"><pre>Matches QualType nodes that are const-qualified, i.e., that
2991 include "top-level" const.
2992
2993 Given
2994   void a(int);
2995   void b(int const);
2996   void c(const int);
2997   void d(const int*);
2998   void e(int const) {};
2999 functionDecl(hasAnyParameter(hasType(isConstQualified())))
3000   matches "void b(int const)", "void c(const int)" and
3001   "void e(int const) {}". It does not match d as there
3002   is no top-level const on the parameter type "const int *".
3003 </pre></td></tr>
3004
3005
3006 <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>
3007 <tr><td colspan="4" class="doc" id="isInteger0"><pre>Matches QualType nodes that are of integer type.
3008
3009 Given
3010   void a(int);
3011   void b(long);
3012   void c(double);
3013 functionDecl(hasAnyParameter(hasType(isInteger())))
3014 matches "a(int)", "b(long)", but not "c(double)".
3015 </pre></td></tr>
3016
3017
3018 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isSignedInteger0')"><a name="isSignedInteger0Anchor">isSignedInteger</a></td><td></td></tr>
3019 <tr><td colspan="4" class="doc" id="isSignedInteger0"><pre>Matches QualType nodes that are of signed integer type.
3020
3021 Given
3022   void a(int);
3023   void b(unsigned long);
3024   void c(double);
3025 functionDecl(hasAnyParameter(hasType(isSignedInteger())))
3026 matches "a(int)", but not "b(unsigned long)" and "c(double)".
3027 </pre></td></tr>
3028
3029
3030 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isUnsignedInteger0')"><a name="isUnsignedInteger0Anchor">isUnsignedInteger</a></td><td></td></tr>
3031 <tr><td colspan="4" class="doc" id="isUnsignedInteger0"><pre>Matches QualType nodes that are of unsigned integer type.
3032
3033 Given
3034   void a(int);
3035   void b(unsigned long);
3036   void c(double);
3037 functionDecl(hasAnyParameter(hasType(isUnsignedInteger())))
3038 matches "b(unsigned long)", but not "a(int)" and "c(double)".
3039 </pre></td></tr>
3040
3041
3042 <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>
3043 <tr><td colspan="4" class="doc" id="isVolatileQualified0"><pre>Matches QualType nodes that are volatile-qualified, i.e., that
3044 include "top-level" volatile.
3045
3046 Given
3047   void a(int);
3048   void b(int volatile);
3049   void c(volatile int);
3050   void d(volatile int*);
3051   void e(int volatile) {};
3052 functionDecl(hasAnyParameter(hasType(isVolatileQualified())))
3053   matches "void b(int volatile)", "void c(volatile int)" and
3054   "void e(int volatile) {}". It does not match d as there
3055   is no top-level volatile on the parameter type "volatile int *".
3056 </pre></td></tr>
3057
3058
3059 <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>
3060 <tr><td colspan="4" class="doc" id="isClass0"><pre>Matches RecordDecl object that are spelled with "class."
3061
3062 Example matches C, but not S or U.
3063   struct S {};
3064   class C {};
3065   union U {};
3066 </pre></td></tr>
3067
3068
3069 <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>
3070 <tr><td colspan="4" class="doc" id="isStruct0"><pre>Matches RecordDecl object that are spelled with "struct."
3071
3072 Example matches S, but not C or U.
3073   struct S {};
3074   class C {};
3075   union U {};
3076 </pre></td></tr>
3077
3078
3079 <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>
3080 <tr><td colspan="4" class="doc" id="isUnion0"><pre>Matches RecordDecl object that are spelled with "union."
3081
3082 Example matches U, but not C or S.
3083   struct S {};
3084   class C {};
3085   union U {};
3086 </pre></td></tr>
3087
3088
3089 <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>
3090 <tr><td colspan="4" class="doc" id="equalsBoundNode0"><pre>Matches if a node equals a previously bound node.
3091
3092 Matches a node if it equals the node previously bound to ID.
3093
3094 Given
3095   class X { int a; int b; };
3096 cxxRecordDecl(
3097     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
3098     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
3099   matches the class X, as a and b have the same type.
3100
3101 Note that when multiple matches are involved via forEach* matchers,
3102 equalsBoundNodes acts as a filter.
3103 For example:
3104 compoundStmt(
3105     forEachDescendant(varDecl().bind("d")),
3106     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
3107 will trigger a match for each combination of variable declaration
3108 and reference to that variable declaration within a compound statement.
3109 </pre></td></tr>
3110
3111
3112 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('equalsNode1')"><a name="equalsNode1Anchor">equalsNode</a></td><td>const Stmt* Other</td></tr>
3113 <tr><td colspan="4" class="doc" id="equalsNode1"><pre>Matches if a node equals another node.
3114
3115 Stmt has pointer identity in the AST.
3116 </pre></td></tr>
3117
3118
3119 <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>
3120 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching1"><pre>Matches AST nodes that were expanded within files whose name is
3121 partially matching a given regex.
3122
3123 Example matches Y but not X
3124     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
3125   #include "ASTMatcher.h"
3126   class X {};
3127 ASTMatcher.h:
3128   class Y {};
3129
3130 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;
3131 </pre></td></tr>
3132
3133
3134 <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>
3135 <tr><td colspan="4" class="doc" id="isExpansionInMainFile1"><pre>Matches AST nodes that were expanded within the main-file.
3136
3137 Example matches X but not Y
3138   (matcher = cxxRecordDecl(isExpansionInMainFile())
3139   #include &lt;Y.h&gt;
3140   class X {};
3141 Y.h:
3142   class Y {};
3143
3144 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;
3145 </pre></td></tr>
3146
3147
3148 <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>
3149 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader1"><pre>Matches AST nodes that were expanded within system-header-files.
3150
3151 Example matches Y but not X
3152     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
3153   #include &lt;SystemHeader.h&gt;
3154   class X {};
3155 SystemHeader.h:
3156   class Y {};
3157
3158 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;
3159 </pre></td></tr>
3160
3161
3162 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1StringLiteral.html">StringLiteral</a>&gt;</td><td class="name" onclick="toggle('hasSize1')"><a name="hasSize1Anchor">hasSize</a></td><td>unsigned N</td></tr>
3163 <tr><td colspan="4" class="doc" id="hasSize1"><pre>Matches nodes that have the specified size.
3164
3165 Given
3166   int a[42];
3167   int b[2 * 21];
3168   int c[41], d[43];
3169   char *s = "abcd";
3170   wchar_t *ws = L"abcd";
3171   char *w = "a";
3172 constantArrayType(hasSize(42))
3173   matches "int a[42]" and "int b[2 * 21]"
3174 stringLiteral(hasSize(4))
3175   matches "abcd", L"abcd"
3176 </pre></td></tr>
3177
3178
3179 <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>
3180 <tr><td colspan="4" class="doc" id="isDefinition0"><pre>Matches if a declaration has a body attached.
3181
3182 Example matches A, va, fa
3183   class A {};
3184   class B;  Doesn't match, as it has no body.
3185   int va;
3186   extern int vb;  Doesn't match, as it doesn't define the variable.
3187   void fa() {}
3188   void fb();  Doesn't match, as it has no body.
3189
3190 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;
3191 </pre></td></tr>
3192
3193
3194 <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>
3195 <tr><td colspan="4" class="doc" id="equalsIntegralValue0"><pre>Matches a TemplateArgument of integral type with a given value.
3196
3197 Note that 'Value' is a string as the template argument's value is
3198 an arbitrary precision integer. 'Value' must be euqal to the canonical
3199 representation of that integral value in base 10.
3200
3201 Given
3202   template&lt;int T&gt; struct A {};
3203   C&lt;42&gt; c;
3204 classTemplateSpecializationDecl(
3205   hasAnyTemplateArgument(equalsIntegralValue("42")))
3206   matches the implicit instantiation of C in C&lt;42&gt;.
3207 </pre></td></tr>
3208
3209
3210 <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>
3211 <tr><td colspan="4" class="doc" id="isIntegral0"><pre>Matches a TemplateArgument that is an integral value.
3212
3213 Given
3214   template&lt;int T&gt; struct A {};
3215   C&lt;42&gt; c;
3216 classTemplateSpecializationDecl(
3217   hasAnyTemplateArgument(isIntegral()))
3218   matches the implicit instantiation of C in C&lt;42&gt;
3219   with isIntegral() matching 42.
3220 </pre></td></tr>
3221
3222
3223 <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>
3224 <tr><td colspan="4" class="doc" id="templateArgumentCountIs1"><pre>Matches if the number of template arguments equals N.
3225
3226 Given
3227   template&lt;typename T&gt; struct C {};
3228   C&lt;int&gt; c;
3229 classTemplateSpecializationDecl(templateArgumentCountIs(1))
3230   matches C&lt;int&gt;.
3231 </pre></td></tr>
3232
3233
3234 <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>
3235 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching2"><pre>Matches AST nodes that were expanded within files whose name is
3236 partially matching a given regex.
3237
3238 Example matches Y but not X
3239     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
3240   #include "ASTMatcher.h"
3241   class X {};
3242 ASTMatcher.h:
3243   class Y {};
3244
3245 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;
3246 </pre></td></tr>
3247
3248
3249 <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>
3250 <tr><td colspan="4" class="doc" id="isExpansionInMainFile2"><pre>Matches AST nodes that were expanded within the main-file.
3251
3252 Example matches X but not Y
3253   (matcher = cxxRecordDecl(isExpansionInMainFile())
3254   #include &lt;Y.h&gt;
3255   class X {};
3256 Y.h:
3257   class Y {};
3258
3259 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;
3260 </pre></td></tr>
3261
3262
3263 <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>
3264 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader2"><pre>Matches AST nodes that were expanded within system-header-files.
3265
3266 Example matches Y but not X
3267     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
3268   #include &lt;SystemHeader.h&gt;
3269   class X {};
3270 SystemHeader.h:
3271   class Y {};
3272
3273 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;
3274 </pre></td></tr>
3275
3276
3277 <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>
3278 <tr><td colspan="4" class="doc" id="booleanType0"><pre>Matches type bool.
3279
3280 Given
3281  struct S { bool func(); };
3282 functionDecl(returns(booleanType()))
3283   matches "bool func();"
3284 </pre></td></tr>
3285
3286
3287 <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>
3288 <tr><td colspan="4" class="doc" id="equalsBoundNode2"><pre>Matches if a node equals a previously bound node.
3289
3290 Matches a node if it equals the node previously bound to ID.
3291
3292 Given
3293   class X { int a; int b; };
3294 cxxRecordDecl(
3295     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
3296     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
3297   matches the class X, as a and b have the same type.
3298
3299 Note that when multiple matches are involved via forEach* matchers,
3300 equalsBoundNodes acts as a filter.
3301 For example:
3302 compoundStmt(
3303     forEachDescendant(varDecl().bind("d")),
3304     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
3305 will trigger a match for each combination of variable declaration
3306 and reference to that variable declaration within a compound statement.
3307 </pre></td></tr>
3308
3309
3310 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('equalsNode2')"><a name="equalsNode2Anchor">equalsNode</a></td><td>const Type* Other</td></tr>
3311 <tr><td colspan="4" class="doc" id="equalsNode2"><pre>Matches if a node equals another node.
3312
3313 Type has pointer identity in the AST.
3314 </pre></td></tr>
3315
3316
3317 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('realFloatingPointType0')"><a name="realFloatingPointType0Anchor">realFloatingPointType</a></td><td></td></tr>
3318 <tr><td colspan="4" class="doc" id="realFloatingPointType0"><pre>Matches any real floating-point type (float, double, long double).
3319
3320 Given
3321   int i;
3322   float f;
3323 realFloatingPointType()
3324   matches "float f" but not "int i"
3325 </pre></td></tr>
3326
3327
3328 <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>
3329 <tr><td colspan="4" class="doc" id="voidType0"><pre>Matches type void.
3330
3331 Given
3332  struct S { void func(); };
3333 functionDecl(returns(voidType()))
3334   matches "void func();"
3335 </pre></td></tr>
3336
3337
3338 <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>
3339 <tr><td colspan="4" class="doc" id="ofKind0"><pre>Matches unary expressions of a certain kind.
3340
3341 Given
3342   int x;
3343   int s = sizeof(x) + alignof(x)
3344 unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
3345   matches sizeof(x)
3346 </pre></td></tr>
3347
3348
3349 <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>
3350 <tr><td colspan="4" class="doc" id="hasOperatorName1"><pre>Matches the operator Name of operator expressions (binary or
3351 unary).
3352
3353 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3354   !(a || b)
3355 </pre></td></tr>
3356
3357
3358 <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>
3359 <tr><td colspan="4" class="doc" id="hasAutomaticStorageDuration0"><pre>Matches a variable declaration that has automatic storage duration.
3360
3361 Example matches x, but not y, z, or a.
3362 (matcher = varDecl(hasAutomaticStorageDuration())
3363 void f() {
3364   int x;
3365   static int y;
3366   thread_local int z;
3367 }
3368 int a;
3369 </pre></td></tr>
3370
3371
3372 <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>
3373 <tr><td colspan="4" class="doc" id="hasGlobalStorage0"><pre>Matches a variable declaration that does not have local storage.
3374
3375 Example matches y and z (matcher = varDecl(hasGlobalStorage())
3376 void f() {
3377   int x;
3378   static int y;
3379 }
3380 int z;
3381 </pre></td></tr>
3382
3383
3384 <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>
3385 <tr><td colspan="4" class="doc" id="hasLocalStorage0"><pre>Matches a variable declaration that has function scope and is a
3386 non-static local variable.
3387
3388 Example matches x (matcher = varDecl(hasLocalStorage())
3389 void f() {
3390   int x;
3391   static int y;
3392 }
3393 int z;
3394 </pre></td></tr>
3395
3396
3397 <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>
3398 <tr><td colspan="4" class="doc" id="hasStaticStorageDuration0"><pre>Matches a variable declaration that has static storage duration.
3399 It includes the variable declared at namespace scope and those declared
3400 with "static" and "extern" storage class specifiers.
3401
3402 void f() {
3403   int x;
3404   static int y;
3405   thread_local int z;
3406 }
3407 int a;
3408 static int b;
3409 extern int c;
3410 varDecl(hasStaticStorageDuration())
3411   matches the function declaration y, a, b and c.
3412 </pre></td></tr>
3413
3414
3415 <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>
3416 <tr><td colspan="4" class="doc" id="hasThreadStorageDuration0"><pre>Matches a variable declaration that has thread storage duration.
3417
3418 Example matches z, but not x, z, or a.
3419 (matcher = varDecl(hasThreadStorageDuration())
3420 void f() {
3421   int x;
3422   static int y;
3423   thread_local int z;
3424 }
3425 int a;
3426 </pre></td></tr>
3427
3428
3429 <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>
3430 <tr><td colspan="4" class="doc" id="isConstexpr0"><pre>Matches constexpr variable and function declarations.
3431
3432 Given:
3433   constexpr int foo = 42;
3434   constexpr int bar();
3435 varDecl(isConstexpr())
3436   matches the declaration of foo.
3437 functionDecl(isConstexpr())
3438   matches the declaration of bar.
3439 </pre></td></tr>
3440
3441
3442 <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>
3443 <tr><td colspan="4" class="doc" id="isDefinition1"><pre>Matches if a declaration has a body attached.
3444
3445 Example matches A, va, fa
3446   class A {};
3447   class B;  Doesn't match, as it has no body.
3448   int va;
3449   extern int vb;  Doesn't match, as it doesn't define the variable.
3450   void fa() {}
3451   void fb();  Doesn't match, as it has no body.
3452
3453 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;
3454 </pre></td></tr>
3455
3456
3457 <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>
3458 <tr><td colspan="4" class="doc" id="isExceptionVariable0"><pre>Matches a variable declaration that is an exception variable from
3459 a C++ catch block, or an Objective-C statement.
3460
3461 Example matches x (matcher = varDecl(isExceptionVariable())
3462 void f(int y) {
3463   try {
3464   } catch (int x) {
3465   }
3466 }
3467 </pre></td></tr>
3468
3469
3470 <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>
3471 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization1"><pre>Matches explicit template specializations of function, class, or
3472 static member variable template instantiations.
3473
3474 Given
3475   template&lt;typename T&gt; void A(T t) { }
3476   template&lt;&gt; void A(int N) { }
3477 functionDecl(isExplicitTemplateSpecialization())
3478   matches the specialization A&lt;int&gt;().
3479
3480 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;
3481 </pre></td></tr>
3482
3483
3484 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isExternC1')"><a name="isExternC1Anchor">isExternC</a></td><td></td></tr>
3485 <tr><td colspan="4" class="doc" id="isExternC1"><pre>Matches extern "C" function declarations.
3486
3487 Given:
3488   extern "C" void f() {}
3489   extern "C" { void g() {} }
3490   void h() {}
3491 functionDecl(isExternC())
3492   matches the declaration of f and g, but not the declaration h
3493 </pre></td></tr>
3494
3495
3496 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isStaticStorageClass1')"><a name="isStaticStorageClass1Anchor">isStaticStorageClass</a></td><td></td></tr>
3497 <tr><td colspan="4" class="doc" id="isStaticStorageClass1"><pre>Matches variablefunction declarations that have "static" storage
3498 class specifier ("static" keyword) written in the source.
3499
3500 Given:
3501   static void f() {}
3502   static int i = 0;
3503   extern int j;
3504   int k;
3505 functionDecl(isStaticStorageClass())
3506   matches the function declaration f.
3507 varDecl(isStaticStorageClass())
3508   matches the variable declaration i.
3509 </pre></td></tr>
3510
3511
3512 <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>
3513 <tr><td colspan="4" class="doc" id="isTemplateInstantiation1"><pre>Matches template instantiations of function, class, or static
3514 member variable template instantiations.
3515
3516 Given
3517   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
3518 or
3519   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
3520 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3521   matches the template instantiation of X&lt;A&gt;.
3522
3523 But given
3524   template &lt;typename T&gt;  class X {}; class A {};
3525   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
3526 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3527   does not match, as X&lt;A&gt; is an explicit template specialization.
3528
3529 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;
3530 </pre></td></tr>
3531
3532
3533 <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>
3534 <tr><td colspan="4" class="doc" id="isInstantiated0"><pre>Matches declarations that are template instantiations or are inside
3535 template instantiations.
3536
3537 Given
3538   template&lt;typename T&gt; void A(T t) { T i; }
3539   A(0);
3540   A(0U);
3541 functionDecl(isInstantiated())
3542   matches 'A(int) {...};' and 'A(unsigned) {...}'.
3543 </pre></td></tr>
3544
3545
3546 <tr><td>Matcher&lt;internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;&gt;</td><td class="name" onclick="toggle('nullPointerConstant0')"><a name="nullPointerConstant0Anchor">nullPointerConstant</a></td><td></td></tr>
3547 <tr><td colspan="4" class="doc" id="nullPointerConstant0"><pre>Matches expressions that resolve to a null pointer constant, such as
3548 GNU's __null, C++11's nullptr, or C's NULL macro.
3549
3550 Given:
3551   void *v1 = NULL;
3552   void *v2 = nullptr;
3553   void *v3 = __null; GNU extension
3554   char *cp = (char *)0;
3555   int *ip = 0;
3556   int i = 0;
3557 expr(nullPointerConstant())
3558   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
3559   initializer for i.
3560 </pre></td></tr>
3561
3562
3563 <tr><td>Matcher&lt;internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;&gt;</td><td class="name" onclick="toggle('hasAnyName0')"><a name="hasAnyName0Anchor">hasAnyName</a></td><td>StringRef, ..., StringRef</td></tr>
3564 <tr><td colspan="4" class="doc" id="hasAnyName0"><pre>Matches NamedDecl nodes that have any of the specified names.
3565
3566 This matcher is only provided as a performance optimization of hasName.
3567     hasAnyName(a, b, c)
3568  is equivalent to, but faster than
3569     anyOf(hasName(a), hasName(b), hasName(c))
3570 </pre></td></tr>
3571
3572
3573 <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>
3574 <tr><td colspan="4" class="doc" id="isInTemplateInstantiation0"><pre>Matches statements inside of a template instantiation.
3575
3576 Given
3577   int j;
3578   template&lt;typename T&gt; void A(T t) { T i; j += 42;}
3579   A(0);
3580   A(0U);
3581 declStmt(isInTemplateInstantiation())
3582   matches 'int i;' and 'unsigned i'.
3583 unless(stmt(isInTemplateInstantiation()))
3584   will NOT match j += 42; as it's shared between the template definition and
3585   instantiation.
3586 </pre></td></tr>
3587
3588 <!--END_NARROWING_MATCHERS -->
3589 </table>
3590
3591 <!-- ======================================================================= -->
3592 <h2 id="traversal-matchers">AST Traversal Matchers</h2>
3593 <!-- ======================================================================= -->
3594
3595 <p>Traversal matchers specify the relationship to other nodes that are
3596 reachable from the current node.</p>
3597
3598 <p>Note that there are special traversal matchers (has, hasDescendant, forEach and
3599 forEachDescendant) which work on all nodes and allow users to write more generic
3600 match expressions.</p>
3601
3602 <table>
3603 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
3604 <!-- START_TRAVERSAL_MATCHERS -->
3605
3606 <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>
3607 <tr><td colspan="4" class="doc" id="eachOf0"><pre>Matches if any of the given matchers matches.
3608
3609 Unlike anyOf, eachOf will generate a match result for each
3610 matching submatcher.
3611
3612 For example, in:
3613   class A { int a; int b; };
3614 The matcher:
3615   cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
3616                        has(fieldDecl(hasName("b")).bind("v"))))
3617 will generate two results binding "v", the first of which binds
3618 the field declaration of a, the second the field declaration of
3619 b.
3620
3621 Usable as: Any Matcher
3622 </pre></td></tr>
3623
3624
3625 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEachDescendant0')"><a name="forEachDescendant0Anchor">forEachDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
3626 <tr><td colspan="4" class="doc" id="forEachDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
3627 provided matcher.
3628
3629 Example matches X, A, B, C
3630   (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X")))))
3631   class X {};  Matches X, because X::X is a class of name X inside X.
3632   class A { class X {}; };
3633   class B { class C { class X {}; }; };
3634
3635 DescendantT must be an AST base type.
3636
3637 As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
3638 each result that matches instead of only on the first one.
3639
3640 Note: Recursively combined ForEachDescendant can cause many matches:
3641   cxxRecordDecl(forEachDescendant(cxxRecordDecl(
3642     forEachDescendant(cxxRecordDecl())
3643   )))
3644 will match 10 times (plus injected class name matches) on:
3645   class A { class B { class C { class D { class E {}; }; }; }; };
3646
3647 Usable as: Any Matcher
3648 </pre></td></tr>
3649
3650
3651 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEach0')"><a name="forEach0Anchor">forEach</a></td><td>Matcher&lt;*&gt;</td></tr>
3652 <tr><td colspan="4" class="doc" id="forEach0"><pre>Matches AST nodes that have child AST nodes that match the
3653 provided matcher.
3654
3655 Example matches X, Y
3656   (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X")))
3657   class X {};  Matches X, because X::X is a class of name X inside X.
3658   class Y { class X {}; };
3659   class Z { class Y { class X {}; }; };  Does not match Z.
3660
3661 ChildT must be an AST base type.
3662
3663 As opposed to 'has', 'forEach' will cause a match for each result that
3664 matches instead of only on the first one.
3665
3666 Usable as: Any Matcher
3667 </pre></td></tr>
3668
3669
3670 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasAncestor0')"><a name="hasAncestor0Anchor">hasAncestor</a></td><td>Matcher&lt;*&gt;</td></tr>
3671 <tr><td colspan="4" class="doc" id="hasAncestor0"><pre>Matches AST nodes that have an ancestor that matches the provided
3672 matcher.
3673
3674 Given
3675 void f() { if (true) { int x = 42; } }
3676 void g() { for (;;) { int x = 43; } }
3677 expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
3678
3679 Usable as: Any Matcher
3680 </pre></td></tr>
3681
3682
3683 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasDescendant0')"><a name="hasDescendant0Anchor">hasDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
3684 <tr><td colspan="4" class="doc" id="hasDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
3685 provided matcher.
3686
3687 Example matches X, Y, Z
3688     (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))
3689   class X {};  Matches X, because X::X is a class of name X inside X.
3690   class Y { class X {}; };
3691   class Z { class Y { class X {}; }; };
3692
3693 DescendantT must be an AST base type.
3694
3695 Usable as: Any Matcher
3696 </pre></td></tr>
3697
3698
3699 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('has0')"><a name="has0Anchor">has</a></td><td>Matcher&lt;*&gt;</td></tr>
3700 <tr><td colspan="4" class="doc" id="has0"><pre>Matches AST nodes that have child AST nodes that match the
3701 provided matcher.
3702
3703 Example matches X, Y
3704   (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X")))
3705   class X {};  Matches X, because X::X is a class of name X inside X.
3706   class Y { class X {}; };
3707   class Z { class Y { class X {}; }; };  Does not match Z.
3708
3709 ChildT must be an AST base type.
3710
3711 Usable as: Any Matcher
3712 Note that has is direct matcher, so it also matches things like implicit
3713 casts and paren casts. If you are matching with expr then you should
3714 probably consider using ignoringParenImpCasts like:
3715 has(ignoringParenImpCasts(expr())).
3716 </pre></td></tr>
3717
3718
3719 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasParent0')"><a name="hasParent0Anchor">hasParent</a></td><td>Matcher&lt;*&gt;</td></tr>
3720 <tr><td colspan="4" class="doc" id="hasParent0"><pre>Matches AST nodes that have a parent that matches the provided
3721 matcher.
3722
3723 Given
3724 void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
3725 compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
3726
3727 Usable as: Any Matcher
3728 </pre></td></tr>
3729
3730
3731 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AbstractConditionalOperator.html">AbstractConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasCondition5')"><a name="hasCondition5Anchor">hasCondition</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
3732 <tr><td colspan="4" class="doc" id="hasCondition5"><pre>Matches the condition expression of an if statement, for loop,
3733 switch statement or conditional operator.
3734
3735 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
3736   if (true) {}
3737 </pre></td></tr>
3738
3739
3740 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AbstractConditionalOperator.html">AbstractConditionalOperator</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>
3741 <tr><td colspan="4" class="doc" id="hasFalseExpression0"><pre>Matches the false branch expression of a conditional operator
3742 (binary or ternary).
3743
3744 Example matches b
3745   condition ? a : b
3746   condition ?: b
3747 </pre></td></tr>
3748
3749
3750 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AbstractConditionalOperator.html">AbstractConditionalOperator</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>
3751 <tr><td colspan="4" class="doc" id="hasTrueExpression0"><pre>Matches the true branch expression of a conditional operator.
3752
3753 Example 1 (conditional ternary operator): matches a
3754   condition ? a : b
3755
3756 Example 2 (conditional binary operator): matches opaqueValueExpr(condition)
3757   condition ?: b
3758 </pre></td></tr>
3759
3760
3761 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</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>
3762 <tr><td colspan="4" class="doc" id="hasDeclaration8"><pre>Matches a node if the declaration associated with that node
3763 matches the given matcher.
3764
3765 The associated declaration is:
3766 - for type nodes, the declaration of the underlying type
3767 - for CallExpr, the declaration of the callee
3768 - for MemberExpr, the declaration of the referenced member
3769 - for CXXConstructExpr, the declaration of the constructor
3770 - for CXXNewExpr, the declaration of the operator new
3771
3772 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
3773 function. e.g. various subtypes of clang::Type and various expressions.
3774
3775 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;,
3776   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
3777   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;,
3778   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
3779   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
3780   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;,
3781   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;
3782 </pre></td></tr>
3783
3784
3785 <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>
3786 <tr><td colspan="4" class="doc" id="hasBase0"><pre>Matches the base expression of an array subscript expression.
3787
3788 Given
3789   int i[5];
3790   void f() { i[1] = 42; }
3791 arraySubscriptExpression(hasBase(implicitCastExpr(
3792     hasSourceExpression(declRefExpr()))))
3793   matches i[1] with the declRefExpr() matching i
3794 </pre></td></tr>
3795
3796
3797 <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>
3798 <tr><td colspan="4" class="doc" id="hasIndex0"><pre>Matches the index expression of an array subscript expression.
3799
3800 Given
3801   int i[5];
3802   void f() { i[1] = 42; }
3803 arraySubscriptExpression(hasIndex(integerLiteral()))
3804   matches i[1] with the integerLiteral() matching 1
3805 </pre></td></tr>
3806
3807
3808 <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>
3809 <tr><td colspan="4" class="doc" id="hasLHS1"><pre>Matches the left hand side of binary operator expressions.
3810
3811 Example matches a (matcher = binaryOperator(hasLHS()))
3812   a || b
3813 </pre></td></tr>
3814
3815
3816 <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>
3817 <tr><td colspan="4" class="doc" id="hasRHS1"><pre>Matches the right hand side of binary operator expressions.
3818
3819 Example matches b (matcher = binaryOperator(hasRHS()))
3820   a || b
3821 </pre></td></tr>
3822
3823
3824 <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>
3825 <tr><td colspan="4" class="doc" id="hasElementTypeLoc0"><pre>Matches arrays and C99 complex types that have a specific element
3826 type.
3827
3828 Given
3829   struct A {};
3830   A a[7];
3831   int b[7];
3832 arrayType(hasElementType(builtinType()))
3833   matches "int b[7]"
3834
3835 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;
3836 </pre></td></tr>
3837
3838
3839 <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>
3840 <tr><td colspan="4" class="doc" id="hasElementType0"><pre>Matches arrays and C99 complex types that have a specific element
3841 type.
3842
3843 Given
3844   struct A {};
3845   A a[7];
3846   int b[7];
3847 arrayType(hasElementType(builtinType()))
3848   matches "int b[7]"
3849
3850 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;
3851 </pre></td></tr>
3852
3853
3854 <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>
3855 <tr><td colspan="4" class="doc" id="hasValueTypeLoc0"><pre>Matches atomic types with a specific value type.
3856
3857 Given
3858   _Atomic(int) i;
3859   _Atomic(float) f;
3860 atomicType(hasValueType(isInteger()))
3861  matches "_Atomic(int) i"
3862
3863 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
3864 </pre></td></tr>
3865
3866
3867 <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>
3868 <tr><td colspan="4" class="doc" id="hasValueType0"><pre>Matches atomic types with a specific value type.
3869
3870 Given
3871   _Atomic(int) i;
3872   _Atomic(float) f;
3873 atomicType(hasValueType(isInteger()))
3874  matches "_Atomic(int) i"
3875
3876 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
3877 </pre></td></tr>
3878
3879
3880 <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>
3881 <tr><td colspan="4" class="doc" id="hasDeducedType0"><pre>Matches AutoType nodes where the deduced type is a specific type.
3882
3883 Note: There is no TypeLoc for the deduced type and thus no
3884 getDeducedLoc() matcher.
3885
3886 Given
3887   auto a = 1;
3888   auto b = 2.0;
3889 autoType(hasDeducedType(isInteger()))
3890   matches "auto a"
3891
3892 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;
3893 </pre></td></tr>
3894
3895
3896 <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>
3897 <tr><td colspan="4" class="doc" id="hasEitherOperand0"><pre>Matches if either the left hand side or the right hand side of a
3898 binary operator matches.
3899 </pre></td></tr>
3900
3901
3902 <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>
3903 <tr><td colspan="4" class="doc" id="hasLHS0"><pre>Matches the left hand side of binary operator expressions.
3904
3905 Example matches a (matcher = binaryOperator(hasLHS()))
3906   a || b
3907 </pre></td></tr>
3908
3909
3910 <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>
3911 <tr><td colspan="4" class="doc" id="hasRHS0"><pre>Matches the right hand side of binary operator expressions.
3912
3913 Example matches b (matcher = binaryOperator(hasRHS()))
3914   a || b
3915 </pre></td></tr>
3916
3917
3918 <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>
3919 <tr><td colspan="4" class="doc" id="pointeeLoc0"><pre>Narrows PointerType (and similar) matchers to those where the
3920 pointee matches a given matcher.
3921
3922 Given
3923   int *a;
3924   int const *b;
3925   float const *f;
3926 pointerType(pointee(isConstQualified(), isInteger()))
3927   matches "int const *b"
3928
3929 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;,
3930   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;
3931 </pre></td></tr>
3932
3933
3934 <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>
3935 <tr><td colspan="4" class="doc" id="pointee0"><pre>Narrows PointerType (and similar) matchers to those where the
3936 pointee matches a given matcher.
3937
3938 Given
3939   int *a;
3940   int const *b;
3941   float const *f;
3942 pointerType(pointee(isConstQualified(), isInteger()))
3943   matches "int const *b"
3944
3945 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;,
3946   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;
3947 </pre></td></tr>
3948
3949
3950 <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>
3951 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam1"><pre>Matches all arguments and their respective ParmVarDecl.
3952
3953 Given
3954   void f(int i);
3955   int y;
3956   f(y);
3957 callExpr(
3958   forEachArgumentWithParam(
3959     declRefExpr(to(varDecl(hasName("y")))),
3960     parmVarDecl(hasType(isInteger()))
3961 ))
3962   matches f(y);
3963 with declRefExpr(...)
3964   matching int y
3965 and parmVarDecl(...)
3966   matching int i
3967 </pre></td></tr>
3968
3969
3970 <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>
3971 <tr><td colspan="4" class="doc" id="hasAnyArgument1"><pre>Matches any argument of a call expression or a constructor call
3972 expression.
3973
3974 Given
3975   void x(int, int, int) { int y; x(1, y, 42); }
3976 callExpr(hasAnyArgument(declRefExpr()))
3977   matches x(1, y, 42)
3978 with hasAnyArgument(...)
3979   matching y
3980 </pre></td></tr>
3981
3982
3983 <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>
3984 <tr><td colspan="4" class="doc" id="hasArgument1"><pre>Matches the n'th argument of a call expression or a constructor
3985 call expression.
3986
3987 Example matches y in x(y)
3988     (matcher = callExpr(hasArgument(0, declRefExpr())))
3989   void x(int) { int y; x(y); }
3990 </pre></td></tr>
3991
3992
3993 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</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>
3994 <tr><td colspan="4" class="doc" id="hasDeclaration13"><pre>Matches a node if the declaration associated with that node
3995 matches the given matcher.
3996
3997 The associated declaration is:
3998 - for type nodes, the declaration of the underlying type
3999 - for CallExpr, the declaration of the callee
4000 - for MemberExpr, the declaration of the referenced member
4001 - for CXXConstructExpr, the declaration of the constructor
4002 - for CXXNewExpr, the declaration of the operator new
4003
4004 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4005 function. e.g. various subtypes of clang::Type and various expressions.
4006
4007 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;,
4008   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4009   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;,
4010   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4011   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4012   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;,
4013   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;
4014 </pre></td></tr>
4015
4016
4017 <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>
4018 <tr><td colspan="4" class="doc" id="forEachConstructorInitializer0"><pre>Matches each constructor initializer in a constructor definition.
4019
4020 Given
4021   class A { A() : i(42), j(42) {} int i; int j; };
4022 cxxConstructorDecl(forEachConstructorInitializer(
4023   forField(decl().bind("x"))
4024 ))
4025   will trigger two matches, binding for 'i' and 'j' respectively.
4026 </pre></td></tr>
4027
4028
4029 <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>
4030 <tr><td colspan="4" class="doc" id="hasAnyConstructorInitializer0"><pre>Matches a constructor initializer.
4031
4032 Given
4033   struct Foo {
4034     Foo() : foo_(1) { }
4035     int foo_;
4036   };
4037 cxxRecordDecl(has(cxxConstructorDecl(
4038   hasAnyConstructorInitializer(anything())
4039 )))
4040   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
4041 </pre></td></tr>
4042
4043
4044 <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>
4045 <tr><td colspan="4" class="doc" id="forField0"><pre>Matches the field declaration of a constructor initializer.
4046
4047 Given
4048   struct Foo {
4049     Foo() : foo_(1) { }
4050     int foo_;
4051   };
4052 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
4053     forField(hasName("foo_"))))))
4054   matches Foo
4055 with forField matching foo_
4056 </pre></td></tr>
4057
4058
4059 <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>
4060 <tr><td colspan="4" class="doc" id="withInitializer0"><pre>Matches the initializer expression of a constructor initializer.
4061
4062 Given
4063   struct Foo {
4064     Foo() : foo_(1) { }
4065     int foo_;
4066   };
4067 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
4068     withInitializer(integerLiteral(equals(1)))))))
4069   matches Foo
4070 with withInitializer matching (1)
4071 </pre></td></tr>
4072
4073
4074 <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>
4075 <tr><td colspan="4" class="doc" id="hasBody3"><pre>Matches a 'for', 'while', 'do while' statement or a function
4076 definition that has a given body.
4077
4078 Given
4079   for (;;) {}
4080 hasBody(compoundStmt())
4081   matches 'for (;;) {}'
4082 with compoundStmt()
4083   matching '{}'
4084 </pre></td></tr>
4085
4086
4087 <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>
4088 <tr><td colspan="4" class="doc" id="hasLoopVariable0"><pre>Matches the initialization statement of a for loop.
4089
4090 Example:
4091     forStmt(hasLoopVariable(anything()))
4092 matches 'int x' in
4093     for (int x : a) { }
4094 </pre></td></tr>
4095
4096
4097 <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>
4098 <tr><td colspan="4" class="doc" id="hasRangeInit0"><pre>Matches the range initialization statement of a for loop.
4099
4100 Example:
4101     forStmt(hasRangeInit(anything()))
4102 matches 'a' in
4103     for (int x : a) { }
4104 </pre></td></tr>
4105
4106
4107 <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>
4108 <tr><td colspan="4" class="doc" id="onImplicitObjectArgument0"><pre></pre></td></tr>
4109
4110
4111 <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>
4112 <tr><td colspan="4" class="doc" id="on0"><pre>Matches on the implicit object argument of a member call expression.
4113
4114 Example matches y.x()
4115   (matcher = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y"))))))
4116   class Y { public: void x(); };
4117   void z() { Y y; y.x(); }",
4118
4119 FIXME: Overload to allow directly matching types?
4120 </pre></td></tr>
4121
4122
4123 <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>
4124 <tr><td colspan="4" class="doc" id="thisPointerType1"><pre>Overloaded to match the type's declaration.
4125 </pre></td></tr>
4126
4127
4128 <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>
4129 <tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the expression's type either matches the specified
4130 matcher, or is a pointer to a type that matches the InnerMatcher.
4131 </pre></td></tr>
4132
4133
4134 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('forEachOverridden0')"><a name="forEachOverridden0Anchor">forEachOverridden</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
4135 <tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overriden by the given method. This matcher may
4136 produce multiple matches.
4137
4138 Given
4139   class A { virtual void f(); };
4140   class B : public A { void f(); };
4141   class C : public B { void f(); };
4142 cxxMethodDecl(ofClass(hasName("C")),
4143               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
4144   matches once, with "b" binding "A::f" and "d" binding "C::f" (Note
4145   that B::f is not overridden by C::f).
4146
4147 The check can produce multiple matches in case of multiple inheritance, e.g.
4148   class A1 { virtual void f(); };
4149   class A2 { virtual void f(); };
4150   class C : public A1, public A2 { void f(); };
4151 cxxMethodDecl(ofClass(hasName("C")),
4152               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
4153   matches twice, once with "b" binding "A1::f" and "d" binding "C::f", and
4154   once with "b" binding "A2::f" and "d" binding "C::f".
4155 </pre></td></tr>
4156
4157
4158 <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>
4159 <tr><td colspan="4" class="doc" id="ofClass0"><pre>Matches the class declaration that the given method declaration
4160 belongs to.
4161
4162 FIXME: Generalize this for other kinds of declarations.
4163 FIXME: What other kind of declarations would we need to generalize
4164 this to?
4165
4166 Example matches A() in the last line
4167     (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
4168         ofClass(hasName("A"))))))
4169   class A {
4170    public:
4171     A();
4172   };
4173   A a = A();
4174 </pre></td></tr>
4175
4176
4177 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration15')"><a name="hasDeclaration15Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
4178 <tr><td colspan="4" class="doc" id="hasDeclaration15"><pre>Matches a node if the declaration associated with that node
4179 matches the given matcher.
4180
4181 The associated declaration is:
4182 - for type nodes, the declaration of the underlying type
4183 - for CallExpr, the declaration of the callee
4184 - for MemberExpr, the declaration of the referenced member
4185 - for CXXConstructExpr, the declaration of the constructor
4186 - for CXXNewExpr, the declaration of the operator new
4187
4188 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4189 function. e.g. various subtypes of clang::Type and various expressions.
4190
4191 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;,
4192   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4193   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;,
4194   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4195   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4196   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;,
4197   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;
4198 </pre></td></tr>
4199
4200
4201 <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>
4202 <tr><td colspan="4" class="doc" id="hasMethod0"><pre>Matches the first method of a class or struct that satisfies InnerMatcher.
4203
4204 Given:
4205   class A { void func(); };
4206   class B { void member(); };
4207
4208 cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
4209 A but not B.
4210 </pre></td></tr>
4211
4212
4213 <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>
4214 <tr><td colspan="4" class="doc" id="isDerivedFrom0"><pre>Matches C++ classes that are directly or indirectly derived from
4215 a class matching Base.
4216
4217 Note that a class is not considered to be derived from itself.
4218
4219 Example matches Y, Z, C (Base == hasName("X"))
4220   class X;
4221   class Y : public X {};  directly derived
4222   class Z : public Y {};  indirectly derived
4223   typedef X A;
4224   typedef A B;
4225   class C : public B {};  derived from a typedef of X
4226
4227 In the following example, Bar matches isDerivedFrom(hasName("X")):
4228   class Foo;
4229   typedef Foo X;
4230   class Bar : public Foo {};  derived from a type that X is a typedef of
4231 </pre></td></tr>
4232
4233
4234 <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>
4235 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom0"><pre>Similar to isDerivedFrom(), but also matches classes that directly
4236 match Base.
4237 </pre></td></tr>
4238
4239
4240 <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>
4241 <tr><td colspan="4" class="doc" id="callee1"><pre>Matches if the call expression's callee's declaration matches the
4242 given matcher.
4243
4244 Example matches y.x() (matcher = callExpr(callee(
4245                                    cxxMethodDecl(hasName("x")))))
4246   class Y { public: void x(); };
4247   void z() { Y y; y.x(); }
4248 </pre></td></tr>
4249
4250
4251 <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>
4252 <tr><td colspan="4" class="doc" id="callee0"><pre>Matches if the call expression's callee expression matches.
4253
4254 Given
4255   class Y { void x() { this-&gt;x(); x(); Y y; y.x(); } };
4256   void f() { f(); }
4257 callExpr(callee(expr()))
4258   matches this-&gt;x(), x(), y.x(), f()
4259 with callee(...)
4260   matching this-&gt;x, x, y.x, f respectively
4261
4262 Note: Callee cannot take the more general internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;
4263 because this introduces ambiguous overloads with calls to Callee taking a
4264 internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, as the matcher hierarchy is purely
4265 implemented in terms of implicit casts.
4266 </pre></td></tr>
4267
4268
4269 <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>
4270 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam0"><pre>Matches all arguments and their respective ParmVarDecl.
4271
4272 Given
4273   void f(int i);
4274   int y;
4275   f(y);
4276 callExpr(
4277   forEachArgumentWithParam(
4278     declRefExpr(to(varDecl(hasName("y")))),
4279     parmVarDecl(hasType(isInteger()))
4280 ))
4281   matches f(y);
4282 with declRefExpr(...)
4283   matching int y
4284 and parmVarDecl(...)
4285   matching int i
4286 </pre></td></tr>
4287
4288
4289 <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>
4290 <tr><td colspan="4" class="doc" id="hasAnyArgument0"><pre>Matches any argument of a call expression or a constructor call
4291 expression.
4292
4293 Given
4294   void x(int, int, int) { int y; x(1, y, 42); }
4295 callExpr(hasAnyArgument(declRefExpr()))
4296   matches x(1, y, 42)
4297 with hasAnyArgument(...)
4298   matching y
4299 </pre></td></tr>
4300
4301
4302 <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>
4303 <tr><td colspan="4" class="doc" id="hasArgument0"><pre>Matches the n'th argument of a call expression or a constructor
4304 call expression.
4305
4306 Example matches y in x(y)
4307     (matcher = callExpr(hasArgument(0, declRefExpr())))
4308   void x(int) { int y; x(y); }
4309 </pre></td></tr>
4310
4311
4312 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration14')"><a name="hasDeclaration14Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
4313 <tr><td colspan="4" class="doc" id="hasDeclaration14"><pre>Matches a node if the declaration associated with that node
4314 matches the given matcher.
4315
4316 The associated declaration is:
4317 - for type nodes, the declaration of the underlying type
4318 - for CallExpr, the declaration of the callee
4319 - for MemberExpr, the declaration of the referenced member
4320 - for CXXConstructExpr, the declaration of the constructor
4321 - for CXXNewExpr, the declaration of the operator new
4322
4323 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4324 function. e.g. various subtypes of clang::Type and various expressions.
4325
4326 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;,
4327   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4328   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;,
4329   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4330   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4331   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;,
4332   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;
4333 </pre></td></tr>
4334
4335
4336 <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>
4337 <tr><td colspan="4" class="doc" id="hasCaseConstant0"><pre>If the given case statement does not use the GNU case range
4338 extension, matches the constant given in the statement.
4339
4340 Given
4341   switch (1) { case 1: case 1+1: case 3 ... 4: ; }
4342 caseStmt(hasCaseConstant(integerLiteral()))
4343   matches "case 1:"
4344 </pre></td></tr>
4345
4346
4347 <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>
4348 <tr><td colspan="4" class="doc" id="hasSourceExpression0"><pre></pre></td></tr>
4349
4350
4351 <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>
4352 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches classTemplateSpecializations, templateSpecializationType and
4353 functionDecl that have at least one TemplateArgument matching the given
4354 InnerMatcher.
4355
4356 Given
4357   template&lt;typename T&gt; class A {};
4358   template&lt;&gt; class A&lt;double&gt; {};
4359   A&lt;int&gt; a;
4360
4361   template&lt;typename T&gt; f() {};
4362   void func() { f&lt;int&gt;(); };
4363
4364 classTemplateSpecializationDecl(hasAnyTemplateArgument(
4365     refersToType(asString("int"))))
4366   matches the specialization A&lt;int&gt;
4367
4368 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
4369   matches the specialization f&lt;int&gt;
4370 </pre></td></tr>
4371
4372
4373 <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>
4374 <tr><td colspan="4" class="doc" id="hasTemplateArgument0"><pre>Matches classTemplateSpecializations, templateSpecializationType and
4375 functionDecl where the n'th TemplateArgument matches the given InnerMatcher.
4376
4377 Given
4378   template&lt;typename T, typename U&gt; class A {};
4379   A&lt;bool, int&gt; b;
4380   A&lt;int, bool&gt; c;
4381
4382   template&lt;typename T&gt; f() {};
4383   void func() { f&lt;int&gt;(); };
4384 classTemplateSpecializationDecl(hasTemplateArgument(
4385     1, refersToType(asString("int"))))
4386   matches the specialization A&lt;bool, int&gt;
4387
4388 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
4389   matches the specialization f&lt;int&gt;
4390 </pre></td></tr>
4391
4392
4393 <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>
4394 <tr><td colspan="4" class="doc" id="hasElementTypeLoc1"><pre>Matches arrays and C99 complex types that have a specific element
4395 type.
4396
4397 Given
4398   struct A {};
4399   A a[7];
4400   int b[7];
4401 arrayType(hasElementType(builtinType()))
4402   matches "int b[7]"
4403
4404 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;
4405 </pre></td></tr>
4406
4407
4408 <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>
4409 <tr><td colspan="4" class="doc" id="hasElementType1"><pre>Matches arrays and C99 complex types that have a specific element
4410 type.
4411
4412 Given
4413   struct A {};
4414   A a[7];
4415   int b[7];
4416 arrayType(hasElementType(builtinType()))
4417   matches "int b[7]"
4418
4419 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;
4420 </pre></td></tr>
4421
4422
4423 <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>
4424 <tr><td colspan="4" class="doc" id="hasAnySubstatement0"><pre>Matches compound statements where at least one substatement matches
4425 a given matcher. Also matches StmtExprs that have CompoundStmt as children.
4426
4427 Given
4428   { {}; 1+2; }
4429 hasAnySubstatement(compoundStmt())
4430   matches '{ {}; 1+2; }'
4431 with compoundStmt()
4432   matching '{}'
4433 </pre></td></tr>
4434
4435
4436 <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>
4437 <tr><td colspan="4" class="doc" id="hasDecayedType0"><pre>Matches the decayed type, whos decayed type matches InnerMatcher
4438 </pre></td></tr>
4439
4440
4441 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</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>
4442 <tr><td colspan="4" class="doc" id="hasDeclaration12"><pre>Matches a node if the declaration associated with that node
4443 matches the given matcher.
4444
4445 The associated declaration is:
4446 - for type nodes, the declaration of the underlying type
4447 - for CallExpr, the declaration of the callee
4448 - for MemberExpr, the declaration of the referenced member
4449 - for CXXConstructExpr, the declaration of the constructor
4450 - for CXXNewExpr, the declaration of the operator new
4451
4452 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4453 function. e.g. various subtypes of clang::Type and various expressions.
4454
4455 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;,
4456   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4457   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;,
4458   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4459   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4460   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;,
4461   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;
4462 </pre></td></tr>
4463
4464
4465 <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>
4466 <tr><td colspan="4" class="doc" id="throughUsingDecl0"><pre>Matches a DeclRefExpr that refers to a declaration through a
4467 specific using shadow declaration.
4468
4469 Given
4470   namespace a { void f() {} }
4471   using a::f;
4472   void g() {
4473     f();     Matches this ..
4474     a::f();  .. but not this.
4475   }
4476 declRefExpr(throughUsingDecl(anything()))
4477   matches f()
4478 </pre></td></tr>
4479
4480
4481 <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>
4482 <tr><td colspan="4" class="doc" id="to0"><pre>Matches a DeclRefExpr that refers to a declaration that matches the
4483 specified matcher.
4484
4485 Example matches x in if(x)
4486     (matcher = declRefExpr(to(varDecl(hasName("x")))))
4487   bool x;
4488   if (x) {}
4489 </pre></td></tr>
4490
4491
4492 <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>
4493 <tr><td colspan="4" class="doc" id="containsDeclaration0"><pre>Matches the n'th declaration of a declaration statement.
4494
4495 Note that this does not work for global declarations because the AST
4496 breaks up multiple-declaration DeclStmt's into multiple single-declaration
4497 DeclStmt's.
4498 Example: Given non-global declarations
4499   int a, b = 0;
4500   int c;
4501   int d = 2, e;
4502 declStmt(containsDeclaration(
4503       0, varDecl(hasInitializer(anything()))))
4504   matches only 'int d = 2, e;', and
4505 declStmt(containsDeclaration(1, varDecl()))
4506   matches 'int a, b = 0' as well as 'int d = 2, e;'
4507   but 'int c;' is not matched.
4508 </pre></td></tr>
4509
4510
4511 <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>
4512 <tr><td colspan="4" class="doc" id="hasSingleDecl0"><pre>Matches the Decl of a DeclStmt which has a single declaration.
4513
4514 Given
4515   int a, b;
4516   int c;
4517 declStmt(hasSingleDecl(anything()))
4518   matches 'int c;' but not 'int a, b;'.
4519 </pre></td></tr>
4520
4521
4522 <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>
4523 <tr><td colspan="4" class="doc" id="hasTypeLoc0"><pre>Matches if the type location of the declarator decl's type matches
4524 the inner matcher.
4525
4526 Given
4527   int x;
4528 declaratorDecl(hasTypeLoc(loc(asString("int"))))
4529   matches int x
4530 </pre></td></tr>
4531
4532
4533 <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>
4534 <tr><td colspan="4" class="doc" id="hasDeclContext0"><pre>Matches declarations whose declaration context, interpreted as a
4535 Decl, matches InnerMatcher.
4536
4537 Given
4538   namespace N {
4539     namespace M {
4540       class D {};
4541     }
4542   }
4543
4544 cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
4545 declaration of class D.
4546 </pre></td></tr>
4547
4548
4549 <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>
4550 <tr><td colspan="4" class="doc" id="hasBody0"><pre>Matches a 'for', 'while', 'do while' statement or a function
4551 definition that has a given body.
4552
4553 Given
4554   for (;;) {}
4555 hasBody(compoundStmt())
4556   matches 'for (;;) {}'
4557 with compoundStmt()
4558   matching '{}'
4559 </pre></td></tr>
4560
4561
4562 <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>
4563 <tr><td colspan="4" class="doc" id="hasCondition3"><pre>Matches the condition expression of an if statement, for loop,
4564 switch statement or conditional operator.
4565
4566 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
4567   if (true) {}
4568 </pre></td></tr>
4569
4570
4571 <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>
4572 <tr><td colspan="4" class="doc" id="hasQualifier0"><pre>Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
4573 matches InnerMatcher if the qualifier exists.
4574
4575 Given
4576   namespace N {
4577     namespace M {
4578       class D {};
4579     }
4580   }
4581   N::M::D d;
4582
4583 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
4584 matches the type of the variable declaration of d.
4585 </pre></td></tr>
4586
4587
4588 <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>
4589 <tr><td colspan="4" class="doc" id="namesType0"><pre>Matches ElaboratedTypes whose named type matches InnerMatcher.
4590
4591 Given
4592   namespace N {
4593     namespace M {
4594       class D {};
4595     }
4596   }
4597   N::M::D d;
4598
4599 elaboratedType(namesType(recordType(
4600 hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
4601 declaration of d.
4602 </pre></td></tr>
4603
4604
4605 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</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>
4606 <tr><td colspan="4" class="doc" id="hasDeclaration11"><pre>Matches a node if the declaration associated with that node
4607 matches the given matcher.
4608
4609 The associated declaration is:
4610 - for type nodes, the declaration of the underlying type
4611 - for CallExpr, the declaration of the callee
4612 - for MemberExpr, the declaration of the referenced member
4613 - for CXXConstructExpr, the declaration of the constructor
4614 - for CXXNewExpr, the declaration of the operator new
4615
4616 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4617 function. e.g. various subtypes of clang::Type and various expressions.
4618
4619 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;,
4620   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4621   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;,
4622   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4623   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4624   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;,
4625   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;
4626 </pre></td></tr>
4627
4628
4629 <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>
4630 <tr><td colspan="4" class="doc" id="hasDestinationType0"><pre>Matches casts whose destination type matches a given matcher.
4631
4632 (Note: Clang's AST refers to other conversions as "casts" too, and calls
4633 actual casts "explicit" casts.)
4634 </pre></td></tr>
4635
4636
4637 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('hasType3')"><a name="hasType3Anchor">hasType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
4638 <tr><td colspan="4" class="doc" id="hasType3"><pre>Overloaded to match the declaration of the expression's or value
4639 declaration's type.
4640
4641 In case of a value declaration (for example a variable declaration),
4642 this resolves one layer of indirection. For example, in the value
4643 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
4644 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
4645 declaration of x.
4646
4647 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
4648             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
4649  class X {};
4650  void y(X &amp;x) { x; X z; }
4651
4652 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;
4653 </pre></td></tr>
4654
4655
4656 <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>
4657 <tr><td colspan="4" class="doc" id="hasType0"><pre>Matches if the expression's or declaration's type matches a type
4658 matcher.
4659
4660 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
4661             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
4662             and U (matcher = typedefDecl(hasType(asString("int")))
4663  class X {};
4664  void y(X &amp;x) { x; X z; }
4665  typedef int U;
4666 </pre></td></tr>
4667
4668
4669 <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>
4670 <tr><td colspan="4" class="doc" id="ignoringImpCasts0"><pre>Matches expressions that match InnerMatcher after any implicit casts
4671 are stripped off.
4672
4673 Parentheses and explicit casts are not discarded.
4674 Given
4675   int arr[5];
4676   int a = 0;
4677   char b = 0;
4678   const int c = a;
4679   int *d = arr;
4680   long e = (long) 0l;
4681 The matchers
4682    varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
4683    varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
4684 would match the declarations for a, b, c, and d, but not e.
4685 While
4686    varDecl(hasInitializer(integerLiteral()))
4687    varDecl(hasInitializer(declRefExpr()))
4688 only match the declarations for b, c, and d.
4689 </pre></td></tr>
4690
4691
4692 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringImplicit0')"><a name="ignoringImplicit0Anchor">ignoringImplicit</a></td><td>ast_matchers::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
4693 <tr><td colspan="4" class="doc" id="ignoringImplicit0"><pre>Matches expressions that match InnerMatcher after any implicit AST
4694 nodes are stripped off.
4695
4696 Parentheses and explicit casts are not discarded.
4697 Given
4698   class C {};
4699   C a = C();
4700   C b;
4701   C c = b;
4702 The matchers
4703    varDecl(hasInitializer(ignoringImplicit(cxxConstructExpr())))
4704 would match the declarations for a, b, and c.
4705 While
4706    varDecl(hasInitializer(cxxConstructExpr()))
4707 only match the declarations for b and c.
4708 </pre></td></tr>
4709
4710
4711 <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>
4712 <tr><td colspan="4" class="doc" id="ignoringParenCasts0"><pre>Matches expressions that match InnerMatcher after parentheses and
4713 casts are stripped off.
4714
4715 Implicit and non-C Style casts are also discarded.
4716 Given
4717   int a = 0;
4718   char b = (0);
4719   void* c = reinterpret_cast&lt;char*&gt;(0);
4720   char d = char(0);
4721 The matcher
4722    varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
4723 would match the declarations for a, b, c, and d.
4724 while
4725    varDecl(hasInitializer(integerLiteral()))
4726 only match the declaration for a.
4727 </pre></td></tr>
4728
4729
4730 <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>
4731 <tr><td colspan="4" class="doc" id="ignoringParenImpCasts0"><pre>Matches expressions that match InnerMatcher after implicit casts and
4732 parentheses are stripped off.
4733
4734 Explicit casts are not discarded.
4735 Given
4736   int arr[5];
4737   int a = 0;
4738   char b = (0);
4739   const int c = a;
4740   int *d = (arr);
4741   long e = ((long) 0l);
4742 The matchers
4743    varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
4744    varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
4745 would match the declarations for a, b, c, and d, but not e.
4746 while
4747    varDecl(hasInitializer(integerLiteral()))
4748    varDecl(hasInitializer(declRefExpr()))
4749 would only match the declaration for a.
4750 </pre></td></tr>
4751
4752
4753 <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>
4754 <tr><td colspan="4" class="doc" id="hasBody1"><pre>Matches a 'for', 'while', 'do while' statement or a function
4755 definition that has a given body.
4756
4757 Given
4758   for (;;) {}
4759 hasBody(compoundStmt())
4760   matches 'for (;;) {}'
4761 with compoundStmt()
4762   matching '{}'
4763 </pre></td></tr>
4764
4765
4766 <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>
4767 <tr><td colspan="4" class="doc" id="hasCondition1"><pre>Matches the condition expression of an if statement, for loop,
4768 switch statement or conditional operator.
4769
4770 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
4771   if (true) {}
4772 </pre></td></tr>
4773
4774
4775 <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>
4776 <tr><td colspan="4" class="doc" id="hasIncrement0"><pre>Matches the increment statement of a for loop.
4777
4778 Example:
4779     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
4780 matches '++x' in
4781     for (x; x &lt; N; ++x) { }
4782 </pre></td></tr>
4783
4784
4785 <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>
4786 <tr><td colspan="4" class="doc" id="hasLoopInit0"><pre>Matches the initialization statement of a for loop.
4787
4788 Example:
4789     forStmt(hasLoopInit(declStmt()))
4790 matches 'int x = 0' in
4791     for (int x = 0; x &lt; N; ++x) { }
4792 </pre></td></tr>
4793
4794
4795 <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>
4796 <tr><td colspan="4" class="doc" id="hasAnyParameter0"><pre>Matches any parameter of a function declaration.
4797
4798 Does not match the 'this' parameter of a method.
4799
4800 Given
4801   class X { void f(int x, int y, int z) {} };
4802 cxxMethodDecl(hasAnyParameter(hasName("y")))
4803   matches f(int x, int y, int z) {}
4804 with hasAnyParameter(...)
4805   matching int y
4806 </pre></td></tr>
4807
4808
4809 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument2')"><a name="hasAnyTemplateArgument2Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
4810 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument2"><pre>Matches classTemplateSpecializations, templateSpecializationType and
4811 functionDecl that have at least one TemplateArgument matching the given
4812 InnerMatcher.
4813
4814 Given
4815   template&lt;typename T&gt; class A {};
4816   template&lt;&gt; class A&lt;double&gt; {};
4817   A&lt;int&gt; a;
4818
4819   template&lt;typename T&gt; f() {};
4820   void func() { f&lt;int&gt;(); };
4821
4822 classTemplateSpecializationDecl(hasAnyTemplateArgument(
4823     refersToType(asString("int"))))
4824   matches the specialization A&lt;int&gt;
4825
4826 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
4827   matches the specialization f&lt;int&gt;
4828 </pre></td></tr>
4829
4830
4831 <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>
4832 <tr><td colspan="4" class="doc" id="hasBody4"><pre>Matches a 'for', 'while', 'do while' statement or a function
4833 definition that has a given body.
4834
4835 Given
4836   for (;;) {}
4837 hasBody(compoundStmt())
4838   matches 'for (;;) {}'
4839 with compoundStmt()
4840   matching '{}'
4841 </pre></td></tr>
4842
4843
4844 <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>
4845 <tr><td colspan="4" class="doc" id="hasParameter0"><pre>Matches the n'th parameter of a function declaration.
4846
4847 Given
4848   class X { void f(int x) {} };
4849 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
4850   matches f(int x) {}
4851 with hasParameter(...)
4852   matching int x
4853 </pre></td></tr>
4854
4855
4856 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument2')"><a name="hasTemplateArgument2Anchor">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>
4857 <tr><td colspan="4" class="doc" id="hasTemplateArgument2"><pre>Matches classTemplateSpecializations, templateSpecializationType and
4858 functionDecl where the n'th TemplateArgument matches the given InnerMatcher.
4859
4860 Given
4861   template&lt;typename T, typename U&gt; class A {};
4862   A&lt;bool, int&gt; b;
4863   A&lt;int, bool&gt; c;
4864
4865   template&lt;typename T&gt; f() {};
4866   void func() { f&lt;int&gt;(); };
4867 classTemplateSpecializationDecl(hasTemplateArgument(
4868     1, refersToType(asString("int"))))
4869   matches the specialization A&lt;bool, int&gt;
4870
4871 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
4872   matches the specialization f&lt;int&gt;
4873 </pre></td></tr>
4874
4875
4876 <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>
4877 <tr><td colspan="4" class="doc" id="returns0"><pre>Matches the return type of a function declaration.
4878
4879 Given:
4880   class X { int f() { return 1; } };
4881 cxxMethodDecl(returns(asString("int")))
4882   matches int f() { return 1; }
4883 </pre></td></tr>
4884
4885
4886 <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>
4887 <tr><td colspan="4" class="doc" id="hasCondition0"><pre>Matches the condition expression of an if statement, for loop,
4888 switch statement or conditional operator.
4889
4890 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
4891   if (true) {}
4892 </pre></td></tr>
4893
4894
4895 <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>
4896 <tr><td colspan="4" class="doc" id="hasConditionVariableStatement0"><pre>Matches the condition variable statement in an if statement.
4897
4898 Given
4899   if (A* a = GetAPointer()) {}
4900 hasConditionVariableStatement(...)
4901   matches 'A* a = GetAPointer()'.
4902 </pre></td></tr>
4903
4904
4905 <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>
4906 <tr><td colspan="4" class="doc" id="hasElse0"><pre>Matches the else-statement of an if statement.
4907
4908 Examples matches the if statement
4909   (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true)))))
4910   if (false) false; else true;
4911 </pre></td></tr>
4912
4913
4914 <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>
4915 <tr><td colspan="4" class="doc" id="hasThen0"><pre>Matches the then-statement of an if statement.
4916
4917 Examples matches the if statement
4918   (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true)))))
4919   if (false) true; else false;
4920 </pre></td></tr>
4921
4922
4923 <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>
4924 <tr><td colspan="4" class="doc" id="hasImplicitDestinationType0"><pre>Matches implicit casts whose destination type matches a given
4925 matcher.
4926
4927 FIXME: Unit test this matcher
4928 </pre></td></tr>
4929
4930
4931 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;</td><td class="name" onclick="toggle('hasSyntacticForm0')"><a name="hasSyntacticForm0Anchor">hasSyntacticForm</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
4932 <tr><td colspan="4" class="doc" id="hasSyntacticForm0"><pre>Matches the syntactic form of init list expressions
4933 (if expression have it).
4934 </pre></td></tr>
4935
4936
4937 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</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>
4938 <tr><td colspan="4" class="doc" id="hasDeclaration10"><pre>Matches a node if the declaration associated with that node
4939 matches the given matcher.
4940
4941 The associated declaration is:
4942 - for type nodes, the declaration of the underlying type
4943 - for CallExpr, the declaration of the callee
4944 - for MemberExpr, the declaration of the referenced member
4945 - for CXXConstructExpr, the declaration of the constructor
4946 - for CXXNewExpr, the declaration of the operator new
4947
4948 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4949 function. e.g. various subtypes of clang::Type and various expressions.
4950
4951 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;,
4952   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4953   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;,
4954   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4955   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4956   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;,
4957   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;
4958 </pre></td></tr>
4959
4960
4961 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</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>
4962 <tr><td colspan="4" class="doc" id="hasDeclaration9"><pre>Matches a node if the declaration associated with that node
4963 matches the given matcher.
4964
4965 The associated declaration is:
4966 - for type nodes, the declaration of the underlying type
4967 - for CallExpr, the declaration of the callee
4968 - for MemberExpr, the declaration of the referenced member
4969 - for CXXConstructExpr, the declaration of the constructor
4970 - for CXXNewExpr, the declaration of the operator new
4971
4972 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4973 function. e.g. various subtypes of clang::Type and various expressions.
4974
4975 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;,
4976   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
4977   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;,
4978   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
4979   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
4980   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;,
4981   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;
4982 </pre></td></tr>
4983
4984
4985 <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>
4986 <tr><td colspan="4" class="doc" id="hasDeclaration7"><pre>Matches a node if the declaration associated with that node
4987 matches the given matcher.
4988
4989 The associated declaration is:
4990 - for type nodes, the declaration of the underlying type
4991 - for CallExpr, the declaration of the callee
4992 - for MemberExpr, the declaration of the referenced member
4993 - for CXXConstructExpr, the declaration of the constructor
4994 - for CXXNewExpr, the declaration of the operator new
4995
4996 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
4997 function. e.g. various subtypes of clang::Type and various expressions.
4998
4999 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;,
5000   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5001   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;,
5002   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5003   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5004   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;,
5005   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;
5006 </pre></td></tr>
5007
5008
5009 <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>
5010 <tr><td colspan="4" class="doc" id="hasObjectExpression0"><pre>Matches a member expression where the object expression is
5011 matched by a given matcher.
5012
5013 Given
5014   struct X { int m; };
5015   void f(X x) { x.m; m; }
5016 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))))
5017   matches "x.m" and "m"
5018 with hasObjectExpression(...)
5019   matching "x" and the implicit object expression of "m" which has type X*.
5020 </pre></td></tr>
5021
5022
5023 <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>
5024 <tr><td colspan="4" class="doc" id="member0"><pre>Matches a member expression where the member is matched by a
5025 given matcher.
5026
5027 Given
5028   struct { int first, second; } first, second;
5029   int i(second.first);
5030   int j(first.second);
5031 memberExpr(member(hasName("first")))
5032   matches second.first
5033   but not first.second (because the member name there is "second").
5034 </pre></td></tr>
5035
5036
5037 <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>
5038 <tr><td colspan="4" class="doc" id="pointeeLoc1"><pre>Narrows PointerType (and similar) matchers to those where the
5039 pointee matches a given matcher.
5040
5041 Given
5042   int *a;
5043   int const *b;
5044   float const *f;
5045 pointerType(pointee(isConstQualified(), isInteger()))
5046   matches "int const *b"
5047
5048 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;,
5049   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;
5050 </pre></td></tr>
5051
5052
5053 <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>
5054 <tr><td colspan="4" class="doc" id="pointee1"><pre>Narrows PointerType (and similar) matchers to those where the
5055 pointee matches a given matcher.
5056
5057 Given
5058   int *a;
5059   int const *b;
5060   float const *f;
5061 pointerType(pointee(isConstQualified(), isInteger()))
5062   matches "int const *b"
5063
5064 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;,
5065   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;
5066 </pre></td></tr>
5067
5068
5069 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasUnderlyingDecl0')"><a name="hasUnderlyingDecl0Anchor">hasUnderlyingDecl</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; InnerMatcher</td></tr>
5070 <tr><td colspan="4" class="doc" id="hasUnderlyingDecl0"><pre>Matches a NamedDecl whose underlying declaration matches the given
5071 matcher.
5072
5073 Given
5074   namespace N { template&lt;class T&gt; void f(T t); }
5075   template &lt;class T&gt; void g() { using N::f; f(T()); }
5076 unresolvedLookupExpr(hasAnyDeclaration(
5077     namedDecl(hasUnderlyingDecl(hasName("::N::f")))))
5078   matches the use of f in g() .
5079 </pre></td></tr>
5080
5081
5082 <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>
5083 <tr><td colspan="4" class="doc" id="hasPrefix1"><pre>Matches on the prefix of a NestedNameSpecifierLoc.
5084
5085 Given
5086   struct A { struct B { struct C {}; }; };
5087   A::B::C c;
5088 nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
5089   matches "A::"
5090 </pre></td></tr>
5091
5092
5093 <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>
5094 <tr><td colspan="4" class="doc" id="specifiesTypeLoc0"><pre>Matches nested name specifier locs that specify a type matching the
5095 given TypeLoc.
5096
5097 Given
5098   struct A { struct B { struct C {}; }; };
5099   A::B::C c;
5100 nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
5101   hasDeclaration(cxxRecordDecl(hasName("A")))))))
5102   matches "A::"
5103 </pre></td></tr>
5104
5105
5106 <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>
5107 <tr><td colspan="4" class="doc" id="hasPrefix0"><pre>Matches on the prefix of a NestedNameSpecifier.
5108
5109 Given
5110   struct A { struct B { struct C {}; }; };
5111   A::B::C c;
5112 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
5113   matches "A::"
5114 </pre></td></tr>
5115
5116
5117 <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>
5118 <tr><td colspan="4" class="doc" id="specifiesNamespace0"><pre>Matches nested name specifiers that specify a namespace matching the
5119 given namespace matcher.
5120
5121 Given
5122   namespace ns { struct A {}; }
5123   ns::A a;
5124 nestedNameSpecifier(specifiesNamespace(hasName("ns")))
5125   matches "ns::"
5126 </pre></td></tr>
5127
5128
5129 <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>
5130 <tr><td colspan="4" class="doc" id="specifiesType0"><pre>Matches nested name specifiers that specify a type matching the
5131 given QualType matcher without qualifiers.
5132
5133 Given
5134   struct A { struct B { struct C {}; }; };
5135   A::B::C c;
5136 nestedNameSpecifier(specifiesType(
5137   hasDeclaration(cxxRecordDecl(hasName("A")))
5138 ))
5139   matches "A::"
5140 </pre></td></tr>
5141
5142
5143 <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>
5144 <tr><td colspan="4" class="doc" id="hasArgument2"><pre>Matches the n'th argument of a call expression or a constructor
5145 call expression.
5146
5147 Example matches y in x(y)
5148     (matcher = callExpr(hasArgument(0, declRefExpr())))
5149   void x(int) { int y; x(y); }
5150 </pre></td></tr>
5151
5152
5153 <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>
5154 <tr><td colspan="4" class="doc" id="hasReceiverType0"><pre>Matches on the receiver of an ObjectiveC Message expression.
5155
5156 Example
5157 matcher = objCMessageExpr(hasRecieverType(asString("UIWebView *")));
5158 matches the [webView ...] message invocation.
5159   NSString *webViewJavaScript = ...
5160   UIWebView *webView = ...
5161   [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
5162 </pre></td></tr>
5163
5164
5165 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1OpaqueValueExpr.html">OpaqueValueExpr</a>&gt;</td><td class="name" onclick="toggle('hasSourceExpression1')"><a name="hasSourceExpression1Anchor">hasSourceExpression</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
5166 <tr><td colspan="4" class="doc" id="hasSourceExpression1"><pre></pre></td></tr>
5167
5168
5169 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1OverloadExpr.html">OverloadExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyDeclaration0')"><a name="hasAnyDeclaration0Anchor">hasAnyDeclaration</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
5170 <tr><td colspan="4" class="doc" id="hasAnyDeclaration0"><pre>Matches an OverloadExpr if any of the declarations in the set of
5171 overloads matches the given matcher.
5172
5173 Given
5174   template &lt;typename T&gt; void foo(T);
5175   template &lt;typename T&gt; void bar(T);
5176   template &lt;typename T&gt; void baz(T t) {
5177     foo(t);
5178     bar(t);
5179   }
5180 unresolvedLookupExpr(hasAnyDeclaration(
5181     functionTemplateDecl(hasName("foo"))))
5182   matches foo in foo(t); but not bar in bar(t);
5183 </pre></td></tr>
5184
5185
5186 <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>
5187 <tr><td colspan="4" class="doc" id="innerType0"><pre>Matches ParenType nodes where the inner type is a specific type.
5188
5189 Given
5190   int (*ptr_to_array)[4];
5191   int (*ptr_to_func)(int);
5192
5193 varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
5194 ptr_to_func but not ptr_to_array.
5195
5196 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;
5197 </pre></td></tr>
5198
5199
5200 <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>
5201 <tr><td colspan="4" class="doc" id="pointeeLoc2"><pre>Narrows PointerType (and similar) matchers to those where the
5202 pointee matches a given matcher.
5203
5204 Given
5205   int *a;
5206   int const *b;
5207   float const *f;
5208 pointerType(pointee(isConstQualified(), isInteger()))
5209   matches "int const *b"
5210
5211 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;,
5212   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;
5213 </pre></td></tr>
5214
5215
5216 <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>
5217 <tr><td colspan="4" class="doc" id="pointee2"><pre>Narrows PointerType (and similar) matchers to those where the
5218 pointee matches a given matcher.
5219
5220 Given
5221   int *a;
5222   int const *b;
5223   float const *f;
5224 pointerType(pointee(isConstQualified(), isInteger()))
5225   matches "int const *b"
5226
5227 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;,
5228   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;
5229 </pre></td></tr>
5230
5231
5232 <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>
5233 <tr><td colspan="4" class="doc" id="hasCanonicalType0"><pre>Matches QualTypes whose canonical type matches InnerMatcher.
5234
5235 Given:
5236   typedef int &amp;int_ref;
5237   int a;
5238   int_ref b = a;
5239
5240 varDecl(hasType(qualType(referenceType()))))) will not match the
5241 declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
5242 </pre></td></tr>
5243
5244
5245 <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>
5246 <tr><td colspan="4" class="doc" id="hasDeclaration6"><pre>Matches a node if the declaration associated with that node
5247 matches the given matcher.
5248
5249 The associated declaration is:
5250 - for type nodes, the declaration of the underlying type
5251 - for CallExpr, the declaration of the callee
5252 - for MemberExpr, the declaration of the referenced member
5253 - for CXXConstructExpr, the declaration of the constructor
5254 - for CXXNewExpr, the declaration of the operator new
5255
5256 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5257 function. e.g. various subtypes of clang::Type and various expressions.
5258
5259 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;,
5260   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5261   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;,
5262   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5263   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5264   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;,
5265   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;
5266 </pre></td></tr>
5267
5268
5269 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('ignoringParens0')"><a name="ignoringParens0Anchor">ignoringParens</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
5270 <tr><td colspan="4" class="doc" id="ignoringParens0"><pre>Matches types that match InnerMatcher after any parens are stripped.
5271
5272 Given
5273   void (*fp)(void);
5274 The matcher
5275   varDecl(hasType(pointerType(pointee(ignoringParens(functionType())))))
5276 would match the declaration for fp.
5277 </pre></td></tr>
5278
5279
5280 <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>
5281 <tr><td colspan="4" class="doc" id="pointsTo1"><pre>Overloaded to match the pointee type's declaration.
5282 </pre></td></tr>
5283
5284
5285 <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>
5286 <tr><td colspan="4" class="doc" id="pointsTo0"><pre>Matches if the matched type is a pointer type and the pointee type
5287 matches the specified matcher.
5288
5289 Example matches y-&gt;x()
5290   (matcher = cxxMemberCallExpr(on(hasType(pointsTo
5291      cxxRecordDecl(hasName("Y")))))))
5292   class Y { public: void x(); };
5293   void z() { Y *y; y-&gt;x(); }
5294 </pre></td></tr>
5295
5296
5297 <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>
5298 <tr><td colspan="4" class="doc" id="references1"><pre>Overloaded to match the referenced type's declaration.
5299 </pre></td></tr>
5300
5301
5302 <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>
5303 <tr><td colspan="4" class="doc" id="references0"><pre>Matches if the matched type is a reference type and the referenced
5304 type matches the specified matcher.
5305
5306 Example matches X &amp;x and const X &amp;y
5307     (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X"))))))
5308   class X {
5309     void a(X b) {
5310       X &amp;x = b;
5311       const X &amp;y = b;
5312     }
5313   };
5314 </pre></td></tr>
5315
5316
5317 <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>
5318 <tr><td colspan="4" class="doc" id="hasDeclaration5"><pre>Matches a node if the declaration associated with that node
5319 matches the given matcher.
5320
5321 The associated declaration is:
5322 - for type nodes, the declaration of the underlying type
5323 - for CallExpr, the declaration of the callee
5324 - for MemberExpr, the declaration of the referenced member
5325 - for CXXConstructExpr, the declaration of the constructor
5326 - for CXXNewExpr, the declaration of the operator new
5327
5328 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5329 function. e.g. various subtypes of clang::Type and various expressions.
5330
5331 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;,
5332   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5333   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;,
5334   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5335   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5336   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;,
5337   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;
5338 </pre></td></tr>
5339
5340
5341 <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>
5342 <tr><td colspan="4" class="doc" id="pointeeLoc3"><pre>Narrows PointerType (and similar) matchers to those where the
5343 pointee matches a given matcher.
5344
5345 Given
5346   int *a;
5347   int const *b;
5348   float const *f;
5349 pointerType(pointee(isConstQualified(), isInteger()))
5350   matches "int const *b"
5351
5352 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;,
5353   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;
5354 </pre></td></tr>
5355
5356
5357 <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>
5358 <tr><td colspan="4" class="doc" id="pointee3"><pre>Narrows PointerType (and similar) matchers to those where the
5359 pointee matches a given matcher.
5360
5361 Given
5362   int *a;
5363   int const *b;
5364   float const *f;
5365 pointerType(pointee(isConstQualified(), isInteger()))
5366   matches "int const *b"
5367
5368 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;,
5369   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;
5370 </pre></td></tr>
5371
5372
5373 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ReturnStmt.html">ReturnStmt</a>&gt;</td><td class="name" onclick="toggle('hasReturnValue0')"><a name="hasReturnValue0Anchor">hasReturnValue</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
5374 <tr><td colspan="4" class="doc" id="hasReturnValue0"><pre>Matches the return value expression of a return statement
5375
5376 Given
5377   return a + b;
5378 hasReturnValue(binaryOperator())
5379   matches 'return a + b'
5380 with binaryOperator()
5381   matching 'a + b'
5382 </pre></td></tr>
5383
5384
5385 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1StmtExpr.html">StmtExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnySubstatement1')"><a name="hasAnySubstatement1Anchor">hasAnySubstatement</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
5386 <tr><td colspan="4" class="doc" id="hasAnySubstatement1"><pre>Matches compound statements where at least one substatement matches
5387 a given matcher. Also matches StmtExprs that have CompoundStmt as children.
5388
5389 Given
5390   { {}; 1+2; }
5391 hasAnySubstatement(compoundStmt())
5392   matches '{ {}; 1+2; }'
5393 with compoundStmt()
5394   matching '{}'
5395 </pre></td></tr>
5396
5397
5398 <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>
5399 <tr><td colspan="4" class="doc" id="alignOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
5400 alignof.
5401 </pre></td></tr>
5402
5403
5404 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forFunction0')"><a name="forFunction0Anchor">forFunction</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt; InnerMatcher</td></tr>
5405 <tr><td colspan="4" class="doc" id="forFunction0"><pre>Matches declaration of the function the statemenet belongs to
5406
5407 Given:
5408 F&amp; operator=(const F&amp; o) {
5409   std::copy_if(o.begin(), o.end(), begin(), [](V v) { return v &gt; 0; });
5410   return *this;
5411 }
5412 returnStmt(forFunction(hasName("operator=")))
5413   matches 'return *this'
5414   but does match 'return &gt; 0'
5415 </pre></td></tr>
5416
5417
5418 <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>
5419 <tr><td colspan="4" class="doc" id="sizeOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
5420 sizeof.
5421 </pre></td></tr>
5422
5423
5424 <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>
5425 <tr><td colspan="4" class="doc" id="forEachSwitchCase0"><pre>Matches each case or default statement belonging to the given switch
5426 statement. This matcher may produce multiple matches.
5427
5428 Given
5429   switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
5430 switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
5431   matches four times, with "c" binding each of "case 1:", "case 2:",
5432 "case 3:" and "case 4:", and "s" respectively binding "switch (1)",
5433 "switch (1)", "switch (2)" and "switch (2)".
5434 </pre></td></tr>
5435
5436
5437 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</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>
5438 <tr><td colspan="4" class="doc" id="hasCondition4"><pre>Matches the condition expression of an if statement, for loop,
5439 switch statement or conditional operator.
5440
5441 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
5442   if (true) {}
5443 </pre></td></tr>
5444
5445
5446 <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>
5447 <tr><td colspan="4" class="doc" id="hasDeclaration4"><pre>Matches a node if the declaration associated with that node
5448 matches the given matcher.
5449
5450 The associated declaration is:
5451 - for type nodes, the declaration of the underlying type
5452 - for CallExpr, the declaration of the callee
5453 - for MemberExpr, the declaration of the referenced member
5454 - for CXXConstructExpr, the declaration of the constructor
5455 - for CXXNewExpr, the declaration of the operator new
5456
5457 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5458 function. e.g. various subtypes of clang::Type and various expressions.
5459
5460 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;,
5461   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5462   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;,
5463   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5464   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5465   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;,
5466   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;
5467 </pre></td></tr>
5468
5469
5470 <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>
5471 <tr><td colspan="4" class="doc" id="isExpr0"><pre>Matches a sugar TemplateArgument that refers to a certain expression.
5472
5473 Given
5474   template&lt;typename T&gt; struct A {};
5475   struct B { B* next; };
5476   A&lt;&amp;B::next&gt; a;
5477 templateSpecializationType(hasAnyTemplateArgument(
5478   isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
5479   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
5480     B::next
5481 </pre></td></tr>
5482
5483
5484 <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>
5485 <tr><td colspan="4" class="doc" id="refersToDeclaration0"><pre>Matches a canonical TemplateArgument that refers to a certain
5486 declaration.
5487
5488 Given
5489   template&lt;typename T&gt; struct A {};
5490   struct B { B* next; };
5491   A&lt;&amp;B::next&gt; a;
5492 classTemplateSpecializationDecl(hasAnyTemplateArgument(
5493     refersToDeclaration(fieldDecl(hasName("next"))))
5494   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
5495     B::next
5496 </pre></td></tr>
5497
5498
5499 <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>
5500 <tr><td colspan="4" class="doc" id="refersToIntegralType0"><pre>Matches a TemplateArgument that referes to an integral type.
5501
5502 Given
5503   template&lt;int T&gt; struct A {};
5504   C&lt;42&gt; c;
5505 classTemplateSpecializationDecl(
5506   hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
5507   matches the implicit instantiation of C in C&lt;42&gt;.
5508 </pre></td></tr>
5509
5510
5511 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToTemplate0')"><a name="refersToTemplate0Anchor">refersToTemplate</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt; InnerMatcher</td></tr>
5512 <tr><td colspan="4" class="doc" id="refersToTemplate0"><pre>Matches a TemplateArgument that refers to a certain template.
5513
5514 Given
5515   template&lt;template &lt;typename&gt; class S&gt; class X {};
5516   template&lt;typename T&gt; class Y {};"
5517   X&lt;Y&gt; xi;
5518 classTemplateSpecializationDecl(hasAnyTemplateArgument(
5519     refersToTemplate(templateName())))
5520   matches the specialization X&lt;Y&gt;
5521 </pre></td></tr>
5522
5523
5524 <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>
5525 <tr><td colspan="4" class="doc" id="refersToType0"><pre>Matches a TemplateArgument that refers to a certain type.
5526
5527 Given
5528   struct X {};
5529   template&lt;typename T&gt; struct A {};
5530   A&lt;X&gt; a;
5531 classTemplateSpecializationDecl(hasAnyTemplateArgument(
5532     refersToType(class(hasName("X")))))
5533   matches the specialization A&lt;X&gt;
5534 </pre></td></tr>
5535
5536
5537 <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>
5538 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument1"><pre>Matches classTemplateSpecializations, templateSpecializationType and
5539 functionDecl that have at least one TemplateArgument matching the given
5540 InnerMatcher.
5541
5542 Given
5543   template&lt;typename T&gt; class A {};
5544   template&lt;&gt; class A&lt;double&gt; {};
5545   A&lt;int&gt; a;
5546
5547   template&lt;typename T&gt; f() {};
5548   void func() { f&lt;int&gt;(); };
5549
5550 classTemplateSpecializationDecl(hasAnyTemplateArgument(
5551     refersToType(asString("int"))))
5552   matches the specialization A&lt;int&gt;
5553
5554 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
5555   matches the specialization f&lt;int&gt;
5556 </pre></td></tr>
5557
5558
5559 <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>
5560 <tr><td colspan="4" class="doc" id="hasDeclaration3"><pre>Matches a node if the declaration associated with that node
5561 matches the given matcher.
5562
5563 The associated declaration is:
5564 - for type nodes, the declaration of the underlying type
5565 - for CallExpr, the declaration of the callee
5566 - for MemberExpr, the declaration of the referenced member
5567 - for CXXConstructExpr, the declaration of the constructor
5568 - for CXXNewExpr, the declaration of the operator new
5569
5570 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5571 function. e.g. various subtypes of clang::Type and various expressions.
5572
5573 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;,
5574   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5575   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;,
5576   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5577   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5578   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;,
5579   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;
5580 </pre></td></tr>
5581
5582
5583 <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>
5584 <tr><td colspan="4" class="doc" id="hasTemplateArgument1"><pre>Matches classTemplateSpecializations, templateSpecializationType and
5585 functionDecl where the n'th TemplateArgument matches the given InnerMatcher.
5586
5587 Given
5588   template&lt;typename T, typename U&gt; class A {};
5589   A&lt;bool, int&gt; b;
5590   A&lt;int, bool&gt; c;
5591
5592   template&lt;typename T&gt; f() {};
5593   void func() { f&lt;int&gt;(); };
5594 classTemplateSpecializationDecl(hasTemplateArgument(
5595     1, refersToType(asString("int"))))
5596   matches the specialization A&lt;bool, int&gt;
5597
5598 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
5599   matches the specialization f&lt;int&gt;
5600 </pre></td></tr>
5601
5602
5603 <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>
5604 <tr><td colspan="4" class="doc" id="hasDeclaration2"><pre>Matches a node if the declaration associated with that node
5605 matches the given matcher.
5606
5607 The associated declaration is:
5608 - for type nodes, the declaration of the underlying type
5609 - for CallExpr, the declaration of the callee
5610 - for MemberExpr, the declaration of the referenced member
5611 - for CXXConstructExpr, the declaration of the constructor
5612 - for CXXNewExpr, the declaration of the operator new
5613
5614 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5615 function. e.g. various subtypes of clang::Type and various expressions.
5616
5617 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;,
5618   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5619   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;,
5620   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5621   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5622   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;,
5623   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;
5624 </pre></td></tr>
5625
5626
5627 <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>
5628 <tr><td colspan="4" class="doc" id="findAll0"><pre>Matches if the node or any descendant matches.
5629
5630 Generates results for each match.
5631
5632 For example, in:
5633   class A { class B {}; class C {}; };
5634 The matcher:
5635   cxxRecordDecl(hasName("::A"),
5636                 findAll(cxxRecordDecl(isDefinition()).bind("m")))
5637 will generate results for A, B and C.
5638
5639 Usable as: Any Matcher
5640 </pre></td></tr>
5641
5642
5643 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</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>
5644 <tr><td colspan="4" class="doc" id="hasType1"><pre>Matches if the expression's or declaration's type matches a type
5645 matcher.
5646
5647 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
5648             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
5649             and U (matcher = typedefDecl(hasType(asString("int")))
5650  class X {};
5651  void y(X &amp;x) { x; X z; }
5652  typedef int U;
5653 </pre></td></tr>
5654
5655
5656 <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>
5657 <tr><td colspan="4" class="doc" id="hasDeclaration1"><pre>Matches a node if the declaration associated with that node
5658 matches the given matcher.
5659
5660 The associated declaration is:
5661 - for type nodes, the declaration of the underlying type
5662 - for CallExpr, the declaration of the callee
5663 - for MemberExpr, the declaration of the referenced member
5664 - for CXXConstructExpr, the declaration of the constructor
5665 - for CXXNewExpr, the declaration of the operator new
5666
5667 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5668 function. e.g. various subtypes of clang::Type and various expressions.
5669
5670 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;,
5671   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5672   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;,
5673   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5674   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5675   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;,
5676   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;
5677 </pre></td></tr>
5678
5679
5680 <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>
5681 <tr><td colspan="4" class="doc" id="hasArgumentOfType0"><pre>Matches unary expressions that have a specific type of argument.
5682
5683 Given
5684   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
5685 unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
5686   matches sizeof(a) and alignof(c)
5687 </pre></td></tr>
5688
5689
5690 <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>
5691 <tr><td colspan="4" class="doc" id="hasUnaryOperand0"><pre>Matches if the operand of a unary operator matches.
5692
5693 Example matches true (matcher = hasUnaryOperand(
5694                                   cxxBoolLiteral(equals(true))))
5695   !true
5696 </pre></td></tr>
5697
5698
5699 <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>
5700 <tr><td colspan="4" class="doc" id="hasDeclaration0"><pre>Matches a node if the declaration associated with that node
5701 matches the given matcher.
5702
5703 The associated declaration is:
5704 - for type nodes, the declaration of the underlying type
5705 - for CallExpr, the declaration of the callee
5706 - for MemberExpr, the declaration of the referenced member
5707 - for CXXConstructExpr, the declaration of the constructor
5708 - for CXXNewExpr, the declaration of the operator new
5709
5710 Also usable as Matcher&lt;T&gt; for any T supporting the getDecl() member
5711 function. e.g. various subtypes of clang::Type and various expressions.
5712
5713 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;,
5714   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;,
5715   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;,
5716   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_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;,
5717   Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;,
5718   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;,
5719   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;
5720 </pre></td></tr>
5721
5722
5723 <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>
5724 <tr><td colspan="4" class="doc" id="hasAnyUsingShadowDecl0"><pre>Matches any using shadow declaration.
5725
5726 Given
5727   namespace X { void b(); }
5728   using X::b;
5729 usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
5730   matches using X::b </pre></td></tr>
5731
5732
5733 <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>
5734 <tr><td colspan="4" class="doc" id="hasTargetDecl0"><pre>Matches a using shadow declaration where the target declaration is
5735 matched by the given matcher.
5736
5737 Given
5738   namespace X { int a; void b(); }
5739   using X::a;
5740   using X::b;
5741 usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
5742   matches using X::b but not using X::a </pre></td></tr>
5743
5744
5745 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;</td><td class="name" onclick="toggle('hasType4')"><a name="hasType4Anchor">hasType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
5746 <tr><td colspan="4" class="doc" id="hasType4"><pre>Overloaded to match the declaration of the expression's or value
5747 declaration's type.
5748
5749 In case of a value declaration (for example a variable declaration),
5750 this resolves one layer of indirection. For example, in the value
5751 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
5752 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
5753 declaration of x.
5754
5755 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
5756             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
5757  class X {};
5758  void y(X &amp;x) { x; X z; }
5759
5760 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;
5761 </pre></td></tr>
5762
5763
5764 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;</td><td class="name" onclick="toggle('hasType2')"><a name="hasType2Anchor">hasType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
5765 <tr><td colspan="4" class="doc" id="hasType2"><pre>Matches if the expression's or declaration's type matches a type
5766 matcher.
5767
5768 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
5769             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
5770             and U (matcher = typedefDecl(hasType(asString("int")))
5771  class X {};
5772  void y(X &amp;x) { x; X z; }
5773  typedef int U;
5774 </pre></td></tr>
5775
5776
5777 <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>
5778 <tr><td colspan="4" class="doc" id="hasInitializer0"><pre>Matches a variable declaration that has an initializer expression
5779 that matches the given matcher.
5780
5781 Example matches x (matcher = varDecl(hasInitializer(callExpr())))
5782   bool y() { return true; }
5783   bool x = y();
5784 </pre></td></tr>
5785
5786
5787 <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>
5788 <tr><td colspan="4" class="doc" id="hasSizeExpr0"><pre>Matches VariableArrayType nodes that have a specific size
5789 expression.
5790
5791 Given
5792   void f(int b) {
5793     int a[b];
5794   }
5795 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
5796   varDecl(hasName("b")))))))
5797   matches "int a[b]"
5798 </pre></td></tr>
5799
5800
5801 <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>
5802 <tr><td colspan="4" class="doc" id="hasBody2"><pre>Matches a 'for', 'while', 'do while' statement or a function
5803 definition that has a given body.
5804
5805 Given
5806   for (;;) {}
5807 hasBody(compoundStmt())
5808   matches 'for (;;) {}'
5809 with compoundStmt()
5810   matching '{}'
5811 </pre></td></tr>
5812
5813
5814 <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>
5815 <tr><td colspan="4" class="doc" id="hasCondition2"><pre>Matches the condition expression of an if statement, for loop,
5816 switch statement or conditional operator.
5817
5818 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
5819   if (true) {}
5820 </pre></td></tr>
5821
5822
5823 <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>
5824 <tr><td colspan="4" class="doc" id="loc1"><pre>Matches NestedNameSpecifierLocs for which the given inner
5825 NestedNameSpecifier-matcher matches.
5826 </pre></td></tr>
5827
5828
5829 <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>
5830 <tr><td colspan="4" class="doc" id="loc0"><pre>Matches TypeLocs for which the given inner
5831 QualType-matcher matches.
5832 </pre></td></tr>
5833
5834 <!--END_TRAVERSAL_MATCHERS -->
5835 </table>
5836
5837 </div>
5838 </body>
5839 </html>
5840
5841