clang/docs/LibASTMatchersReference.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
   2           "http://www.w3.org/TR/html4/strict.dtd">
   3 <html>
   4 <head>
   5 <title>AST Matcher Reference</title>
   6 <link type="text/css" rel="stylesheet" href="../menu.css" />
   7 <link type="text/css" rel="stylesheet" href="../content.css" />
   8 <style type="text/css">
   9 td {
  10   padding: .33em;
  11 }
  12 td.doc {
  13   display: none;
  14   border-bottom: 1px solid black;
  15 }
  16 td.name:hover {
  17   color: blue;
  18   cursor: pointer;
  19 }
  20 </style>
  21 <script type="text/javascript">
  22 function toggle(id) {
  23   if (!id) return;
  24   row = document.getElementById(id);
  25   if (row.style.display != 'table-cell')
  26     row.style.display = 'table-cell';
  27   else
  28     row.style.display = 'none';
  29 }
  30 </script>
  31 </head>
  32 <body onLoad="toggle(location.hash.substring(1, location.hash.length - 6))">
  33
  34 <!--#include virtual="../menu.html.incl"-->
  35
  36 <div id="content">
  37
  38 <h1>AST Matcher Reference</h1>
  39
  40 <p>This document shows all currently implemented matchers. The matchers are grouped
  41 by category and node type they match. You can click on matcher names to show the
  42 matcher's source documentation.</p>
  43
  44 <p>There are three different basic categories of matchers:
  45 <ul>
  46 <li><a href="#decl-matchers">Node Matchers:</a> Matchers that match a specific type of AST node.</li>
  47 <li><a href="#narrowing-matchers">Narrowing Matchers:</a> Matchers that match attributes on AST nodes.</li>
  48 <li><a href="#traversal-matchers">Traversal Matchers:</a> Matchers that allow traversal between AST nodes.</li>
  49 </ul>
  50 </p>
  51
  52 <p>Within each category the matchers are ordered by node type they match on.
  53 Note that if a matcher can match multiple node types, it will appear
  54 multiple times. This means that by searching for Matcher&lt;Stmt&gt; you can
  55 find all matchers that can be used to match on Stmt nodes.</p>
  56
  57 <p>The exception to that rule are matchers that can match on any node. Those
  58 are marked with a * and are listed in the beginning of each category.</p>
  59
  60 <p>Note that the categorization of matchers is a great help when you combine
  61 them into matcher expressions. You will usually want to form matcher expressions
  62 that read like english sentences by alternating between node matchers and
  63 narrowing or traversal matchers, like this:
  64 <pre>
  65 recordDecl(hasDescendant(
  66     ifStmt(hasTrueExpression(
  67         expr(hasDescendant(
  68             ifStmt()))))))
  69 </pre>
  70 </p>
  71
  72 <!-- ======================================================================= -->
  73 <h2 id="decl-matchers">Node Matchers</h2>
  74 <!-- ======================================================================= -->
  75
  76 <p>Node matchers are at the core of matcher expressions - they specify the type
  77 of node that is expected. Every match expression starts with a node matcher,
  78 which can then be further refined with a narrowing or traversal matcher. All
  79 traversal matchers take node matchers as their arguments.</p>
  80
  81 <p>For convenience, all node matchers take an arbitrary number of arguments
  82 and implicitly act as allOf matchers.</p>
  83
  84 <p>Node matchers are the only matchers that support the bind("id") call to
  85 bind the matched node to the given string, to be later retrieved from the
  86 match callback.</p>
  87
  88 <p>It is important to remember that the arguments to node matchers are
  89 predicates on the same node, just with additional information about the type.
  90 This is often useful to make matcher expression more readable by inlining bind
  91 calls into redundant node matchers inside another node matcher:
  92 <pre>
  93 // This binds the CXXRecordDecl to "id", as the decl() matcher will stay on
  94 // the same node.
  95 recordDecl(decl().bind("id"), hasName("::MyClass"))
  96 </pre>
  97 </p>
  98
  99 <table>
 100 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
 101 <!-- START_DECL_MATCHERS -->
 102
 103 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;...</td></tr>
 104 <tr><td colspan="4" class="doc" id="cxxCtorInitializer0"><pre>Matches constructor initializers.
 105
 106 Examples matches i(42).
 107   class C {
 108     C() : i(42) {}
 109     int i;
 110   };
 111 </pre></td></tr>
 112
 113
 114 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1AccessSpecDecl.html">AccessSpecDecl</a>&gt;...</td></tr>
 115 <tr><td colspan="4" class="doc" id="accessSpecDecl0"><pre>Matches C++ access specifier declarations.
 116
 117 Given
 118   class C {
 119   public:
 120     int a;
 121   };
 122 accessSpecDecl()
 123   matches 'public:'
 124 </pre></td></tr>
 125
 126
 127 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('blockDecl0')"><a name="blockDecl0Anchor">blockDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;...</td></tr>
 128 <tr><td colspan="4" class="doc" id="blockDecl0"><pre>Matches block declarations.
 129
 130 Example matches the declaration of the nameless block printing an input
 131 integer.
 132
 133   myFunc(^(int p) {
 134     printf("%d", p);
 135   })
 136 </pre></td></tr>
 137
 138
 139 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateDecl.html">ClassTemplateDecl</a>&gt;...</td></tr>
 140 <tr><td colspan="4" class="doc" id="classTemplateDecl0"><pre>Matches C++ class template declarations.
 141
 142 Example matches Z
 143   template&lt;class T&gt; class Z {};
 144 </pre></td></tr>
 145
 146
 147 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('classTemplatePartialSpecializationDecl0')"><a name="classTemplatePartialSpecializationDecl0Anchor">classTemplatePartialSpecializationDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplatePartialSpecializationDecl.html">ClassTemplatePartialSpecializationDecl</a>&gt;...</td></tr>
 148 <tr><td colspan="4" class="doc" id="classTemplatePartialSpecializationDecl0"><pre>Matches C++ class template partial specializations.
 149
 150 Given
 151   template&lt;class T1, class T2, int I&gt;
 152   class A {};
 153
 154   template&lt;class T, int I&gt;
 155   class A&lt;T, T*, I&gt; {};
 156
 157   template&lt;&gt;
 158   class A&lt;int, int, 1&gt; {};
 159 classTemplatePartialSpecializationDecl()
 160   matches the specialization A&lt;T,T*,I&gt; but not A&lt;int,int,1&gt;
 161 </pre></td></tr>
 162
 163
 164 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;...</td></tr>
 165 <tr><td colspan="4" class="doc" id="classTemplateSpecializationDecl0"><pre>Matches C++ class template specializations.
 166
 167 Given
 168   template&lt;typename T&gt; class A {};
 169   template&lt;&gt; class A&lt;double&gt; {};
 170   A&lt;int&gt; a;
 171 classTemplateSpecializationDecl()
 172   matches the specializations A&lt;int&gt; and A&lt;double&gt;
 173 </pre></td></tr>
 174
 175
 176 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;...</td></tr>
 177 <tr><td colspan="4" class="doc" id="cxxConstructorDecl0"><pre>Matches C++ constructor declarations.
 178
 179 Example matches Foo::Foo() and Foo::Foo(int)
 180   class Foo {
 181    public:
 182     Foo();
 183     Foo(int);
 184     int DoSomething();
 185   };
 186 </pre></td></tr>
 187
 188
 189 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXConversionDecl.html">CXXConversionDecl</a>&gt;...</td></tr>
 190 <tr><td colspan="4" class="doc" id="cxxConversionDecl0"><pre>Matches conversion operator declarations.
 191
 192 Example matches the operator.
 193   class X { operator int() const; };
 194 </pre></td></tr>
 195
 196
 197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxDeductionGuideDecl0')"><a name="cxxDeductionGuideDecl0Anchor">cxxDeductionGuideDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDeductionGuideDecl.html">CXXDeductionGuideDecl</a>&gt;...</td></tr>
 198 <tr><td colspan="4" class="doc" id="cxxDeductionGuideDecl0"><pre>Matches user-defined and implicitly generated deduction guide.
 199
 200 Example matches the deduction guide.
 201   template&lt;typename T&gt;
 202   class X { X(int) };
 203   X(int) -&gt; X&lt;int&gt;;
 204 </pre></td></tr>
 205
 206
 207 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXDestructorDecl.html">CXXDestructorDecl</a>&gt;...</td></tr>
 208 <tr><td colspan="4" class="doc" id="cxxDestructorDecl0"><pre>Matches explicit C++ destructor declarations.
 209
 210 Example matches Foo::~Foo()
 211   class Foo {
 212    public:
 213     virtual ~Foo();
 214   };
 215 </pre></td></tr>
 216
 217
 218 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;...</td></tr>
 219 <tr><td colspan="4" class="doc" id="cxxMethodDecl0"><pre>Matches method declarations.
 220
 221 Example matches y
 222   class X { void y(); };
 223 </pre></td></tr>
 224
 225
 226 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;...</td></tr>
 227 <tr><td colspan="4" class="doc" id="cxxRecordDecl0"><pre>Matches C++ class declarations.
 228
 229 Example matches X, Z
 230   class X;
 231   template&lt;class T&gt; class Z {};
 232 </pre></td></tr>
 233
 234
 235 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;...</td></tr>
 236 <tr><td colspan="4" class="doc" id="decl0"><pre>Matches declarations.
 237
 238 Examples matches X, C, and the friend declaration inside C;
 239   void X();
 240   class C {
 241     friend X;
 242   };
 243 </pre></td></tr>
 244
 245
 246 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;...</td></tr>
 247 <tr><td colspan="4" class="doc" id="declaratorDecl0"><pre>Matches declarator declarations (field, variable, function
 248 and non-type template parameter declarations).
 249
 250 Given
 251   class X { int y; };
 252 declaratorDecl()
 253   matches int y.
 254 </pre></td></tr>
 255
 256
 257 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1EnumConstantDecl.html">EnumConstantDecl</a>&gt;...</td></tr>
 258 <tr><td colspan="4" class="doc" id="enumConstantDecl0"><pre>Matches enum constants.
 259
 260 Example matches A, B, C
 261   enum X {
 262     A, B, C
 263   };
 264 </pre></td></tr>
 265
 266
 267 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1EnumDecl.html">EnumDecl</a>&gt;...</td></tr>
 268 <tr><td colspan="4" class="doc" id="enumDecl0"><pre>Matches enum declarations.
 269
 270 Example matches X
 271   enum X {
 272     A, B, C
 273   };
 274 </pre></td></tr>
 275
 276
 277 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;...</td></tr>
 278 <tr><td colspan="4" class="doc" id="fieldDecl0"><pre>Matches field declarations.
 279
 280 Given
 281   class X { int m; };
 282 fieldDecl()
 283   matches 'm'.
 284 </pre></td></tr>
 285
 286
 287 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;...</td></tr>
 288 <tr><td colspan="4" class="doc" id="friendDecl0"><pre>Matches friend declarations.
 289
 290 Given
 291   class X { friend void foo(); };
 292 friendDecl()
 293   matches 'friend void foo()'.
 294 </pre></td></tr>
 295
 296
 297 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;...</td></tr>
 298 <tr><td colspan="4" class="doc" id="functionDecl0"><pre>Matches function declarations.
 299
 300 Example matches f
 301   void f();
 302 </pre></td></tr>
 303
 304
 305 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1FunctionTemplateDecl.html">FunctionTemplateDecl</a>&gt;...</td></tr>
 306 <tr><td colspan="4" class="doc" id="functionTemplateDecl0"><pre>Matches C++ function template declarations.
 307
 308 Example matches f
 309   template&lt;class T&gt; void f(T t) {}
 310 </pre></td></tr>
 311
 312
 313 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('indirectFieldDecl0')"><a name="indirectFieldDecl0Anchor">indirectFieldDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IndirectFieldDecl.html">IndirectFieldDecl</a>&gt;...</td></tr>
 314 <tr><td colspan="4" class="doc" id="indirectFieldDecl0"><pre>Matches indirect field declarations.
 315
 316 Given
 317   struct X { struct { int a; }; };
 318 indirectFieldDecl()
 319   matches 'a'.
 320 </pre></td></tr>
 321
 322
 323 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('labelDecl0')"><a name="labelDecl0Anchor">labelDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelDecl.html">LabelDecl</a>&gt;...</td></tr>
 324 <tr><td colspan="4" class="doc" id="labelDecl0"><pre>Matches a declaration of label.
 325
 326 Given
 327   goto FOO;
 328   FOO: bar();
 329 labelDecl()
 330   matches 'FOO:'
 331 </pre></td></tr>
 332
 333
 334 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1LinkageSpecDecl.html">LinkageSpecDecl</a>&gt;...</td></tr>
 335 <tr><td colspan="4" class="doc" id="linkageSpecDecl0"><pre>Matches a declaration of a linkage specification.
 336
 337 Given
 338   extern "C" {}
 339 linkageSpecDecl()
 340   matches "extern "C" {}"
 341 </pre></td></tr>
 342
 343
 344 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;...</td></tr>
 345 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
 346
 347 Example matches X, S, the anonymous union type, i, and U;
 348   typedef int X;
 349   struct S {
 350     union {
 351       int i;
 352     } U;
 353   };
 354 </pre></td></tr>
 355
 356
 357 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NamespaceAliasDecl.html">NamespaceAliasDecl</a>&gt;...</td></tr>
 358 <tr><td colspan="4" class="doc" id="namespaceAliasDecl0"><pre>Matches a declaration of a namespace alias.
 359
 360 Given
 361   namespace test {}
 362   namespace alias = ::test;
 363 namespaceAliasDecl()
 364   matches "namespace alias" but not "namespace test"
 365 </pre></td></tr>
 366
 367
 368 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt;...</td></tr>
 369 <tr><td colspan="4" class="doc" id="namespaceDecl0"><pre>Matches a declaration of a namespace.
 370
 371 Given
 372   namespace {}
 373   namespace test {}
 374 namespaceDecl()
 375   matches "namespace {}" and "namespace test {}"
 376 </pre></td></tr>
 377
 378
 379 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NonTypeTemplateParmDecl.html">NonTypeTemplateParmDecl</a>&gt;...</td></tr>
 380 <tr><td colspan="4" class="doc" id="nonTypeTemplateParmDecl0"><pre>Matches non-type template parameter declarations.
 381
 382 Given
 383   template &lt;typename T, int N&gt; struct C {};
 384 nonTypeTemplateParmDecl()
 385   matches 'N', but not 'T'.
 386 </pre></td></tr>
 387
 388
 389 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcCategoryDecl0')"><a name="objcCategoryDecl0Anchor">objcCategoryDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCCategoryDecl.html">ObjCCategoryDecl</a>&gt;...</td></tr>
 390 <tr><td colspan="4" class="doc" id="objcCategoryDecl0"><pre>Matches Objective-C category declarations.
 391
 392 Example matches Foo (Additions)
 393   @interface Foo (Additions)
 394   @end
 395 </pre></td></tr>
 396
 397
 398 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcCategoryImplDecl0')"><a name="objcCategoryImplDecl0Anchor">objcCategoryImplDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCCategoryImplDecl.html">ObjCCategoryImplDecl</a>&gt;...</td></tr>
 399 <tr><td colspan="4" class="doc" id="objcCategoryImplDecl0"><pre>Matches Objective-C category definitions.
 400
 401 Example matches Foo (Additions)
 402   @implementation Foo (Additions)
 403   @end
 404 </pre></td></tr>
 405
 406
 407 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcImplementationDecl0')"><a name="objcImplementationDecl0Anchor">objcImplementationDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCImplementationDecl.html">ObjCImplementationDecl</a>&gt;...</td></tr>
 408 <tr><td colspan="4" class="doc" id="objcImplementationDecl0"><pre>Matches Objective-C implementation declarations.
 409
 410 Example matches Foo
 411   @implementation Foo
 412   @end
 413 </pre></td></tr>
 414
 415
 416 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;...</td></tr>
 417 <tr><td colspan="4" class="doc" id="objcInterfaceDecl0"><pre>Matches Objective-C interface declarations.
 418
 419 Example matches Foo
 420   @interface Foo
 421   @end
 422 </pre></td></tr>
 423
 424
 425 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcIvarDecl0')"><a name="objcIvarDecl0Anchor">objcIvarDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCIvarDecl.html">ObjCIvarDecl</a>&gt;...</td></tr>
 426 <tr><td colspan="4" class="doc" id="objcIvarDecl0"><pre>Matches Objective-C instance variable declarations.
 427
 428 Example matches _enabled
 429   @implementation Foo {
 430     BOOL _enabled;
 431   }
 432   @end
 433 </pre></td></tr>
 434
 435
 436 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcMethodDecl0')"><a name="objcMethodDecl0Anchor">objcMethodDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;...</td></tr>
 437 <tr><td colspan="4" class="doc" id="objcMethodDecl0"><pre>Matches Objective-C method declarations.
 438
 439 Example matches both declaration and definition of -[Foo method]
 440   @interface Foo
 441   - (void)method;
 442   @end
 443
 444   @implementation Foo
 445   - (void)method {}
 446   @end
 447 </pre></td></tr>
 448
 449
 450 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcPropertyDecl0')"><a name="objcPropertyDecl0Anchor">objcPropertyDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;...</td></tr>
 451 <tr><td colspan="4" class="doc" id="objcPropertyDecl0"><pre>Matches Objective-C property declarations.
 452
 453 Example matches enabled
 454   @interface Foo
 455   @property BOOL enabled;
 456   @end
 457 </pre></td></tr>
 458
 459
 460 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcProtocolDecl0')"><a name="objcProtocolDecl0Anchor">objcProtocolDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCProtocolDecl.html">ObjCProtocolDecl</a>&gt;...</td></tr>
 461 <tr><td colspan="4" class="doc" id="objcProtocolDecl0"><pre>Matches Objective-C protocol declarations.
 462
 463 Example matches FooDelegate
 464   @protocol FooDelegate
 465   @end
 466 </pre></td></tr>
 467
 468
 469 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt;...</td></tr>
 470 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
 471
 472 Given
 473   void f(int x);
 474 parmVarDecl()
 475   matches int x.
 476 </pre></td></tr>
 477
 478
 479 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1RecordDecl.html">RecordDecl</a>&gt;...</td></tr>
 480 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches class, struct, and union declarations.
 481
 482 Example matches X, Z, U, and S
 483   class X;
 484   template&lt;class T&gt; class Z {};
 485   struct S {};
 486   union U {};
 487 </pre></td></tr>
 488
 489
 490 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1StaticAssertDecl.html">StaticAssertDecl</a>&gt;...</td></tr>
 491 <tr><td colspan="4" class="doc" id="staticAssertDecl0"><pre>Matches a C++ static_assert declaration.
 492
 493 Example:
 494   staticAssertExpr()
 495 matches
 496   static_assert(sizeof(S) == sizeof(int))
 497 in
 498   struct S {
 499     int x;
 500   };
 501   static_assert(sizeof(S) == sizeof(int));
 502 </pre></td></tr>
 503
 504
 505 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('tagDecl0')"><a name="tagDecl0Anchor">tagDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;...</td></tr>
 506 <tr><td colspan="4" class="doc" id="tagDecl0"><pre>Matches tag declarations.
 507
 508 Example matches X, Z, U, S, E
 509   class X;
 510   template&lt;class T&gt; class Z {};
 511   struct S {};
 512   union U {};
 513   enum E {
 514     A, B, C
 515   };
 516 </pre></td></tr>
 517
 518
 519 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('templateTemplateParmDecl0')"><a name="templateTemplateParmDecl0Anchor">templateTemplateParmDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTemplateParmDecl.html">TemplateTemplateParmDecl</a>&gt;...</td></tr>
 520 <tr><td colspan="4" class="doc" id="templateTemplateParmDecl0"><pre>Matches template template parameter declarations.
 521
 522 Given
 523   template &lt;template &lt;typename&gt; class Z, int N&gt; struct C {};
 524 templateTypeParmDecl()
 525   matches 'Z', but not 'N'.
 526 </pre></td></tr>
 527
 528
 529 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmDecl.html">TemplateTypeParmDecl</a>&gt;...</td></tr>
 530 <tr><td colspan="4" class="doc" id="templateTypeParmDecl0"><pre>Matches template type parameter declarations.
 531
 532 Given
 533   template &lt;typename T, int N&gt; struct C {};
 534 templateTypeParmDecl()
 535   matches 'T', but not 'N'.
 536 </pre></td></tr>
 537
 538
 539 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TranslationUnitDecl.html">TranslationUnitDecl</a>&gt;...</td></tr>
 540 <tr><td colspan="4" class="doc" id="translationUnitDecl0"><pre>Matches the top declaration context.
 541
 542 Given
 543   int X;
 544   namespace NS {
 545   int Y;
 546   }  // namespace NS
 547 decl(hasDeclContext(translationUnitDecl()))
 548   matches "int X", but not "int Y".
 549 </pre></td></tr>
 550
 551
 552 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typeAliasDecl0')"><a name="typeAliasDecl0Anchor">typeAliasDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeAliasDecl.html">TypeAliasDecl</a>&gt;...</td></tr>
 553 <tr><td colspan="4" class="doc" id="typeAliasDecl0"><pre>Matches type alias declarations.
 554
 555 Given
 556   typedef int X;
 557   using Y = int;
 558 typeAliasDecl()
 559   matches "using Y = int", but not "typedef int X"
 560 </pre></td></tr>
 561
 562
 563 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typeAliasTemplateDecl0')"><a name="typeAliasTemplateDecl0Anchor">typeAliasTemplateDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeAliasTemplateDecl.html">TypeAliasTemplateDecl</a>&gt;...</td></tr>
 564 <tr><td colspan="4" class="doc" id="typeAliasTemplateDecl0"><pre>Matches type alias template declarations.
 565
 566 typeAliasTemplateDecl() matches
 567   template &lt;typename T&gt;
 568   using Y = X&lt;T&gt;;
 569 </pre></td></tr>
 570
 571
 572 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TypedefDecl.html">TypedefDecl</a>&gt;...</td></tr>
 573 <tr><td colspan="4" class="doc" id="typedefDecl0"><pre>Matches typedef declarations.
 574
 575 Given
 576   typedef int X;
 577   using Y = int;
 578 typedefDecl()
 579   matches "typedef int X", but not "using Y = int"
 580 </pre></td></tr>
 581
 582
 583 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typedefNameDecl0')"><a name="typedefNameDecl0Anchor">typedefNameDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;...</td></tr>
 584 <tr><td colspan="4" class="doc" id="typedefNameDecl0"><pre>Matches typedef name declarations.
 585
 586 Given
 587   typedef int X;
 588   using Y = int;
 589 typedefNameDecl()
 590   matches "typedef int X" and "using Y = int"
 591 </pre></td></tr>
 592
 593
 594 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingTypenameDecl.html">UnresolvedUsingTypenameDecl</a>&gt;...</td></tr>
 595 <tr><td colspan="4" class="doc" id="unresolvedUsingTypenameDecl0"><pre>Matches unresolved using value declarations that involve the
 596 typename.
 597
 598 Given
 599   template &lt;typename T&gt;
 600   struct Base { typedef T Foo; };
 601
 602   template&lt;typename T&gt;
 603   struct S : private Base&lt;T&gt; {
 604     using typename Base&lt;T&gt;::Foo;
 605   };
 606 unresolvedUsingTypenameDecl()
 607   matches using Base&lt;T&gt;::Foo </pre></td></tr>
 608
 609
 610 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingValueDecl.html">UnresolvedUsingValueDecl</a>&gt;...</td></tr>
 611 <tr><td colspan="4" class="doc" id="unresolvedUsingValueDecl0"><pre>Matches unresolved using value declarations.
 612
 613 Given
 614   template&lt;typename X&gt;
 615   class C : private X {
 616     using X::x;
 617   };
 618 unresolvedUsingValueDecl()
 619   matches using X::x </pre></td></tr>
 620
 621
 622 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UsingDecl.html">UsingDecl</a>&gt;...</td></tr>
 623 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
 624
 625 Given
 626   namespace X { int x; }
 627   using X::x;
 628 usingDecl()
 629   matches using X::x </pre></td></tr>
 630
 631
 632 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UsingDirectiveDecl.html">UsingDirectiveDecl</a>&gt;...</td></tr>
 633 <tr><td colspan="4" class="doc" id="usingDirectiveDecl0"><pre>Matches using namespace declarations.
 634
 635 Given
 636   namespace X { int x; }
 637   using namespace X;
 638 usingDirectiveDecl()
 639   matches using namespace X </pre></td></tr>
 640
 641
 642 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;...</td></tr>
 643 <tr><td colspan="4" class="doc" id="valueDecl0"><pre>Matches any value declaration.
 644
 645 Example matches A, B, C and F
 646   enum X { A, B, C };
 647   void F();
 648 </pre></td></tr>
 649
 650
 651 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;...</td></tr>
 652 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
 653
 654 Note: this does not match declarations of member variables, which are
 655 "field" declarations in Clang parlance.
 656
 657 Example matches a
 658   int a;
 659 </pre></td></tr>
 660
 661
 662 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecompositionDecl.html">DecompositionDecl</a>&gt;</td><td class="name" onclick="toggle('decompositionDecl0')"><a name="decompositionDecl0Anchor">decompositionDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecompositionDecl.html">DecompositionDecl</a>&gt;...</td></tr>
 663 <tr><td colspan="4" class="doc" id="decompositionDecl0"><pre>Matches decomposition-declarations.
 664
 665 Examples matches the declaration node with foo and bar, but not
 666 number.
 667 (matcher = declStmt(has(decompositionDecl())))
 668
 669   int number = 42;
 670   auto [foo, bar] = std::make_pair{42, 42};
 671 </pre></td></tr>
 672
 673
 674 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;...</td></tr>
 675 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
 676 </pre></td></tr>
 677
 678
 679 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;...</td></tr>
 680 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
 681
 682 Given
 683   namespace ns {
 684     struct A { static void f(); };
 685     void A::f() {}
 686     void g() { A::f(); }
 687   }
 688   ns::A a;
 689 nestedNameSpecifier()
 690   matches "ns::" and both "A::"
 691 </pre></td></tr>
 692
 693
 694 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPClause.html">OMPClause</a>&gt;</td><td class="name" onclick="toggle('ompDefaultClause0')"><a name="ompDefaultClause0Anchor">ompDefaultClause</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;...</td></tr>
 695 <tr><td colspan="4" class="doc" id="ompDefaultClause0"><pre>Matches OpenMP ``default`` clause.
 696
 697 Given
 698
 699   #pragma omp parallel default(none)
 700   #pragma omp parallel default(shared)
 701   #pragma omp parallel default(firstprivate)
 702   #pragma omp parallel
 703
 704 ``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``, and
 705 ``default(firstprivate)``
 706 </pre></td></tr>
 707
 708
 709 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;...</td></tr>
 710 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
 711 </pre></td></tr>
 712
 713
 714 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('addrLabelExpr0')"><a name="addrLabelExpr0Anchor">addrLabelExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;...</td></tr>
 715 <tr><td colspan="4" class="doc" id="addrLabelExpr0"><pre>Matches address of label statements (GNU extension).
 716
 717 Given
 718   FOO: bar();
 719   void *ptr = &amp;&amp;FOO;
 720   goto *bar;
 721 addrLabelExpr()
 722   matches '&amp;&amp;FOO'
 723 </pre></td></tr>
 724
 725
 726 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;...</td></tr>
 727 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
 728
 729 Given
 730   int i = a[1];
 731 arraySubscriptExpr()
 732   matches "a[1]"
 733 </pre></td></tr>
 734
 735
 736 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1AsmStmt.html">AsmStmt</a>&gt;...</td></tr>
 737 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
 738
 739  int i = 100;
 740   __asm("mov al, 2");
 741 asmStmt()
 742   matches '__asm("mov al, 2")'
 743 </pre></td></tr>
 744
 745
 746 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('atomicExpr0')"><a name="atomicExpr0Anchor">atomicExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AtomicExpr.html">AtomicExpr</a>&gt;...</td></tr>
 747 <tr><td colspan="4" class="doc" id="atomicExpr0"><pre>Matches atomic builtins.
 748 Example matches __atomic_load_n(ptr, 1)
 749   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
 750 </pre></td></tr>
 751
 752
 753 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('autoreleasePoolStmt0')"><a name="autoreleasePoolStmt0Anchor">autoreleasePoolStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAutoreleasePoolStmt.html">ObjCAutoreleasePoolStmt</a>&gt;...</td></tr>
 754 <tr><td colspan="4" class="doc" id="autoreleasePoolStmt0"><pre>Matches an Objective-C autorelease pool statement.
 755
 756 Given
 757   @autoreleasepool {
 758     int x = 0;
 759   }
 760 autoreleasePoolStmt(stmt()) matches the declaration of "x"
 761 inside the autorelease pool.
 762 </pre></td></tr>
 763
 764
 765 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('binaryConditionalOperator0')"><a name="binaryConditionalOperator0Anchor">binaryConditionalOperator</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryConditionalOperator.html">BinaryConditionalOperator</a>&gt;...</td></tr>
 766 <tr><td colspan="4" class="doc" id="binaryConditionalOperator0"><pre>Matches binary conditional operator expressions (GNU extension).
 767
 768 Example matches a ?: b
 769   (a ?: b) + 42;
 770 </pre></td></tr>
 771
 772
 773 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;...</td></tr>
 774 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
 775
 776 Example matches a || b
 777   !(a || b)
 778 </pre></td></tr>
 779
 780
 781 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('blockExpr0')"><a name="blockExpr0Anchor">blockExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockExpr.html">BlockExpr</a>&gt;...</td></tr>
 782 <tr><td colspan="4" class="doc" id="blockExpr0"><pre>Matches a reference to a block.
 783
 784 Example: matches "^{}":
 785   void f() { ^{}(); }
 786 </pre></td></tr>
 787
 788
 789 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1BreakStmt.html">BreakStmt</a>&gt;...</td></tr>
 790 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
 791
 792 Given
 793   while (true) { break; }
 794 breakStmt()
 795   matches 'break'
 796 </pre></td></tr>
 797
 798
 799 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CStyleCastExpr.html">CStyleCastExpr</a>&gt;...</td></tr>
 800 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
 801
 802 Example: Matches (int) 2.2f in
 803   int i = (int) 2.2f;
 804 </pre></td></tr>
 805
 806
 807 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;...</td></tr>
 808 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
 809
 810 Example matches x.y() and y()
 811   X x;
 812   x.y();
 813   y();
 814 </pre></td></tr>
 815
 816
 817 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CaseStmt.html">CaseStmt</a>&gt;...</td></tr>
 818 <tr><td colspan="4" class="doc" id="caseStmt0"><pre>Matches case statements inside switch statements.
 819
 820 Given
 821   switch(a) { case 42: break; default: break; }
 822 caseStmt()
 823   matches 'case 42:'.
 824 </pre></td></tr>
 825
 826
 827 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;...</td></tr>
 828 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
 829
 830 Example: castExpr() matches each of the following:
 831   (int) 3;
 832   const_cast&lt;Expr *&gt;(SubExpr);
 833   char c = 0;
 834 but does not match
 835   int i = (0);
 836   int k = 0;
 837 </pre></td></tr>
 838
 839
 840 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;...</td></tr>
 841 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
 842
 843 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
 844 though.
 845
 846 Example matches 'a', L'a'
 847   char ch = 'a';
 848   wchar_t chw = L'a';
 849 </pre></td></tr>
 850
 851
 852 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('chooseExpr0')"><a name="chooseExpr0Anchor">chooseExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ChooseExpr.html">ChooseExpr</a>&gt;...</td></tr>
 853 <tr><td colspan="4" class="doc" id="chooseExpr0"><pre>Matches GNU __builtin_choose_expr.
 854 </pre></td></tr>
 855
 856
 857 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;...</td></tr>
 858 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
 859
 860 Example match: {1}, (1, 2)
 861   int array[4] = {1};
 862   vector int myvec = (vector int)(1, 2);
 863 </pre></td></tr>
 864
 865
 866 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;...</td></tr>
 867 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
 868
 869 Example matches '{}' and '{{}}' in 'for (;;) {{}}'
 870   for (;;) {{}}
 871 </pre></td></tr>
 872
 873
 874 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ConditionalOperator.html">ConditionalOperator</a>&gt;...</td></tr>
 875 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
 876
 877 Example matches a ? b : c
 878   (a ? b : c) + 42
 879 </pre></td></tr>
 880
 881
 882 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('constantExpr0')"><a name="constantExpr0Anchor">constantExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConstantExpr.html">ConstantExpr</a>&gt;...</td></tr>
 883 <tr><td colspan="4" class="doc" id="constantExpr0"><pre>Matches a constant expression wrapper.
 884
 885 Example matches the constant in the case statement:
 886     (matcher = constantExpr())
 887   switch (a) {
 888   case 37: break;
 889   }
 890 </pre></td></tr>
 891
 892
 893 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ContinueStmt.html">ContinueStmt</a>&gt;...</td></tr>
 894 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
 895
 896 Given
 897   while (true) { continue; }
 898 continueStmt()
 899   matches 'continue'
 900 </pre></td></tr>
 901
 902
 903 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CUDAKernelCallExpr.html">CUDAKernelCallExpr</a>&gt;...</td></tr>
 904 <tr><td colspan="4" class="doc" id="cudaKernelCallExpr0"><pre>Matches CUDA kernel call expression.
 905
 906 Example matches,
 907   kernel&lt;&lt;&lt;i,j&gt;&gt;&gt;();
 908 </pre></td></tr>
 909
 910
 911 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXBindTemporaryExpr.html">CXXBindTemporaryExpr</a>&gt;...</td></tr>
 912 <tr><td colspan="4" class="doc" id="cxxBindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
 913
 914 Example matches FunctionTakesString(GetStringByValue())
 915     (matcher = cxxBindTemporaryExpr())
 916   FunctionTakesString(GetStringByValue());
 917   FunctionTakesStringByPointer(GetStringPointer());
 918 </pre></td></tr>
 919
 920
 921 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;...</td></tr>
 922 <tr><td colspan="4" class="doc" id="cxxBoolLiteral0"><pre>Matches bool literals.
 923
 924 Example matches true
 925   true
 926 </pre></td></tr>
 927
 928
 929 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>&gt;...</td></tr>
 930 <tr><td colspan="4" class="doc" id="cxxCatchStmt0"><pre>Matches catch statements.
 931
 932   try {} catch(int i) {}
 933 cxxCatchStmt()
 934   matches 'catch(int i)'
 935 </pre></td></tr>
 936
 937
 938 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXConstCastExpr.html">CXXConstCastExpr</a>&gt;...</td></tr>
 939 <tr><td colspan="4" class="doc" id="cxxConstCastExpr0"><pre>Matches a const_cast expression.
 940
 941 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
 942   int n = 42;
 943   const int &amp;r(n);
 944   int* p = const_cast&lt;int*&gt;(&amp;r);
 945 </pre></td></tr>
 946
 947
 948 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;...</td></tr>
 949 <tr><td colspan="4" class="doc" id="cxxConstructExpr0"><pre>Matches constructor call expressions (including implicit ones).
 950
 951 Example matches string(ptr, n) and ptr within arguments of f
 952     (matcher = cxxConstructExpr())
 953   void f(const string &amp;a, const string &amp;b);
 954   char *ptr;
 955   int n;
 956   f(string(ptr, n), ptr);
 957 </pre></td></tr>
 958
 959
 960 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXDefaultArgExpr.html">CXXDefaultArgExpr</a>&gt;...</td></tr>
 961 <tr><td colspan="4" class="doc" id="cxxDefaultArgExpr0"><pre>Matches the value of a default argument at the call site.
 962
 963 Example matches the CXXDefaultArgExpr placeholder inserted for the
 964     default value of the second parameter in the call expression f(42)
 965     (matcher = cxxDefaultArgExpr())
 966   void f(int x, int y = 0);
 967   f(42);
 968 </pre></td></tr>
 969
 970
 971 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXDeleteExpr.html">CXXDeleteExpr</a>&gt;...</td></tr>
 972 <tr><td colspan="4" class="doc" id="cxxDeleteExpr0"><pre>Matches delete expressions.
 973
 974 Given
 975   delete X;
 976 cxxDeleteExpr()
 977   matches 'delete X'.
 978 </pre></td></tr>
 979
 980
 981 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDependentScopeMemberExpr0')"><a name="cxxDependentScopeMemberExpr0Anchor">cxxDependentScopeMemberExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;...</td></tr>
 982 <tr><td colspan="4" class="doc" id="cxxDependentScopeMemberExpr0"><pre>Matches member expressions where the actual member referenced could not be
 983 resolved because the base expression or the member name was dependent.
 984
 985 Given
 986   template &lt;class T&gt; void f() { T t; t.g(); }
 987 cxxDependentScopeMemberExpr()
 988   matches t.g
 989 </pre></td></tr>
 990
 991
 992 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXDynamicCastExpr.html">CXXDynamicCastExpr</a>&gt;...</td></tr>
 993 <tr><td colspan="4" class="doc" id="cxxDynamicCastExpr0"><pre>Matches a dynamic_cast expression.
 994
 995 Example:
 996   cxxDynamicCastExpr()
 997 matches
 998   dynamic_cast&lt;D*&gt;(&amp;b);
 999 in
1000   struct B { virtual ~B() {} }; struct D : B {};
1001   B b;
1002   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
1003 </pre></td></tr>
1004
1005
1006 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;...</td></tr>
1007 <tr><td colspan="4" class="doc" id="cxxForRangeStmt0"><pre>Matches range-based for statements.
1008
1009 cxxForRangeStmt() matches 'for (auto a : i)'
1010   int i[] =  {1, 2, 3}; for (auto a : i);
1011   for(int j = 0; j &lt; 5; ++j);
1012 </pre></td></tr>
1013
1014
1015 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;...</td></tr>
1016 <tr><td colspan="4" class="doc" id="cxxFunctionalCastExpr0"><pre>Matches functional cast expressions
1017
1018 Example: Matches Foo(bar);
1019   Foo f = bar;
1020   Foo g = (Foo) bar;
1021   Foo h = Foo(bar);
1022 </pre></td></tr>
1023
1024
1025 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;...</td></tr>
1026 <tr><td colspan="4" class="doc" id="cxxMemberCallExpr0"><pre>Matches member call expressions.
1027
1028 Example matches x.y()
1029   X x;
1030   x.y();
1031 </pre></td></tr>
1032
1033
1034 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;...</td></tr>
1035 <tr><td colspan="4" class="doc" id="cxxNewExpr0"><pre>Matches new expressions.
1036
1037 Given
1038   new X;
1039 cxxNewExpr()
1040   matches 'new X'.
1041 </pre></td></tr>
1042
1043
1044 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxNoexceptExpr0')"><a name="cxxNoexceptExpr0Anchor">cxxNoexceptExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNoexceptExpr.html">CXXNoexceptExpr</a>&gt;...</td></tr>
1045 <tr><td colspan="4" class="doc" id="cxxNoexceptExpr0"><pre>Matches noexcept expressions.
1046
1047 Given
1048   bool a() noexcept;
1049   bool b() noexcept(true);
1050   bool c() noexcept(false);
1051   bool d() noexcept(noexcept(a()));
1052   bool e = noexcept(b()) || noexcept(c());
1053 cxxNoexceptExpr()
1054   matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`.
1055   doesn't match the noexcept specifier in the declarations a, b, c or d.
1056 </pre></td></tr>
1057
1058
1059 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXNullPtrLiteralExpr.html">CXXNullPtrLiteralExpr</a>&gt;...</td></tr>
1060 <tr><td colspan="4" class="doc" id="cxxNullPtrLiteralExpr0"><pre>Matches nullptr literal.
1061 </pre></td></tr>
1062
1063
1064 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;...</td></tr>
1065 <tr><td colspan="4" class="doc" id="cxxOperatorCallExpr0"><pre>Matches overloaded operator calls.
1066
1067 Note that if an operator isn't overloaded, it won't match. Instead, use
1068 binaryOperator matcher.
1069 Currently it does not match operators such as new delete.
1070 FIXME: figure out why these do not match?
1071
1072 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
1073     (matcher = cxxOperatorCallExpr())
1074   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
1075   ostream &amp;o; int b = 1, c = 1;
1076   o &lt;&lt; b &lt;&lt; c;
1077 </pre></td></tr>
1078
1079
1080 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXReinterpretCastExpr.html">CXXReinterpretCastExpr</a>&gt;...</td></tr>
1081 <tr><td colspan="4" class="doc" id="cxxReinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
1082
1083 Either the source expression or the destination type can be matched
1084 using has(), but hasDestinationType() is more specific and can be
1085 more readable.
1086
1087 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
1088   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
1089 </pre></td></tr>
1090
1091
1092 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXStaticCastExpr.html">CXXStaticCastExpr</a>&gt;...</td></tr>
1093 <tr><td colspan="4" class="doc" id="cxxStaticCastExpr0"><pre>Matches a C++ static_cast expression.
1094
1095 See also: hasDestinationType
1096 See also: reinterpretCast
1097
1098 Example:
1099   cxxStaticCastExpr()
1100 matches
1101   static_cast&lt;long&gt;(8)
1102 in
1103   long eight(static_cast&lt;long&gt;(8));
1104 </pre></td></tr>
1105
1106
1107 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxStdInitializerListExpr0')"><a name="cxxStdInitializerListExpr0Anchor">cxxStdInitializerListExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXStdInitializerListExpr.html">CXXStdInitializerListExpr</a>&gt;...</td></tr>
1108 <tr><td colspan="4" class="doc" id="cxxStdInitializerListExpr0"><pre>Matches C++ initializer list expressions.
1109
1110 Given
1111   std::vector&lt;int&gt; a({ 1, 2, 3 });
1112   std::vector&lt;int&gt; b = { 4, 5 };
1113   int c[] = { 6, 7 };
1114   std::pair&lt;int, int&gt; d = { 8, 9 };
1115 cxxStdInitializerListExpr()
1116   matches "{ 1, 2, 3 }" and "{ 4, 5 }"
1117 </pre></td></tr>
1118
1119
1120 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;...</td></tr>
1121 <tr><td colspan="4" class="doc" id="cxxTemporaryObjectExpr0"><pre>Matches functional cast expressions having N != 1 arguments
1122
1123 Example: Matches Foo(bar, bar)
1124   Foo h = Foo(bar, bar);
1125 </pre></td></tr>
1126
1127
1128 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXThisExpr.html">CXXThisExpr</a>&gt;...</td></tr>
1129 <tr><td colspan="4" class="doc" id="cxxThisExpr0"><pre>Matches implicit and explicit this expressions.
1130
1131 Example matches the implicit this expression in "return i".
1132     (matcher = cxxThisExpr())
1133 struct foo {
1134   int i;
1135   int f() { return i; }
1136 };
1137 </pre></td></tr>
1138
1139
1140 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXThrowExpr.html">CXXThrowExpr</a>&gt;...</td></tr>
1141 <tr><td colspan="4" class="doc" id="cxxThrowExpr0"><pre>Matches throw expressions.
1142
1143   try { throw 5; } catch(int i) {}
1144 cxxThrowExpr()
1145   matches 'throw 5'
1146 </pre></td></tr>
1147
1148
1149 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXTryStmt.html">CXXTryStmt</a>&gt;...</td></tr>
1150 <tr><td colspan="4" class="doc" id="cxxTryStmt0"><pre>Matches try statements.
1151
1152   try {} catch(int i) {}
1153 cxxTryStmt()
1154   matches 'try {}'
1155 </pre></td></tr>
1156
1157
1158 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;...</td></tr>
1159 <tr><td colspan="4" class="doc" id="cxxUnresolvedConstructExpr0"><pre>Matches unresolved constructor call expressions.
1160
1161 Example matches T(t) in return statement of f
1162     (matcher = cxxUnresolvedConstructExpr())
1163   template &lt;typename T&gt;
1164   void f(const T&amp; t) { return T(t); }
1165 </pre></td></tr>
1166
1167
1168 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;...</td></tr>
1169 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
1170
1171 Example matches x in if (x)
1172   bool x;
1173   if (x) {}
1174 </pre></td></tr>
1175
1176
1177 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;...</td></tr>
1178 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
1179
1180 Given
1181   int a;
1182 declStmt()
1183   matches 'int a'.
1184 </pre></td></tr>
1185
1186
1187 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DefaultStmt.html">DefaultStmt</a>&gt;...</td></tr>
1188 <tr><td colspan="4" class="doc" id="defaultStmt0"><pre>Matches default statements inside switch statements.
1189
1190 Given
1191   switch(a) { case 42: break; default: break; }
1192 defaultStmt()
1193   matches 'default:'.
1194 </pre></td></tr>
1195
1196
1197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('designatedInitExpr0')"><a name="designatedInitExpr0Anchor">designatedInitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;...</td></tr>
1198 <tr><td colspan="4" class="doc" id="designatedInitExpr0"><pre>Matches C99 designated initializer expressions [C99 6.7.8].
1199
1200 Example: Matches { [2].y = 1.0, [0].x = 1.0 }
1201   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
1202 </pre></td></tr>
1203
1204
1205 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;...</td></tr>
1206 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
1207
1208 Given
1209   do {} while (true);
1210 doStmt()
1211   matches 'do {} while(true)'
1212 </pre></td></tr>
1213
1214
1215 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;...</td></tr>
1216 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
1217
1218 Matches any cast expression written in user code, whether it be a
1219 C-style cast, a functional-style cast, or a keyword cast.
1220
1221 Does not match implicit conversions.
1222
1223 Note: the name "explicitCast" is chosen to match Clang's terminology, as
1224 Clang uses the term "cast" to apply to implicit conversions as well as to
1225 actual cast expressions.
1226
1227 See also: hasDestinationType.
1228
1229 Example: matches all five of the casts in
1230   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
1231 but does not match the implicit conversion in
1232   long ell = 42;
1233 </pre></td></tr>
1234
1235
1236 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;...</td></tr>
1237 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
1238
1239 Example matches x()
1240   void f() { x(); }
1241 </pre></td></tr>
1242
1243
1244 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ExprWithCleanups.html">ExprWithCleanups</a>&gt;...</td></tr>
1245 <tr><td colspan="4" class="doc" id="exprWithCleanups0"><pre>Matches expressions that introduce cleanups to be run at the end
1246 of the sub-expression's evaluation.
1247
1248 Example matches std::string()
1249   const std::string str = std::string();
1250 </pre></td></tr>
1251
1252
1253 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('fixedPointLiteral0')"><a name="fixedPointLiteral0Anchor">fixedPointLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FixedPointLiteral.html">FixedPointLiteral</a>&gt;...</td></tr>
1254 <tr><td colspan="4" class="doc" id="fixedPointLiteral0"><pre>Matches fixed point literals
1255 </pre></td></tr>
1256
1257
1258 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;...</td></tr>
1259 <tr><td colspan="4" class="doc" id="floatLiteral0"><pre>Matches float literals of all sizes / encodings, e.g.
1260 1.0, 1.0f, 1.0L and 1e10.
1261
1262 Does not match implicit conversions such as
1263   float a = 10;
1264 </pre></td></tr>
1265
1266
1267 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;...</td></tr>
1268 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
1269
1270 Example matches 'for (;;) {}'
1271   for (;;) {}
1272   int i[] =  {1, 2, 3}; for (auto a : i);
1273 </pre></td></tr>
1274
1275
1276 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1GNUNullExpr.html">GNUNullExpr</a>&gt;...</td></tr>
1277 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
1278 </pre></td></tr>
1279
1280
1281 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1GotoStmt.html">GotoStmt</a>&gt;...</td></tr>
1282 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
1283
1284 Given
1285   goto FOO;
1286   FOO: bar();
1287 gotoStmt()
1288   matches 'goto FOO'
1289 </pre></td></tr>
1290
1291
1292 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;...</td></tr>
1293 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
1294
1295 Example matches 'if (x) {}'
1296   if (x) {}
1297 </pre></td></tr>
1298
1299
1300 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('imaginaryLiteral0')"><a name="imaginaryLiteral0Anchor">imaginaryLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImaginaryLiteral.html">ImaginaryLiteral</a>&gt;...</td></tr>
1301 <tr><td colspan="4" class="doc" id="imaginaryLiteral0"><pre>Matches imaginary literals, which are based on integer and floating
1302 point literals e.g.: 1i, 1.0i
1303 </pre></td></tr>
1304
1305
1306 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ImplicitCastExpr.html">ImplicitCastExpr</a>&gt;...</td></tr>
1307 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
1308
1309 This matches many different places, including function call return value
1310 eliding, as well as any type conversions.
1311 </pre></td></tr>
1312
1313
1314 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('implicitValueInitExpr0')"><a name="implicitValueInitExpr0Anchor">implicitValueInitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImplicitValueInitExpr.html">ImplicitValueInitExpr</a>&gt;...</td></tr>
1315 <tr><td colspan="4" class="doc" id="implicitValueInitExpr0"><pre>Matches implicit initializers of init list expressions.
1316
1317 Given
1318   point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
1319 implicitValueInitExpr()
1320   matches "[0].y" (implicitly)
1321 </pre></td></tr>
1322
1323
1324 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;...</td></tr>
1325 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
1326
1327 Given
1328   int a[] = { 1, 2 };
1329   struct B { int x, y; };
1330   B b = { 5, 6 };
1331 initListExpr()
1332   matches "{ 1, 2 }" and "{ 5, 6 }"
1333 </pre></td></tr>
1334
1335
1336 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;...</td></tr>
1337 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes / encodings, e.g.
1338 1, 1L, 0x1 and 1U.
1339
1340 Does not match character-encoded integers such as L'a'.
1341 </pre></td></tr>
1342
1343
1344 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;...</td></tr>
1345 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
1346
1347 Given
1348   goto FOO;
1349   FOO: bar();
1350 labelStmt()
1351   matches 'FOO:'
1352 </pre></td></tr>
1353
1354
1355 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1LambdaExpr.html">LambdaExpr</a>&gt;...</td></tr>
1356 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
1357
1358 Example matches [&amp;](){return 5;}
1359   [&amp;](){return 5;}
1360 </pre></td></tr>
1361
1362
1363 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1MaterializeTemporaryExpr.html">MaterializeTemporaryExpr</a>&gt;...</td></tr>
1364 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
1365
1366 Example: Given
1367   struct T {void func();};
1368   T f();
1369   void g(T);
1370 materializeTemporaryExpr() matches 'f()' in these statements
1371   T u(f());
1372   g(f());
1373   f().func();
1374 but does not match
1375   f();
1376 </pre></td></tr>
1377
1378
1379 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;...</td></tr>
1380 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
1381
1382 Given
1383   class Y {
1384     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
1385     int a; static int b;
1386   };
1387 memberExpr()
1388   matches this-&gt;x, x, y.x, a, this-&gt;b
1389 </pre></td></tr>
1390
1391
1392 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1NullStmt.html">NullStmt</a>&gt;...</td></tr>
1393 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
1394
1395   foo();;
1396 nullStmt()
1397   matches the second ';'
1398 </pre></td></tr>
1399
1400
1401 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcCatchStmt0')"><a name="objcCatchStmt0Anchor">objcCatchStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtCatchStmt.html">ObjCAtCatchStmt</a>&gt;...</td></tr>
1402 <tr><td colspan="4" class="doc" id="objcCatchStmt0"><pre>Matches Objective-C @catch statements.
1403
1404 Example matches @catch
1405   @try {}
1406   @catch (...) {}
1407 </pre></td></tr>
1408
1409
1410 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcFinallyStmt0')"><a name="objcFinallyStmt0Anchor">objcFinallyStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtFinallyStmt.html">ObjCAtFinallyStmt</a>&gt;...</td></tr>
1411 <tr><td colspan="4" class="doc" id="objcFinallyStmt0"><pre>Matches Objective-C @finally statements.
1412
1413 Example matches @finally
1414   @try {}
1415   @finally {}
1416 </pre></td></tr>
1417
1418
1419 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcIvarRefExpr0')"><a name="objcIvarRefExpr0Anchor">objcIvarRefExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCIvarRefExpr.html">ObjCIvarRefExpr</a>&gt;...</td></tr>
1420 <tr><td colspan="4" class="doc" id="objcIvarRefExpr0"><pre>Matches a reference to an ObjCIvar.
1421
1422 Example: matches "a" in "init" method:
1423 @implementation A {
1424   NSString *a;
1425 }
1426 - (void) init {
1427   a = @"hello";
1428 }
1429 </pre></td></tr>
1430
1431
1432 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;...</td></tr>
1433 <tr><td colspan="4" class="doc" id="objcMessageExpr0"><pre>Matches ObjectiveC Message invocation expressions.
1434
1435 The innermost message send invokes the "alloc" class method on the
1436 NSString class, while the outermost message send invokes the
1437 "initWithString" instance method on the object returned from
1438 NSString's "alloc". This matcher should match both message sends.
1439   [[NSString alloc] initWithString:@"Hello"]
1440 </pre></td></tr>
1441
1442
1443 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcThrowStmt0')"><a name="objcThrowStmt0Anchor">objcThrowStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtThrowStmt.html">ObjCAtThrowStmt</a>&gt;...</td></tr>
1444 <tr><td colspan="4" class="doc" id="objcThrowStmt0"><pre>Matches Objective-C statements.
1445
1446 Example matches @throw obj;
1447 </pre></td></tr>
1448
1449
1450 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcTryStmt0')"><a name="objcTryStmt0Anchor">objcTryStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtTryStmt.html">ObjCAtTryStmt</a>&gt;...</td></tr>
1451 <tr><td colspan="4" class="doc" id="objcTryStmt0"><pre>Matches Objective-C @try statements.
1452
1453 Example matches @try
1454   @try {}
1455   @catch (...) {}
1456 </pre></td></tr>
1457
1458
1459 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('ompExecutableDirective0')"><a name="ompExecutableDirective0Anchor">ompExecutableDirective</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPExecutableDirective.html">OMPExecutableDirective</a>&gt;...</td></tr>
1460 <tr><td colspan="4" class="doc" id="ompExecutableDirective0"><pre>Matches any ``#pragma omp`` executable directive.
1461
1462 Given
1463
1464   #pragma omp parallel
1465   #pragma omp parallel default(none)
1466   #pragma omp taskyield
1467
1468 ``ompExecutableDirective()`` matches ``omp parallel``,
1469 ``omp parallel default(none)`` and ``omp taskyield``.
1470 </pre></td></tr>
1471
1472
1473 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('opaqueValueExpr0')"><a name="opaqueValueExpr0Anchor">opaqueValueExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OpaqueValueExpr.html">OpaqueValueExpr</a>&gt;...</td></tr>
1474 <tr><td colspan="4" class="doc" id="opaqueValueExpr0"><pre>Matches opaque value expressions. They are used as helpers
1475 to reference another expressions and can be met
1476 in BinaryConditionalOperators, for example.
1477
1478 Example matches 'a'
1479   (a ?: c) + 42;
1480 </pre></td></tr>
1481
1482
1483 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('parenExpr0')"><a name="parenExpr0Anchor">parenExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenExpr.html">ParenExpr</a>&gt;...</td></tr>
1484 <tr><td colspan="4" class="doc" id="parenExpr0"><pre>Matches parentheses used in expressions.
1485
1486 Example matches (foo() + 1)
1487   int foo() { return 1; }
1488   int a = (foo() + 1);
1489 </pre></td></tr>
1490
1491
1492 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('parenListExpr0')"><a name="parenListExpr0Anchor">parenListExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenListExpr.html">ParenListExpr</a>&gt;...</td></tr>
1493 <tr><td colspan="4" class="doc" id="parenListExpr0"><pre>Matches paren list expressions.
1494 ParenListExprs don't have a predefined type and are used for late parsing.
1495 In the final AST, they can be met in template declarations.
1496
1497 Given
1498   template&lt;typename T&gt; class X {
1499     void f() {
1500       X x(*this);
1501       int a = 0, b = 1; int i = (a, b);
1502     }
1503   };
1504 parenListExpr() matches "*this" but NOT matches (a, b) because (a, b)
1505 has a predefined type and is a ParenExpr, not a ParenListExpr.
1506 </pre></td></tr>
1507
1508
1509 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('predefinedExpr0')"><a name="predefinedExpr0Anchor">predefinedExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PredefinedExpr.html">PredefinedExpr</a>&gt;...</td></tr>
1510 <tr><td colspan="4" class="doc" id="predefinedExpr0"><pre>Matches predefined identifier expressions [C99 6.4.2.2].
1511
1512 Example: Matches __func__
1513   printf("%s", __func__);
1514 </pre></td></tr>
1515
1516
1517 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ReturnStmt.html">ReturnStmt</a>&gt;...</td></tr>
1518 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
1519
1520 Given
1521   return 1;
1522 returnStmt()
1523   matches 'return 1'
1524 </pre></td></tr>
1525
1526
1527 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;...</td></tr>
1528 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
1529
1530 Given
1531   { ++a; }
1532 stmt()
1533   matches both the compound statement '{ ++a; }' and '++a'.
1534 </pre></td></tr>
1535
1536
1537 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stmtExpr0')"><a name="stmtExpr0Anchor">stmtExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StmtExpr.html">StmtExpr</a>&gt;...</td></tr>
1538 <tr><td colspan="4" class="doc" id="stmtExpr0"><pre>Matches statement expression (GNU extension).
1539
1540 Example match: ({ int X = 4; X; })
1541   int C = ({ int X = 4; X; });
1542 </pre></td></tr>
1543
1544
1545 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1StringLiteral.html">StringLiteral</a>&gt;...</td></tr>
1546 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
1547
1548 Example matches "abcd", L"abcd"
1549   char *s = "abcd";
1550   wchar_t *ws = L"abcd";
1551 </pre></td></tr>
1552
1553
1554 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1SubstNonTypeTemplateParmExpr.html">SubstNonTypeTemplateParmExpr</a>&gt;...</td></tr>
1555 <tr><td colspan="4" class="doc" id="substNonTypeTemplateParmExpr0"><pre>Matches substitutions of non-type template parameters.
1556
1557 Given
1558   template &lt;int N&gt;
1559   struct A { static const int n = N; };
1560   struct B : public A&lt;42&gt; {};
1561 substNonTypeTemplateParmExpr()
1562   matches "N" in the right-hand side of "static const int n = N;"
1563 </pre></td></tr>
1564
1565
1566 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1SwitchCase.html">SwitchCase</a>&gt;...</td></tr>
1567 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
1568
1569 Given
1570   switch(a) { case 42: break; default: break; }
1571 switchCase()
1572   matches 'case 42:' and 'default:'.
1573 </pre></td></tr>
1574
1575
1576 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;...</td></tr>
1577 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
1578
1579 Given
1580   switch(a) { case 42: break; default: break; }
1581 switchStmt()
1582   matches 'switch(a)'.
1583 </pre></td></tr>
1584
1585
1586 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;...</td></tr>
1587 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
1588
1589 Given
1590   Foo x = bar;
1591   int y = sizeof(x) + alignof(x);
1592 unaryExprOrTypeTraitExpr()
1593   matches sizeof(x) and alignof(x)
1594 </pre></td></tr>
1595
1596
1597 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;...</td></tr>
1598 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
1599
1600 Example matches !a
1601   !a || b
1602 </pre></td></tr>
1603
1604
1605 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unresolvedLookupExpr0')"><a name="unresolvedLookupExpr0Anchor">unresolvedLookupExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedLookupExpr.html">UnresolvedLookupExpr</a>&gt;...</td></tr>
1606 <tr><td colspan="4" class="doc" id="unresolvedLookupExpr0"><pre>Matches reference to a name that can be looked up during parsing
1607 but could not be resolved to a specific declaration.
1608
1609 Given
1610   template&lt;typename T&gt;
1611   T foo() { T a; return a; }
1612   template&lt;typename T&gt;
1613   void bar() {
1614     foo&lt;T&gt;();
1615   }
1616 unresolvedLookupExpr()
1617   matches foo&lt;T&gt;() </pre></td></tr>
1618
1619
1620 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unresolvedMemberExpr0')"><a name="unresolvedMemberExpr0Anchor">unresolvedMemberExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedMemberExpr.html">UnresolvedMemberExpr</a>&gt;...</td></tr>
1621 <tr><td colspan="4" class="doc" id="unresolvedMemberExpr0"><pre>Matches unresolved member expressions.
1622
1623 Given
1624   struct X {
1625     template &lt;class T&gt; void f();
1626     void g();
1627   };
1628   template &lt;class T&gt; void h() { X x; x.f&lt;T&gt;(); x.g(); }
1629 unresolvedMemberExpr()
1630   matches x.f&lt;T&gt;
1631 </pre></td></tr>
1632
1633
1634 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UserDefinedLiteral.html">UserDefinedLiteral</a>&gt;...</td></tr>
1635 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
1636
1637 Example match: "foo"_suffix
1638 </pre></td></tr>
1639
1640
1641 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;...</td></tr>
1642 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
1643
1644 Given
1645   while (true) {}
1646 whileStmt()
1647   matches 'while (true) {}'.
1648 </pre></td></tr>
1649
1650
1651 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;</td><td class="name" onclick="toggle('templateArgumentLoc0')"><a name="templateArgumentLoc0Anchor">templateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;...</td></tr>
1652 <tr><td colspan="4" class="doc" id="templateArgumentLoc0"><pre>Matches template arguments (with location info).
1653
1654 Given
1655   template &lt;typename T&gt; struct C {};
1656   C&lt;int&gt; c;
1657 templateArgumentLoc()
1658   matches 'int' in C&lt;int&gt;.
1659 </pre></td></tr>
1660
1661
1662 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;...</td></tr>
1663 <tr><td colspan="4" class="doc" id="templateArgument0"><pre>Matches template arguments.
1664
1665 Given
1666   template &lt;typename T&gt; struct C {};
1667   C&lt;int&gt; c;
1668 templateArgument()
1669   matches 'int' in C&lt;int&gt;.
1670 </pre></td></tr>
1671
1672
1673 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt;</td><td class="name" onclick="toggle('templateName0')"><a name="templateName0Anchor">templateName</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt;...</td></tr>
1674 <tr><td colspan="4" class="doc" id="templateName0"><pre>Matches template name.
1675
1676 Given
1677   template &lt;typename T&gt; class X { };
1678   X&lt;int&gt; xi;
1679 templateName()
1680   matches 'X' in X&lt;int&gt;.
1681 </pre></td></tr>
1682
1683
1684 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;...</td></tr>
1685 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
1686 </pre></td></tr>
1687
1688
1689 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;...</td></tr>
1690 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
1691
1692 Given
1693   int a[] = { 2, 3 };
1694   int b[4];
1695   void f() { int c[a[0]]; }
1696 arrayType()
1697   matches "int a[]", "int b[4]" and "int c[a[0]]";
1698 </pre></td></tr>
1699
1700
1701 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;...</td></tr>
1702 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
1703
1704 Given
1705   _Atomic(int) i;
1706 atomicType()
1707   matches "_Atomic(int) i"
1708 </pre></td></tr>
1709
1710
1711 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;...</td></tr>
1712 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
1713
1714 Given:
1715   auto n = 4;
1716   int v[] = { 2, 3 }
1717   for (auto i : v) { }
1718 autoType()
1719   matches "auto n" and "auto i"
1720 </pre></td></tr>
1721
1722
1723 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;...</td></tr>
1724 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
1725 "void (^)(int)".
1726
1727 The pointee is always required to be a FunctionType.
1728 </pre></td></tr>
1729
1730
1731 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1BuiltinType.html">BuiltinType</a>&gt;...</td></tr>
1732 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
1733
1734 Given
1735   struct A {};
1736   A a;
1737   int b;
1738   float c;
1739   bool d;
1740 builtinType()
1741   matches "int b", "float c" and "bool d"
1742 </pre></td></tr>
1743
1744
1745 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;...</td></tr>
1746 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
1747
1748 Given
1749   _Complex float f;
1750 complexType()
1751   matches "_Complex float f"
1752 </pre></td></tr>
1753
1754
1755 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ConstantArrayType.html">ConstantArrayType</a>&gt;...</td></tr>
1756 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
1757
1758 Given
1759   void() {
1760     int a[2];
1761     int b[] = { 2, 3 };
1762     int c[b[0]];
1763   }
1764 constantArrayType()
1765   matches "int a[2]"
1766 </pre></td></tr>
1767
1768
1769 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DecayedType.html">DecayedType</a>&gt;...</td></tr>
1770 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
1771 Example matches i[] in declaration of f.
1772     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
1773 Example matches i[1].
1774     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
1775   void f(int i[]) {
1776     i[1] = 0;
1777   }
1778 </pre></td></tr>
1779
1780
1781 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('decltypeType0')"><a name="decltypeType0Anchor">decltypeType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecltypeType.html">DecltypeType</a>&gt;...</td></tr>
1782 <tr><td colspan="4" class="doc" id="decltypeType0"><pre>Matches types nodes representing C++11 decltype(&lt;expr&gt;) types.
1783
1784 Given:
1785   short i = 1;
1786   int j = 42;
1787   decltype(i + j) result = i + j;
1788 decltypeType()
1789   matches "decltype(i + j)"
1790 </pre></td></tr>
1791
1792
1793 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('deducedTemplateSpecializationType0')"><a name="deducedTemplateSpecializationType0Anchor">deducedTemplateSpecializationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeducedTemplateSpecializationType.html">DeducedTemplateSpecializationType</a>&gt;...</td></tr>
1794 <tr><td colspan="4" class="doc" id="deducedTemplateSpecializationType0"><pre>Matches C++17 deduced template specialization types, e.g. deduced class
1795 template types.
1796
1797 Given
1798   template &lt;typename T&gt;
1799   class C { public: C(T); };
1800
1801   C c(123);
1802 deducedTemplateSpecializationType() matches the type in the declaration
1803 of the variable c.
1804 </pre></td></tr>
1805
1806
1807 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedArrayType.html">DependentSizedArrayType</a>&gt;...</td></tr>
1808 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
1809
1810 Given
1811   template&lt;typename T, int Size&gt;
1812   class array {
1813     T data[Size];
1814   };
1815 dependentSizedArrayType
1816   matches "T data[Size]"
1817 </pre></td></tr>
1818
1819
1820 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;...</td></tr>
1821 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
1822 qualified name.
1823
1824 Given
1825   namespace N {
1826     namespace M {
1827       class D {};
1828     }
1829   }
1830   class C {};
1831
1832   class C c;
1833   N::M::D d;
1834
1835 elaboratedType() matches the type of the variable declarations of both
1836 c and d.
1837 </pre></td></tr>
1838
1839
1840 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('enumType0')"><a name="enumType0Anchor">enumType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;...</td></tr>
1841 <tr><td colspan="4" class="doc" id="enumType0"><pre>Matches enum types.
1842
1843 Given
1844   enum C { Green };
1845   enum class S { Red };
1846
1847   C c;
1848   S s;
1849
1850 enumType() matches the type of the variable declarations of both c and
1851 s.
1852 </pre></td></tr>
1853
1854
1855 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('functionProtoType0')"><a name="functionProtoType0Anchor">functionProtoType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;...</td></tr>
1856 <tr><td colspan="4" class="doc" id="functionProtoType0"><pre>Matches FunctionProtoType nodes.
1857
1858 Given
1859   int (*f)(int);
1860   void g();
1861 functionProtoType()
1862   matches "int (*f)(int)" and the type of "g" in C++ mode.
1863   In C mode, "g" is not matched because it does not contain a prototype.
1864 </pre></td></tr>
1865
1866
1867 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1FunctionType.html">FunctionType</a>&gt;...</td></tr>
1868 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
1869
1870 Given
1871   int (*f)(int);
1872   void g();
1873 functionType()
1874   matches "int (*f)(int)" and the type of "g".
1875 </pre></td></tr>
1876
1877
1878 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1IncompleteArrayType.html">IncompleteArrayType</a>&gt;...</td></tr>
1879 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
1880
1881 Given
1882   int a[] = { 2, 3 };
1883   int b[42];
1884   void f(int c[]) { int d[a[0]]; };
1885 incompleteArrayType()
1886   matches "int a[]" and "int c[]"
1887 </pre></td></tr>
1888
1889
1890 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;...</td></tr>
1891 <tr><td colspan="4" class="doc" id="injectedClassNameType0"><pre>Matches injected class name types.
1892
1893 Example matches S s, but not S&lt;T&gt; s.
1894     (matcher = parmVarDecl(hasType(injectedClassNameType())))
1895   template &lt;typename T&gt; struct S {
1896     void f(S s);
1897     void g(S&lt;T&gt; s);
1898   };
1899 </pre></td></tr>
1900
1901
1902 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1LValueReferenceType.html">LValueReferenceType</a>&gt;...</td></tr>
1903 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
1904
1905 Given:
1906   int *a;
1907   int &amp;b = *a;
1908   int &amp;&amp;c = 1;
1909   auto &amp;d = b;
1910   auto &amp;&amp;e = c;
1911   auto &amp;&amp;f = 2;
1912   int g = 5;
1913
1914 lValueReferenceType() matches the types of b, d, and e. e is
1915 matched since the type is deduced as int&amp; by reference collapsing rules.
1916 </pre></td></tr>
1917
1918
1919 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;...</td></tr>
1920 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
1921 Given
1922   struct A { int i; }
1923   A::* ptr = A::i;
1924 memberPointerType()
1925   matches "A::* ptr"
1926 </pre></td></tr>
1927
1928
1929 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ObjCObjectPointerType.html">ObjCObjectPointerType</a>&gt;...</td></tr>
1930 <tr><td colspan="4" class="doc" id="objcObjectPointerType0"><pre>Matches an Objective-C object pointer type, which is different from
1931 a pointer type, despite being syntactically similar.
1932
1933 Given
1934   int *a;
1935
1936   @interface Foo
1937   @end
1938   Foo *f;
1939 pointerType()
1940   matches "Foo *f", but does not match "int *a".
1941 </pre></td></tr>
1942
1943
1944 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;...</td></tr>
1945 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
1946
1947 Given
1948   int (*ptr_to_array)[4];
1949   int *array_of_ptrs[4];
1950
1951 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
1952 array_of_ptrs.
1953 </pre></td></tr>
1954
1955
1956 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;...</td></tr>
1957 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
1958 types.
1959
1960 Given
1961   int *a;
1962   int &amp;b = *a;
1963   int c = 5;
1964
1965   @interface Foo
1966   @end
1967   Foo *f;
1968 pointerType()
1969   matches "int *a", but does not match "Foo *f".
1970 </pre></td></tr>
1971
1972
1973 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1RValueReferenceType.html">RValueReferenceType</a>&gt;...</td></tr>
1974 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
1975
1976 Given:
1977   int *a;
1978   int &amp;b = *a;
1979   int &amp;&amp;c = 1;
1980   auto &amp;d = b;
1981   auto &amp;&amp;e = c;
1982   auto &amp;&amp;f = 2;
1983   int g = 5;
1984
1985 rValueReferenceType() matches the types of c and f. e is not
1986 matched as it is deduced to int&amp; by reference collapsing rules.
1987 </pre></td></tr>
1988
1989
1990 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;...</td></tr>
1991 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
1992
1993 Given
1994   class C {};
1995   struct S {};
1996
1997   C c;
1998   S s;
1999
2000 recordType() matches the type of the variable declarations of both c
2001 and s.
2002 </pre></td></tr>
2003
2004
2005 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;...</td></tr>
2006 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
2007
2008 Given
2009   int *a;
2010   int &amp;b = *a;
2011   int &amp;&amp;c = 1;
2012   auto &amp;d = b;
2013   auto &amp;&amp;e = c;
2014   auto &amp;&amp;f = 2;
2015   int g = 5;
2016
2017 referenceType() matches the types of b, c, d, e, and f.
2018 </pre></td></tr>
2019
2020
2021 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1SubstTemplateTypeParmType.html">SubstTemplateTypeParmType</a>&gt;...</td></tr>
2022 <tr><td colspan="4" class="doc" id="substTemplateTypeParmType0"><pre>Matches types that represent the result of substituting a type for a
2023 template type parameter.
2024
2025 Given
2026   template &lt;typename T&gt;
2027   void F(T t) {
2028     int i = 1 + t;
2029   }
2030
2031 substTemplateTypeParmType() matches the type of 't' but not '1'
2032 </pre></td></tr>
2033
2034
2035 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('tagType0')"><a name="tagType0Anchor">tagType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;...</td></tr>
2036 <tr><td colspan="4" class="doc" id="tagType0"><pre>Matches tag types (record and enum types).
2037
2038 Given
2039   enum E {};
2040   class C {};
2041
2042   E e;
2043   C c;
2044
2045 tagType() matches the type of the variable declarations of both e
2046 and c.
2047 </pre></td></tr>
2048
2049
2050 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;...</td></tr>
2051 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
2052
2053 Given
2054   template &lt;typename T&gt;
2055   class C { };
2056
2057   template class C&lt;int&gt;;  // A
2058   C&lt;char&gt; var;            // B
2059
2060 templateSpecializationType() matches the type of the explicit
2061 instantiation in A and the type of the variable declaration in B.
2062 </pre></td></tr>
2063
2064
2065 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;...</td></tr>
2066 <tr><td colspan="4" class="doc" id="templateTypeParmType0"><pre>Matches template type parameter types.
2067
2068 Example matches T, but not int.
2069     (matcher = templateTypeParmType())
2070   template &lt;typename T&gt; void f(int i);
2071 </pre></td></tr>
2072
2073
2074 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;...</td></tr>
2075 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
2076 </pre></td></tr>
2077
2078
2079 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;...</td></tr>
2080 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
2081
2082 Given
2083   typedef int X;
2084 typedefType()
2085   matches "typedef int X"
2086 </pre></td></tr>
2087
2088
2089 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1UnaryTransformType.html">UnaryTransformType</a>&gt;...</td></tr>
2090 <tr><td colspan="4" class="doc" id="unaryTransformType0"><pre>Matches types nodes representing unary type transformations.
2091
2092 Given:
2093   typedef __underlying_type(T) type;
2094 unaryTransformType()
2095   matches "__underlying_type(T)"
2096 </pre></td></tr>
2097
2098
2099 <tr><td>Matcher&lt;<a href="https://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="https://clang.llvm.org/doxygen/classclang_1_1VariableArrayType.html">VariableArrayType</a>&gt;...</td></tr>
2100 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
2101 integer-constant-expression.
2102
2103 Given
2104   void f() {
2105     int a[] = { 2, 3 }
2106     int b[42];
2107     int c[a[0]];
2108   }
2109 variableArrayType()
2110   matches "int c[a[0]]"
2111 </pre></td></tr>
2112
2113 <!--END_DECL_MATCHERS -->
2114 </table>
2115
2116 <!-- ======================================================================= -->
2117 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
2118 <!-- ======================================================================= -->
2119
2120 <p>Narrowing matchers match certain attributes on the current node, thus
2121 narrowing down the set of nodes of the current type to match on.</p>
2122
2123 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
2124 which allow users to create more powerful match expressions.</p>
2125
2126 <table>
2127 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
2128 <!-- START_NARROWING_MATCHERS -->
2129
2130 <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>
2131 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
2132
2133 Usable as: Any Matcher
2134 </pre></td></tr>
2135
2136
2137 <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>
2138 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
2139
2140 Usable as: Any Matcher
2141 </pre></td></tr>
2142
2143
2144 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
2145 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
2146
2147 Useful when another matcher requires a child matcher, but there's no
2148 additional constraint. This will often be used with an explicit conversion
2149 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
2150
2151 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
2152 "int* p" and "void f()" in
2153   int* p;
2154   void f();
2155
2156 Usable as: Any Matcher
2157 </pre></td></tr>
2158
2159
2160 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;</td></tr>
2161 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
2162
2163 Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
2164   class X {};
2165   class Y {};
2166
2167 Usable as: Any Matcher
2168 </pre></td></tr>
2169
2170
2171 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasAnyOperatorName0')"><a name="hasAnyOperatorName0Anchor">hasAnyOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
2172 <tr><td colspan="4" class="doc" id="hasAnyOperatorName0"><pre>Matches operator expressions (binary or unary) that have any of the
2173 specified names.
2174
2175    hasAnyOperatorName("+", "-")
2176  Is equivalent to
2177    anyOf(hasOperatorName("+"), hasOperatorName("-"))
2178 </pre></td></tr>
2179
2180
2181 <tr><td>Matcher&lt;<a href="https://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>
2182 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions (binary or
2183 unary).
2184
2185 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
2186   !(a || b)
2187 </pre></td></tr>
2188
2189
2190 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('isAssignmentOperator0')"><a name="isAssignmentOperator0Anchor">isAssignmentOperator</a></td><td></td></tr>
2191 <tr><td colspan="4" class="doc" id="isAssignmentOperator0"><pre>Matches all kinds of assignment operators.
2192
2193 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
2194   if (a == b)
2195     a += b;
2196
2197 Example 2: matches s1 = s2
2198            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
2199   struct S { S&amp; operator=(const S&amp;); };
2200   void x() { S s1, s2; s1 = s2; }
2201 </pre></td></tr>
2202
2203
2204 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('isComparisonOperator0')"><a name="isComparisonOperator0Anchor">isComparisonOperator</a></td><td></td></tr>
2205 <tr><td colspan="4" class="doc" id="isComparisonOperator0"><pre>Matches comparison operators.
2206
2207 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
2208   if (a == b)
2209     a += b;
2210
2211 Example 2: matches s1 &lt; s2
2212            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
2213   struct S { bool operator&lt;(const S&amp; other); };
2214   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
2215 </pre></td></tr>
2216
2217
2218 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isPrivate1')"><a name="isPrivate1Anchor">isPrivate</a></td><td></td></tr>
2219 <tr><td colspan="4" class="doc" id="isPrivate1"><pre>Matches private C++ declarations and C++ base specifers that specify private
2220 inheritance.
2221
2222 Examples:
2223   class C {
2224   public:    int a;
2225   protected: int b;
2226   private:   int c; // fieldDecl(isPrivate()) matches 'c'
2227   };
2228
2229   struct Base {};
2230   struct Derived1 : private Base {}; // matches 'Base'
2231   class Derived2 : Base {}; // matches 'Base'
2232 </pre></td></tr>
2233
2234
2235 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isProtected1')"><a name="isProtected1Anchor">isProtected</a></td><td></td></tr>
2236 <tr><td colspan="4" class="doc" id="isProtected1"><pre>Matches protected C++ declarations and C++ base specifers that specify
2237 protected inheritance.
2238
2239 Examples:
2240   class C {
2241   public:    int a;
2242   protected: int b; // fieldDecl(isProtected()) matches 'b'
2243   private:   int c;
2244   };
2245
2246   class Base {};
2247   class Derived : protected Base {}; // matches 'Base'
2248 </pre></td></tr>
2249
2250
2251 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isPublic1')"><a name="isPublic1Anchor">isPublic</a></td><td></td></tr>
2252 <tr><td colspan="4" class="doc" id="isPublic1"><pre>Matches public C++ declarations and C++ base specifers that specify public
2253 inheritance.
2254
2255 Examples:
2256   class C {
2257   public:    int a; // fieldDecl(isPublic()) matches 'a'
2258   protected: int b;
2259   private:   int c;
2260   };
2261
2262   class Base {};
2263   class Derived1 : public Base {}; // matches 'Base'
2264   struct Derived2 : Base {}; // matches 'Base'
2265 </pre></td></tr>
2266
2267
2268 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isVirtual1')"><a name="isVirtual1Anchor">isVirtual</a></td><td></td></tr>
2269 <tr><td colspan="4" class="doc" id="isVirtual1"><pre>Matches declarations of virtual methods and C++ base specifers that specify
2270 virtual inheritance.
2271
2272 Example:
2273   class A {
2274    public:
2275     virtual void x(); // matches x
2276   };
2277
2278 Example:
2279   class Base {};
2280   class DirectlyDerived : virtual Base {}; // matches Base
2281   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
2282
2283 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
2284 </pre></td></tr>
2285
2286
2287 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals5')"><a name="equals5Anchor">equals</a></td><td>bool Value</td></tr>
2288 <tr><td colspan="4" class="doc" id="equals5"><pre></pre></td></tr>
2289
2290
2291 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals2')"><a name="equals2Anchor">equals</a></td><td>const ValueT  Value</td></tr>
2292 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value of type ValueT.
2293
2294 Given
2295   f('false, 3.14, 42);
2296 characterLiteral(equals(0))
2297   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
2298   match false
2299 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
2300   match 3.14
2301 integerLiteral(equals(42))
2302   matches 42
2303
2304 Note that you cannot directly match a negative numeric literal because the
2305 minus sign is not part of the literal: It is a unary operator whose operand
2306 is the positive numeric literal. Instead, you must use a unaryOperator()
2307 matcher to match the minus sign:
2308
2309 unaryOperator(hasOperatorName("-"),
2310               hasUnaryOperand(integerLiteral(equals(13))))
2311
2312 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
2313            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
2314 </pre></td></tr>
2315
2316
2317 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals11')"><a name="equals11Anchor">equals</a></td><td>double Value</td></tr>
2318 <tr><td colspan="4" class="doc" id="equals11"><pre></pre></td></tr>
2319
2320
2321 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals8')"><a name="equals8Anchor">equals</a></td><td>unsigned Value</td></tr>
2322 <tr><td colspan="4" class="doc" id="equals8"><pre></pre></td></tr>
2323
2324
2325 <tr><td>Matcher&lt;<a href="https://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>
2326 <tr><td colspan="4" class="doc" id="isCatchAll0"><pre>Matches a C++ catch statement that has a catch-all handler.
2327
2328 Given
2329   try {
2330     // ...
2331   } catch (int) {
2332     // ...
2333   } catch (...) {
2334     // ...
2335   }
2336 cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
2337 </pre></td></tr>
2338
2339
2340 <tr><td>Matcher&lt;<a href="https://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>
2341 <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has
2342 a specific number of arguments (including absent default arguments).
2343
2344 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2345   void f(int x, int y);
2346   f(0, 0);
2347 </pre></td></tr>
2348
2349
2350 <tr><td>Matcher&lt;<a href="https://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>
2351 <tr><td colspan="4" class="doc" id="isListInitialization0"><pre>Matches a constructor call expression which uses list initialization.
2352 </pre></td></tr>
2353
2354
2355 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('requiresZeroInitialization0')"><a name="requiresZeroInitialization0Anchor">requiresZeroInitialization</a></td><td></td></tr>
2356 <tr><td colspan="4" class="doc" id="requiresZeroInitialization0"><pre>Matches a constructor call expression which requires
2357 zero initialization.
2358
2359 Given
2360 void foo() {
2361   struct point { double x; double y; };
2362   point pt[2] = { { 1.0, 2.0 } };
2363 }
2364 initListExpr(has(cxxConstructExpr(requiresZeroInitialization()))
2365 will match the implicit array filler for pt[1].
2366 </pre></td></tr>
2367
2368
2369 <tr><td>Matcher&lt;<a href="https://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>
2370 <tr><td colspan="4" class="doc" id="isCopyConstructor0"><pre>Matches constructor declarations that are copy constructors.
2371
2372 Given
2373   struct S {
2374     S(); // #1
2375     S(const S &amp;); // #2
2376     S(S &amp;&amp;); // #3
2377   };
2378 cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
2379 </pre></td></tr>
2380
2381
2382 <tr><td>Matcher&lt;<a href="https://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>
2383 <tr><td colspan="4" class="doc" id="isDefaultConstructor0"><pre>Matches constructor declarations that are default constructors.
2384
2385 Given
2386   struct S {
2387     S(); // #1
2388     S(const S &amp;); // #2
2389     S(S &amp;&amp;); // #3
2390   };
2391 cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
2392 </pre></td></tr>
2393
2394
2395 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isDelegatingConstructor0')"><a name="isDelegatingConstructor0Anchor">isDelegatingConstructor</a></td><td></td></tr>
2396 <tr><td colspan="4" class="doc" id="isDelegatingConstructor0"><pre>Matches constructors that delegate to another constructor.
2397
2398 Given
2399   struct S {
2400     S(); // #1
2401     S(int) {} // #2
2402     S(S &amp;&amp;) : S() {} // #3
2403   };
2404   S::S() : S(0) {} // #4
2405 cxxConstructorDecl(isDelegatingConstructor()) will match #3 and #4, but not
2406 #1 or #2.
2407 </pre></td></tr>
2408
2409
2410 <tr><td>Matcher&lt;<a href="https://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>
2411 <tr><td colspan="4" class="doc" id="isExplicit0"><pre>Matches constructor, conversion function, and deduction guide declarations
2412 that have an explicit specifier if this explicit specifier is resolved to
2413 true.
2414
2415 Given
2416   template&lt;bool b&gt;
2417   struct S {
2418     S(int); // #1
2419     explicit S(double); // #2
2420     operator int(); // #3
2421     explicit operator bool(); // #4
2422     explicit(false) S(bool) // # 7
2423     explicit(true) S(char) // # 8
2424     explicit(b) S(S) // # 9
2425   };
2426   S(int) -&gt; S&lt;true&gt; // #5
2427   explicit S(double) -&gt; S&lt;false&gt; // #6
2428 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
2429 cxxConversionDecl(isExplicit()) will match #4, but not #3.
2430 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
2431 </pre></td></tr>
2432
2433
2434 <tr><td>Matcher&lt;<a href="https://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>
2435 <tr><td colspan="4" class="doc" id="isMoveConstructor0"><pre>Matches constructor declarations that are move constructors.
2436
2437 Given
2438   struct S {
2439     S(); // #1
2440     S(const S &amp;); // #2
2441     S(S &amp;&amp;); // #3
2442   };
2443 cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
2444 </pre></td></tr>
2445
2446
2447 <tr><td>Matcher&lt;<a href="https://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>
2448 <tr><td colspan="4" class="doc" id="isExplicit1"><pre>Matches constructor, conversion function, and deduction guide declarations
2449 that have an explicit specifier if this explicit specifier is resolved to
2450 true.
2451
2452 Given
2453   template&lt;bool b&gt;
2454   struct S {
2455     S(int); // #1
2456     explicit S(double); // #2
2457     operator int(); // #3
2458     explicit operator bool(); // #4
2459     explicit(false) S(bool) // # 7
2460     explicit(true) S(char) // # 8
2461     explicit(b) S(S) // # 9
2462   };
2463   S(int) -&gt; S&lt;true&gt; // #5
2464   explicit S(double) -&gt; S&lt;false&gt; // #6
2465 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
2466 cxxConversionDecl(isExplicit()) will match #4, but not #3.
2467 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
2468 </pre></td></tr>
2469
2470
2471 <tr><td>Matcher&lt;<a href="https://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>
2472 <tr><td colspan="4" class="doc" id="isBaseInitializer0"><pre>Matches a constructor initializer if it is initializing a base, as
2473 opposed to a member.
2474
2475 Given
2476   struct B {};
2477   struct D : B {
2478     int I;
2479     D(int i) : I(i) {}
2480   };
2481   struct E : B {
2482     E() : B() {}
2483   };
2484 cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
2485   will match E(), but not match D(int).
2486 </pre></td></tr>
2487
2488
2489 <tr><td>Matcher&lt;<a href="https://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>
2490 <tr><td colspan="4" class="doc" id="isMemberInitializer0"><pre>Matches a constructor initializer if it is initializing a member, as
2491 opposed to a base.
2492
2493 Given
2494   struct B {};
2495   struct D : B {
2496     int I;
2497     D(int i) : I(i) {}
2498   };
2499   struct E : B {
2500     E() : B() {}
2501   };
2502 cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
2503   will match D(int), but not match E().
2504 </pre></td></tr>
2505
2506
2507 <tr><td>Matcher&lt;<a href="https://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>
2508 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a constructor initializer if it is explicitly written in
2509 code (as opposed to implicitly added by the compiler).
2510
2511 Given
2512   struct Foo {
2513     Foo() { }
2514     Foo(int) : foo_("A") { }
2515     string foo_;
2516   };
2517 cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
2518   will match Foo(int), but not Foo()
2519 </pre></td></tr>
2520
2521
2522 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDeductionGuideDecl.html">CXXDeductionGuideDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicit2')"><a name="isExplicit2Anchor">isExplicit</a></td><td></td></tr>
2523 <tr><td colspan="4" class="doc" id="isExplicit2"><pre>Matches constructor, conversion function, and deduction guide declarations
2524 that have an explicit specifier if this explicit specifier is resolved to
2525 true.
2526
2527 Given
2528   template&lt;bool b&gt;
2529   struct S {
2530     S(int); // #1
2531     explicit S(double); // #2
2532     operator int(); // #3
2533     explicit operator bool(); // #4
2534     explicit(false) S(bool) // # 7
2535     explicit(true) S(char) // # 8
2536     explicit(b) S(S) // # 9
2537   };
2538   S(int) -&gt; S&lt;true&gt; // #5
2539   explicit S(double) -&gt; S&lt;false&gt; // #6
2540 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
2541 cxxConversionDecl(isExplicit()) will match #4, but not #3.
2542 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
2543 </pre></td></tr>
2544
2545
2546 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;</td><td class="name" onclick="toggle('isArrow2')"><a name="isArrow2Anchor">isArrow</a></td><td></td></tr>
2547 <tr><td colspan="4" class="doc" id="isArrow2"><pre>Matches member expressions that are called with '-&gt;' as opposed
2548 to '.'.
2549
2550 Member calls on the implicit this pointer match as called with '-&gt;'.
2551
2552 Given
2553   class Y {
2554     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
2555     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
2556     int a;
2557     static int b;
2558   };
2559   template &lt;class T&gt;
2560   class Z {
2561     void x() { this-&gt;m; }
2562   };
2563 memberExpr(isArrow())
2564   matches this-&gt;x, x, y.x, a, this-&gt;b
2565 cxxDependentScopeMemberExpr(isArrow())
2566   matches this-&gt;m
2567 unresolvedMemberExpr(isArrow())
2568   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
2569 </pre></td></tr>
2570
2571
2572 <tr><td>Matcher&lt;<a href="https://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>
2573 <tr><td colspan="4" class="doc" id="isConst0"><pre>Matches if the given method declaration is const.
2574
2575 Given
2576 struct A {
2577   void foo() const;
2578   void bar();
2579 };
2580
2581 cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
2582 </pre></td></tr>
2583
2584
2585 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isCopyAssignmentOperator0')"><a name="isCopyAssignmentOperator0Anchor">isCopyAssignmentOperator</a></td><td></td></tr>
2586 <tr><td colspan="4" class="doc" id="isCopyAssignmentOperator0"><pre>Matches if the given method declaration declares a copy assignment
2587 operator.
2588
2589 Given
2590 struct A {
2591   A &amp;operator=(const A &amp;);
2592   A &amp;operator=(A &amp;&amp;);
2593 };
2594
2595 cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
2596 the second one.
2597 </pre></td></tr>
2598
2599
2600 <tr><td>Matcher&lt;<a href="https://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>
2601 <tr><td colspan="4" class="doc" id="isFinal1"><pre>Matches if the given method or class declaration is final.
2602
2603 Given:
2604   class A final {};
2605
2606   struct B {
2607     virtual void f();
2608   };
2609
2610   struct C : B {
2611     void f() final;
2612   };
2613 matches A and C::f, but not B, C, or B::f
2614 </pre></td></tr>
2615
2616
2617 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isMoveAssignmentOperator0')"><a name="isMoveAssignmentOperator0Anchor">isMoveAssignmentOperator</a></td><td></td></tr>
2618 <tr><td colspan="4" class="doc" id="isMoveAssignmentOperator0"><pre>Matches if the given method declaration declares a move assignment
2619 operator.
2620
2621 Given
2622 struct A {
2623   A &amp;operator=(const A &amp;);
2624   A &amp;operator=(A &amp;&amp;);
2625 };
2626
2627 cxxMethodDecl(isMoveAssignmentOperator()) matches the second method but not
2628 the first one.
2629 </pre></td></tr>
2630
2631
2632 <tr><td>Matcher&lt;<a href="https://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>
2633 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
2634
2635 Given
2636   class A {
2637    public:
2638     virtual void x();
2639   };
2640   class B : public A {
2641    public:
2642     virtual void x();
2643   };
2644   matches B::x
2645 </pre></td></tr>
2646
2647
2648 <tr><td>Matcher&lt;<a href="https://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>
2649 <tr><td colspan="4" class="doc" id="isPure0"><pre>Matches if the given method declaration is pure.
2650
2651 Given
2652   class A {
2653    public:
2654     virtual void x() = 0;
2655   };
2656   matches A::x
2657 </pre></td></tr>
2658
2659
2660 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isUserProvided0')"><a name="isUserProvided0Anchor">isUserProvided</a></td><td></td></tr>
2661 <tr><td colspan="4" class="doc" id="isUserProvided0"><pre>Matches method declarations that are user-provided.
2662
2663 Given
2664   struct S {
2665     S(); // #1
2666     S(const S &amp;) = default; // #2
2667     S(S &amp;&amp;) = delete; // #3
2668   };
2669 cxxConstructorDecl(isUserProvided()) will match #1, but not #2 or #3.
2670 </pre></td></tr>
2671
2672
2673 <tr><td>Matcher&lt;<a href="https://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>
2674 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches declarations of virtual methods and C++ base specifers that specify
2675 virtual inheritance.
2676
2677 Example:
2678   class A {
2679    public:
2680     virtual void x(); // matches x
2681   };
2682
2683 Example:
2684   class Base {};
2685   class DirectlyDerived : virtual Base {}; // matches Base
2686   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
2687
2688 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
2689 </pre></td></tr>
2690
2691
2692 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isVirtualAsWritten0')"><a name="isVirtualAsWritten0Anchor">isVirtualAsWritten</a></td><td></td></tr>
2693 <tr><td colspan="4" class="doc" id="isVirtualAsWritten0"><pre>Matches if the given method declaration has an explicit "virtual".
2694
2695 Given
2696   class A {
2697    public:
2698     virtual void x();
2699   };
2700   class B : public A {
2701    public:
2702     void x();
2703   };
2704   matches A::x but not B::x
2705 </pre></td></tr>
2706
2707
2708 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('isArray0')"><a name="isArray0Anchor">isArray</a></td><td></td></tr>
2709 <tr><td colspan="4" class="doc" id="isArray0"><pre>Matches array new expressions.
2710
2711 Given:
2712   MyClass *p1 = new MyClass[10];
2713 cxxNewExpr(isArray())
2714   matches the expression 'new MyClass[10]'.
2715 </pre></td></tr>
2716
2717
2718 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyOverloadedOperatorName0')"><a name="hasAnyOverloadedOperatorName0Anchor">hasAnyOverloadedOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
2719 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName0"><pre>Matches overloaded operator names.
2720
2721 Matches overloaded operator names specified in strings without the
2722 "operator" prefix: e.g. "&lt;&lt;".
2723
2724   hasAnyOverloadesOperatorName("+", "-")
2725 Is equivalent to
2726   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
2727 </pre></td></tr>
2728
2729
2730 <tr><td>Matcher&lt;<a href="https://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>
2731 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
2732
2733 Matches overloaded operator names specified in strings without the
2734 "operator" prefix: e.g. "&lt;&lt;".
2735
2736 Given:
2737   class A { int operator*(); };
2738   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
2739   A a;
2740   a &lt;&lt; a;   // &lt;-- This matches
2741
2742 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
2743 specified line and
2744 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
2745 matches the declaration of A.
2746
2747 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
2748 </pre></td></tr>
2749
2750
2751 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('isAssignmentOperator1')"><a name="isAssignmentOperator1Anchor">isAssignmentOperator</a></td><td></td></tr>
2752 <tr><td colspan="4" class="doc" id="isAssignmentOperator1"><pre>Matches all kinds of assignment operators.
2753
2754 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
2755   if (a == b)
2756     a += b;
2757
2758 Example 2: matches s1 = s2
2759            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
2760   struct S { S&amp; operator=(const S&amp;); };
2761   void x() { S s1, s2; s1 = s2; }
2762 </pre></td></tr>
2763
2764
2765 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('isComparisonOperator1')"><a name="isComparisonOperator1Anchor">isComparisonOperator</a></td><td></td></tr>
2766 <tr><td colspan="4" class="doc" id="isComparisonOperator1"><pre>Matches comparison operators.
2767
2768 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
2769   if (a == b)
2770     a += b;
2771
2772 Example 2: matches s1 &lt; s2
2773            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
2774   struct S { bool operator&lt;(const S&amp; other); };
2775   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
2776 </pre></td></tr>
2777
2778
2779 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasDefinition0')"><a name="hasDefinition0Anchor">hasDefinition</a></td><td></td></tr>
2780 <tr><td colspan="4" class="doc" id="hasDefinition0"><pre>Matches a class declaration that is defined.
2781
2782 Example matches x (matcher = cxxRecordDecl(hasDefinition()))
2783 class x {};
2784 class y;
2785 </pre></td></tr>
2786
2787
2788 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom2')"><a name="isDerivedFrom2Anchor">isDerivedFrom</a></td><td>std::string BaseName</td></tr>
2789 <tr><td colspan="4" class="doc" id="isDerivedFrom2"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
2790 </pre></td></tr>
2791
2792
2793 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDirectlyDerivedFrom2')"><a name="isDirectlyDerivedFrom2Anchor">isDirectlyDerivedFrom</a></td><td>std::string BaseName</td></tr>
2794 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom2"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
2795 </pre></td></tr>
2796
2797
2798 <tr><td>Matcher&lt;<a href="https://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>
2799 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
2800 static member variable template instantiations.
2801
2802 Given
2803   template&lt;typename T&gt; void A(T t) { }
2804   template&lt;&gt; void A(int N) { }
2805 functionDecl(isExplicitTemplateSpecialization())
2806   matches the specialization A&lt;int&gt;().
2807
2808 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
2809 </pre></td></tr>
2810
2811
2812 <tr><td>Matcher&lt;<a href="https://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>
2813 <tr><td colspan="4" class="doc" id="isFinal0"><pre>Matches if the given method or class declaration is final.
2814
2815 Given:
2816   class A final {};
2817
2818   struct B {
2819     virtual void f();
2820   };
2821
2822   struct C : B {
2823     void f() final;
2824   };
2825 matches A and C::f, but not B, C, or B::f
2826 </pre></td></tr>
2827
2828
2829 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isLambda0')"><a name="isLambda0Anchor">isLambda</a></td><td></td></tr>
2830 <tr><td colspan="4" class="doc" id="isLambda0"><pre>Matches the generated class of lambda expressions.
2831
2832 Given:
2833   auto x = []{};
2834
2835 cxxRecordDecl(isLambda()) matches the implicit class declaration of
2836 decltype(x)
2837 </pre></td></tr>
2838
2839
2840 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom2')"><a name="isSameOrDerivedFrom2Anchor">isSameOrDerivedFrom</a></td><td>std::string BaseName</td></tr>
2841 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom2"><pre>Overloaded method as shortcut for
2842 isSameOrDerivedFrom(hasName(...)).
2843 </pre></td></tr>
2844
2845
2846 <tr><td>Matcher&lt;<a href="https://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>
2847 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
2848 member variable template instantiations.
2849
2850 Given
2851   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
2852 or
2853   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
2854 or
2855   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
2856 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2857   matches the template instantiation of X&lt;A&gt;.
2858
2859 But given
2860   template &lt;typename T&gt;  class X {}; class A {};
2861   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2862 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2863   does not match, as X&lt;A&gt; is an explicit template specialization.
2864
2865 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
2866 </pre></td></tr>
2867
2868
2869 <tr><td>Matcher&lt;<a href="https://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>
2870 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
2871 a specific number of arguments (including absent default arguments).
2872
2873 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2874   void f(int x, int y);
2875   f(0, 0);
2876 </pre></td></tr>
2877
2878
2879 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('usesADL0')"><a name="usesADL0Anchor">usesADL</a></td><td></td></tr>
2880 <tr><td colspan="4" class="doc" id="usesADL0"><pre>Matches call expressions which were resolved using ADL.
2881
2882 Example matches y(x) but not y(42) or NS::y(x).
2883   namespace NS {
2884     struct X {};
2885     void y(X);
2886   }
2887
2888   void y(...);
2889
2890   void test() {
2891     NS::X x;
2892     y(x); // Matches
2893     NS::y(x); // Doesn't match
2894     y(42); // Doesn't match
2895     using NS::y;
2896     y(x); // Found by both unqualified lookup and ADL, doesn't match
2897    }
2898 </pre></td></tr>
2899
2900
2901 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;</td><td class="name" onclick="toggle('hasCastKind0')"><a name="hasCastKind0Anchor">hasCastKind</a></td><td>CastKind Kind</td></tr>
2902 <tr><td colspan="4" class="doc" id="hasCastKind0"><pre>Matches casts that has a given cast kind.
2903
2904 Example: matches the implicit cast around 0
2905 (matcher = castExpr(hasCastKind(CK_NullToPointer)))
2906   int *p = 0;
2907
2908 If the matcher is use from clang-query, CastKind parameter
2909 should be passed as a quoted string. e.g., hasCastKind("CK_NullToPointer").
2910 </pre></td></tr>
2911
2912
2913 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals4')"><a name="equals4Anchor">equals</a></td><td>bool Value</td></tr>
2914 <tr><td colspan="4" class="doc" id="equals4"><pre></pre></td></tr>
2915
2916
2917 <tr><td>Matcher&lt;<a href="https://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>const ValueT  Value</td></tr>
2918 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value of type ValueT.
2919
2920 Given
2921   f('false, 3.14, 42);
2922 characterLiteral(equals(0))
2923   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
2924   match false
2925 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
2926   match 3.14
2927 integerLiteral(equals(42))
2928   matches 42
2929
2930 Note that you cannot directly match a negative numeric literal because the
2931 minus sign is not part of the literal: It is a unary operator whose operand
2932 is the positive numeric literal. Instead, you must use a unaryOperator()
2933 matcher to match the minus sign:
2934
2935 unaryOperator(hasOperatorName("-"),
2936               hasUnaryOperand(integerLiteral(equals(13))))
2937
2938 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
2939            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
2940 </pre></td></tr>
2941
2942
2943 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals10')"><a name="equals10Anchor">equals</a></td><td>double Value</td></tr>
2944 <tr><td colspan="4" class="doc" id="equals10"><pre></pre></td></tr>
2945
2946
2947 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals7')"><a name="equals7Anchor">equals</a></td><td>unsigned Value</td></tr>
2948 <tr><td colspan="4" class="doc" id="equals7"><pre></pre></td></tr>
2949
2950
2951 <tr><td>Matcher&lt;<a href="https://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>
2952 <tr><td colspan="4" class="doc" id="templateArgumentCountIs0"><pre>Matches if the number of template arguments equals N.
2953
2954 Given
2955   template&lt;typename T&gt; struct C {};
2956   C&lt;int&gt; c;
2957 classTemplateSpecializationDecl(templateArgumentCountIs(1))
2958   matches C&lt;int&gt;.
2959 </pre></td></tr>
2960
2961
2962 <tr><td>Matcher&lt;<a href="https://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>
2963 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
2964 child statements.
2965
2966 Example: Given
2967   { for (;;) {} }
2968 compoundStmt(statementCountIs(0)))
2969   matches '{}'
2970   but does not match the outer compound statement.
2971 </pre></td></tr>
2972
2973
2974 <tr><td>Matcher&lt;<a href="https://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>
2975 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches nodes that have the specified size.
2976
2977 Given
2978   int a[42];
2979   int b[2 * 21];
2980   int c[41], d[43];
2981   char *s = "abcd";
2982   wchar_t *ws = L"abcd";
2983   char *w = "a";
2984 constantArrayType(hasSize(42))
2985   matches "int a[42]" and "int b[2 * 21]"
2986 stringLiteral(hasSize(4))
2987   matches "abcd", L"abcd"
2988 </pre></td></tr>
2989
2990
2991 <tr><td>Matcher&lt;<a href="https://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>
2992 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
2993 declarations.
2994
2995 Example: Given
2996   int a, b;
2997   int c;
2998   int d = 2, e;
2999 declCountIs(2)
3000   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
3001 </pre></td></tr>
3002
3003
3004 <tr><td>Matcher&lt;<a href="https://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>
3005 <tr><td colspan="4" class="doc" id="equalsBoundNode1"><pre>Matches if a node equals a previously bound node.
3006
3007 Matches a node if it equals the node previously bound to ID.
3008
3009 Given
3010   class X { int a; int b; };
3011 cxxRecordDecl(
3012     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
3013     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
3014   matches the class X, as a and b have the same type.
3015
3016 Note that when multiple matches are involved via forEach* matchers,
3017 equalsBoundNodes acts as a filter.
3018 For example:
3019 compoundStmt(
3020     forEachDescendant(varDecl().bind("d")),
3021     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
3022 will trigger a match for each combination of variable declaration
3023 and reference to that variable declaration within a compound statement.
3024 </pre></td></tr>
3025
3026
3027 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('equalsNode0')"><a name="equalsNode0Anchor">equalsNode</a></td><td>const Decl* Other</td></tr>
3028 <tr><td colspan="4" class="doc" id="equalsNode0"><pre>Matches if a node equals another node.
3029
3030 Decl has pointer identity in the AST.
3031 </pre></td></tr>
3032
3033
3034 <tr><td>Matcher&lt;<a href="https://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>
3035 <tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
3036
3037 Given
3038   __attribute__((device)) void f() { ... }
3039 decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
3040 f. If the matcher is used from clang-query, attr::Kind parameter should be
3041 passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
3042 </pre></td></tr>
3043
3044
3045 <tr><td>Matcher&lt;<a href="https://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>StringRef RegExp, Regex::RegexFlags Flags = NoFlags</td></tr>
3046 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching0"><pre>Matches AST nodes that were expanded within files whose name is
3047 partially matching a given regex.
3048
3049 Example matches Y but not X
3050     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
3051   #include "ASTMatcher.h"
3052   class X {};
3053 ASTMatcher.h:
3054   class Y {};
3055
3056 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
3057
3058 If the matcher is used in clang-query, RegexFlags parameter
3059 should be passed as a quoted string. e.g: "NoFlags".
3060 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
3061 </pre></td></tr>
3062
3063
3064 <tr><td>Matcher&lt;<a href="https://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>
3065 <tr><td colspan="4" class="doc" id="isExpansionInMainFile0"><pre>Matches AST nodes that were expanded within the main-file.
3066
3067 Example matches X but not Y
3068   (matcher = cxxRecordDecl(isExpansionInMainFile())
3069   #include &lt;Y.h&gt;
3070   class X {};
3071 Y.h:
3072   class Y {};
3073
3074 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
3075 </pre></td></tr>
3076
3077
3078 <tr><td>Matcher&lt;<a href="https://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>
3079 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader0"><pre>Matches AST nodes that were expanded within system-header-files.
3080
3081 Example matches Y but not X
3082     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
3083   #include &lt;SystemHeader.h&gt;
3084   class X {};
3085 SystemHeader.h:
3086   class Y {};
3087
3088 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
3089 </pre></td></tr>
3090
3091
3092 <tr><td>Matcher&lt;<a href="https://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>
3093 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches a declaration that has been implicitly added
3094 by the compiler (eg. implicit default/copy constructors).
3095 </pre></td></tr>
3096
3097
3098 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isInStdNamespace0')"><a name="isInStdNamespace0Anchor">isInStdNamespace</a></td><td></td></tr>
3099 <tr><td colspan="4" class="doc" id="isInStdNamespace0"><pre>Matches declarations in the namespace `std`, but not in nested namespaces.
3100
3101 Given
3102   class vector {};
3103   namespace foo {
3104     class vector {};
3105     namespace std {
3106       class vector {};
3107     }
3108   }
3109   namespace std {
3110     inline namespace __1 {
3111       class vector {}; // #1
3112       namespace experimental {
3113         class vector {};
3114       }
3115     }
3116   }
3117 cxxRecordDecl(hasName("vector"), isInStdNamespace()) will match only #1.
3118 </pre></td></tr>
3119
3120
3121 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isInstantiated0')"><a name="isInstantiated0Anchor">isInstantiated</a></td><td></td></tr>
3122 <tr><td colspan="4" class="doc" id="isInstantiated0"><pre>Matches declarations that are template instantiations or are inside
3123 template instantiations.
3124
3125 Given
3126   template&lt;typename T&gt; void A(T t) { T i; }
3127   A(0);
3128   A(0U);
3129 functionDecl(isInstantiated())
3130   matches 'A(int) {...};' and 'A(unsigned) {...}'.
3131 </pre></td></tr>
3132
3133
3134 <tr><td>Matcher&lt;<a href="https://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>
3135 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations and C++ base specifers that specify private
3136 inheritance.
3137
3138 Examples:
3139   class C {
3140   public:    int a;
3141   protected: int b;
3142   private:   int c; // fieldDecl(isPrivate()) matches 'c'
3143   };
3144
3145   struct Base {};
3146   struct Derived1 : private Base {}; // matches 'Base'
3147   class Derived2 : Base {}; // matches 'Base'
3148 </pre></td></tr>
3149
3150
3151 <tr><td>Matcher&lt;<a href="https://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>
3152 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations and C++ base specifers that specify
3153 protected inheritance.
3154
3155 Examples:
3156   class C {
3157   public:    int a;
3158   protected: int b; // fieldDecl(isProtected()) matches 'b'
3159   private:   int c;
3160   };
3161
3162   class Base {};
3163   class Derived : protected Base {}; // matches 'Base'
3164 </pre></td></tr>
3165
3166
3167 <tr><td>Matcher&lt;<a href="https://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>
3168 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations and C++ base specifers that specify public
3169 inheritance.
3170
3171 Examples:
3172   class C {
3173   public:    int a; // fieldDecl(isPublic()) matches 'a'
3174   protected: int b;
3175   private:   int c;
3176   };
3177
3178   class Base {};
3179   class Derived1 : public Base {}; // matches 'Base'
3180   struct Derived2 : Base {}; // matches 'Base'
3181 </pre></td></tr>
3182
3183
3184 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;</td><td class="name" onclick="toggle('designatorCountIs0')"><a name="designatorCountIs0Anchor">designatorCountIs</a></td><td>unsigned N</td></tr>
3185 <tr><td colspan="4" class="doc" id="designatorCountIs0"><pre>Matches designated initializer expressions that contain
3186 a specific number of designators.
3187
3188 Example: Given
3189   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
3190   point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 };
3191 designatorCountIs(2)
3192   matches '{ [2].y = 1.0, [0].x = 1.0 }',
3193   but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'.
3194 </pre></td></tr>
3195
3196
3197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumDecl.html">EnumDecl</a>&gt;</td><td class="name" onclick="toggle('isScoped0')"><a name="isScoped0Anchor">isScoped</a></td><td></td></tr>
3198 <tr><td colspan="4" class="doc" id="isScoped0"><pre>Matches C++11 scoped enum declaration.
3199
3200 Example matches Y (matcher = enumDecl(isScoped()))
3201 enum X {};
3202 enum class Y {};
3203 </pre></td></tr>
3204
3205
3206 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('isInstantiationDependent0')"><a name="isInstantiationDependent0Anchor">isInstantiationDependent</a></td><td></td></tr>
3207 <tr><td colspan="4" class="doc" id="isInstantiationDependent0"><pre>Matches expressions that are instantiation-dependent even if it is
3208 neither type- nor value-dependent.
3209
3210 In the following example, the expression sizeof(sizeof(T() + T()))
3211 is instantiation-dependent (since it involves a template parameter T),
3212 but is neither type- nor value-dependent, since the type of the inner
3213 sizeof is known (std::size_t) and therefore the size of the outer
3214 sizeof is known.
3215   template&lt;typename T&gt;
3216   void f(T x, T y) { sizeof(sizeof(T() + T()); }
3217 expr(isInstantiationDependent()) matches sizeof(sizeof(T() + T())
3218 </pre></td></tr>
3219
3220
3221 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('isTypeDependent0')"><a name="isTypeDependent0Anchor">isTypeDependent</a></td><td></td></tr>
3222 <tr><td colspan="4" class="doc" id="isTypeDependent0"><pre>Matches expressions that are type-dependent because the template type
3223 is not yet instantiated.
3224
3225 For example, the expressions "x" and "x + y" are type-dependent in
3226 the following code, but "y" is not type-dependent:
3227   template&lt;typename T&gt;
3228   void add(T x, int y) {
3229     x + y;
3230   }
3231 expr(isTypeDependent()) matches x + y
3232 </pre></td></tr>
3233
3234
3235 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('isValueDependent0')"><a name="isValueDependent0Anchor">isValueDependent</a></td><td></td></tr>
3236 <tr><td colspan="4" class="doc" id="isValueDependent0"><pre>Matches expression that are value-dependent because they contain a
3237 non-type template parameter.
3238
3239 For example, the array bound of "Chars" in the following example is
3240 value-dependent.
3241   template&lt;int Size&gt; int f() { return Size; }
3242 expr(isValueDependent()) matches return Size
3243 </pre></td></tr>
3244
3245
3246 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('nullPointerConstant0')"><a name="nullPointerConstant0Anchor">nullPointerConstant</a></td><td></td></tr>
3247 <tr><td colspan="4" class="doc" id="nullPointerConstant0"><pre>Matches expressions that resolve to a null pointer constant, such as
3248 GNU's __null, C++11's nullptr, or C's NULL macro.
3249
3250 Given:
3251   void *v1 = NULL;
3252   void *v2 = nullptr;
3253   void *v3 = __null; // GNU extension
3254   char *cp = (char *)0;
3255   int *ip = 0;
3256   int i = 0;
3257 expr(nullPointerConstant())
3258   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
3259   initializer for i.
3260 </pre></td></tr>
3261
3262
3263 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('hasBitWidth0')"><a name="hasBitWidth0Anchor">hasBitWidth</a></td><td>unsigned Width</td></tr>
3264 <tr><td colspan="4" class="doc" id="hasBitWidth0"><pre>Matches non-static data members that are bit-fields of the specified
3265 bit width.
3266
3267 Given
3268   class C {
3269     int a : 2;
3270     int b : 4;
3271     int c : 2;
3272   };
3273 fieldDecl(hasBitWidth(2))
3274   matches 'int a;' and 'int c;' but not 'int b;'.
3275 </pre></td></tr>
3276
3277
3278 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('isBitField0')"><a name="isBitField0Anchor">isBitField</a></td><td></td></tr>
3279 <tr><td colspan="4" class="doc" id="isBitField0"><pre>Matches non-static data members that are bit-fields.
3280
3281 Given
3282   class C {
3283     int a : 2;
3284     int b;
3285   };
3286 fieldDecl(isBitField())
3287   matches 'int a;' but not 'int b;'.
3288 </pre></td></tr>
3289
3290
3291 <tr><td>Matcher&lt;<a href="https://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>const ValueT  Value</td></tr>
3292 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value of type ValueT.
3293
3294 Given
3295   f('false, 3.14, 42);
3296 characterLiteral(equals(0))
3297   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
3298   match false
3299 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
3300   match 3.14
3301 integerLiteral(equals(42))
3302   matches 42
3303
3304 Note that you cannot directly match a negative numeric literal because the
3305 minus sign is not part of the literal: It is a unary operator whose operand
3306 is the positive numeric literal. Instead, you must use a unaryOperator()
3307 matcher to match the minus sign:
3308
3309 unaryOperator(hasOperatorName("-"),
3310               hasUnaryOperand(integerLiteral(equals(13))))
3311
3312 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
3313            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
3314 </pre></td></tr>
3315
3316
3317 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;</td><td class="name" onclick="toggle('equals12')"><a name="equals12Anchor">equals</a></td><td>double Value</td></tr>
3318 <tr><td colspan="4" class="doc" id="equals12"><pre></pre></td></tr>
3319
3320
3321 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyOverloadedOperatorName1')"><a name="hasAnyOverloadedOperatorName1Anchor">hasAnyOverloadedOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
3322 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName1"><pre>Matches overloaded operator names.
3323
3324 Matches overloaded operator names specified in strings without the
3325 "operator" prefix: e.g. "&lt;&lt;".
3326
3327   hasAnyOverloadesOperatorName("+", "-")
3328 Is equivalent to
3329   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
3330 </pre></td></tr>
3331
3332
3333 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasDynamicExceptionSpec0')"><a name="hasDynamicExceptionSpec0Anchor">hasDynamicExceptionSpec</a></td><td></td></tr>
3334 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec0"><pre>Matches functions that have a dynamic exception specification.
3335
3336 Given:
3337   void f();
3338   void g() noexcept;
3339   void h() noexcept(true);
3340   void i() noexcept(false);
3341   void j() throw();
3342   void k() throw(int);
3343   void l() throw(...);
3344 functionDecl(hasDynamicExceptionSpec()) and
3345   functionProtoType(hasDynamicExceptionSpec())
3346   match the declarations of j, k, and l, but not f, g, h, or i.
3347 </pre></td></tr>
3348
3349
3350 <tr><td>Matcher&lt;<a href="https://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>
3351 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
3352
3353 Matches overloaded operator names specified in strings without the
3354 "operator" prefix: e.g. "&lt;&lt;".
3355
3356 Given:
3357   class A { int operator*(); };
3358   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
3359   A a;
3360   a &lt;&lt; a;   // &lt;-- This matches
3361
3362 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
3363 specified line and
3364 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
3365 matches the declaration of A.
3366
3367 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
3368 </pre></td></tr>
3369
3370
3371 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasTrailingReturn0')"><a name="hasTrailingReturn0Anchor">hasTrailingReturn</a></td><td></td></tr>
3372 <tr><td colspan="4" class="doc" id="hasTrailingReturn0"><pre>Matches a function declared with a trailing return type.
3373
3374 Example matches Y (matcher = functionDecl(hasTrailingReturn()))
3375 int X() {}
3376 auto Y() -&gt; int {}
3377 </pre></td></tr>
3378
3379
3380 <tr><td>Matcher&lt;<a href="https://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>
3381 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations,
3382        and if constexpr.
3383
3384 Given:
3385   constexpr int foo = 42;
3386   constexpr int bar();
3387   void baz() { if constexpr(1 &gt; 0) {} }
3388 varDecl(isConstexpr())
3389   matches the declaration of foo.
3390 functionDecl(isConstexpr())
3391   matches the declaration of bar.
3392 ifStmt(isConstexpr())
3393   matches the if statement in baz.
3394 </pre></td></tr>
3395
3396
3397 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isDefaulted0')"><a name="isDefaulted0Anchor">isDefaulted</a></td><td></td></tr>
3398 <tr><td colspan="4" class="doc" id="isDefaulted0"><pre>Matches defaulted function declarations.
3399
3400 Given:
3401   class A { ~A(); };
3402   class B { ~B() = default; };
3403 functionDecl(isDefaulted())
3404   matches the declaration of ~B, but not ~A.
3405 </pre></td></tr>
3406
3407
3408 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition3')"><a name="isDefinition3Anchor">isDefinition</a></td><td></td></tr>
3409 <tr><td colspan="4" class="doc" id="isDefinition3"><pre>Matches if a declaration has a body attached.
3410
3411 Example matches A, va, fa
3412   class A {};
3413   class B;  // Doesn't match, as it has no body.
3414   int va;
3415   extern int vb;  // Doesn't match, as it doesn't define the variable.
3416   void fa() {}
3417   void fb();  // Doesn't match, as it has no body.
3418   @interface X
3419   - (void)ma; // Doesn't match, interface is declaration.
3420   @end
3421   @implementation X
3422   - (void)ma {}
3423   @end
3424
3425 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;,
3426   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
3427 </pre></td></tr>
3428
3429
3430 <tr><td>Matcher&lt;<a href="https://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>
3431 <tr><td colspan="4" class="doc" id="isDeleted0"><pre>Matches deleted function declarations.
3432
3433 Given:
3434   void Func();
3435   void DeletedFunc() = delete;
3436 functionDecl(isDeleted())
3437   matches the declaration of DeletedFunc, but not Func.
3438 </pre></td></tr>
3439
3440
3441 <tr><td>Matcher&lt;<a href="https://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>
3442 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization0"><pre>Matches explicit template specializations of function, class, or
3443 static member variable template instantiations.
3444
3445 Given
3446   template&lt;typename T&gt; void A(T t) { }
3447   template&lt;&gt; void A(int N) { }
3448 functionDecl(isExplicitTemplateSpecialization())
3449   matches the specialization A&lt;int&gt;().
3450
3451 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
3452 </pre></td></tr>
3453
3454
3455 <tr><td>Matcher&lt;<a href="https://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>
3456 <tr><td colspan="4" class="doc" id="isExternC0"><pre>Matches extern "C" function or variable declarations.
3457
3458 Given:
3459   extern "C" void f() {}
3460   extern "C" { void g() {} }
3461   void h() {}
3462   extern "C" int x = 1;
3463   extern "C" int y = 2;
3464   int z = 3;
3465 functionDecl(isExternC())
3466   matches the declaration of f and g, but not the declaration of h.
3467 varDecl(isExternC())
3468   matches the declaration of x and y, but not the declaration of z.
3469 </pre></td></tr>
3470
3471
3472 <tr><td>Matcher&lt;<a href="https://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>
3473 <tr><td colspan="4" class="doc" id="isInline1"><pre>Matches function and namespace declarations that are marked with
3474 the inline keyword.
3475
3476 Given
3477   inline void f();
3478   void g();
3479   namespace n {
3480   inline namespace m {}
3481   }
3482 functionDecl(isInline()) will match ::f().
3483 namespaceDecl(isInline()) will match n::m.
3484 </pre></td></tr>
3485
3486
3487 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isMain0')"><a name="isMain0Anchor">isMain</a></td><td></td></tr>
3488 <tr><td colspan="4" class="doc" id="isMain0"><pre>Determines whether the function is "main", which is the entry point
3489 into an executable program.
3490 </pre></td></tr>
3491
3492
3493 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isNoReturn0')"><a name="isNoReturn0Anchor">isNoReturn</a></td><td></td></tr>
3494 <tr><td colspan="4" class="doc" id="isNoReturn0"><pre>Matches FunctionDecls that have a noreturn attribute.
3495
3496 Given
3497   void nope();
3498   [[noreturn]] void a();
3499   __attribute__((noreturn)) void b();
3500   struct c { [[noreturn]] c(); };
3501 functionDecl(isNoReturn())
3502   matches all of those except
3503   void nope();
3504 </pre></td></tr>
3505
3506
3507 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isNoThrow0')"><a name="isNoThrow0Anchor">isNoThrow</a></td><td></td></tr>
3508 <tr><td colspan="4" class="doc" id="isNoThrow0"><pre>Matches functions that have a non-throwing exception specification.
3509
3510 Given:
3511   void f();
3512   void g() noexcept;
3513   void h() throw();
3514   void i() throw(int);
3515   void j() noexcept(false);
3516 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
3517   match the declarations of g, and h, but not f, i or j.
3518 </pre></td></tr>
3519
3520
3521 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isStaticStorageClass0')"><a name="isStaticStorageClass0Anchor">isStaticStorageClass</a></td><td></td></tr>
3522 <tr><td colspan="4" class="doc" id="isStaticStorageClass0"><pre>Matches variable/function declarations that have "static" storage
3523 class specifier ("static" keyword) written in the source.
3524
3525 Given:
3526   static void f() {}
3527   static int i = 0;
3528   extern int j;
3529   int k;
3530 functionDecl(isStaticStorageClass())
3531   matches the function declaration f.
3532 varDecl(isStaticStorageClass())
3533   matches the variable declaration i.
3534 </pre></td></tr>
3535
3536
3537 <tr><td>Matcher&lt;<a href="https://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>
3538 <tr><td colspan="4" class="doc" id="isTemplateInstantiation0"><pre>Matches template instantiations of function, class, or static
3539 member variable template instantiations.
3540
3541 Given
3542   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
3543 or
3544   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
3545 or
3546   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
3547 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3548   matches the template instantiation of X&lt;A&gt;.
3549
3550 But given
3551   template &lt;typename T&gt;  class X {}; class A {};
3552   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
3553 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3554   does not match, as X&lt;A&gt; is an explicit template specialization.
3555
3556 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
3557 </pre></td></tr>
3558
3559
3560 <tr><td>Matcher&lt;<a href="https://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>
3561 <tr><td colspan="4" class="doc" id="isVariadic0"><pre>Matches if a function declaration is variadic.
3562
3563 Example matches f, but not g or h. The function i will not match, even when
3564 compiled in C mode.
3565   void f(...);
3566   void g(int);
3567   template &lt;typename... Ts&gt; void h(Ts...);
3568   void i();
3569 </pre></td></tr>
3570
3571
3572 <tr><td>Matcher&lt;<a href="https://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>
3573 <tr><td colspan="4" class="doc" id="parameterCountIs0"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
3574 specific parameter count.
3575
3576 Given
3577   void f(int i) {}
3578   void g(int i, int j) {}
3579   void h(int i, int j);
3580   void j(int i);
3581   void k(int x, int y, int z, ...);
3582 functionDecl(parameterCountIs(2))
3583   matches g and h
3584 functionProtoType(parameterCountIs(2))
3585   matches g and h
3586 functionProtoType(parameterCountIs(3))
3587   matches k
3588 </pre></td></tr>
3589
3590
3591 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;</td><td class="name" onclick="toggle('hasDynamicExceptionSpec1')"><a name="hasDynamicExceptionSpec1Anchor">hasDynamicExceptionSpec</a></td><td></td></tr>
3592 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec1"><pre>Matches functions that have a dynamic exception specification.
3593
3594 Given:
3595   void f();
3596   void g() noexcept;
3597   void h() noexcept(true);
3598   void i() noexcept(false);
3599   void j() throw();
3600   void k() throw(int);
3601   void l() throw(...);
3602 functionDecl(hasDynamicExceptionSpec()) and
3603   functionProtoType(hasDynamicExceptionSpec())
3604   match the declarations of j, k, and l, but not f, g, h, or i.
3605 </pre></td></tr>
3606
3607
3608 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;</td><td class="name" onclick="toggle('isNoThrow1')"><a name="isNoThrow1Anchor">isNoThrow</a></td><td></td></tr>
3609 <tr><td colspan="4" class="doc" id="isNoThrow1"><pre>Matches functions that have a non-throwing exception specification.
3610
3611 Given:
3612   void f();
3613   void g() noexcept;
3614   void h() throw();
3615   void i() throw(int);
3616   void j() noexcept(false);
3617 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
3618   match the declarations of g, and h, but not f, i or j.
3619 </pre></td></tr>
3620
3621
3622 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;</td><td class="name" onclick="toggle('parameterCountIs1')"><a name="parameterCountIs1Anchor">parameterCountIs</a></td><td>unsigned N</td></tr>
3623 <tr><td colspan="4" class="doc" id="parameterCountIs1"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
3624 specific parameter count.
3625
3626 Given
3627   void f(int i) {}
3628   void g(int i, int j) {}
3629   void h(int i, int j);
3630   void j(int i);
3631   void k(int x, int y, int z, ...);
3632 functionDecl(parameterCountIs(2))
3633   matches g and h
3634 functionProtoType(parameterCountIs(2))
3635   matches g and h
3636 functionProtoType(parameterCountIs(3))
3637   matches k
3638 </pre></td></tr>
3639
3640
3641 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('isConstexpr2')"><a name="isConstexpr2Anchor">isConstexpr</a></td><td></td></tr>
3642 <tr><td colspan="4" class="doc" id="isConstexpr2"><pre>Matches constexpr variable and function declarations,
3643        and if constexpr.
3644
3645 Given:
3646   constexpr int foo = 42;
3647   constexpr int bar();
3648   void baz() { if constexpr(1 &gt; 0) {} }
3649 varDecl(isConstexpr())
3650   matches the declaration of foo.
3651 functionDecl(isConstexpr())
3652   matches the declaration of bar.
3653 ifStmt(isConstexpr())
3654   matches the if statement in baz.
3655 </pre></td></tr>
3656
3657
3658 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;</td><td class="name" onclick="toggle('equals6')"><a name="equals6Anchor">equals</a></td><td>bool Value</td></tr>
3659 <tr><td colspan="4" class="doc" id="equals6"><pre></pre></td></tr>
3660
3661
3662 <tr><td>Matcher&lt;<a href="https://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>const ValueT  Value</td></tr>
3663 <tr><td colspan="4" class="doc" id="equals0"><pre>Matches literals that are equal to the given value of type ValueT.
3664
3665 Given
3666   f('false, 3.14, 42);
3667 characterLiteral(equals(0))
3668   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
3669   match false
3670 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
3671   match 3.14
3672 integerLiteral(equals(42))
3673   matches 42
3674
3675 Note that you cannot directly match a negative numeric literal because the
3676 minus sign is not part of the literal: It is a unary operator whose operand
3677 is the positive numeric literal. Instead, you must use a unaryOperator()
3678 matcher to match the minus sign:
3679
3680 unaryOperator(hasOperatorName("-"),
3681               hasUnaryOperand(integerLiteral(equals(13))))
3682
3683 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
3684            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
3685 </pre></td></tr>
3686
3687
3688 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;</td><td class="name" onclick="toggle('equals13')"><a name="equals13Anchor">equals</a></td><td>double Value</td></tr>
3689 <tr><td colspan="4" class="doc" id="equals13"><pre></pre></td></tr>
3690
3691
3692 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;</td><td class="name" onclick="toggle('equals9')"><a name="equals9Anchor">equals</a></td><td>unsigned Value</td></tr>
3693 <tr><td colspan="4" class="doc" id="equals9"><pre></pre></td></tr>
3694
3695
3696 <tr><td>Matcher&lt;<a href="https://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>
3697 <tr><td colspan="4" class="doc" id="isArrow0"><pre>Matches member expressions that are called with '-&gt;' as opposed
3698 to '.'.
3699
3700 Member calls on the implicit this pointer match as called with '-&gt;'.
3701
3702 Given
3703   class Y {
3704     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
3705     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
3706     int a;
3707     static int b;
3708   };
3709   template &lt;class T&gt;
3710   class Z {
3711     void x() { this-&gt;m; }
3712   };
3713 memberExpr(isArrow())
3714   matches this-&gt;x, x, y.x, a, this-&gt;b
3715 cxxDependentScopeMemberExpr(isArrow())
3716   matches this-&gt;m
3717 unresolvedMemberExpr(isArrow())
3718   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
3719 </pre></td></tr>
3720
3721
3722 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyName0')"><a name="hasAnyName0Anchor">hasAnyName</a></td><td>StringRef, ..., StringRef</td></tr>
3723 <tr><td colspan="4" class="doc" id="hasAnyName0"><pre>Matches NamedDecl nodes that have any of the specified names.
3724
3725 This matcher is only provided as a performance optimization of hasName.
3726     hasAnyName(a, b, c)
3727  is equivalent to, but faster than
3728     anyOf(hasName(a), hasName(b), hasName(c))
3729 </pre></td></tr>
3730
3731
3732 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasExternalFormalLinkage0')"><a name="hasExternalFormalLinkage0Anchor">hasExternalFormalLinkage</a></td><td></td></tr>
3733 <tr><td colspan="4" class="doc" id="hasExternalFormalLinkage0"><pre>Matches a declaration that has external formal linkage.
3734
3735 Example matches only z (matcher = varDecl(hasExternalFormalLinkage()))
3736 void f() {
3737   int x;
3738   static int y;
3739 }
3740 int z;
3741
3742 Example matches f() because it has external formal linkage despite being
3743 unique to the translation unit as though it has internal likage
3744 (matcher = functionDecl(hasExternalFormalLinkage()))
3745
3746 namespace {
3747 void f() {}
3748 }
3749 </pre></td></tr>
3750
3751
3752 <tr><td>Matcher&lt;<a href="https://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>StringRef Name</td></tr>
3753 <tr><td colspan="4" class="doc" id="hasName0"><pre>Matches NamedDecl nodes that have the specified name.
3754
3755 Supports specifying enclosing namespaces or classes by prefixing the name
3756 with '&lt;enclosing&gt;::'.
3757 Does not match typedefs of an underlying type with the given name.
3758
3759 Example matches X (Name == "X")
3760   class X;
3761
3762 Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
3763   namespace a { namespace b { class X; } }
3764 </pre></td></tr>
3765
3766
3767 <tr><td>Matcher&lt;<a href="https://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>StringRef RegExp, Regex::RegexFlags Flags = NoFlags</td></tr>
3768 <tr><td colspan="4" class="doc" id="matchesName0"><pre>Matches NamedDecl nodes whose fully qualified names contain
3769 a substring matched by the given RegExp.
3770
3771 Supports specifying enclosing namespaces or classes by
3772 prefixing the name with '&lt;enclosing&gt;::'.  Does not match typedefs
3773 of an underlying type with the given name.
3774
3775 Example matches X (regexp == "::X")
3776   class X;
3777
3778 Example matches X (regexp is one of "::X", "^foo::.*X", among others)
3779   namespace foo { namespace bar { class X; } }
3780
3781 If the matcher is used in clang-query, RegexFlags parameter
3782 should be passed as a quoted string. e.g: "NoFlags".
3783 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
3784 </pre></td></tr>
3785
3786
3787 <tr><td>Matcher&lt;<a href="https://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>
3788 <tr><td colspan="4" class="doc" id="isAnonymous0"><pre>Matches anonymous namespace declarations.
3789
3790 Given
3791   namespace n {
3792   namespace {} // #1
3793   }
3794 namespaceDecl(isAnonymous()) will match #1 but not ::n.
3795 </pre></td></tr>
3796
3797
3798 <tr><td>Matcher&lt;<a href="https://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>
3799 <tr><td colspan="4" class="doc" id="isInline0"><pre>Matches function and namespace declarations that are marked with
3800 the inline keyword.
3801
3802 Given
3803   inline void f();
3804   void g();
3805   namespace n {
3806   inline namespace m {}
3807   }
3808 functionDecl(isInline()) will match ::f().
3809 namespaceDecl(isInline()) will match n::m.
3810 </pre></td></tr>
3811
3812
3813 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isFirstPrivateKind0')"><a name="isFirstPrivateKind0Anchor">isFirstPrivateKind</a></td><td></td></tr>
3814 <tr><td colspan="4" class="doc" id="isFirstPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``firstprivate`` kind
3815 specified.
3816
3817 Given
3818
3819   #pragma omp parallel
3820   #pragma omp parallel default(none)
3821   #pragma omp parallel default(shared)
3822   #pragma omp parallel default(firstprivate)
3823
3824 ``ompDefaultClause(isFirstPrivateKind())`` matches only
3825 ``default(firstprivate)``.
3826 </pre></td></tr>
3827
3828
3829 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isNoneKind0')"><a name="isNoneKind0Anchor">isNoneKind</a></td><td></td></tr>
3830 <tr><td colspan="4" class="doc" id="isNoneKind0"><pre>Matches if the OpenMP ``default`` clause has ``none`` kind specified.
3831
3832 Given
3833
3834   #pragma omp parallel
3835   #pragma omp parallel default(none)
3836   #pragma omp parallel default(shared)
3837   #pragma omp parallel default(firstprivate)
3838
3839 ``ompDefaultClause(isNoneKind())`` matches only ``default(none)``.
3840 </pre></td></tr>
3841
3842
3843 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isSharedKind0')"><a name="isSharedKind0Anchor">isSharedKind</a></td><td></td></tr>
3844 <tr><td colspan="4" class="doc" id="isSharedKind0"><pre>Matches if the OpenMP ``default`` clause has ``shared`` kind specified.
3845
3846 Given
3847
3848   #pragma omp parallel
3849   #pragma omp parallel default(none)
3850   #pragma omp parallel default(shared)
3851   #pragma omp parallel default(firstprivate)
3852
3853 ``ompDefaultClause(isSharedKind())`` matches only ``default(shared)``.
3854 </pre></td></tr>
3855
3856
3857 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPExecutableDirective.html">OMPExecutableDirective</a>&gt;</td><td class="name" onclick="toggle('isAllowedToContainClauseKind0')"><a name="isAllowedToContainClauseKind0Anchor">isAllowedToContainClauseKind</a></td><td>OpenMPClauseKind CKind</td></tr>
3858 <tr><td colspan="4" class="doc" id="isAllowedToContainClauseKind0"><pre>Matches if the OpenMP directive is allowed to contain the specified OpenMP
3859 clause kind.
3860
3861 Given
3862
3863   #pragma omp parallel
3864   #pragma omp parallel for
3865   #pragma omp          for
3866
3867 `ompExecutableDirective(isAllowedToContainClause(OMPC_default))`` matches
3868 ``omp parallel`` and ``omp parallel for``.
3869
3870 If the matcher is use from clang-query, ``OpenMPClauseKind`` parameter
3871 should be passed as a quoted string. e.g.,
3872 ``isAllowedToContainClauseKind("OMPC_default").``
3873 </pre></td></tr>
3874
3875
3876 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPExecutableDirective.html">OMPExecutableDirective</a>&gt;</td><td class="name" onclick="toggle('isStandaloneDirective0')"><a name="isStandaloneDirective0Anchor">isStandaloneDirective</a></td><td></td></tr>
3877 <tr><td colspan="4" class="doc" id="isStandaloneDirective0"><pre>Matches standalone OpenMP directives,
3878 i.e., directives that can't have a structured block.
3879
3880 Given
3881
3882   #pragma omp parallel
3883   {}
3884   #pragma omp taskyield
3885
3886 ``ompExecutableDirective(isStandaloneDirective()))`` matches
3887 ``omp taskyield``.
3888 </pre></td></tr>
3889
3890
3891 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom3')"><a name="isDerivedFrom3Anchor">isDerivedFrom</a></td><td>std::string BaseName</td></tr>
3892 <tr><td colspan="4" class="doc" id="isDerivedFrom3"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
3893 </pre></td></tr>
3894
3895
3896 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;</td><td class="name" onclick="toggle('isDirectlyDerivedFrom3')"><a name="isDirectlyDerivedFrom3Anchor">isDirectlyDerivedFrom</a></td><td>std::string BaseName</td></tr>
3897 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom3"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
3898 </pre></td></tr>
3899
3900
3901 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom3')"><a name="isSameOrDerivedFrom3Anchor">isSameOrDerivedFrom</a></td><td>std::string BaseName</td></tr>
3902 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom3"><pre>Overloaded method as shortcut for
3903 isSameOrDerivedFrom(hasName(...)).
3904 </pre></td></tr>
3905
3906
3907 <tr><td>Matcher&lt;<a href="https://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>
3908 <tr><td colspan="4" class="doc" id="argumentCountIs2"><pre>Checks that a call expression or a constructor call expression has
3909 a specific number of arguments (including absent default arguments).
3910
3911 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
3912   void f(int x, int y);
3913   f(0, 0);
3914 </pre></td></tr>
3915
3916
3917 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnySelector0')"><a name="hasAnySelector0Anchor">hasAnySelector</a></td><td>StringRef, ..., StringRef</td></tr>
3918 <tr><td colspan="4" class="doc" id="hasAnySelector0"><pre>Matches when at least one of the supplied string equals to the
3919 Selector.getAsString()
3920
3921  matcher = objCMessageExpr(hasSelector("methodA:", "methodB:"));
3922  matches both of the expressions below:
3923     [myObj methodA:argA];
3924     [myObj methodB:argB];
3925 </pre></td></tr>
3926
3927
3928 <tr><td>Matcher&lt;<a href="https://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>
3929 <tr><td colspan="4" class="doc" id="hasKeywordSelector0"><pre>Matches when the selector is a keyword selector
3930
3931 objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
3932 message expression in
3933
3934   UIWebView *webView = ...;
3935   CGRect bodyFrame = webView.frame;
3936   bodyFrame.size.height = self.bodyContentHeight;
3937   webView.frame = bodyFrame;
3938   //     ^---- matches here
3939 </pre></td></tr>
3940
3941
3942 <tr><td>Matcher&lt;<a href="https://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>
3943 <tr><td colspan="4" class="doc" id="hasNullSelector0"><pre>Matches when the selector is the empty selector
3944
3945 Matches only when the selector of the objCMessageExpr is NULL. This may
3946 represent an error condition in the tree!
3947 </pre></td></tr>
3948
3949
3950 <tr><td>Matcher&lt;<a href="https://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>
3951 <tr><td colspan="4" class="doc" id="hasSelector0"><pre>Matches when BaseName == Selector.getAsString()
3952
3953  matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
3954  matches the outer message expr in the code below, but NOT the message
3955  invocation for self.bodyView.
3956     [self.bodyView loadHTMLString:html baseURL:NULL];
3957 </pre></td></tr>
3958
3959
3960 <tr><td>Matcher&lt;<a href="https://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>
3961 <tr><td colspan="4" class="doc" id="hasUnarySelector0"><pre>Matches when the selector is a Unary Selector
3962
3963  matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
3964  matches self.bodyView in the code below, but NOT the outer message
3965  invocation of "loadHTMLString:baseURL:".
3966     [self.bodyView loadHTMLString:html baseURL:NULL];
3967 </pre></td></tr>
3968
3969
3970 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('isClassMessage0')"><a name="isClassMessage0Anchor">isClassMessage</a></td><td></td></tr>
3971 <tr><td colspan="4" class="doc" id="isClassMessage0"><pre>Returns true when the Objective-C message is sent to a class.
3972
3973 Example
3974 matcher = objcMessageExpr(isClassMessage())
3975 matches
3976   [NSString stringWithFormat:@"format"];
3977 but not
3978   NSString *x = @"hello";
3979   [x containsString:@"h"];
3980 </pre></td></tr>
3981
3982
3983 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('isInstanceMessage0')"><a name="isInstanceMessage0Anchor">isInstanceMessage</a></td><td></td></tr>
3984 <tr><td colspan="4" class="doc" id="isInstanceMessage0"><pre>Returns true when the Objective-C message is sent to an instance.
3985
3986 Example
3987 matcher = objcMessageExpr(isInstanceMessage())
3988 matches
3989   NSString *x = @"hello";
3990   [x containsString:@"h"];
39