granicus.if.org Git - clang/blob - docs/LibASTMatchersReference.html

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