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