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 span.mono { font-family: monospace; }
  21
  22 .traverse_compare, .traverse_compare td, .traverse_compare th {
  23   border: 1px solid black;
  24   border-collapse: collapse;
  25 }
  26 </style>
  27 <script type="text/javascript">
  28 function toggle(id) {
  29   if (!id) return;
  30   row = document.getElementById(id);
  31   if (row.style.display != 'table-cell')
  32     row.style.display = 'table-cell';
  33   else
  34     row.style.display = 'none';
  35 }
  36 </script>
  37 </head>
  38 <body onLoad="toggle(location.hash.substring(1, location.hash.length - 6))">
  39
  40 <!--#include virtual="../menu.html.incl"-->
  41
  42 <div id="content">
  43
  44 <h1>AST Matcher Reference</h1>
  45
  46 <p>This document shows all currently implemented matchers. The matchers are grouped
  47 by category and node type they match. You can click on matcher names to show the
  48 matcher's source documentation.</p>
  49
  50 <p>There are three different basic categories of matchers:
  51 <ul>
  52 <li><a href="#decl-matchers">Node Matchers:</a> Matchers that match a specific type of AST node.</li>
  53 <li><a href="#narrowing-matchers">Narrowing Matchers:</a> Matchers that match attributes on AST nodes.</li>
  54 <li><a href="#traversal-matchers">Traversal Matchers:</a> Matchers that allow traversal between AST nodes.</li>
  55 </ul>
  56 </p>
  57
  58 <p>Within each category the matchers are ordered by node type they match on.
  59 Note that if a matcher can match multiple node types, it will appear
  60 multiple times. This means that by searching for Matcher&lt;Stmt&gt; you can
  61 find all matchers that can be used to match on Stmt nodes.</p>
  62
  63 <p>The exception to that rule are matchers that can match on any node. Those
  64 are marked with a * and are listed in the beginning of each category.</p>
  65
  66 <p>Note that the categorization of matchers is a great help when you combine
  67 them into matcher expressions. You will usually want to form matcher expressions
  68 that read like english sentences by alternating between node matchers and
  69 narrowing or traversal matchers, like this:
  70 <pre>
  71 recordDecl(hasDescendant(
  72     ifStmt(hasTrueExpression(
  73         expr(hasDescendant(
  74             ifStmt()))))))
  75 </pre>
  76 </p>
  77
  78 <!-- ======================================================================= -->
  79 <h2 id="traverse-mode">Traverse Mode</h2>
  80 <!-- ======================================================================= -->
  81
  82 <p>The default mode of operation of AST Matchers visits all nodes in the AST,
  83 even if they are not spelled in the source. This is
  84 <span class="mono">AsIs</span> mode.  This mode requires writing AST matchers
  85 that explicitly traverse or ignore implicit nodes, such as parentheses
  86 surrounding an expression or expressions with cleanups.  These implicit
  87 nodes are not always obvious from the syntax of the source code, and so this
  88 mode requires careful consideration and testing to get the desired behavior
  89 from an AST matcher.
  90 </p>
  91
  92 <p>In addition, because template instantiations are matched in the default mode,
  93 transformations can be accidentally made to template declarations. Finally,
  94 because implicit nodes are matched by default, transformations can be made on
  95 entirely incorrect places in the code.</p>
  96
  97 <p>For these reasons, it is possible to ignore AST nodes which are not spelled
  98 in the source using the <span class="mono">IgnoreUnlessSpelledInSource</span>
  99 mode. This is likely to be far less error-prone for users who are not already
 100 very familiar with where implicit nodes appear in the AST. It is also likely
 101 to be less error-prone for experienced AST users, as difficult cases do not
 102 need to be encountered and matcher expressions adjusted for these cases.</p>
 103
 104 <p>In clang-query, the mode can be changed with
 105 <pre>
 106 set traversal IgnoreUnlessSpelledInSource
 107 </pre>
 108 </p>
 109 This affects both matchers and AST dump output in results.
 110
 111 <p>When using the C++ API such as in clang-tidy checks, the
 112 <span class="mono">traverse()</span> matcher is used to set the mode:
 113 <pre>
 114 Finder->addMatcher(traverse(TK_IgnoreUnlessSpelledInSource,
 115   returnStmt(hasReturnValue(integerLiteral(equals(0))))
 116   ), this);
 117 </pre>
 118 </p>
 119 <p>The following table compares the <span class="mono">AsIs</span> mode with
 120 the <span class="mono">IgnoreUnlessSpelledInSource</span> mode:</p>
 121
 122 <table class="traverse_compare">
 123 <tr>
 124 <th></th>
 125 <th><span class="mono">AsIs</span></th>
 126 <th><span class="mono">IgnoreUnlessSpelledInSource</span></th>
 127 </tr>
 128 <tr>
 129   <td>AST dump of <span class="mono">func1</span>:
 130 <pre>
 131 struct B {
 132   B(int);
 133 };
 134
 135 B func1() { return 42; }
 136 </pre>
 137
 138   </td>
 139   <td>
 140 C++98 dialect:
 141 <pre>
 142 FunctionDecl
 143 `-CompoundStmt
 144   `-ReturnStmt
 145     `-ExprWithCleanups
 146       `-CXXConstructExpr
 147         `-MaterializeTemporaryExpr
 148           `-ImplicitCastExpr
 149             `-ImplicitCastExpr
 150               `-CXXConstructExpr
 151                 `-IntegerLiteral 'int' 42
 152 </pre>
 153 C++11, C++14 dialect:
 154 <pre>
 155 FunctionDecl
 156 `-CompoundStmt
 157   `-ReturnStmt
 158     `-ExprWithCleanups
 159       `-CXXConstructExpr
 160         `-MaterializeTemporaryExpr
 161           `-ImplicitCastExpr
 162             `-CXXConstructExpr
 163               `-IntegerLiteral 'int' 42
 164 </pre>
 165 C++17, C++20 dialect:
 166 <pre>
 167 FunctionDecl
 168 `-CompoundStmt
 169   `-ReturnStmt
 170     `-ImplicitCastExpr
 171       `-CXXConstructExpr
 172         `-IntegerLiteral 'int' 42
 173 </pre>
 174 </td>
 175   <td>
 176 All dialects:
 177     <pre>
 178 FunctionDecl
 179 `-CompoundStmt
 180   `-ReturnStmt
 181     `-IntegerLiteral 'int' 42
 182 </pre></td>
 183 </tr>
 184
 185 <tr>
 186 <td>Matcher for returned <span class="mono">42</span>:
 187 <pre>
 188 struct B {
 189   B(int);
 190 };
 191
 192 B func1() { return 42; }
 193 </pre>
 194
 195   </td>
 196   <td>
 197 All dialects:
 198 <pre>
 199 returnStmt(hasReturnValue(
 200     ignoringImplicit(
 201         ignoringElidableConstructorCall(
 202             ignoringImplicit(
 203                 cxxConstructExpr(hasArgument(0,
 204                     ignoringImplicit(
 205                         integerLiteral().bind("returnVal")
 206                         )
 207                     ))
 208                 )
 209             )
 210         )
 211     ))
 212 </pre></td>
 213   <td>
 214 All dialects:
 215 <pre>
 216 returnStmt(hasReturnValue(
 217     integerLiteral().bind("returnVal")
 218 ))
 219 </pre></td>
 220 </tr>
 221 <tr>
 222 <td>Match result for
 223 <pre>implicitCastExpr()</pre>
 224 given:
 225 <pre>
 226 struct B {
 227   B(int);
 228 };
 229
 230 B func1() { return 42; }
 231 </pre>
 232
 233 </td>
 234 <td>
 235 Match found.</td>
 236   <td>
 237 No match.</td>
 238 </tr>
 239 <tr>
 240   <td>Match result for:
 241 <pre>
 242 cxxConstructorDecl(
 243   isCopyConstructor()
 244   ).bind("prepend_explicit")
 245 </pre>
 246 given:
 247 <pre>
 248 struct Other {};
 249 struct Copyable {
 250   Other m_o;
 251   Copyable();
 252 };
 253 </pre>
 254 </td>
 255 <td>
 256 Match found. Insertion produces incorrect output:
 257 <pre>
 258 struct Other {};
 259 struct explicit Copyable {
 260   Other m_o;
 261   Copyable();
 262 };
 263 </pre>
 264 </td>
 265 <td>
 266 No match found. Incorrect replacement not possible.
 267 </td>
 268 </tr>
 269 <tr>
 270   <td>Replacement of <span class="mono">begin()</span>
 271     with <span class="mono">cbegin()</span>:
 272 <pre>
 273 cxxMemberCallExpr(
 274   on(ConstContainerExpr),
 275   callee(cxxMethodDecl(hasName("begin")))
 276   ).bind("replace_with_cbegin")
 277 </pre>
 278 given:
 279 <pre>
 280 void foo() {
 281   const Container c;
 282   c.begin();
 283
 284   for (auto i : c) {
 285   }
 286 }
 287 </pre>
 288 </td>
 289 <td>
 290 2 matches found. Replacement produces incorrect output:
 291 <pre>
 292 void foo() {
 293   const Container c;
 294   c.cbegin();
 295
 296   for (auto i :.cbegin() c) {
 297   }
 298 }
 299 </pre>
 300 </td>
 301 <td>
 302 1 match found. Replacement produces correct output:
 303 <pre>
 304 void foo() {
 305   const Container c;
 306   c.cbegin();
 307
 308   for (auto i : c) {
 309   }
 310 }
 311 </pre>
 312 </td>
 313 </tr>
 314 <tr>
 315   <td>Replacement of <span class="mono">int</span> member
 316     with <span class="mono">safe_int</span>:
 317 <pre>
 318 fieldDecl(
 319   hasType(asString("int"))
 320   ).bind("use_safe_int")
 321 </pre>
 322 given:
 323 <pre>
 324 struct S {
 325   int m_i;
 326 };
 327
 328 template &lt;typename T&gt; struct TemplStruct {
 329   TemplStruct() {}
 330   ~TemplStruct() {}
 331
 332 private:
 333   T m_t;
 334 };
 335
 336 void instantiate() { TemplStruct&lt;int&gt; ti; }
 337 </pre>
 338 </td>
 339 <td>
 340 2 matches found. Replacement produces incorrect output:
 341 <pre>
 342 struct S {
 343   safe_int m_i;
 344 };
 345
 346 template &lt;typename T&gt; struct TemplStruct {
 347   TemplStruct() {}
 348   ~TemplStruct() {}
 349
 350 private:
 351   safe_int m_t;
 352 };
 353
 354 void instantiate() { TemplStruct&lt;int&gt; ti; }
 355 </pre>
 356 </td>
 357 <td>
 358 1 match found. Replacement produces correct output:
 359 <pre>
 360 struct S {
 361   safe_int m_i;
 362 };
 363
 364 template &lt;typename T&gt; struct TemplStruct {
 365   TemplStruct() {}
 366   ~TemplStruct() {}
 367
 368 private:
 369   T m_t;
 370 };
 371
 372 void instantiate() { TemplStruct&lt;int&gt; ti; }
 373 </pre>
 374 </td>
 375 </tr>
 376 <tr>
 377   <td>Add prefix to member initializer
 378 <pre>
 379 cxxCtorInitializer(
 380   forField(fieldDecl())
 381   ).bind("add_prefix")
 382 </pre>
 383 given:
 384 <pre>
 385 struct Simple {};
 386
 387 struct Record {
 388   Record() : i(42) {}
 389 private:
 390   int i;
 391   Simple s;
 392 };
 393 </pre>
 394 </td>
 395 <td>
 396 2 matches found. Replacement produces incorrect output:
 397 <pre>
 398 struct Simple {};
 399
 400 struct Record {
 401   m_Record() : m_i(42) {}
 402 private:
 403   int i;
 404   Simple s;
 405 };
 406 </pre>
 407 </td>
 408 <td>
 409 1 match found. Replacement produces correct output:
 410 <pre>
 411 struct Simple {};
 412
 413 struct Record {
 414   Record() : m_i(42) {}
 415 private:
 416   int i;
 417   Simple s;
 418 };
 419 </pre>
 420 </td>
 421 </tr>
 422 <tr>
 423   <td>Ignored default arguments
 424 <pre>
 425 callExpr(
 426   callee(functionDecl(
 427     hasName("hasDefaultArg")
 428     )),
 429   argumentCountIs(1)
 430   ).bind("add_prefix")
 431 </pre>
 432 given:
 433 <pre>
 434 void hasDefaultArg(int i, int j = 0) {}
 435 void callDefaultArg() { hasDefaultArg(42); }
 436 </pre>
 437 </td>
 438 <td>
 439 No match.
 440 </td>
 441 <td>
 442 1 match found.
 443 </td>
 444 </tr>
 445 <tr>
 446   <td>Lambda fields
 447 <pre>
 448 fieldDecl(
 449   hasType(asString("int"))
 450   ).bind("make_safe")
 451 </pre>
 452 given:
 453 <pre>
 454 struct S {
 455   int m_i;
 456 };
 457
 458 void func() {
 459   int a = 0;
 460   int c = 0;
 461
 462   auto l = [a, b = c](int d) { int e = d; };
 463   l(43);
 464 }
 465 </pre>
 466 </td>
 467 <td>
 468 2 matches found. Replacement produces incorrect output:
 469 <pre>
 470 struct S {
 471   safe_int m_i;
 472 };
 473
 474 void func() {
 475   int a = 0;
 476   int c = 0;
 477
 478   auto l = [safe_a, safe_b = c](int d) { int e = d; };
 479   l(43);
 480 }
 481 </pre>
 482 </td>
 483 <td>
 484 1 match found. Replacement produces correct output:
 485 <pre>
 486 struct S {
 487   safe_int m_i;
 488 };
 489
 490 void func() {
 491   int a = 0;
 492   int c = 0;
 493
 494   auto l = [a, b = c](int d) { int e = d; };
 495   l(43);
 496 }
 497 </pre>
 498 </td>
 499
 500 </tr>
 501
 502
 503
 504
 505
 506 <tr>
 507   <td>Rewritten binary operators
 508 <pre>
 509 binaryOperator(
 510   hasOperatorName("&lt;"),
 511   hasRHS(hasDescendant(integerLiteral(equals(0))))
 512   )
 513 </pre>
 514 given:
 515 <pre>
 516 #include &lt;compare&gt;
 517
 518 class HasSpaceship {
 519 public:
 520    int x;
 521    bool operator==(const HasSpaceship&) const = default;
 522    std::strong_ordering operator<=>(const HasSpaceship&) const = default;
 523 };
 524
 525 bool isLess(const HasSpaceship& a, const HasSpaceship& b) {
 526    return a < b;
 527 }
 528 </pre>
 529 </td>
 530 <td>
 531 1 match found.
 532
 533 <pre>
 534    return a < b;
 535           ^~~~~
 536 </pre>
 537
 538 </td>
 539 <td>
 540 No match found.
 541 </td>
 542 </tr>
 543 </table>
 544
 545 <!-- ======================================================================= -->
 546 <h2 id="decl-matchers">Node Matchers</h2>
 547 <!-- ======================================================================= -->
 548
 549 <p>Node matchers are at the core of matcher expressions - they specify the type
 550 of node that is expected. Every match expression starts with a node matcher,
 551 which can then be further refined with a narrowing or traversal matcher. All
 552 traversal matchers take node matchers as their arguments.</p>
 553
 554 <p>For convenience, all node matchers take an arbitrary number of arguments
 555 and implicitly act as allOf matchers.</p>
 556
 557 <p>Node matchers are the only matchers that support the bind("id") call to
 558 bind the matched node to the given string, to be later retrieved from the
 559 match callback.</p>
 560
 561 <p>It is important to remember that the arguments to node matchers are
 562 predicates on the same node, just with additional information about the type.
 563 This is often useful to make matcher expression more readable by inlining bind
 564 calls into redundant node matchers inside another node matcher:
 565 <pre>
 566 // This binds the CXXRecordDecl to "id", as the decl() matcher will stay on
 567 // the same node.
 568 recordDecl(decl().bind("id"), hasName("::MyClass"))
 569 </pre>
 570 </p>
 571
 572 <table>
 573 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
 574 <!-- START_DECL_MATCHERS -->
 575
 576 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>&gt;</td><td class="name" onclick="toggle('attr0')"><a name="attr0Anchor">attr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>&gt;...</td></tr>
 577 <tr><td colspan="4" class="doc" id="attr0"><pre>Matches attributes.
 578 Attributes may be attached with a variety of different syntaxes (including
 579 keywords, C++11 attributes, GNU ``__attribute``` and MSVC `__declspec``,
 580 and ``#pragma``s). They may also be implicit.
 581
 582 Given
 583   struct [[nodiscard]] Foo{};
 584   void bar(int * __attribute__((nonnull)) );
 585   __declspec(noinline) void baz();
 586
 587   #pragma omp declare simd
 588   int min();
 589 attr()
 590   matches "nodiscard", "nonnull", "noinline", and the whole "#pragma" line.
 591 </pre></td></tr>
 592
 593
 594 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('cxxBaseSpecifier0')"><a name="cxxBaseSpecifier0Anchor">cxxBaseSpecifier</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;...</td></tr>
 595 <tr><td colspan="4" class="doc" id="cxxBaseSpecifier0"><pre>Matches class bases.
 596
 597 Examples matches public virtual B.
 598   class B {};
 599   class C : public virtual B {};
 600 </pre></td></tr>
 601
 602
 603 <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>
 604 <tr><td colspan="4" class="doc" id="cxxCtorInitializer0"><pre>Matches constructor initializers.
 605
 606 Examples matches i(42).
 607   class C {
 608     C() : i(42) {}
 609     int i;
 610   };
 611 </pre></td></tr>
 612
 613
 614 <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>
 615 <tr><td colspan="4" class="doc" id="accessSpecDecl0"><pre>Matches C++ access specifier declarations.
 616
 617 Given
 618   class C {
 619   public:
 620     int a;
 621   };
 622 accessSpecDecl()
 623   matches 'public:'
 624 </pre></td></tr>
 625
 626
 627 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('bindingDecl0')"><a name="bindingDecl0Anchor">bindingDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BindingDecl.html">BindingDecl</a>&gt;...</td></tr>
 628 <tr><td colspan="4" class="doc" id="bindingDecl0"><pre>Matches binding declarations
 629 Example matches foo and bar
 630 (matcher = bindingDecl()
 631
 632   auto [foo, bar] = std::make_pair{42, 42};
 633 </pre></td></tr>
 634
 635
 636 <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>
 637 <tr><td colspan="4" class="doc" id="blockDecl0"><pre>Matches block declarations.
 638
 639 Example matches the declaration of the nameless block printing an input
 640 integer.
 641
 642   myFunc(^(int p) {
 643     printf("%d", p);
 644   })
 645 </pre></td></tr>
 646
 647
 648 <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>
 649 <tr><td colspan="4" class="doc" id="classTemplateDecl0"><pre>Matches C++ class template declarations.
 650
 651 Example matches Z
 652   template&lt;class T&gt; class Z {};
 653 </pre></td></tr>
 654
 655
 656 <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>
 657 <tr><td colspan="4" class="doc" id="classTemplatePartialSpecializationDecl0"><pre>Matches C++ class template partial specializations.
 658
 659 Given
 660   template&lt;class T1, class T2, int I&gt;
 661   class A {};
 662
 663   template&lt;class T, int I&gt;
 664   class A&lt;T, T*, I&gt; {};
 665
 666   template&lt;&gt;
 667   class A&lt;int, int, 1&gt; {};
 668 classTemplatePartialSpecializationDecl()
 669   matches the specialization A&lt;T,T*,I&gt; but not A&lt;int,int,1&gt;
 670 </pre></td></tr>
 671
 672
 673 <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>
 674 <tr><td colspan="4" class="doc" id="classTemplateSpecializationDecl0"><pre>Matches C++ class template specializations.
 675
 676 Given
 677   template&lt;typename T&gt; class A {};
 678   template&lt;&gt; class A&lt;double&gt; {};
 679   A&lt;int&gt; a;
 680 classTemplateSpecializationDecl()
 681   matches the specializations A&lt;int&gt; and A&lt;double&gt;
 682 </pre></td></tr>
 683
 684
 685 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('conceptDecl0')"><a name="conceptDecl0Anchor">conceptDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConceptDecl.html">ConceptDecl</a>&gt;...</td></tr>
 686 <tr><td colspan="4" class="doc" id="conceptDecl0"><pre>Matches concept declarations.
 687
 688 Example matches integral
 689   template&lt;typename T&gt;
 690   concept integral = std::is_integral_v&lt;T&gt;;
 691 </pre></td></tr>
 692
 693
 694 <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>
 695 <tr><td colspan="4" class="doc" id="cxxConstructorDecl0"><pre>Matches C++ constructor declarations.
 696
 697 Example matches Foo::Foo() and Foo::Foo(int)
 698   class Foo {
 699    public:
 700     Foo();
 701     Foo(int);
 702     int DoSomething();
 703   };
 704 </pre></td></tr>
 705
 706
 707 <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>
 708 <tr><td colspan="4" class="doc" id="cxxConversionDecl0"><pre>Matches conversion operator declarations.
 709
 710 Example matches the operator.
 711   class X { operator int() const; };
 712 </pre></td></tr>
 713
 714
 715 <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>
 716 <tr><td colspan="4" class="doc" id="cxxDeductionGuideDecl0"><pre>Matches user-defined and implicitly generated deduction guide.
 717
 718 Example matches the deduction guide.
 719   template&lt;typename T&gt;
 720   class X { X(int) };
 721   X(int) -&gt; X&lt;int&gt;;
 722 </pre></td></tr>
 723
 724
 725 <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>
 726 <tr><td colspan="4" class="doc" id="cxxDestructorDecl0"><pre>Matches explicit C++ destructor declarations.
 727
 728 Example matches Foo::~Foo()
 729   class Foo {
 730    public:
 731     virtual ~Foo();
 732   };
 733 </pre></td></tr>
 734
 735
 736 <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>
 737 <tr><td colspan="4" class="doc" id="cxxMethodDecl0"><pre>Matches method declarations.
 738
 739 Example matches y
 740   class X { void y(); };
 741 </pre></td></tr>
 742
 743
 744 <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>
 745 <tr><td colspan="4" class="doc" id="cxxRecordDecl0"><pre>Matches C++ class declarations.
 746
 747 Example matches X, Z
 748   class X;
 749   template&lt;class T&gt; class Z {};
 750 </pre></td></tr>
 751
 752
 753 <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>
 754 <tr><td colspan="4" class="doc" id="decl0"><pre>Matches declarations.
 755
 756 Examples matches X, C, and the friend declaration inside C;
 757   void X();
 758   class C {
 759     friend X;
 760   };
 761 </pre></td></tr>
 762
 763
 764 <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>
 765 <tr><td colspan="4" class="doc" id="declaratorDecl0"><pre>Matches declarator declarations (field, variable, function
 766 and non-type template parameter declarations).
 767
 768 Given
 769   class X { int y; };
 770 declaratorDecl()
 771   matches int y.
 772 </pre></td></tr>
 773
 774
 775 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</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>
 776 <tr><td colspan="4" class="doc" id="decompositionDecl0"><pre>Matches decomposition-declarations.
 777
 778 Examples matches the declaration node with foo and bar, but not
 779 number.
 780 (matcher = declStmt(has(decompositionDecl())))
 781
 782   int number = 42;
 783   auto [foo, bar] = std::make_pair{42, 42};
 784 </pre></td></tr>
 785
 786
 787 <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>
 788 <tr><td colspan="4" class="doc" id="enumConstantDecl0"><pre>Matches enum constants.
 789
 790 Example matches A, B, C
 791   enum X {
 792     A, B, C
 793   };
 794 </pre></td></tr>
 795
 796
 797 <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>
 798 <tr><td colspan="4" class="doc" id="enumDecl0"><pre>Matches enum declarations.
 799
 800 Example matches X
 801   enum X {
 802     A, B, C
 803   };
 804 </pre></td></tr>
 805
 806
 807 <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>
 808 <tr><td colspan="4" class="doc" id="fieldDecl0"><pre>Matches field declarations.
 809
 810 Given
 811   class X { int m; };
 812 fieldDecl()
 813   matches 'm'.
 814 </pre></td></tr>
 815
 816
 817 <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>
 818 <tr><td colspan="4" class="doc" id="friendDecl0"><pre>Matches friend declarations.
 819
 820 Given
 821   class X { friend void foo(); };
 822 friendDecl()
 823   matches 'friend void foo()'.
 824 </pre></td></tr>
 825
 826
 827 <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>
 828 <tr><td colspan="4" class="doc" id="functionDecl0"><pre>Matches function declarations.
 829
 830 Example matches f
 831   void f();
 832 </pre></td></tr>
 833
 834
 835 <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>
 836 <tr><td colspan="4" class="doc" id="functionTemplateDecl0"><pre>Matches C++ function template declarations.
 837
 838 Example matches f
 839   template&lt;class T&gt; void f(T t) {}
 840 </pre></td></tr>
 841
 842
 843 <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>
 844 <tr><td colspan="4" class="doc" id="indirectFieldDecl0"><pre>Matches indirect field declarations.
 845
 846 Given
 847   struct X { struct { int a; }; };
 848 indirectFieldDecl()
 849   matches 'a'.
 850 </pre></td></tr>
 851
 852
 853 <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>
 854 <tr><td colspan="4" class="doc" id="labelDecl0"><pre>Matches a declaration of label.
 855
 856 Given
 857   goto FOO;
 858   FOO: bar();
 859 labelDecl()
 860   matches 'FOO:'
 861 </pre></td></tr>
 862
 863
 864 <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>
 865 <tr><td colspan="4" class="doc" id="linkageSpecDecl0"><pre>Matches a declaration of a linkage specification.
 866
 867 Given
 868   extern "C" {}
 869 linkageSpecDecl()
 870   matches "extern "C" {}"
 871 </pre></td></tr>
 872
 873
 874 <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>
 875 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
 876
 877 Example matches X, S, the anonymous union type, i, and U;
 878   typedef int X;
 879   struct S {
 880     union {
 881       int i;
 882     } U;
 883   };
 884 </pre></td></tr>
 885
 886
 887 <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>
 888 <tr><td colspan="4" class="doc" id="namespaceAliasDecl0"><pre>Matches a declaration of a namespace alias.
 889
 890 Given
 891   namespace test {}
 892   namespace alias = ::test;
 893 namespaceAliasDecl()
 894   matches "namespace alias" but not "namespace test"
 895 </pre></td></tr>
 896
 897
 898 <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>
 899 <tr><td colspan="4" class="doc" id="namespaceDecl0"><pre>Matches a declaration of a namespace.
 900
 901 Given
 902   namespace {}
 903   namespace test {}
 904 namespaceDecl()
 905   matches "namespace {}" and "namespace test {}"
 906 </pre></td></tr>
 907
 908
 909 <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>
 910 <tr><td colspan="4" class="doc" id="nonTypeTemplateParmDecl0"><pre>Matches non-type template parameter declarations.
 911
 912 Given
 913   template &lt;typename T, int N&gt; struct C {};
 914 nonTypeTemplateParmDecl()
 915   matches 'N', but not 'T'.
 916 </pre></td></tr>
 917
 918
 919 <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>
 920 <tr><td colspan="4" class="doc" id="objcCategoryDecl0"><pre>Matches Objective-C category declarations.
 921
 922 Example matches Foo (Additions)
 923   @interface Foo (Additions)
 924   @end
 925 </pre></td></tr>
 926
 927
 928 <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>
 929 <tr><td colspan="4" class="doc" id="objcCategoryImplDecl0"><pre>Matches Objective-C category definitions.
 930
 931 Example matches Foo (Additions)
 932   @implementation Foo (Additions)
 933   @end
 934 </pre></td></tr>
 935
 936
 937 <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>
 938 <tr><td colspan="4" class="doc" id="objcImplementationDecl0"><pre>Matches Objective-C implementation declarations.
 939
 940 Example matches Foo
 941   @implementation Foo
 942   @end
 943 </pre></td></tr>
 944
 945
 946 <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>
 947 <tr><td colspan="4" class="doc" id="objcInterfaceDecl0"><pre>Matches Objective-C interface declarations.
 948
 949 Example matches Foo
 950   @interface Foo
 951   @end
 952 </pre></td></tr>
 953
 954
 955 <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>
 956 <tr><td colspan="4" class="doc" id="objcIvarDecl0"><pre>Matches Objective-C instance variable declarations.
 957
 958 Example matches _enabled
 959   @implementation Foo {
 960     BOOL _enabled;
 961   }
 962   @end
 963 </pre></td></tr>
 964
 965
 966 <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>
 967 <tr><td colspan="4" class="doc" id="objcMethodDecl0"><pre>Matches Objective-C method declarations.
 968
 969 Example matches both declaration and definition of -[Foo method]
 970   @interface Foo
 971   - (void)method;
 972   @end
 973
 974   @implementation Foo
 975   - (void)method {}
 976   @end
 977 </pre></td></tr>
 978
 979
 980 <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>
 981 <tr><td colspan="4" class="doc" id="objcPropertyDecl0"><pre>Matches Objective-C property declarations.
 982
 983 Example matches enabled
 984   @interface Foo
 985   @property BOOL enabled;
 986   @end
 987 </pre></td></tr>
 988
 989
 990 <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>
 991 <tr><td colspan="4" class="doc" id="objcProtocolDecl0"><pre>Matches Objective-C protocol declarations.
 992
 993 Example matches FooDelegate
 994   @protocol FooDelegate
 995   @end
 996 </pre></td></tr>
 997
 998
 999 <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>
1000 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
1001
1002 Given
1003   void f(int x);
1004 parmVarDecl()
1005   matches int x.
1006 </pre></td></tr>
1007
1008
1009 <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>
1010 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches class, struct, and union declarations.
1011
1012 Example matches X, Z, U, and S
1013   class X;
1014   template&lt;class T&gt; class Z {};
1015   struct S {};
1016   union U {};
1017 </pre></td></tr>
1018
1019
1020 <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>
1021 <tr><td colspan="4" class="doc" id="staticAssertDecl0"><pre>Matches a C++ static_assert declaration.
1022
1023 Example:
1024   staticAssertDecl()
1025 matches
1026   static_assert(sizeof(S) == sizeof(int))
1027 in
1028   struct S {
1029     int x;
1030   };
1031   static_assert(sizeof(S) == sizeof(int));
1032 </pre></td></tr>
1033
1034
1035 <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>
1036 <tr><td colspan="4" class="doc" id="tagDecl0"><pre>Matches tag declarations.
1037
1038 Example matches X, Z, U, S, E
1039   class X;
1040   template&lt;class T&gt; class Z {};
1041   struct S {};
1042   union U {};
1043   enum E {
1044     A, B, C
1045   };
1046 </pre></td></tr>
1047
1048
1049 <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>
1050 <tr><td colspan="4" class="doc" id="templateTemplateParmDecl0"><pre>Matches template template parameter declarations.
1051
1052 Given
1053   template &lt;template &lt;typename&gt; class Z, int N&gt; struct C {};
1054 templateTypeParmDecl()
1055   matches 'Z', but not 'N'.
1056 </pre></td></tr>
1057
1058
1059 <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>
1060 <tr><td colspan="4" class="doc" id="templateTypeParmDecl0"><pre>Matches template type parameter declarations.
1061
1062 Given
1063   template &lt;typename T, int N&gt; struct C {};
1064 templateTypeParmDecl()
1065   matches 'T', but not 'N'.
1066 </pre></td></tr>
1067
1068
1069 <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>
1070 <tr><td colspan="4" class="doc" id="translationUnitDecl0"><pre>Matches the top declaration context.
1071
1072 Given
1073   int X;
1074   namespace NS {
1075   int Y;
1076   }  // namespace NS
1077 decl(hasDeclContext(translationUnitDecl()))
1078   matches "int X", but not "int Y".
1079 </pre></td></tr>
1080
1081
1082 <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>
1083 <tr><td colspan="4" class="doc" id="typeAliasDecl0"><pre>Matches type alias declarations.
1084
1085 Given
1086   typedef int X;
1087   using Y = int;
1088 typeAliasDecl()
1089   matches "using Y = int", but not "typedef int X"
1090 </pre></td></tr>
1091
1092
1093 <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>
1094 <tr><td colspan="4" class="doc" id="typeAliasTemplateDecl0"><pre>Matches type alias template declarations.
1095
1096 typeAliasTemplateDecl() matches
1097   template &lt;typename T&gt;
1098   using Y = X&lt;T&gt;;
1099 </pre></td></tr>
1100
1101
1102 <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>
1103 <tr><td colspan="4" class="doc" id="typedefDecl0"><pre>Matches typedef declarations.
1104
1105 Given
1106   typedef int X;
1107   using Y = int;
1108 typedefDecl()
1109   matches "typedef int X", but not "using Y = int"
1110 </pre></td></tr>
1111
1112
1113 <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>
1114 <tr><td colspan="4" class="doc" id="typedefNameDecl0"><pre>Matches typedef name declarations.
1115
1116 Given
1117   typedef int X;
1118   using Y = int;
1119 typedefNameDecl()
1120   matches "typedef int X" and "using Y = int"
1121 </pre></td></tr>
1122
1123
1124 <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>
1125 <tr><td colspan="4" class="doc" id="unresolvedUsingTypenameDecl0"><pre>Matches unresolved using value declarations that involve the
1126 typename.
1127
1128 Given
1129   template &lt;typename T&gt;
1130   struct Base { typedef T Foo; };
1131
1132   template&lt;typename T&gt;
1133   struct S : private Base&lt;T&gt; {
1134     using typename Base&lt;T&gt;::Foo;
1135   };
1136 unresolvedUsingTypenameDecl()
1137   matches using Base&lt;T&gt;::Foo </pre></td></tr>
1138
1139
1140 <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>
1141 <tr><td colspan="4" class="doc" id="unresolvedUsingValueDecl0"><pre>Matches unresolved using value declarations.
1142
1143 Given
1144   template&lt;typename X&gt;
1145   class C : private X {
1146     using X::x;
1147   };
1148 unresolvedUsingValueDecl()
1149   matches using X::x </pre></td></tr>
1150
1151
1152 <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>
1153 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
1154
1155 Given
1156   namespace X { int x; }
1157   using X::x;
1158 usingDecl()
1159   matches using X::x </pre></td></tr>
1160
1161
1162 <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>
1163 <tr><td colspan="4" class="doc" id="usingDirectiveDecl0"><pre>Matches using namespace declarations.
1164
1165 Given
1166   namespace X { int x; }
1167   using namespace X;
1168 usingDirectiveDecl()
1169   matches using namespace X </pre></td></tr>
1170
1171
1172 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('usingEnumDecl0')"><a name="usingEnumDecl0Anchor">usingEnumDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingEnumDecl.html">UsingEnumDecl</a>&gt;...</td></tr>
1173 <tr><td colspan="4" class="doc" id="usingEnumDecl0"><pre>Matches using-enum declarations.
1174
1175 Given
1176   namespace X { enum x {...}; }
1177   using enum X::x;
1178 usingEnumDecl()
1179   matches using enum X::x </pre></td></tr>
1180
1181
1182 <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>
1183 <tr><td colspan="4" class="doc" id="valueDecl0"><pre>Matches any value declaration.
1184
1185 Example matches A, B, C and F
1186   enum X { A, B, C };
1187   void F();
1188 </pre></td></tr>
1189
1190
1191 <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>
1192 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
1193
1194 Note: this does not match declarations of member variables, which are
1195 "field" declarations in Clang parlance.
1196
1197 Example matches a
1198   int a;
1199 </pre></td></tr>
1200
1201
1202 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt;</td><td class="name" onclick="toggle('lambdaCapture0')"><a name="lambdaCapture0Anchor">lambdaCapture</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt;...</td></tr>
1203 <tr><td colspan="4" class="doc" id="lambdaCapture0"><pre>Matches lambda captures.
1204
1205 Given
1206   int main() {
1207     int x;
1208     auto f = [x](){};
1209     auto g = [x = 1](){};
1210   }
1211 In the matcher `lambdaExpr(hasAnyCapture(lambdaCapture()))`,
1212 `lambdaCapture()` matches `x` and `x=1`.
1213 </pre></td></tr>
1214
1215
1216 <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>
1217 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
1218 </pre></td></tr>
1219
1220
1221 <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>
1222 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
1223
1224 Given
1225   namespace ns {
1226     struct A { static void f(); };
1227     void A::f() {}
1228     void g() { A::f(); }
1229   }
1230   ns::A a;
1231 nestedNameSpecifier()
1232   matches "ns::" and both "A::"
1233 </pre></td></tr>
1234
1235
1236 <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>
1237 <tr><td colspan="4" class="doc" id="ompDefaultClause0"><pre>Matches OpenMP ``default`` clause.
1238
1239 Given
1240
1241   #pragma omp parallel default(none)
1242   #pragma omp parallel default(shared)
1243   #pragma omp parallel default(private)
1244   #pragma omp parallel default(firstprivate)
1245   #pragma omp parallel
1246
1247 ``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``,
1248 `` default(private)`` and ``default(firstprivate)``
1249 </pre></td></tr>
1250
1251
1252 <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>
1253 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
1254 </pre></td></tr>
1255
1256
1257 <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>
1258 <tr><td colspan="4" class="doc" id="addrLabelExpr0"><pre>Matches address of label statements (GNU extension).
1259
1260 Given
1261   FOO: bar();
1262   void *ptr = &amp;&amp;FOO;
1263   goto *bar;
1264 addrLabelExpr()
1265   matches '&amp;&amp;FOO'
1266 </pre></td></tr>
1267
1268
1269 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('arrayInitIndexExpr0')"><a name="arrayInitIndexExpr0Anchor">arrayInitIndexExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArrayInitIndexExpr.html">ArrayInitIndexExpr</a>&gt;...</td></tr>
1270 <tr><td colspan="4" class="doc" id="arrayInitIndexExpr0"><pre>The arrayInitIndexExpr consists of two subexpressions: a common expression
1271 (the source array) that is evaluated once up-front, and a per-element initializer
1272 that runs once for each array element. Within the per-element initializer,
1273 the current index may be obtained via an ArrayInitIndexExpr.
1274
1275 Given
1276   void testStructBinding() {
1277     int a[2] = {1, 2};
1278     auto [x, y] = a;
1279   }
1280 arrayInitIndexExpr() matches the array index that implicitly iterates
1281 over the array `a` to copy each element to the anonymous array
1282 that backs the structured binding `[x, y]` elements of which are
1283 referred to by their aliases `x` and `y`.
1284 </pre></td></tr>
1285
1286
1287 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('arrayInitLoopExpr0')"><a name="arrayInitLoopExpr0Anchor">arrayInitLoopExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArrayInitLoopExpr.html">ArrayInitLoopExpr</a>&gt;...</td></tr>
1288 <tr><td colspan="4" class="doc" id="arrayInitLoopExpr0"><pre>Matches a loop initializing the elements of an array in a number of contexts:
1289  * in the implicit copy/move constructor for a class with an array member
1290  * when a lambda-expression captures an array by value
1291  * when a decomposition declaration decomposes an array
1292
1293 Given
1294   void testLambdaCapture() {
1295     int a[10];
1296     auto Lam1 = [a]() {
1297       return;
1298     };
1299   }
1300 arrayInitLoopExpr() matches the implicit loop that initializes each element of
1301 the implicit array field inside the lambda object, that represents the array `a`
1302 captured by value.
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('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>
1307 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
1308
1309 Given
1310   int i = a[1];
1311 arraySubscriptExpr()
1312   matches "a[1]"
1313 </pre></td></tr>
1314
1315
1316 <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>
1317 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
1318
1319  int i = 100;
1320   __asm("mov al, 2");
1321 asmStmt()
1322   matches '__asm("mov al, 2")'
1323 </pre></td></tr>
1324
1325
1326 <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>
1327 <tr><td colspan="4" class="doc" id="atomicExpr0"><pre>Matches atomic builtins.
1328 Example matches __atomic_load_n(ptr, 1)
1329   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
1330 </pre></td></tr>
1331
1332
1333 <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>
1334 <tr><td colspan="4" class="doc" id="autoreleasePoolStmt0"><pre>Matches an Objective-C autorelease pool statement.
1335
1336 Given
1337   @autoreleasepool {
1338     int x = 0;
1339   }
1340 autoreleasePoolStmt(stmt()) matches the declaration of "x"
1341 inside the autorelease pool.
1342 </pre></td></tr>
1343
1344
1345 <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>
1346 <tr><td colspan="4" class="doc" id="binaryConditionalOperator0"><pre>Matches binary conditional operator expressions (GNU extension).
1347
1348 Example matches a ?: b
1349   (a ?: b) + 42;
1350 </pre></td></tr>
1351
1352
1353 <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>
1354 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
1355
1356 Example matches a || b
1357   !(a || b)
1358 See also the binaryOperation() matcher for more-general matching.
1359 </pre></td></tr>
1360
1361
1362 <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>
1363 <tr><td colspan="4" class="doc" id="blockExpr0"><pre>Matches a reference to a block.
1364
1365 Example: matches "^{}":
1366   void f() { ^{}(); }
1367 </pre></td></tr>
1368
1369
1370 <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>
1371 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
1372
1373 Given
1374   while (true) { break; }
1375 breakStmt()
1376   matches 'break'
1377 </pre></td></tr>
1378
1379
1380 <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>
1381 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
1382
1383 Example: Matches (int) 2.2f in
1384   int i = (int) 2.2f;
1385 </pre></td></tr>
1386
1387
1388 <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>
1389 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
1390
1391 Example matches x.y() and y()
1392   X x;
1393   x.y();
1394   y();
1395 </pre></td></tr>
1396
1397
1398 <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>
1399 <tr><td colspan="4" class="doc" id="caseStmt0"><pre>Matches case statements inside switch statements.
1400
1401 Given
1402   switch(a) { case 42: break; default: break; }
1403 caseStmt()
1404   matches 'case 42:'.
1405 </pre></td></tr>
1406
1407
1408 <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>
1409 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
1410
1411 Example: castExpr() matches each of the following:
1412   (int) 3;
1413   const_cast&lt;Expr *&gt;(SubExpr);
1414   char c = 0;
1415 but does not match
1416   int i = (0);
1417   int k = 0;
1418 </pre></td></tr>
1419
1420
1421 <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>
1422 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
1423
1424 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
1425 though.
1426
1427 Example matches 'a', L'a'
1428   char ch = 'a';
1429   wchar_t chw = L'a';
1430 </pre></td></tr>
1431
1432
1433 <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>
1434 <tr><td colspan="4" class="doc" id="chooseExpr0"><pre>Matches GNU __builtin_choose_expr.
1435 </pre></td></tr>
1436
1437
1438 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('coawaitExpr0')"><a name="coawaitExpr0Anchor">coawaitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CoawaitExpr.html">CoawaitExpr</a>&gt;...</td></tr>
1439 <tr><td colspan="4" class="doc" id="coawaitExpr0"><pre>Matches co_await expressions.
1440
1441 Given
1442   co_await 1;
1443 coawaitExpr()
1444   matches 'co_await 1'
1445 </pre></td></tr>
1446
1447
1448 <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>
1449 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
1450
1451 Example match: {1}, (1, 2)
1452   int array[4] = {1};
1453   vector int myvec = (vector int)(1, 2);
1454 </pre></td></tr>
1455
1456
1457 <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>
1458 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
1459
1460 Example matches '{}' and '{{}}' in 'for (;;) {{}}'
1461   for (;;) {{}}
1462 </pre></td></tr>
1463
1464
1465 <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>
1466 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
1467
1468 Example matches a ? b : c
1469   (a ? b : c) + 42
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('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>
1474 <tr><td colspan="4" class="doc" id="constantExpr0"><pre>Matches a constant expression wrapper.
1475
1476 Example matches the constant in the case statement:
1477     (matcher = constantExpr())
1478   switch (a) {
1479   case 37: break;
1480   }
1481 </pre></td></tr>
1482
1483
1484 <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>
1485 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
1486
1487 Given
1488   while (true) { continue; }
1489 continueStmt()
1490   matches 'continue'
1491 </pre></td></tr>
1492
1493
1494 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('convertVectorExpr0')"><a name="convertVectorExpr0Anchor">convertVectorExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConvertVectorExpr.html">ConvertVectorExpr</a>&gt;...</td></tr>
1495 <tr><td colspan="4" class="doc" id="convertVectorExpr0"><pre>Matches builtin function __builtin_convertvector.
1496 </pre></td></tr>
1497
1498
1499 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('coreturnStmt0')"><a name="coreturnStmt0Anchor">coreturnStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CoreturnStmt.html">CoreturnStmt</a>&gt;...</td></tr>
1500 <tr><td colspan="4" class="doc" id="coreturnStmt0"><pre>Matches co_return statements.
1501
1502 Given
1503   while (true) { co_return; }
1504 coreturnStmt()
1505   matches 'co_return'
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('coroutineBodyStmt0')"><a name="coroutineBodyStmt0Anchor">coroutineBodyStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CoroutineBodyStmt.html">CoroutineBodyStmt</a>&gt;...</td></tr>
1510 <tr><td colspan="4" class="doc" id="coroutineBodyStmt0"><pre>Matches coroutine body statements.
1511
1512 coroutineBodyStmt() matches the coroutine below
1513   generator&lt;int&gt; gen() {
1514     co_return;
1515   }
1516 </pre></td></tr>
1517
1518
1519 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('coyieldExpr0')"><a name="coyieldExpr0Anchor">coyieldExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CoyieldExpr.html">CoyieldExpr</a>&gt;...</td></tr>
1520 <tr><td colspan="4" class="doc" id="coyieldExpr0"><pre>Matches co_yield expressions.
1521
1522 Given
1523   co_yield 1;
1524 coyieldExpr()
1525   matches 'co_yield 1'
1526 </pre></td></tr>
1527
1528
1529 <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>
1530 <tr><td colspan="4" class="doc" id="cudaKernelCallExpr0"><pre>Matches CUDA kernel call expression.
1531
1532 Example matches,
1533   kernel&lt;&lt;&lt;i,j&gt;&gt;&gt;();
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('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>
1538 <tr><td colspan="4" class="doc" id="cxxBindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
1539
1540 Example matches FunctionTakesString(GetStringByValue())
1541     (matcher = cxxBindTemporaryExpr())
1542   FunctionTakesString(GetStringByValue());
1543   FunctionTakesStringByPointer(GetStringPointer());
1544 </pre></td></tr>
1545
1546
1547 <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>
1548 <tr><td colspan="4" class="doc" id="cxxBoolLiteral0"><pre>Matches bool literals.
1549
1550 Example matches true
1551   true
1552 </pre></td></tr>
1553
1554
1555 <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>
1556 <tr><td colspan="4" class="doc" id="cxxCatchStmt0"><pre>Matches catch statements.
1557
1558   try {} catch(int i) {}
1559 cxxCatchStmt()
1560   matches 'catch(int i)'
1561 </pre></td></tr>
1562
1563
1564 <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>
1565 <tr><td colspan="4" class="doc" id="cxxConstCastExpr0"><pre>Matches a const_cast expression.
1566
1567 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
1568   int n = 42;
1569   const int &amp;r(n);
1570   int* p = const_cast&lt;int*&gt;(&amp;r);
1571 </pre></td></tr>
1572
1573
1574 <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>
1575 <tr><td colspan="4" class="doc" id="cxxConstructExpr0"><pre>Matches constructor call expressions (including implicit ones).
1576
1577 Example matches string(ptr, n) and ptr within arguments of f
1578     (matcher = cxxConstructExpr())
1579   void f(const string &amp;a, const string &amp;b);
1580   char *ptr;
1581   int n;
1582   f(string(ptr, n), ptr);
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('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>
1587 <tr><td colspan="4" class="doc" id="cxxDefaultArgExpr0"><pre>Matches the value of a default argument at the call site.
1588
1589 Example matches the CXXDefaultArgExpr placeholder inserted for the
1590     default value of the second parameter in the call expression f(42)
1591     (matcher = cxxDefaultArgExpr())
1592   void f(int x, int y = 0);
1593   f(42);
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('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>
1598 <tr><td colspan="4" class="doc" id="cxxDeleteExpr0"><pre>Matches delete expressions.
1599
1600 Given
1601   delete X;
1602 cxxDeleteExpr()
1603   matches 'delete X'.
1604 </pre></td></tr>
1605
1606
1607 <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>
1608 <tr><td colspan="4" class="doc" id="cxxDependentScopeMemberExpr0"><pre>Matches member expressions where the actual member referenced could not be
1609 resolved because the base expression or the member name was dependent.
1610
1611 Given
1612   template &lt;class T&gt; void f() { T t; t.g(); }
1613 cxxDependentScopeMemberExpr()
1614   matches t.g
1615 </pre></td></tr>
1616
1617
1618 <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>
1619 <tr><td colspan="4" class="doc" id="cxxDynamicCastExpr0"><pre>Matches a dynamic_cast expression.
1620
1621 Example:
1622   cxxDynamicCastExpr()
1623 matches
1624   dynamic_cast&lt;D*&gt;(&amp;b);
1625 in
1626   struct B { virtual ~B() {} }; struct D : B {};
1627   B b;
1628   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
1629 </pre></td></tr>
1630
1631
1632 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxFoldExpr0')"><a name="cxxFoldExpr0Anchor">cxxFoldExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;...</td></tr>
1633 <tr><td colspan="4" class="doc" id="cxxFoldExpr0"><pre>Matches C++17 fold expressions.
1634
1635 Example matches `(0 + ... + args)`:
1636   template &lt;typename... Args&gt;
1637   auto sum(Args... args) {
1638       return (0 + ... + args);
1639   }
1640 </pre></td></tr>
1641
1642
1643 <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>
1644 <tr><td colspan="4" class="doc" id="cxxForRangeStmt0"><pre>Matches range-based for statements.
1645
1646 cxxForRangeStmt() matches 'for (auto a : i)'
1647   int i[] =  {1, 2, 3}; for (auto a : i);
1648   for(int j = 0; j &lt; 5; ++j);
1649 </pre></td></tr>
1650
1651
1652 <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>
1653 <tr><td colspan="4" class="doc" id="cxxFunctionalCastExpr0"><pre>Matches functional cast expressions
1654
1655 Example: Matches Foo(bar);
1656   Foo f = bar;
1657   Foo g = (Foo) bar;
1658   Foo h = Foo(bar);
1659 </pre></td></tr>
1660
1661
1662 <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>
1663 <tr><td colspan="4" class="doc" id="cxxMemberCallExpr0"><pre>Matches member call expressions.
1664
1665 Example matches x.y()
1666   X x;
1667   x.y();
1668 </pre></td></tr>
1669
1670
1671 <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>
1672 <tr><td colspan="4" class="doc" id="cxxNewExpr0"><pre>Matches new expressions.
1673
1674 Given
1675   new X;
1676 cxxNewExpr()
1677   matches 'new X'.
1678 </pre></td></tr>
1679
1680
1681 <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>
1682 <tr><td colspan="4" class="doc" id="cxxNoexceptExpr0"><pre>Matches noexcept expressions.
1683
1684 Given
1685   bool a() noexcept;
1686   bool b() noexcept(true);
1687   bool c() noexcept(false);
1688   bool d() noexcept(noexcept(a()));
1689   bool e = noexcept(b()) || noexcept(c());
1690 cxxNoexceptExpr()
1691   matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`.
1692   doesn't match the noexcept specifier in the declarations a, b, c or d.
1693 </pre></td></tr>
1694
1695
1696 <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>
1697 <tr><td colspan="4" class="doc" id="cxxNullPtrLiteralExpr0"><pre>Matches nullptr literal.
1698 </pre></td></tr>
1699
1700
1701 <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>
1702 <tr><td colspan="4" class="doc" id="cxxOperatorCallExpr0"><pre>Matches overloaded operator calls.
1703
1704 Note that if an operator isn't overloaded, it won't match. Instead, use
1705 binaryOperator matcher.
1706 Currently it does not match operators such as new delete.
1707 FIXME: figure out why these do not match?
1708
1709 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
1710     (matcher = cxxOperatorCallExpr())
1711   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
1712   ostream &amp;o; int b = 1, c = 1;
1713   o &lt;&lt; b &lt;&lt; c;
1714 See also the binaryOperation() matcher for more-general matching of binary
1715 uses of this AST node.
1716 </pre></td></tr>
1717
1718
1719 <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>
1720 <tr><td colspan="4" class="doc" id="cxxReinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
1721
1722 Either the source expression or the destination type can be matched
1723 using has(), but hasDestinationType() is more specific and can be
1724 more readable.
1725
1726 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
1727   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
1728 </pre></td></tr>
1729
1730
1731 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxRewrittenBinaryOperator0')"><a name="cxxRewrittenBinaryOperator0Anchor">cxxRewrittenBinaryOperator</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;...</td></tr>
1732 <tr><td colspan="4" class="doc" id="cxxRewrittenBinaryOperator0"><pre>Matches rewritten binary operators
1733
1734 Example matches use of "&lt;":
1735   #include &lt;compare&gt;
1736   struct HasSpaceshipMem {
1737     int a;
1738     constexpr auto operator&lt;=&gt;(const HasSpaceshipMem&amp;) const = default;
1739   };
1740   void compare() {
1741     HasSpaceshipMem hs1, hs2;
1742     if (hs1 &lt; hs2)
1743         return;
1744   }
1745 See also the binaryOperation() matcher for more-general matching
1746 of this AST node.
1747 </pre></td></tr>
1748
1749
1750 <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>
1751 <tr><td colspan="4" class="doc" id="cxxStaticCastExpr0"><pre>Matches a C++ static_cast expression.
1752
1753 See also: hasDestinationType
1754 See also: reinterpretCast
1755
1756 Example:
1757   cxxStaticCastExpr()
1758 matches
1759   static_cast&lt;long&gt;(8)
1760 in
1761   long eight(static_cast&lt;long&gt;(8));
1762 </pre></td></tr>
1763
1764
1765 <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>
1766 <tr><td colspan="4" class="doc" id="cxxStdInitializerListExpr0"><pre>Matches C++ initializer list expressions.
1767
1768 Given
1769   std::vector&lt;int&gt; a({ 1, 2, 3 });
1770   std::vector&lt;int&gt; b = { 4, 5 };
1771   int c[] = { 6, 7 };
1772   std::pair&lt;int, int&gt; d = { 8, 9 };
1773 cxxStdInitializerListExpr()
1774   matches "{ 1, 2, 3 }" and "{ 4, 5 }"
1775 </pre></td></tr>
1776
1777
1778 <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>
1779 <tr><td colspan="4" class="doc" id="cxxTemporaryObjectExpr0"><pre>Matches functional cast expressions having N != 1 arguments
1780
1781 Example: Matches Foo(bar, bar)
1782   Foo h = Foo(bar, bar);
1783 </pre></td></tr>
1784
1785
1786 <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>
1787 <tr><td colspan="4" class="doc" id="cxxThisExpr0"><pre>Matches implicit and explicit this expressions.
1788
1789 Example matches the implicit this expression in "return i".
1790     (matcher = cxxThisExpr())
1791 struct foo {
1792   int i;
1793   int f() { return i; }
1794 };
1795 </pre></td></tr>
1796
1797
1798 <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>
1799 <tr><td colspan="4" class="doc" id="cxxThrowExpr0"><pre>Matches throw expressions.
1800
1801   try { throw 5; } catch(int i) {}
1802 cxxThrowExpr()
1803   matches 'throw 5'
1804 </pre></td></tr>
1805
1806
1807 <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>
1808 <tr><td colspan="4" class="doc" id="cxxTryStmt0"><pre>Matches try statements.
1809
1810   try {} catch(int i) {}
1811 cxxTryStmt()
1812   matches 'try {}'
1813 </pre></td></tr>
1814
1815
1816 <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>
1817 <tr><td colspan="4" class="doc" id="cxxUnresolvedConstructExpr0"><pre>Matches unresolved constructor call expressions.
1818
1819 Example matches T(t) in return statement of f
1820     (matcher = cxxUnresolvedConstructExpr())
1821   template &lt;typename T&gt;
1822   void f(const T&amp; t) { return T(t); }
1823 </pre></td></tr>
1824
1825
1826 <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>
1827 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
1828
1829 Example matches x in if (x)
1830   bool x;
1831   if (x) {}
1832 </pre></td></tr>
1833
1834
1835 <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>
1836 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
1837
1838 Given
1839   int a;
1840 declStmt()
1841   matches 'int a'.
1842 </pre></td></tr>
1843
1844
1845 <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>
1846 <tr><td colspan="4" class="doc" id="defaultStmt0"><pre>Matches default statements inside switch statements.
1847
1848 Given
1849   switch(a) { case 42: break; default: break; }
1850 defaultStmt()
1851   matches 'default:'.
1852 </pre></td></tr>
1853
1854
1855 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('dependentCoawaitExpr0')"><a name="dependentCoawaitExpr0Anchor">dependentCoawaitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentCoawaitExpr.html">DependentCoawaitExpr</a>&gt;...</td></tr>
1856 <tr><td colspan="4" class="doc" id="dependentCoawaitExpr0"><pre>Matches co_await expressions where the type of the promise is dependent
1857 </pre></td></tr>
1858
1859
1860 <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>
1861 <tr><td colspan="4" class="doc" id="designatedInitExpr0"><pre>Matches C99 designated initializer expressions [C99 6.7.8].
1862
1863 Example: Matches { [2].y = 1.0, [0].x = 1.0 }
1864   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
1865 </pre></td></tr>
1866
1867
1868 <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>
1869 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
1870
1871 Given
1872   do {} while (true);
1873 doStmt()
1874   matches 'do {} while(true)'
1875 </pre></td></tr>
1876
1877
1878 <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>
1879 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
1880
1881 Matches any cast expression written in user code, whether it be a
1882 C-style cast, a functional-style cast, or a keyword cast.
1883
1884 Does not match implicit conversions.
1885
1886 Note: the name "explicitCast" is chosen to match Clang's terminology, as
1887 Clang uses the term "cast" to apply to implicit conversions as well as to
1888 actual cast expressions.
1889
1890 See also: hasDestinationType.
1891
1892 Example: matches all five of the casts in
1893   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
1894 but does not match the implicit conversion in
1895   long ell = 42;
1896 </pre></td></tr>
1897
1898
1899 <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>
1900 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
1901
1902 Example matches x()
1903   void f() { x(); }
1904 </pre></td></tr>
1905
1906
1907 <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>
1908 <tr><td colspan="4" class="doc" id="exprWithCleanups0"><pre>Matches expressions that introduce cleanups to be run at the end
1909 of the sub-expression's evaluation.
1910
1911 Example matches std::string()
1912   const std::string str = std::string();
1913 </pre></td></tr>
1914
1915
1916 <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>
1917 <tr><td colspan="4" class="doc" id="fixedPointLiteral0"><pre>Matches fixed point literals
1918 </pre></td></tr>
1919
1920
1921 <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>
1922 <tr><td colspan="4" class="doc" id="floatLiteral0"><pre>Matches float literals of all sizes / encodings, e.g.
1923 1.0, 1.0f, 1.0L and 1e10.
1924
1925 Does not match implicit conversions such as
1926   float a = 10;
1927 </pre></td></tr>
1928
1929
1930 <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>
1931 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
1932
1933 Example matches 'for (;;) {}'
1934   for (;;) {}
1935   int i[] =  {1, 2, 3}; for (auto a : i);
1936 </pre></td></tr>
1937
1938
1939 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('genericSelectionExpr0')"><a name="genericSelectionExpr0Anchor">genericSelectionExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1GenericSelectionExpr.html">GenericSelectionExpr</a>&gt;...</td></tr>
1940 <tr><td colspan="4" class="doc" id="genericSelectionExpr0"><pre>Matches C11 _Generic expression.
1941 </pre></td></tr>
1942
1943
1944 <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>
1945 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
1946 </pre></td></tr>
1947
1948
1949 <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>
1950 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
1951
1952 Given
1953   goto FOO;
1954   FOO: bar();
1955 gotoStmt()
1956   matches 'goto FOO'
1957 </pre></td></tr>
1958
1959
1960 <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>
1961 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
1962
1963 Example matches 'if (x) {}'
1964   if (x) {}
1965 </pre></td></tr>
1966
1967
1968 <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>
1969 <tr><td colspan="4" class="doc" id="imaginaryLiteral0"><pre>Matches imaginary literals, which are based on integer and floating
1970 point literals e.g.: 1i, 1.0i
1971 </pre></td></tr>
1972
1973
1974 <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>
1975 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
1976
1977 This matches many different places, including function call return value
1978 eliding, as well as any type conversions.
1979 </pre></td></tr>
1980
1981
1982 <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>
1983 <tr><td colspan="4" class="doc" id="implicitValueInitExpr0"><pre>Matches implicit initializers of init list expressions.
1984
1985 Given
1986   point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
1987 implicitValueInitExpr()
1988   matches "[0].y" (implicitly)
1989 </pre></td></tr>
1990
1991
1992 <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>
1993 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
1994
1995 Given
1996   int a[] = { 1, 2 };
1997   struct B { int x, y; };
1998   B b = { 5, 6 };
1999 initListExpr()
2000   matches "{ 1, 2 }" and "{ 5, 6 }"
2001 </pre></td></tr>
2002
2003
2004 <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>
2005 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes / encodings, e.g.
2006 1, 1L, 0x1 and 1U.
2007
2008 Does not match character-encoded integers such as L'a'.
2009 </pre></td></tr>
2010
2011
2012 <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>
2013 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
2014
2015 Given
2016   goto FOO;
2017   FOO: bar();
2018 labelStmt()
2019   matches 'FOO:'
2020 </pre></td></tr>
2021
2022
2023 <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>
2024 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
2025
2026 Example matches [&amp;](){return 5;}
2027   [&amp;](){return 5;}
2028 </pre></td></tr>
2029
2030
2031 <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>
2032 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
2033
2034 Example: Given
2035   struct T {void func();};
2036   T f();
2037   void g(T);
2038 materializeTemporaryExpr() matches 'f()' in these statements
2039   T u(f());
2040   g(f());
2041   f().func();
2042 but does not match
2043   f();
2044 </pre></td></tr>
2045
2046
2047 <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>
2048 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
2049
2050 Given
2051   class Y {
2052     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
2053     int a; static int b;
2054   };
2055 memberExpr()
2056   matches this-&gt;x, x, y.x, a, this-&gt;b
2057 </pre></td></tr>
2058
2059
2060 <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>
2061 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
2062
2063   foo();;
2064 nullStmt()
2065   matches the second ';'
2066 </pre></td></tr>
2067
2068
2069 <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>
2070 <tr><td colspan="4" class="doc" id="objcCatchStmt0"><pre>Matches Objective-C @catch statements.
2071
2072 Example matches @catch
2073   @try {}
2074   @catch (...) {}
2075 </pre></td></tr>
2076
2077
2078 <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>
2079 <tr><td colspan="4" class="doc" id="objcFinallyStmt0"><pre>Matches Objective-C @finally statements.
2080
2081 Example matches @finally
2082   @try {}
2083   @finally {}
2084 </pre></td></tr>
2085
2086
2087 <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>
2088 <tr><td colspan="4" class="doc" id="objcIvarRefExpr0"><pre>Matches a reference to an ObjCIvar.
2089
2090 Example: matches "a" in "init" method:
2091 @implementation A {
2092   NSString *a;
2093 }
2094 - (void) init {
2095   a = @"hello";
2096 }
2097 </pre></td></tr>
2098
2099
2100 <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>
2101 <tr><td colspan="4" class="doc" id="objcMessageExpr0"><pre>Matches ObjectiveC Message invocation expressions.
2102
2103 The innermost message send invokes the "alloc" class method on the
2104 NSString class, while the outermost message send invokes the
2105 "initWithString" instance method on the object returned from
2106 NSString's "alloc". This matcher should match both message sends.
2107   [[NSString alloc] initWithString:@"Hello"]
2108 </pre></td></tr>
2109
2110
2111 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcStringLiteral0')"><a name="objcStringLiteral0Anchor">objcStringLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCStringLiteral.html">ObjCStringLiteral</a>&gt;...</td></tr>
2112 <tr><td colspan="4" class="doc" id="objcStringLiteral0"><pre>Matches ObjectiveC String literal expressions.
2113
2114 Example matches @"abcd"
2115   NSString *s = @"abcd";
2116 </pre></td></tr>
2117
2118
2119 <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>
2120 <tr><td colspan="4" class="doc" id="objcThrowStmt0"><pre>Matches Objective-C statements.
2121
2122 Example matches @throw obj;
2123 </pre></td></tr>
2124
2125
2126 <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>
2127 <tr><td colspan="4" class="doc" id="objcTryStmt0"><pre>Matches Objective-C @try statements.
2128
2129 Example matches @try
2130   @try {}
2131   @catch (...) {}
2132 </pre></td></tr>
2133
2134
2135 <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>
2136 <tr><td colspan="4" class="doc" id="ompExecutableDirective0"><pre>Matches any ``#pragma omp`` executable directive.
2137
2138 Given
2139
2140   #pragma omp parallel
2141   #pragma omp parallel default(none)
2142   #pragma omp taskyield
2143
2144 ``ompExecutableDirective()`` matches ``omp parallel``,
2145 ``omp parallel default(none)`` and ``omp taskyield``.
2146 </pre></td></tr>
2147
2148
2149 <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>
2150 <tr><td colspan="4" class="doc" id="opaqueValueExpr0"><pre>Matches opaque value expressions. They are used as helpers
2151 to reference another expressions and can be met
2152 in BinaryConditionalOperators, for example.
2153
2154 Example matches 'a'
2155   (a ?: c) + 42;
2156 </pre></td></tr>
2157
2158
2159 <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>
2160 <tr><td colspan="4" class="doc" id="parenExpr0"><pre>Matches parentheses used in expressions.
2161
2162 Example matches (foo() + 1)
2163   int foo() { return 1; }
2164   int a = (foo() + 1);
2165 </pre></td></tr>
2166
2167
2168 <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>
2169 <tr><td colspan="4" class="doc" id="parenListExpr0"><pre>Matches paren list expressions.
2170 ParenListExprs don't have a predefined type and are used for late parsing.
2171 In the final AST, they can be met in template declarations.
2172
2173 Given
2174   template&lt;typename T&gt; class X {
2175     void f() {
2176       X x(*this);
2177       int a = 0, b = 1; int i = (a, b);
2178     }
2179   };
2180 parenListExpr() matches "*this" but NOT matches (a, b) because (a, b)
2181 has a predefined type and is a ParenExpr, not a ParenListExpr.
2182 </pre></td></tr>
2183
2184
2185 <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>
2186 <tr><td colspan="4" class="doc" id="predefinedExpr0"><pre>Matches predefined identifier expressions [C99 6.4.2.2].
2187
2188 Example: Matches __func__
2189   printf("%s", __func__);
2190 </pre></td></tr>
2191
2192
2193 <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>
2194 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
2195
2196 Given
2197   return 1;
2198 returnStmt()
2199   matches 'return 1'
2200 </pre></td></tr>
2201
2202
2203 <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>
2204 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
2205
2206 Given
2207   { ++a; }
2208 stmt()
2209   matches both the compound statement '{ ++a; }' and '++a'.
2210 </pre></td></tr>
2211
2212
2213 <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>
2214 <tr><td colspan="4" class="doc" id="stmtExpr0"><pre>Matches statement expression (GNU extension).
2215
2216 Example match: ({ int X = 4; X; })
2217   int C = ({ int X = 4; X; });
2218 </pre></td></tr>
2219
2220
2221 <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>
2222 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
2223
2224 Example matches "abcd", L"abcd"
2225   char *s = "abcd";
2226   wchar_t *ws = L"abcd";
2227 </pre></td></tr>
2228
2229
2230 <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>
2231 <tr><td colspan="4" class="doc" id="substNonTypeTemplateParmExpr0"><pre>Matches substitutions of non-type template parameters.
2232
2233 Given
2234   template &lt;int N&gt;
2235   struct A { static const int n = N; };
2236   struct B : public A&lt;42&gt; {};
2237 substNonTypeTemplateParmExpr()
2238   matches "N" in the right-hand side of "static const int n = N;"
2239 </pre></td></tr>
2240
2241
2242 <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>
2243 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
2244
2245 Given
2246   switch(a) { case 42: break; default: break; }
2247 switchCase()
2248   matches 'case 42:' and 'default:'.
2249 </pre></td></tr>
2250
2251
2252 <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>
2253 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
2254
2255 Given
2256   switch(a) { case 42: break; default: break; }
2257 switchStmt()
2258   matches 'switch(a)'.
2259 </pre></td></tr>
2260
2261
2262 <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>
2263 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
2264
2265 Given
2266   Foo x = bar;
2267   int y = sizeof(x) + alignof(x);
2268 unaryExprOrTypeTraitExpr()
2269   matches sizeof(x) and alignof(x)
2270 </pre></td></tr>
2271
2272
2273 <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>
2274 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
2275
2276 Example matches !a
2277   !a || b
2278 </pre></td></tr>
2279
2280
2281 <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>
2282 <tr><td colspan="4" class="doc" id="unresolvedLookupExpr0"><pre>Matches reference to a name that can be looked up during parsing
2283 but could not be resolved to a specific declaration.
2284
2285 Given
2286   template&lt;typename T&gt;
2287   T foo() { T a; return a; }
2288   template&lt;typename T&gt;
2289   void bar() {
2290     foo&lt;T&gt;();
2291   }
2292 unresolvedLookupExpr()
2293   matches foo&lt;T&gt;() </pre></td></tr>
2294
2295
2296 <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>
2297 <tr><td colspan="4" class="doc" id="unresolvedMemberExpr0"><pre>Matches unresolved member expressions.
2298
2299 Given
2300   struct X {
2301     template &lt;class T&gt; void f();
2302     void g();
2303   };
2304   template &lt;class T&gt; void h() { X x; x.f&lt;T&gt;(); x.g(); }
2305 unresolvedMemberExpr()
2306   matches x.f&lt;T&gt;
2307 </pre></td></tr>
2308
2309
2310 <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>
2311 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
2312
2313 Example match: "foo"_suffix
2314 </pre></td></tr>
2315
2316
2317 <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>
2318 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
2319
2320 Given
2321   while (true) {}
2322 whileStmt()
2323   matches 'while (true) {}'.
2324 </pre></td></tr>
2325
2326
2327 <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>
2328 <tr><td colspan="4" class="doc" id="templateArgumentLoc0"><pre>Matches template arguments (with location info).
2329
2330 Given
2331   template &lt;typename T&gt; struct C {};
2332   C&lt;int&gt; c;
2333 templateArgumentLoc()
2334   matches 'int' in C&lt;int&gt;.
2335 </pre></td></tr>
2336
2337
2338 <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>
2339 <tr><td colspan="4" class="doc" id="templateArgument0"><pre>Matches template arguments.
2340
2341 Given
2342   template &lt;typename T&gt; struct C {};
2343   C&lt;int&gt; c;
2344 templateArgument()
2345   matches 'int' in C&lt;int&gt;.
2346 </pre></td></tr>
2347
2348
2349 <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>
2350 <tr><td colspan="4" class="doc" id="templateName0"><pre>Matches template name.
2351
2352 Given
2353   template &lt;typename T&gt; class X { };
2354   X&lt;int&gt; xi;
2355 templateName()
2356   matches 'X' in X&lt;int&gt;.
2357 </pre></td></tr>
2358
2359
2360 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('elaboratedTypeLoc0')"><a name="elaboratedTypeLoc0Anchor">elaboratedTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedTypeLoc.html">ElaboratedTypeLoc</a>&gt;...</td></tr>
2361 <tr><td colspan="4" class="doc" id="elaboratedTypeLoc0"><pre>Matches C or C++ elaborated `TypeLoc`s.
2362
2363 Given
2364   struct s {};
2365   struct s ss;
2366 elaboratedTypeLoc()
2367   matches the `TypeLoc` of the variable declaration of `ss`.
2368 </pre></td></tr>
2369
2370
2371 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('pointerTypeLoc0')"><a name="pointerTypeLoc0Anchor">pointerTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerTypeLoc.html">PointerTypeLoc</a>&gt;...</td></tr>
2372 <tr><td colspan="4" class="doc" id="pointerTypeLoc0"><pre>Matches pointer `TypeLoc`s.
2373
2374 Given
2375   int* x;
2376 pointerTypeLoc()
2377   matches `int*`.
2378 </pre></td></tr>
2379
2380
2381 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('qualifiedTypeLoc0')"><a name="qualifiedTypeLoc0Anchor">qualifiedTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualifiedTypeLoc.html">QualifiedTypeLoc</a>&gt;...</td></tr>
2382 <tr><td colspan="4" class="doc" id="qualifiedTypeLoc0"><pre>Matches `QualifiedTypeLoc`s in the clang AST.
2383
2384 Given
2385   const int x = 0;
2386 qualifiedTypeLoc()
2387   matches `const int`.
2388 </pre></td></tr>
2389
2390
2391 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('referenceTypeLoc0')"><a name="referenceTypeLoc0Anchor">referenceTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceTypeLoc.html">ReferenceTypeLoc</a>&gt;...</td></tr>
2392 <tr><td colspan="4" class="doc" id="referenceTypeLoc0"><pre>Matches reference `TypeLoc`s.
2393
2394 Given
2395   int x = 3;
2396   int&amp; l = x;
2397   int&amp;&amp; r = 3;
2398 referenceTypeLoc()
2399   matches `int&amp;` and `int&amp;&amp;`.
2400 </pre></td></tr>
2401
2402
2403 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('templateSpecializationTypeLoc0')"><a name="templateSpecializationTypeLoc0Anchor">templateSpecializationTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationTypeLoc.html">TemplateSpecializationTypeLoc</a>&gt;...</td></tr>
2404 <tr><td colspan="4" class="doc" id="templateSpecializationTypeLoc0"><pre>Matches template specialization `TypeLoc`s.
2405
2406 Given
2407   template &lt;typename T&gt; class C {};
2408   C&lt;char&gt; var;
2409 varDecl(hasTypeLoc(templateSpecializationTypeLoc(typeLoc())))
2410   matches `C&lt;char&gt; var`.
2411 </pre></td></tr>
2412
2413
2414 <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>
2415 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
2416 </pre></td></tr>
2417
2418
2419 <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>
2420 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
2421
2422 Given
2423   int a[] = { 2, 3 };
2424   int b[4];
2425   void f() { int c[a[0]]; }
2426 arrayType()
2427   matches "int a[]", "int b[4]" and "int c[a[0]]";
2428 </pre></td></tr>
2429
2430
2431 <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>
2432 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
2433
2434 Given
2435   _Atomic(int) i;
2436 atomicType()
2437   matches "_Atomic(int) i"
2438 </pre></td></tr>
2439
2440
2441 <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>
2442 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
2443
2444 Given:
2445   auto n = 4;
2446   int v[] = { 2, 3 }
2447   for (auto i : v) { }
2448 autoType()
2449   matches "auto n" and "auto i"
2450 </pre></td></tr>
2451
2452
2453 <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>
2454 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
2455 "void (^)(int)".
2456
2457 The pointee is always required to be a FunctionType.
2458 </pre></td></tr>
2459
2460
2461 <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>
2462 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
2463
2464 Given
2465   struct A {};
2466   A a;
2467   int b;
2468   float c;
2469   bool d;
2470 builtinType()
2471   matches "int b", "float c" and "bool d"
2472 </pre></td></tr>
2473
2474
2475 <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>
2476 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
2477
2478 Given
2479   _Complex float f;
2480 complexType()
2481   matches "_Complex float f"
2482 </pre></td></tr>
2483
2484
2485 <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>
2486 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
2487
2488 Given
2489   void() {
2490     int a[2];
2491     int b[] = { 2, 3 };
2492     int c[b[0]];
2493   }
2494 constantArrayType()
2495   matches "int a[2]"
2496 </pre></td></tr>
2497
2498
2499 <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>
2500 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
2501 Example matches i[] in declaration of f.
2502     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
2503 Example matches i[1].
2504     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
2505   void f(int i[]) {
2506     i[1] = 0;
2507   }
2508 </pre></td></tr>
2509
2510
2511 <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>
2512 <tr><td colspan="4" class="doc" id="decltypeType0"><pre>Matches types nodes representing C++11 decltype(&lt;expr&gt;) types.
2513
2514 Given:
2515   short i = 1;
2516   int j = 42;
2517   decltype(i + j) result = i + j;
2518 decltypeType()
2519   matches "decltype(i + j)"
2520 </pre></td></tr>
2521
2522
2523 <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>
2524 <tr><td colspan="4" class="doc" id="deducedTemplateSpecializationType0"><pre>Matches C++17 deduced template specialization types, e.g. deduced class
2525 template types.
2526
2527 Given
2528   template &lt;typename T&gt;
2529   class C { public: C(T); };
2530
2531   C c(123);
2532 deducedTemplateSpecializationType() matches the type in the declaration
2533 of the variable c.
2534 </pre></td></tr>
2535
2536
2537 <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>
2538 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
2539
2540 Given
2541   template&lt;typename T, int Size&gt;
2542   class array {
2543     T data[Size];
2544   };
2545 dependentSizedArrayType()
2546   matches "T data[Size]"
2547 </pre></td></tr>
2548
2549
2550 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentSizedExtVectorType0')"><a name="dependentSizedExtVectorType0Anchor">dependentSizedExtVectorType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedExtVectorType.html">DependentSizedExtVectorType</a>&gt;...</td></tr>
2551 <tr><td colspan="4" class="doc" id="dependentSizedExtVectorType0"><pre>Matches C++ extended vector type where either the type or size is
2552 dependent.
2553
2554 Given
2555   template&lt;typename T, int Size&gt;
2556   class vector {
2557     typedef T __attribute__((ext_vector_type(Size))) type;
2558   };
2559 dependentSizedExtVectorType()
2560   matches "T __attribute__((ext_vector_type(Size)))"
2561 </pre></td></tr>
2562
2563
2564 <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>
2565 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
2566 qualified name.
2567
2568 Given
2569   namespace N {
2570     namespace M {
2571       class D {};
2572     }
2573   }
2574   class C {};
2575
2576   class C c;
2577   N::M::D d;
2578
2579 elaboratedType() matches the type of the variable declarations of both
2580 c and d.
2581 </pre></td></tr>
2582
2583
2584 <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>
2585 <tr><td colspan="4" class="doc" id="enumType0"><pre>Matches enum types.
2586
2587 Given
2588   enum C { Green };
2589   enum class S { Red };
2590
2591   C c;
2592   S s;
2593
2594 enumType() matches the type of the variable declarations of both c and
2595 s.
2596 </pre></td></tr>
2597
2598
2599 <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>
2600 <tr><td colspan="4" class="doc" id="functionProtoType0"><pre>Matches FunctionProtoType nodes.
2601
2602 Given
2603   int (*f)(int);
2604   void g();
2605 functionProtoType()
2606   matches "int (*f)(int)" and the type of "g" in C++ mode.
2607   In C mode, "g" is not matched because it does not contain a prototype.
2608 </pre></td></tr>
2609
2610
2611 <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>
2612 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
2613
2614 Given
2615   int (*f)(int);
2616   void g();
2617 functionType()
2618   matches "int (*f)(int)" and the type of "g".
2619 </pre></td></tr>
2620
2621
2622 <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>
2623 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
2624
2625 Given
2626   int a[] = { 2, 3 };
2627   int b[42];
2628   void f(int c[]) { int d[a[0]]; };
2629 incompleteArrayType()
2630   matches "int a[]" and "int c[]"
2631 </pre></td></tr>
2632
2633
2634 <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>
2635 <tr><td colspan="4" class="doc" id="injectedClassNameType0"><pre>Matches injected class name types.
2636
2637 Example matches S s, but not S&lt;T&gt; s.
2638     (matcher = parmVarDecl(hasType(injectedClassNameType())))
2639   template &lt;typename T&gt; struct S {
2640     void f(S s);
2641     void g(S&lt;T&gt; s);
2642   };
2643 </pre></td></tr>
2644
2645
2646 <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>
2647 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
2648
2649 Given:
2650   int *a;
2651   int &amp;b = *a;
2652   int &amp;&amp;c = 1;
2653   auto &amp;d = b;
2654   auto &amp;&amp;e = c;
2655   auto &amp;&amp;f = 2;
2656   int g = 5;
2657
2658 lValueReferenceType() matches the types of b, d, and e. e is
2659 matched since the type is deduced as int&amp; by reference collapsing rules.
2660 </pre></td></tr>
2661
2662
2663 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('macroQualifiedType0')"><a name="macroQualifiedType0Anchor">macroQualifiedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MacroQualifiedType.html">MacroQualifiedType</a>&gt;...</td></tr>
2664 <tr><td colspan="4" class="doc" id="macroQualifiedType0"><pre>Matches qualified types when the qualifier is applied via a macro.
2665
2666 Given
2667   #define CDECL __attribute__((cdecl))
2668   typedef void (CDECL *X)();
2669   typedef void (__attribute__((cdecl)) *Y)();
2670 macroQualifiedType()
2671   matches the type of the typedef declaration of X but not Y.
2672 </pre></td></tr>
2673
2674
2675 <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>
2676 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
2677 Given
2678   struct A { int i; }
2679   A::* ptr = A::i;
2680 memberPointerType()
2681   matches "A::* ptr"
2682 </pre></td></tr>
2683
2684
2685 <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>
2686 <tr><td colspan="4" class="doc" id="objcObjectPointerType0"><pre>Matches an Objective-C object pointer type, which is different from
2687 a pointer type, despite being syntactically similar.
2688
2689 Given
2690   int *a;
2691
2692   @interface Foo
2693   @end
2694   Foo *f;
2695 pointerType()
2696   matches "Foo *f", but does not match "int *a".
2697 </pre></td></tr>
2698
2699
2700 <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>
2701 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
2702
2703 Given
2704   int (*ptr_to_array)[4];
2705   int *array_of_ptrs[4];
2706
2707 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
2708 array_of_ptrs.
2709 </pre></td></tr>
2710
2711
2712 <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>
2713 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
2714 types.
2715
2716 Given
2717   int *a;
2718   int &amp;b = *a;
2719   int c = 5;
2720
2721   @interface Foo
2722   @end
2723   Foo *f;
2724 pointerType()
2725   matches "int *a", but does not match "Foo *f".
2726 </pre></td></tr>
2727
2728
2729 <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>
2730 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
2731
2732 Given:
2733   int *a;
2734   int &amp;b = *a;
2735   int &amp;&amp;c = 1;
2736   auto &amp;d = b;
2737   auto &amp;&amp;e = c;
2738   auto &amp;&amp;f = 2;
2739   int g = 5;
2740
2741 rValueReferenceType() matches the types of c and f. e is not
2742 matched as it is deduced to int&amp; by reference collapsing rules.
2743 </pre></td></tr>
2744
2745
2746 <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>
2747 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
2748
2749 Given
2750   class C {};
2751   struct S {};
2752
2753   C c;
2754   S s;
2755
2756 recordType() matches the type of the variable declarations of both c
2757 and s.
2758 </pre></td></tr>
2759
2760
2761 <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>
2762 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
2763
2764 Given
2765   int *a;
2766   int &amp;b = *a;
2767   int &amp;&amp;c = 1;
2768   auto &amp;d = b;
2769   auto &amp;&amp;e = c;
2770   auto &amp;&amp;f = 2;
2771   int g = 5;
2772
2773 referenceType() matches the types of b, c, d, e, and f.
2774 </pre></td></tr>
2775
2776
2777 <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>
2778 <tr><td colspan="4" class="doc" id="substTemplateTypeParmType0"><pre>Matches types that represent the result of substituting a type for a
2779 template type parameter.
2780
2781 Given
2782   template &lt;typename T&gt;
2783   void F(T t) {
2784     int i = 1 + t;
2785   }
2786
2787 substTemplateTypeParmType() matches the type of 't' but not '1'
2788 </pre></td></tr>
2789
2790
2791 <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>
2792 <tr><td colspan="4" class="doc" id="tagType0"><pre>Matches tag types (record and enum types).
2793
2794 Given
2795   enum E {};
2796   class C {};
2797
2798   E e;
2799   C c;
2800
2801 tagType() matches the type of the variable declarations of both e
2802 and c.
2803 </pre></td></tr>
2804
2805
2806 <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>
2807 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
2808
2809 Given
2810   template &lt;typename T&gt;
2811   class C { };
2812
2813   template class C&lt;int&gt;;  // A
2814   C&lt;char&gt; var;            // B
2815
2816 templateSpecializationType() matches the type of the explicit
2817 instantiation in A and the type of the variable declaration in B.
2818 </pre></td></tr>
2819
2820
2821 <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>
2822 <tr><td colspan="4" class="doc" id="templateTypeParmType0"><pre>Matches template type parameter types.
2823
2824 Example matches T, but not int.
2825     (matcher = templateTypeParmType())
2826   template &lt;typename T&gt; void f(int i);
2827 </pre></td></tr>
2828
2829
2830 <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>
2831 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
2832 </pre></td></tr>
2833
2834
2835 <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>
2836 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
2837
2838 Given
2839   typedef int X;
2840 typedefType()
2841   matches "typedef int X"
2842 </pre></td></tr>
2843
2844
2845 <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>
2846 <tr><td colspan="4" class="doc" id="unaryTransformType0"><pre>Matches types nodes representing unary type transformations.
2847
2848 Given:
2849   typedef __underlying_type(T) type;
2850 unaryTransformType()
2851   matches "__underlying_type(T)"
2852 </pre></td></tr>
2853
2854
2855 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('usingType0')"><a name="usingType0Anchor">usingType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;...</td></tr>
2856 <tr><td colspan="4" class="doc" id="usingType0"><pre>Matches types specified through a using declaration.
2857
2858 Given
2859   namespace a { struct S {}; }
2860   using a::S;
2861   S s;
2862
2863 usingType() matches the type of the variable declaration of s.
2864 </pre></td></tr>
2865
2866
2867 <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>
2868 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
2869 integer-constant-expression.
2870
2871 Given
2872   void f() {
2873     int a[] = { 2, 3 }
2874     int b[42];
2875     int c[a[0]];
2876   }
2877 variableArrayType()
2878   matches "int c[a[0]]"
2879 </pre></td></tr>
2880
2881 <!--END_DECL_MATCHERS -->
2882 </table>
2883
2884 <!-- ======================================================================= -->
2885 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
2886 <!-- ======================================================================= -->
2887
2888 <p>Narrowing matchers match certain attributes on the current node, thus
2889 narrowing down the set of nodes of the current type to match on.</p>
2890
2891 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
2892 which allow users to create more powerful match expressions.</p>
2893
2894 <table>
2895 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
2896 <!-- START_NARROWING_MATCHERS -->
2897
2898 <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>
2899 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
2900
2901 Usable as: Any Matcher
2902 </pre></td></tr>
2903
2904
2905 <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>
2906 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
2907
2908 Usable as: Any Matcher
2909 </pre></td></tr>
2910
2911
2912 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
2913 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
2914
2915 Useful when another matcher requires a child matcher, but there's no
2916 additional constraint. This will often be used with an explicit conversion
2917 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
2918
2919 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
2920 "int* p" and "void f()" in
2921   int* p;
2922   void f();
2923
2924 Usable as: Any Matcher
2925 </pre></td></tr>
2926
2927
2928 <tr><td><em>unspecified</em></td><td class="name" onclick="toggle('mapAnyOf0')"><a name="mapAnyOf0Anchor">mapAnyOf</a></td><td>nodeMatcherFunction...</td></tr>
2929 <tr><td colspan="4" class="doc" id="mapAnyOf0"><pre>Matches any of the NodeMatchers with InnerMatchers nested within
2930
2931 Given
2932   if (true);
2933   for (; true; );
2934 with the matcher
2935   mapAnyOf(ifStmt, forStmt).with(
2936     hasCondition(cxxBoolLiteralExpr(equals(true)))
2937     ).bind("trueCond")
2938 matches the if and the for. It is equivalent to:
2939   auto trueCond = hasCondition(cxxBoolLiteralExpr(equals(true)));
2940   anyOf(
2941     ifStmt(trueCond).bind("trueCond"),
2942     forStmt(trueCond).bind("trueCond")
2943     );
2944
2945 The with() chain-call accepts zero or more matchers which are combined
2946 as-if with allOf() in each of the node matchers.
2947 Usable as: Any Matcher
2948 </pre></td></tr>
2949
2950
2951 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;</td></tr>
2952 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
2953
2954 Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
2955   class X {};
2956   class Y {};
2957
2958 Usable as: Any Matcher
2959 </pre></td></tr>
2960
2961
2962 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Attr.html">Attr</a>&gt;</td><td class="name" onclick="toggle('isImplicit1')"><a name="isImplicit1Anchor">isImplicit</a></td><td></td></tr>
2963 <tr><td colspan="4" class="doc" id="isImplicit1"><pre>Matches an entity that has been implicitly added by the compiler (e.g.
2964 implicit default/copy constructors).
2965 </pre></td></tr>
2966
2967
2968 <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>
2969 <tr><td colspan="4" class="doc" id="hasAnyOperatorName0"><pre>Matches operator expressions (binary or unary) that have any of the
2970 specified names.
2971
2972    hasAnyOperatorName("+", "-")
2973  Is equivalent to
2974    anyOf(hasOperatorName("+"), hasOperatorName("-"))
2975 </pre></td></tr>
2976
2977
2978 <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>
2979 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions and fold expressions
2980 (binary or unary).
2981
2982 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
2983   !(a || b)
2984
2985 Example matches `(0 + ... + args)`
2986     (matcher = cxxFoldExpr(hasOperatorName("+")))
2987   template &lt;typename... Args&gt;
2988   auto sum(Args... args) {
2989       return (0 + ... + args);
2990   }
2991 </pre></td></tr>
2992
2993
2994 <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>
2995 <tr><td colspan="4" class="doc" id="isAssignmentOperator0"><pre>Matches all kinds of assignment operators.
2996
2997 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
2998   if (a == b)
2999     a += b;
3000
3001 Example 2: matches s1 = s2
3002            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
3003   struct S { S&amp; operator=(const S&amp;); };
3004   void x() { S s1, s2; s1 = s2; }
3005 </pre></td></tr>
3006
3007
3008 <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>
3009 <tr><td colspan="4" class="doc" id="isComparisonOperator0"><pre>Matches comparison operators.
3010
3011 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
3012   if (a == b)
3013     a += b;
3014
3015 Example 2: matches s1 &lt; s2
3016            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
3017   struct S { bool operator&lt;(const S&amp; other); };
3018   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
3019 </pre></td></tr>
3020
3021
3022 <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>
3023 <tr><td colspan="4" class="doc" id="isPrivate1"><pre>Matches private C++ declarations and C++ base specifers that specify private
3024 inheritance.
3025
3026 Examples:
3027   class C {
3028   public:    int a;
3029   protected: int b;
3030   private:   int c; // fieldDecl(isPrivate()) matches 'c'
3031   };
3032
3033   struct Base {};
3034   struct Derived1 : private Base {}; // matches 'Base'
3035   class Derived2 : Base {}; // matches 'Base'
3036 </pre></td></tr>
3037
3038
3039 <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>
3040 <tr><td colspan="4" class="doc" id="isProtected1"><pre>Matches protected C++ declarations and C++ base specifers that specify
3041 protected inheritance.
3042
3043 Examples:
3044   class C {
3045   public:    int a;
3046   protected: int b; // fieldDecl(isProtected()) matches 'b'
3047   private:   int c;
3048   };
3049
3050   class Base {};
3051   class Derived : protected Base {}; // matches 'Base'
3052 </pre></td></tr>
3053
3054
3055 <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>
3056 <tr><td colspan="4" class="doc" id="isPublic1"><pre>Matches public C++ declarations and C++ base specifers that specify public
3057 inheritance.
3058
3059 Examples:
3060   class C {
3061   public:    int a; // fieldDecl(isPublic()) matches 'a'
3062   protected: int b;
3063   private:   int c;
3064   };
3065
3066   class Base {};
3067   class Derived1 : public Base {}; // matches 'Base'
3068   struct Derived2 : Base {}; // matches 'Base'
3069 </pre></td></tr>
3070
3071
3072 <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>
3073 <tr><td colspan="4" class="doc" id="isVirtual1"><pre>Matches declarations of virtual methods and C++ base specifers that specify
3074 virtual inheritance.
3075
3076 Example:
3077   class A {
3078    public:
3079     virtual void x(); // matches x
3080   };
3081
3082 Example:
3083   class Base {};
3084   class DirectlyDerived : virtual Base {}; // matches Base
3085   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
3086
3087 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;
3088 </pre></td></tr>
3089
3090
3091 <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>
3092 <tr><td colspan="4" class="doc" id="equals5"><pre></pre></td></tr>
3093
3094
3095 <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>
3096 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value of type ValueT.
3097
3098 Given
3099   f('false, 3.14, 42);
3100 characterLiteral(equals(0))
3101   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
3102   match false
3103 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
3104   match 3.14
3105 integerLiteral(equals(42))
3106   matches 42
3107
3108 Note that you cannot directly match a negative numeric literal because the
3109 minus sign is not part of the literal: It is a unary operator whose operand
3110 is the positive numeric literal. Instead, you must use a unaryOperator()
3111 matcher to match the minus sign:
3112
3113 unaryOperator(hasOperatorName("-"),
3114               hasUnaryOperand(integerLiteral(equals(13))))
3115
3116 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;,
3117            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;
3118 </pre></td></tr>
3119
3120
3121 <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>
3122 <tr><td colspan="4" class="doc" id="equals11"><pre></pre></td></tr>
3123
3124
3125 <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>
3126 <tr><td colspan="4" class="doc" id="equals8"><pre></pre></td></tr>
3127
3128
3129 <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>
3130 <tr><td colspan="4" class="doc" id="isCatchAll0"><pre>Matches a C++ catch statement that has a catch-all handler.
3131
3132 Given
3133   try {
3134     // ...
3135   } catch (int) {
3136     // ...
3137   } catch (...) {
3138     // ...
3139   }
3140 cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
3141 </pre></td></tr>
3142
3143
3144 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountAtLeast1')"><a name="argumentCountAtLeast1Anchor">argumentCountAtLeast</a></td><td>unsigned N</td></tr>
3145 <tr><td colspan="4" class="doc" id="argumentCountAtLeast1"><pre>Checks that a call expression or a constructor call expression has at least
3146 the specified number of arguments (including absent default arguments).
3147
3148 Example matches f(0, 0) and g(0, 0, 0)
3149 (matcher = callExpr(argumentCountAtLeast(2)))
3150   void f(int x, int y);
3151   void g(int x, int y, int z);
3152   f(0, 0);
3153   g(0, 0, 0);
3154 </pre></td></tr>
3155
3156
3157 <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>
3158 <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has
3159 a specific number of arguments (including absent default arguments).
3160
3161 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
3162   void f(int x, int y);
3163   f(0, 0);
3164 </pre></td></tr>
3165
3166
3167 <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>
3168 <tr><td colspan="4" class="doc" id="isListInitialization0"><pre>Matches a constructor call expression which uses list initialization.
3169 </pre></td></tr>
3170
3171
3172 <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>
3173 <tr><td colspan="4" class="doc" id="requiresZeroInitialization0"><pre>Matches a constructor call expression which requires
3174 zero initialization.
3175
3176 Given
3177 void foo() {
3178   struct point { double x; double y; };
3179   point pt[2] = { { 1.0, 2.0 } };
3180 }
3181 initListExpr(has(cxxConstructExpr(requiresZeroInitialization()))
3182 will match the implicit array filler for pt[1].
3183 </pre></td></tr>
3184
3185
3186 <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>
3187 <tr><td colspan="4" class="doc" id="isCopyConstructor0"><pre>Matches constructor declarations that are copy constructors.
3188
3189 Given
3190   struct S {
3191     S(); // #1
3192     S(const S &amp;); // #2
3193     S(S &amp;&amp;); // #3
3194   };
3195 cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
3196 </pre></td></tr>
3197
3198
3199 <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>
3200 <tr><td colspan="4" class="doc" id="isDefaultConstructor0"><pre>Matches constructor declarations that are default constructors.
3201
3202 Given
3203   struct S {
3204     S(); // #1
3205     S(const S &amp;); // #2
3206     S(S &amp;&amp;); // #3
3207   };
3208 cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
3209 </pre></td></tr>
3210
3211
3212 <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>
3213 <tr><td colspan="4" class="doc" id="isDelegatingConstructor0"><pre>Matches constructors that delegate to another constructor.
3214
3215 Given
3216   struct S {
3217     S(); // #1
3218     S(int) {} // #2
3219     S(S &amp;&amp;) : S() {} // #3
3220   };
3221   S::S() : S(0) {} // #4
3222 cxxConstructorDecl(isDelegatingConstructor()) will match #3 and #4, but not
3223 #1 or #2.
3224 </pre></td></tr>
3225
3226
3227 <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>
3228 <tr><td colspan="4" class="doc" id="isExplicit0"><pre>Matches constructor, conversion function, and deduction guide declarations
3229 that have an explicit specifier if this explicit specifier is resolved to
3230 true.
3231
3232 Given
3233   template&lt;bool b&gt;
3234   struct S {
3235     S(int); // #1
3236     explicit S(double); // #2
3237     operator int(); // #3
3238     explicit operator bool(); // #4
3239     explicit(false) S(bool) // # 7
3240     explicit(true) S(char) // # 8
3241     explicit(b) S(S) // # 9
3242   };
3243   S(int) -&gt; S&lt;true&gt; // #5
3244   explicit S(double) -&gt; S&lt;false&gt; // #6
3245 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
3246 cxxConversionDecl(isExplicit()) will match #4, but not #3.
3247 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
3248 </pre></td></tr>
3249
3250
3251 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isInheritingConstructor0')"><a name="isInheritingConstructor0Anchor">isInheritingConstructor</a></td><td></td></tr>
3252 <tr><td colspan="4" class="doc" id="isInheritingConstructor0"><pre></pre></td></tr>
3253
3254
3255 <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>
3256 <tr><td colspan="4" class="doc" id="isMoveConstructor0"><pre>Matches constructor declarations that are move constructors.
3257
3258 Given
3259   struct S {
3260     S(); // #1
3261     S(const S &amp;); // #2
3262     S(S &amp;&amp;); // #3
3263   };
3264 cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
3265 </pre></td></tr>
3266
3267
3268 <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>
3269 <tr><td colspan="4" class="doc" id="isExplicit1"><pre>Matches constructor, conversion function, and deduction guide declarations
3270 that have an explicit specifier if this explicit specifier is resolved to
3271 true.
3272
3273 Given
3274   template&lt;bool b&gt;
3275   struct S {
3276     S(int); // #1
3277     explicit S(double); // #2
3278     operator int(); // #3
3279     explicit operator bool(); // #4
3280     explicit(false) S(bool) // # 7
3281     explicit(true) S(char) // # 8
3282     explicit(b) S(S) // # 9
3283   };
3284   S(int) -&gt; S&lt;true&gt; // #5
3285   explicit S(double) -&gt; S&lt;false&gt; // #6
3286 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
3287 cxxConversionDecl(isExplicit()) will match #4, but not #3.
3288 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
3289 </pre></td></tr>
3290
3291
3292 <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>
3293 <tr><td colspan="4" class="doc" id="isBaseInitializer0"><pre>Matches a constructor initializer if it is initializing a base, as
3294 opposed to a member.
3295
3296 Given
3297   struct B {};
3298   struct D : B {
3299     int I;
3300     D(int i) : I(i) {}
3301   };
3302   struct E : B {
3303     E() : B() {}
3304   };
3305 cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
3306   will match E(), but not match D(int).
3307 </pre></td></tr>
3308
3309
3310 <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>
3311 <tr><td colspan="4" class="doc" id="isMemberInitializer0"><pre>Matches a constructor initializer if it is initializing a member, as
3312 opposed to a base.
3313
3314 Given
3315   struct B {};
3316   struct D : B {
3317     int I;
3318     D(int i) : I(i) {}
3319   };
3320   struct E : B {
3321     E() : B() {}
3322   };
3323 cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
3324   will match D(int), but not match E().
3325 </pre></td></tr>
3326
3327
3328 <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>
3329 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a constructor initializer if it is explicitly written in
3330 code (as opposed to implicitly added by the compiler).
3331
3332 Given
3333   struct Foo {
3334     Foo() { }
3335     Foo(int) : foo_("A") { }
3336     string foo_;
3337   };
3338 cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
3339   will match Foo(int), but not Foo()
3340 </pre></td></tr>
3341
3342
3343 <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>
3344 <tr><td colspan="4" class="doc" id="isExplicit2"><pre>Matches constructor, conversion function, and deduction guide declarations
3345 that have an explicit specifier if this explicit specifier is resolved to
3346 true.
3347
3348 Given
3349   template&lt;bool b&gt;
3350   struct S {
3351     S(int); // #1
3352     explicit S(double); // #2
3353     operator int(); // #3
3354     explicit operator bool(); // #4
3355     explicit(false) S(bool) // # 7
3356     explicit(true) S(char) // # 8
3357     explicit(b) S(S) // # 9
3358   };
3359   S(int) -&gt; S&lt;true&gt; // #5
3360   explicit S(double) -&gt; S&lt;false&gt; // #6
3361 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
3362 cxxConversionDecl(isExplicit()) will match #4, but not #3.
3363 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
3364 </pre></td></tr>
3365
3366
3367 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasMemberName0')"><a name="hasMemberName0Anchor">hasMemberName</a></td><td>std::string N</td></tr>
3368 <tr><td colspan="4" class="doc" id="hasMemberName0"><pre>Matches template-dependent, but known, member names.
3369
3370 In template declarations, dependent members are not resolved and so can
3371 not be matched to particular named declarations.
3372
3373 This matcher allows to match on the known name of members.
3374
3375 Given
3376   template &lt;typename T&gt;
3377   struct S {
3378       void mem();
3379   };
3380   template &lt;typename T&gt;
3381   void x() {
3382       S&lt;T&gt; s;
3383       s.mem();
3384   }
3385 cxxDependentScopeMemberExpr(hasMemberName("mem")) matches `s.mem()`
3386 </pre></td></tr>
3387
3388
3389 <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>
3390 <tr><td colspan="4" class="doc" id="isArrow2"><pre>Matches member expressions that are called with '-&gt;' as opposed
3391 to '.'.
3392
3393 Member calls on the implicit this pointer match as called with '-&gt;'.
3394
3395 Given
3396   class Y {
3397     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
3398     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
3399     int a;
3400     static int b;
3401   };
3402   template &lt;class T&gt;
3403   class Z {
3404     void x() { this-&gt;m; }
3405   };
3406 memberExpr(isArrow())
3407   matches this-&gt;x, x, y.x, a, this-&gt;b
3408 cxxDependentScopeMemberExpr(isArrow())
3409   matches this-&gt;m
3410 unresolvedMemberExpr(isArrow())
3411   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
3412 </pre></td></tr>
3413
3414
3415 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;</td><td class="name" onclick="toggle('memberHasSameNameAsBoundNode0')"><a name="memberHasSameNameAsBoundNode0Anchor">memberHasSameNameAsBoundNode</a></td><td>std::string BindingID</td></tr>
3416 <tr><td colspan="4" class="doc" id="memberHasSameNameAsBoundNode0"><pre>Matches template-dependent, but known, member names against an already-bound
3417 node
3418
3419 In template declarations, dependent members are not resolved and so can
3420 not be matched to particular named declarations.
3421
3422 This matcher allows to match on the name of already-bound VarDecl, FieldDecl
3423 and CXXMethodDecl nodes.
3424
3425 Given
3426   template &lt;typename T&gt;
3427   struct S {
3428       void mem();
3429   };
3430   template &lt;typename T&gt;
3431   void x() {
3432       S&lt;T&gt; s;
3433       s.mem();
3434   }
3435 The matcher
3436 @code
3437 cxxDependentScopeMemberExpr(
3438   hasObjectExpression(declRefExpr(hasType(templateSpecializationType(
3439       hasDeclaration(classTemplateDecl(has(cxxRecordDecl(has(
3440           cxxMethodDecl(hasName("mem")).bind("templMem")
3441           )))))
3442       )))),
3443   memberHasSameNameAsBoundNode("templMem")
3444   )
3445 @endcode
3446 first matches and binds the @c mem member of the @c S template, then
3447 compares its name to the usage in @c s.mem() in the @c x function template
3448 </pre></td></tr>
3449
3450
3451 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName3')"><a name="hasOperatorName3Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
3452 <tr><td colspan="4" class="doc" id="hasOperatorName3"><pre>Matches the operator Name of operator expressions and fold expressions
3453 (binary or unary).
3454
3455 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3456   !(a || b)
3457
3458 Example matches `(0 + ... + args)`
3459     (matcher = cxxFoldExpr(hasOperatorName("+")))
3460   template &lt;typename... Args&gt;
3461   auto sum(Args... args) {
3462       return (0 + ... + args);
3463   }
3464 </pre></td></tr>
3465
3466
3467 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('isBinaryFold0')"><a name="isBinaryFold0Anchor">isBinaryFold</a></td><td></td></tr>
3468 <tr><td colspan="4" class="doc" id="isBinaryFold0"><pre>Matches binary fold expressions, i.e. fold expressions with an initializer.
3469
3470 Example matches `(0 + ... + args)`
3471     (matcher = cxxFoldExpr(isBinaryFold()))
3472   template &lt;typename... Args&gt;
3473   auto sum(Args... args) {
3474       return (0 + ... + args);
3475   }
3476
3477   template &lt;typename... Args&gt;
3478   auto multiply(Args... args) {
3479       return (args * ...);
3480   }
3481 </pre></td></tr>
3482
3483
3484 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('isLeftFold0')"><a name="isLeftFold0Anchor">isLeftFold</a></td><td></td></tr>
3485 <tr><td colspan="4" class="doc" id="isLeftFold0"><pre>Matches left-folding fold expressions.
3486
3487 Example matches `(0 + ... + args)`
3488     (matcher = cxxFoldExpr(isLeftFold()))
3489   template &lt;typename... Args&gt;
3490   auto sum(Args... args) {
3491       return (0 + ... + args);
3492   }
3493
3494   template &lt;typename... Args&gt;
3495   auto multiply(Args... args) {
3496       return (args * ... * 1);
3497   }
3498 </pre></td></tr>
3499
3500
3501 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('isRightFold0')"><a name="isRightFold0Anchor">isRightFold</a></td><td></td></tr>
3502 <tr><td colspan="4" class="doc" id="isRightFold0"><pre>Matches right-folding fold expressions.
3503
3504 Example matches `(args * ... * 1)`
3505     (matcher = cxxFoldExpr(isRightFold()))
3506   template &lt;typename... Args&gt;
3507   auto sum(Args... args) {
3508       return (0 + ... + args);
3509   }
3510
3511   template &lt;typename... Args&gt;
3512   auto multiply(Args... args) {
3513       return (args * ... * 1);
3514   }
3515 </pre></td></tr>
3516
3517
3518 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('isUnaryFold0')"><a name="isUnaryFold0Anchor">isUnaryFold</a></td><td></td></tr>
3519 <tr><td colspan="4" class="doc" id="isUnaryFold0"><pre>Matches unary fold expressions, i.e. fold expressions without an
3520 initializer.
3521
3522 Example matches `(args * ...)`
3523     (matcher = cxxFoldExpr(isUnaryFold()))
3524   template &lt;typename... Args&gt;
3525   auto sum(Args... args) {
3526       return (0 + ... + args);
3527   }
3528
3529   template &lt;typename... Args&gt;
3530   auto multiply(Args... args) {
3531       return (args * ...);
3532   }
3533 </pre></td></tr>
3534
3535
3536 <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>
3537 <tr><td colspan="4" class="doc" id="isConst0"><pre>Matches if the given method declaration is const.
3538
3539 Given
3540 struct A {
3541   void foo() const;
3542   void bar();
3543 };
3544
3545 cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
3546 </pre></td></tr>
3547
3548
3549 <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>
3550 <tr><td colspan="4" class="doc" id="isCopyAssignmentOperator0"><pre>Matches if the given method declaration declares a copy assignment
3551 operator.
3552
3553 Given
3554 struct A {
3555   A &amp;operator=(const A &amp;);
3556   A &amp;operator=(A &amp;&amp;);
3557 };
3558
3559 cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
3560 the second one.
3561 </pre></td></tr>
3562
3563
3564 <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>
3565 <tr><td colspan="4" class="doc" id="isFinal1"><pre>Matches if the given method or class declaration is final.
3566
3567 Given:
3568   class A final {};
3569
3570   struct B {
3571     virtual void f();
3572   };
3573
3574   struct C : B {
3575     void f() final;
3576   };
3577 matches A and C::f, but not B, C, or B::f
3578 </pre></td></tr>
3579
3580
3581 <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>
3582 <tr><td colspan="4" class="doc" id="isMoveAssignmentOperator0"><pre>Matches if the given method declaration declares a move assignment
3583 operator.
3584
3585 Given
3586 struct A {
3587   A &amp;operator=(const A &amp;);
3588   A &amp;operator=(A &amp;&amp;);
3589 };
3590
3591 cxxMethodDecl(isMoveAssignmentOperator()) matches the second method but not
3592 the first one.
3593 </pre></td></tr>
3594
3595
3596 <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>
3597 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
3598
3599 Given
3600   class A {
3601    public:
3602     virtual void x();
3603   };
3604   class B : public A {
3605    public:
3606     virtual void x();
3607   };
3608   matches B::x
3609 </pre></td></tr>
3610
3611
3612 <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>
3613 <tr><td colspan="4" class="doc" id="isPure0"><pre>Matches if the given method declaration is pure.
3614
3615 Given
3616   class A {
3617    public:
3618     virtual void x() = 0;
3619   };
3620   matches A::x
3621 </pre></td></tr>
3622
3623
3624 <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>
3625 <tr><td colspan="4" class="doc" id="isUserProvided0"><pre>Matches method declarations that are user-provided.
3626
3627 Given
3628   struct S {
3629     S(); // #1
3630     S(const S &amp;) = default; // #2
3631     S(S &amp;&amp;) = delete; // #3
3632   };
3633 cxxConstructorDecl(isUserProvided()) will match #1, but not #2 or #3.
3634 </pre></td></tr>
3635
3636
3637 <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>
3638 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches declarations of virtual methods and C++ base specifers that specify
3639 virtual inheritance.
3640
3641 Example:
3642   class A {
3643    public:
3644     virtual void x(); // matches x
3645   };
3646
3647 Example:
3648   class Base {};
3649   class DirectlyDerived : virtual Base {}; // matches Base
3650   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
3651
3652 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;
3653 </pre></td></tr>
3654
3655
3656 <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>
3657 <tr><td colspan="4" class="doc" id="isVirtualAsWritten0"><pre>Matches if the given method declaration has an explicit "virtual".
3658
3659 Given
3660   class A {
3661    public:
3662     virtual void x();
3663   };
3664   class B : public A {
3665    public:
3666     void x();
3667   };
3668   matches A::x but not B::x
3669 </pre></td></tr>
3670
3671
3672 <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>
3673 <tr><td colspan="4" class="doc" id="isArray0"><pre>Matches array new expressions.
3674
3675 Given:
3676   MyClass *p1 = new MyClass[10];
3677 cxxNewExpr(isArray())
3678   matches the expression 'new MyClass[10]'.
3679 </pre></td></tr>
3680
3681
3682 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyOperatorName1')"><a name="hasAnyOperatorName1Anchor">hasAnyOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
3683 <tr><td colspan="4" class="doc" id="hasAnyOperatorName1"><pre>Matches operator expressions (binary or unary) that have any of the
3684 specified names.
3685
3686    hasAnyOperatorName("+", "-")
3687  Is equivalent to
3688    anyOf(hasOperatorName("+"), hasOperatorName("-"))
3689 </pre></td></tr>
3690
3691
3692 <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>
3693 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName0"><pre>Matches overloaded operator names.
3694
3695 Matches overloaded operator names specified in strings without the
3696 "operator" prefix: e.g. "&lt;&lt;".
3697
3698   hasAnyOverloadedOperatorName("+", "-")
3699 Is equivalent to
3700   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
3701 </pre></td></tr>
3702
3703
3704 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName1')"><a name="hasOperatorName1Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
3705 <tr><td colspan="4" class="doc" id="hasOperatorName1"><pre>Matches the operator Name of operator expressions and fold expressions
3706 (binary or unary).
3707
3708 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3709   !(a || b)
3710
3711 Example matches `(0 + ... + args)`
3712     (matcher = cxxFoldExpr(hasOperatorName("+")))
3713   template &lt;typename... Args&gt;
3714   auto sum(Args... args) {
3715       return (0 + ... + args);
3716   }
3717 </pre></td></tr>
3718
3719
3720 <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>
3721 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
3722
3723 Matches overloaded operator names specified in strings without the
3724 "operator" prefix: e.g. "&lt;&lt;".
3725
3726 Given:
3727   class A { int operator*(); };
3728   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
3729   A a;
3730   a &lt;&lt; a;   // &lt;-- This matches
3731
3732 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
3733 specified line and
3734 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
3735 matches the declaration of A.
3736
3737 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;
3738 </pre></td></tr>
3739
3740
3741 <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>
3742 <tr><td colspan="4" class="doc" id="isAssignmentOperator1"><pre>Matches all kinds of assignment operators.
3743
3744 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
3745   if (a == b)
3746     a += b;
3747
3748 Example 2: matches s1 = s2
3749            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
3750   struct S { S&amp; operator=(const S&amp;); };
3751   void x() { S s1, s2; s1 = s2; }
3752 </pre></td></tr>
3753
3754
3755 <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>
3756 <tr><td colspan="4" class="doc" id="isComparisonOperator1"><pre>Matches comparison operators.
3757
3758 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
3759   if (a == b)
3760     a += b;
3761
3762 Example 2: matches s1 &lt; s2
3763            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
3764   struct S { bool operator&lt;(const S&amp; other); };
3765   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
3766 </pre></td></tr>
3767
3768
3769 <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>
3770 <tr><td colspan="4" class="doc" id="hasDefinition0"><pre>Matches a class declaration that is defined.
3771
3772 Example matches x (matcher = cxxRecordDecl(hasDefinition()))
3773 class x {};
3774 class y;
3775 </pre></td></tr>
3776
3777
3778 <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>
3779 <tr><td colspan="4" class="doc" id="isDerivedFrom2"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
3780 </pre></td></tr>
3781
3782
3783 <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>
3784 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom2"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
3785 </pre></td></tr>
3786
3787
3788 <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>
3789 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
3790 static member variable template instantiations.
3791
3792 Given
3793   template&lt;typename T&gt; void A(T t) { }
3794   template&lt;&gt; void A(int N) { }
3795 functionDecl(isExplicitTemplateSpecialization())
3796   matches the specialization A&lt;int&gt;().
3797
3798 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;
3799 </pre></td></tr>
3800
3801
3802 <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>
3803 <tr><td colspan="4" class="doc" id="isFinal0"><pre>Matches if the given method or class declaration is final.
3804
3805 Given:
3806   class A final {};
3807
3808   struct B {
3809     virtual void f();
3810   };
3811
3812   struct C : B {
3813     void f() final;
3814   };
3815 matches A and C::f, but not B, C, or B::f
3816 </pre></td></tr>
3817
3818
3819 <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>
3820 <tr><td colspan="4" class="doc" id="isLambda0"><pre>Matches the generated class of lambda expressions.
3821
3822 Given:
3823   auto x = []{};
3824
3825 cxxRecordDecl(isLambda()) matches the implicit class declaration of
3826 decltype(x)
3827 </pre></td></tr>
3828
3829
3830 <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>
3831 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom2"><pre>Overloaded method as shortcut for
3832 isSameOrDerivedFrom(hasName(...)).
3833 </pre></td></tr>
3834
3835
3836 <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>
3837 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
3838 member variable template instantiations.
3839
3840 Given
3841   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
3842 or
3843   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
3844 or
3845   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
3846 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3847   matches the template instantiation of X&lt;A&gt;.
3848
3849 But given
3850   template &lt;typename T&gt;  class X {}; class A {};
3851   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
3852 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3853   does not match, as X&lt;A&gt; is an explicit template specialization.
3854
3855 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;
3856 </pre></td></tr>
3857
3858
3859 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasAnyOperatorName2')"><a name="hasAnyOperatorName2Anchor">hasAnyOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
3860 <tr><td colspan="4" class="doc" id="hasAnyOperatorName2"><pre>Matches operator expressions (binary or unary) that have any of the
3861 specified names.
3862
3863    hasAnyOperatorName("+", "-")
3864  Is equivalent to
3865    anyOf(hasOperatorName("+"), hasOperatorName("-"))
3866 </pre></td></tr>
3867
3868
3869 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName2')"><a name="hasOperatorName2Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
3870 <tr><td colspan="4" class="doc" id="hasOperatorName2"><pre>Matches the operator Name of operator expressions and fold expressions
3871 (binary or unary).
3872
3873 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3874   !(a || b)
3875
3876 Example matches `(0 + ... + args)`
3877     (matcher = cxxFoldExpr(hasOperatorName("+")))
3878   template &lt;typename... Args&gt;
3879   auto sum(Args... args) {
3880       return (0 + ... + args);
3881   }
3882 </pre></td></tr>
3883
3884
3885 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('isAssignmentOperator2')"><a name="isAssignmentOperator2Anchor">isAssignmentOperator</a></td><td></td></tr>
3886 <tr><td colspan="4" class="doc" id="isAssignmentOperator2"><pre>Matches all kinds of assignment operators.
3887
3888 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
3889   if (a == b)
3890     a += b;
3891
3892 Example 2: matches s1 = s2
3893            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
3894   struct S { S&amp; operator=(const S&amp;); };
3895   void x() { S s1, s2; s1 = s2; }
3896 </pre></td></tr>
3897
3898
3899 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('isComparisonOperator2')"><a name="isComparisonOperator2Anchor">isComparisonOperator</a></td><td></td></tr>
3900 <tr><td colspan="4" class="doc" id="isComparisonOperator2"><pre>Matches comparison operators.
3901
3902 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
3903   if (a == b)
3904     a += b;
3905
3906 Example 2: matches s1 &lt; s2
3907            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
3908   struct S { bool operator&lt;(const S&amp; other); };
3909   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
3910 </pre></td></tr>
3911
3912
3913 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountAtLeast2')"><a name="argumentCountAtLeast2Anchor">argumentCountAtLeast</a></td><td>unsigned N</td></tr>
3914 <tr><td colspan="4" class="doc" id="argumentCountAtLeast2"><pre>Checks that a call expression or a constructor call expression has at least
3915 the specified number of arguments (including absent default arguments).
3916
3917 Example matches f(0, 0) and g(0, 0, 0)
3918 (matcher = callExpr(argumentCountAtLeast(2)))
3919   void f(int x, int y);
3920   void g(int x, int y, int z);
3921   f(0, 0);
3922   g(0, 0, 0);
3923 </pre></td></tr>
3924
3925
3926 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs2')"><a name="argumentCountIs2Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
3927 <tr><td colspan="4" class="doc" id="argumentCountIs2"><pre>Checks that a call expression or a constructor call expression has
3928 a specific number of arguments (including absent default arguments).
3929
3930 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
3931   void f(int x, int y);
3932   f(0, 0);
3933 </pre></td></tr>
3934
3935
3936 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountAtLeast0')"><a name="argumentCountAtLeast0Anchor">argumentCountAtLeast</a></td><td>unsigned N</td></tr>
3937 <tr><td colspan="4" class="doc" id="argumentCountAtLeast0"><pre>Checks that a call expression or a constructor call expression has at least
3938 the specified number of arguments (including absent default arguments).
3939
3940 Example matches f(0, 0) and g(0, 0, 0)
3941 (matcher = callExpr(argumentCountAtLeast(2)))
3942   void f(int x, int y);
3943   void g(int x, int y, int z);
3944   f(0, 0);
3945   g(0, 0, 0);
3946 </pre></td></tr>
3947
3948
3949 <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>
3950 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
3951 a specific number of arguments (including absent default arguments).
3952
3953 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
3954   void f(int x, int y);
3955   f(0, 0);
3956 </pre></td></tr>
3957
3958
3959 <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>
3960 <tr><td colspan="4" class="doc" id="usesADL0"><pre>Matches call expressions which were resolved using ADL.
3961
3962 Example matches y(x) but not y(42) or NS::y(x).
3963   namespace NS {
3964     struct X {};
3965     void y(X);
3966   }
3967
3968   void y(...);
3969
3970   void test() {
3971     NS::X x;
3972     y(x); // Matches
3973     NS::y(x); // Doesn't match
3974     y(42); // Doesn't match
3975     using NS::y;
3976     y(x); // Found by both unqualified lookup and ADL, doesn't match
3977    }
3978 </pre></td></tr>
3979
3980
3981 <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>
3982 <tr><td colspan="4" class="doc" id="hasCastKind0"><pre>Matches casts that has a given cast kind.
3983
3984 Example: matches the implicit cast around 0
3985 (matcher = castExpr(hasCastKind(CK_NullToPointer)))
3986   int *p = 0;
3987
3988 If the matcher is use from clang-query, CastKind parameter
3989 should be passed as a quoted string. e.g., hasCastKind("CK_NullToPointer").
3990 </pre></td></tr>
3991
3992
3993 <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>
3994 <tr><td colspan="4" class="doc" id="equals4"><pre></pre></td></tr>
3995
3996
3997 <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>
3998 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value of type ValueT.
3999
4000 Given
4001   f('false, 3.14, 42);
4002 characterLiteral(equals(0))
4003   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
4004   match false
4005 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
4006   match 3.14
4007 integerLiteral(equals(42))
4008   matches 42
4009
4010 Note that you cannot directly match a negative numeric literal because the
4011 minus sign is not part of the literal: It is a unary operator whose operand
4012 is the positive numeric literal. Instead, you must use a unaryOperator()
4013 matcher to match the minus sign:
4014
4015 unaryOperator(hasOperatorName("-"),
4016               hasUnaryOperand(integerLiteral(equals(13))))
4017
4018 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;,
4019            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;
4020 </pre></td></tr>
4021
4022
4023 <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>
4024 <tr><td colspan="4" class="doc" id="equals10"><pre></pre></td></tr>
4025
4026
4027 <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>
4028 <tr><td colspan="4" class="doc" id="equals7"><pre></pre></td></tr>
4029
4030
4031 <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>
4032 <tr><td colspan="4" class="doc" id="templateArgumentCountIs0"><pre>Matches if the number of template arguments equals N.
4033
4034 Given
4035   template&lt;typename T&gt; struct C {};
4036   C&lt;int&gt; c;
4037 classTemplateSpecializationDecl(templateArgumentCountIs(1))
4038   matches C&lt;int&gt;.
4039 </pre></td></tr>
4040
4041
4042 <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>
4043 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
4044 child statements.
4045
4046 Example: Given
4047   { for (;;) {} }
4048 compoundStmt(statementCountIs(0)))
4049   matches '{}'
4050   but does not match the outer compound statement.
4051 </pre></td></tr>
4052
4053
4054 <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>
4055 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches nodes that have the specified size.
4056
4057 Given
4058   int a[42];
4059   int b[2 * 21];
4060   int c[41], d[43];
4061   char *s = "abcd";
4062   wchar_t *ws = L"abcd";
4063   char *w = "a";
4064 constantArrayType(hasSize(42))
4065   matches "int a[42]" and "int b[2 * 21]"
4066 stringLiteral(hasSize(4))
4067   matches "abcd", L"abcd"
4068 </pre></td></tr>
4069
4070
4071 <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>
4072 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
4073 declarations.
4074
4075 Example: Given
4076   int a, b;
4077   int c;
4078   int d = 2, e;
4079 declCountIs(2)
4080   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
4081 </pre></td></tr>
4082
4083
4084 <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>
4085 <tr><td colspan="4" class="doc" id="equalsBoundNode1"><pre>Matches if a node equals a previously bound node.
4086
4087 Matches a node if it equals the node previously bound to ID.
4088
4089 Given
4090   class X { int a; int b; };
4091 cxxRecordDecl(
4092     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
4093     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
4094   matches the class X, as a and b have the same type.
4095
4096 Note that when multiple matches are involved via forEach* matchers,
4097 equalsBoundNodes acts as a filter.
4098 For example:
4099 compoundStmt(
4100     forEachDescendant(varDecl().bind("d")),
4101     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
4102 will trigger a match for each combination of variable declaration
4103 and reference to that variable declaration within a compound statement.
4104 </pre></td></tr>
4105
4106
4107 <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>
4108 <tr><td colspan="4" class="doc" id="equalsNode0"><pre>Matches if a node equals another node.
4109
4110 Decl has pointer identity in the AST.
4111 </pre></td></tr>
4112
4113
4114 <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>
4115 <tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
4116
4117 Given
4118   __attribute__((device)) void f() { ... }
4119 decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
4120 f. If the matcher is used from clang-query, attr::Kind parameter should be
4121 passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
4122 </pre></td></tr>
4123
4124
4125 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpandedFromMacro0')"><a name="isExpandedFromMacro0Anchor">isExpandedFromMacro</a></td><td>std::string MacroName</td></tr>
4126 <tr><td colspan="4" class="doc" id="isExpandedFromMacro0"><pre>Matches statements that are (transitively) expanded from the named macro.
4127 Does not match if only part of the statement is expanded from that macro or
4128 if different parts of the statement are expanded from different
4129 appearances of the macro.
4130 </pre></td></tr>
4131
4132
4133 <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>
4134 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching0"><pre>Matches AST nodes that were expanded within files whose name is
4135 partially matching a given regex.
4136
4137 Example matches Y but not X
4138     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
4139   #include "ASTMatcher.h"
4140   class X {};
4141 ASTMatcher.h:
4142   class Y {};
4143
4144 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;
4145
4146 If the matcher is used in clang-query, RegexFlags parameter
4147 should be passed as a quoted string. e.g: "NoFlags".
4148 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
4149 </pre></td></tr>
4150
4151
4152 <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>
4153 <tr><td colspan="4" class="doc" id="isExpansionInMainFile0"><pre>Matches AST nodes that were expanded within the main-file.
4154
4155 Example matches X but not Y
4156   (matcher = cxxRecordDecl(isExpansionInMainFile())
4157   #include &lt;Y.h&gt;
4158   class X {};
4159 Y.h:
4160   class Y {};
4161
4162 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;
4163 </pre></td></tr>
4164
4165
4166 <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>
4167 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader0"><pre>Matches AST nodes that were expanded within system-header-files.
4168
4169 Example matches Y but not X
4170     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
4171   #include &lt;SystemHeader.h&gt;
4172   class X {};
4173 SystemHeader.h:
4174   class Y {};
4175
4176 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;
4177 </pre></td></tr>
4178
4179
4180 <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>
4181 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches an entity that has been implicitly added by the compiler (e.g.
4182 implicit default/copy constructors).
4183 </pre></td></tr>
4184
4185
4186 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isInAnonymousNamespace0')"><a name="isInAnonymousNamespace0Anchor">isInAnonymousNamespace</a></td><td></td></tr>
4187 <tr><td colspan="4" class="doc" id="isInAnonymousNamespace0"><pre>Matches declarations in an anonymous namespace.
4188
4189 Given
4190   class vector {};
4191   namespace foo {
4192     class vector {};
4193     namespace {
4194       class vector {}; // #1
4195     }
4196   }
4197   namespace {
4198     class vector {}; // #2
4199     namespace foo {
4200       class vector{}; // #3
4201     }
4202   }
4203 cxxRecordDecl(hasName("vector"), isInAnonymousNamespace()) will match
4204 #1, #2 and #3.
4205 </pre></td></tr>
4206
4207
4208 <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>
4209 <tr><td colspan="4" class="doc" id="isInStdNamespace0"><pre>Matches declarations in the namespace `std`, but not in nested namespaces.
4210
4211 Given
4212   class vector {};
4213   namespace foo {
4214     class vector {};
4215     namespace std {
4216       class vector {};
4217     }
4218   }
4219   namespace std {
4220     inline namespace __1 {
4221       class vector {}; // #1
4222       namespace experimental {
4223         class vector {};
4224       }
4225     }
4226   }
4227 cxxRecordDecl(hasName("vector"), isInStdNamespace()) will match only #1.
4228 </pre></td></tr>
4229
4230
4231 <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>
4232 <tr><td colspan="4" class="doc" id="isInstantiated0"><pre>Matches declarations that are template instantiations or are inside
4233 template instantiations.
4234
4235 Given
4236   template&lt;typename T&gt; void A(T t) { T i; }
4237   A(0);
4238   A(0U);
4239 functionDecl(isInstantiated())
4240   matches 'A(int) {...};' and 'A(unsigned) {...}'.
4241 </pre></td></tr>
4242
4243
4244 <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>
4245 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations and C++ base specifers that specify private
4246 inheritance.
4247
4248 Examples:
4249   class C {
4250   public:    int a;
4251   protected: int b;
4252   private:   int c; // fieldDecl(isPrivate()) matches 'c'
4253   };
4254
4255   struct Base {};
4256   struct Derived1 : private Base {}; // matches 'Base'
4257   class Derived2 : Base {}; // matches 'Base'
4258 </pre></td></tr>
4259
4260
4261 <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>
4262 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations and C++ base specifers that specify
4263 protected inheritance.
4264
4265 Examples:
4266   class C {
4267   public:    int a;
4268   protected: int b; // fieldDecl(isProtected()) matches 'b'
4269   private:   int c;
4270   };
4271
4272   class Base {};
4273   class Derived : protected Base {}; // matches 'Base'
4274 </pre></td></tr>
4275
4276
4277 <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>
4278 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations and C++ base specifers that specify public
4279 inheritance.
4280
4281 Examples:
4282   class C {
4283   public:    int a; // fieldDecl(isPublic()) matches 'a'
4284   protected: int b;
4285   private:   int c;
4286   };
4287
4288   class Base {};
4289   class Derived1 : public Base {}; // matches 'Base'
4290   struct Derived2 : Base {}; // matches 'Base'
4291 </pre></td></tr>
4292
4293
4294 <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>
4295 <tr><td colspan="4" class="doc" id="designatorCountIs0"><pre>Matches designated initializer expressions that contain
4296 a specific number of designators.
4297
4298 Example: Given
4299   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
4300   point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 };
4301 designatorCountIs(2)
4302   matches '{ [2].y = 1.0, [0].x = 1.0 }',
4303   but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'.
4304 </pre></td></tr>
4305
4306
4307 <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>
4308 <tr><td colspan="4" class="doc" id="isScoped0"><pre>Matches C++11 scoped enum declaration.
4309
4310 Example matches Y (matcher = enumDecl(isScoped()))
4311 enum X {};
4312 enum class Y {};
4313 </pre></td></tr>
4314
4315
4316 <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>
4317 <tr><td colspan="4" class="doc" id="isInstantiationDependent0"><pre>Matches expressions that are instantiation-dependent even if it is
4318 neither type- nor value-dependent.
4319
4320 In the following example, the expression sizeof(sizeof(T() + T()))
4321 is instantiation-dependent (since it involves a template parameter T),
4322 but is neither type- nor value-dependent, since the type of the inner
4323 sizeof is known (std::size_t) and therefore the size of the outer
4324 sizeof is known.
4325   template&lt;typename T&gt;
4326   void f(T x, T y) { sizeof(sizeof(T() + T()); }
4327 expr(isInstantiationDependent()) matches sizeof(sizeof(T() + T())
4328 </pre></td></tr>
4329
4330
4331 <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>
4332 <tr><td colspan="4" class="doc" id="isTypeDependent0"><pre>Matches expressions that are type-dependent because the template type
4333 is not yet instantiated.
4334
4335 For example, the expressions "x" and "x + y" are type-dependent in
4336 the following code, but "y" is not type-dependent:
4337   template&lt;typename T&gt;
4338   void add(T x, int y) {
4339     x + y;
4340   }
4341 expr(isTypeDependent()) matches x + y
4342 </pre></td></tr>
4343
4344
4345 <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>
4346 <tr><td colspan="4" class="doc" id="isValueDependent0"><pre>Matches expression that are value-dependent because they contain a
4347 non-type template parameter.
4348
4349 For example, the array bound of "Chars" in the following example is
4350 value-dependent.
4351   template&lt;int Size&gt; int f() { return Size; }
4352 expr(isValueDependent()) matches return Size
4353 </pre></td></tr>
4354
4355
4356 <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>
4357 <tr><td colspan="4" class="doc" id="nullPointerConstant0"><pre>Matches expressions that resolve to a null pointer constant, such as
4358 GNU's __null, C++11's nullptr, or C's NULL macro.
4359
4360 Given:
4361   void *v1 = NULL;
4362   void *v2 = nullptr;
4363   void *v3 = __null; // GNU extension
4364   char *cp = (char *)0;
4365   int *ip = 0;
4366   int i = 0;
4367 expr(nullPointerConstant())
4368   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
4369   initializer for i.
4370 </pre></td></tr>
4371
4372
4373 <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>
4374 <tr><td colspan="4" class="doc" id="hasBitWidth0"><pre>Matches non-static data members that are bit-fields of the specified
4375 bit width.
4376
4377 Given
4378   class C {
4379     int a : 2;
4380     int b : 4;
4381     int c : 2;
4382   };
4383 fieldDecl(hasBitWidth(2))
4384   matches 'int a;' and 'int c;' but not 'int b;'.
4385 </pre></td></tr>
4386
4387
4388 <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>
4389 <tr><td colspan="4" class="doc" id="isBitField0"><pre>Matches non-static data members that are bit-fields.
4390
4391 Given
4392   class C {
4393     int a : 2;
4394     int b;
4395   };
4396 fieldDecl(isBitField())
4397   matches 'int a;' but not 'int b;'.
4398 </pre></td></tr>
4399
4400
4401 <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>
4402 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value of type ValueT.
4403
4404 Given
4405   f('false, 3.14, 42);
4406 characterLiteral(equals(0))
4407   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
4408   match false
4409 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
4410   match 3.14
4411 integerLiteral(equals(42))
4412   matches 42
4413
4414 Note that you cannot directly match a negative numeric literal because the
4415 minus sign is not part of the literal: It is a unary operator whose operand
4416 is the positive numeric literal. Instead, you must use a unaryOperator()
4417 matcher to match the minus sign:
4418
4419 unaryOperator(hasOperatorName("-"),
4420               hasUnaryOperand(integerLiteral(equals(13))))
4421
4422 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;,
4423            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;
4424 </pre></td></tr>
4425
4426
4427 <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>
4428 <tr><td colspan="4" class="doc" id="equals12"><pre></pre></td></tr>
4429
4430
4431 <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>
4432 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName1"><pre>Matches overloaded operator names.
4433
4434 Matches overloaded operator names specified in strings without the
4435 "operator" prefix: e.g. "&lt;&lt;".
4436
4437   hasAnyOverloadedOperatorName("+", "-")
4438 Is equivalent to
4439   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
4440 </pre></td></tr>
4441
4442
4443 <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>
4444 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec0"><pre>Matches functions that have a dynamic exception specification.
4445
4446 Given:
4447   void f();
4448   void g() noexcept;
4449   void h() noexcept(true);
4450   void i() noexcept(false);
4451   void j() throw();
4452   void k() throw(int);
4453   void l() throw(...);
4454 functionDecl(hasDynamicExceptionSpec()) and
4455   functionProtoType(hasDynamicExceptionSpec())
4456   match the declarations of j, k, and l, but not f, g, h, or i.
4457 </pre></td></tr>
4458
4459
4460 <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>
4461 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
4462
4463 Matches overloaded operator names specified in strings without the
4464 "operator" prefix: e.g. "&lt;&lt;".
4465
4466 Given:
4467   class A { int operator*(); };
4468   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
4469   A a;
4470   a &lt;&lt; a;   // &lt;-- This matches
4471
4472 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
4473 specified line and
4474 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
4475 matches the declaration of A.
4476
4477 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;
4478 </pre></td></tr>
4479
4480
4481 <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>
4482 <tr><td colspan="4" class="doc" id="hasTrailingReturn0"><pre>Matches a function declared with a trailing return type.
4483
4484 Example matches Y (matcher = functionDecl(hasTrailingReturn()))
4485 int X() {}
4486 auto Y() -&gt; int {}
4487 </pre></td></tr>
4488
4489
4490 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isConsteval0')"><a name="isConsteval0Anchor">isConsteval</a></td><td></td></tr>
4491 <tr><td colspan="4" class="doc" id="isConsteval0"><pre>Matches consteval function declarations and if consteval/if ! consteval
4492 statements.
4493
4494 Given:
4495   consteval int a();
4496   void b() { if consteval {} }
4497   void c() { if ! consteval {} }
4498   void d() { if ! consteval {} else {} }
4499 functionDecl(isConsteval())
4500   matches the declaration of "int a()".
4501 ifStmt(isConsteval())
4502   matches the if statement in "void b()", "void c()", "void d()".
4503 </pre></td></tr>
4504
4505
4506 <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>
4507 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations,
4508        and if constexpr.
4509
4510 Given:
4511   constexpr int foo = 42;
4512   constexpr int bar();
4513   void baz() { if constexpr(1 &gt; 0) {} }
4514 varDecl(isConstexpr())
4515   matches the declaration of foo.
4516 functionDecl(isConstexpr())
4517   matches the declaration of bar.
4518 ifStmt(isConstexpr())
4519   matches the if statement in baz.
4520 </pre></td></tr>
4521
4522
4523 <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>
4524 <tr><td colspan="4" class="doc" id="isDefaulted0"><pre>Matches defaulted function declarations.
4525
4526 Given:
4527   class A { ~A(); };
4528   class B { ~B() = default; };
4529 functionDecl(isDefaulted())
4530   matches the declaration of ~B, but not ~A.
4531 </pre></td></tr>
4532
4533
4534 <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>
4535 <tr><td colspan="4" class="doc" id="isDefinition3"><pre>Matches if a declaration has a body attached.
4536
4537 Example matches A, va, fa
4538   class A {};
4539   class B;  // Doesn't match, as it has no body.
4540   int va;
4541   extern int vb;  // Doesn't match, as it doesn't define the variable.
4542   void fa() {}
4543   void fb();  // Doesn't match, as it has no body.
4544   @interface X
4545   - (void)ma; // Doesn't match, interface is declaration.
4546   @end
4547   @implementation X
4548   - (void)ma {}
4549   @end
4550
4551 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;,
4552   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
4553 </pre></td></tr>
4554
4555
4556 <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>
4557 <tr><td colspan="4" class="doc" id="isDeleted0"><pre>Matches deleted function declarations.
4558
4559 Given:
4560   void Func();
4561   void DeletedFunc() = delete;
4562 functionDecl(isDeleted())
4563   matches the declaration of DeletedFunc, but not Func.
4564 </pre></td></tr>
4565
4566
4567 <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>
4568 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization0"><pre>Matches explicit template specializations of function, class, or
4569 static member variable template instantiations.
4570
4571 Given
4572   template&lt;typename T&gt; void A(T t) { }
4573   template&lt;&gt; void A(int N) { }
4574 functionDecl(isExplicitTemplateSpecialization())
4575   matches the specialization A&lt;int&gt;().
4576
4577 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;
4578 </pre></td></tr>
4579
4580
4581 <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>
4582 <tr><td colspan="4" class="doc" id="isExternC0"><pre>Matches extern "C" function or variable declarations.
4583
4584 Given:
4585   extern "C" void f() {}
4586   extern "C" { void g() {} }
4587   void h() {}
4588   extern "C" int x = 1;
4589   extern "C" int y = 2;
4590   int z = 3;
4591 functionDecl(isExternC())
4592   matches the declaration of f and g, but not the declaration of h.
4593 varDecl(isExternC())
4594   matches the declaration of x and y, but not the declaration of z.
4595 </pre></td></tr>
4596
4597
4598 <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>
4599 <tr><td colspan="4" class="doc" id="isInline1"><pre>Matches functions, variables and namespace declarations that are marked with
4600 the inline keyword.
4601
4602 Given
4603   inline void f();
4604   void g();
4605   namespace n {
4606   inline namespace m {}
4607   }
4608   inline int Foo = 5;
4609 functionDecl(isInline()) will match ::f().
4610 namespaceDecl(isInline()) will match n::m.
4611 varDecl(isInline()) will match Foo;
4612 </pre></td></tr>
4613
4614
4615 <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>
4616 <tr><td colspan="4" class="doc" id="isMain0"><pre>Determines whether the function is "main", which is the entry point
4617 into an executable program.
4618 </pre></td></tr>
4619
4620
4621 <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>
4622 <tr><td colspan="4" class="doc" id="isNoReturn0"><pre>Matches FunctionDecls that have a noreturn attribute.
4623
4624 Given
4625   void nope();
4626   [[noreturn]] void a();
4627   __attribute__((noreturn)) void b();
4628   struct c { [[noreturn]] c(); };
4629 functionDecl(isNoReturn())
4630   matches all of those except
4631   void nope();
4632 </pre></td></tr>
4633
4634
4635 <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>
4636 <tr><td colspan="4" class="doc" id="isNoThrow0"><pre>Matches functions that have a non-throwing exception specification.
4637
4638 Given:
4639   void f();
4640   void g() noexcept;
4641   void h() throw();
4642   void i() throw(int);
4643   void j() noexcept(false);
4644 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
4645   match the declarations of g, and h, but not f, i or j.
4646 </pre></td></tr>
4647
4648
4649 <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>
4650 <tr><td colspan="4" class="doc" id="isStaticStorageClass0"><pre>Matches variable/function declarations that have "static" storage
4651 class specifier ("static" keyword) written in the source.
4652
4653 Given:
4654   static void f() {}
4655   static int i = 0;
4656   extern int j;
4657   int k;
4658 functionDecl(isStaticStorageClass())
4659   matches the function declaration f.
4660 varDecl(isStaticStorageClass())
4661   matches the variable declaration i.
4662 </pre></td></tr>
4663
4664
4665 <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>
4666 <tr><td colspan="4" class="doc" id="isTemplateInstantiation0"><pre>Matches template instantiations of function, class, or static
4667 member variable template instantiations.
4668
4669 Given
4670   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
4671 or
4672   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
4673 or
4674   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
4675 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
4676   matches the template instantiation of X&lt;A&gt;.
4677
4678 But given
4679   template &lt;typename T&gt;  class X {}; class A {};
4680   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
4681 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
4682   does not match, as X&lt;A&gt; is an explicit template specialization.
4683
4684 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;
4685 </pre></td></tr>
4686
4687
4688 <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>
4689 <tr><td colspan="4" class="doc" id="isVariadic0"><pre>Matches if a function declaration is variadic.
4690
4691 Example matches f, but not g or h. The function i will not match, even when
4692 compiled in C mode.
4693   void f(...);
4694   void g(int);
4695   template &lt;typename... Ts&gt; void h(Ts...);
4696   void i();
4697 </pre></td></tr>
4698
4699
4700 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isWeak0')"><a name="isWeak0Anchor">isWeak</a></td><td></td></tr>
4701 <tr><td colspan="4" class="doc" id="isWeak0"><pre>Matches weak function declarations.
4702
4703 Given:
4704   void foo() __attribute__((__weakref__("__foo")));
4705   void bar();
4706 functionDecl(isWeak())
4707   matches the weak declaration "foo", but not "bar".
4708 </pre></td></tr>
4709
4710
4711 <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>
4712 <tr><td colspan="4" class="doc" id="parameterCountIs0"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
4713 specific parameter count.
4714
4715 Given
4716   void f(int i) {}
4717   void g(int i, int j) {}
4718   void h(int i, int j);
4719   void j(int i);
4720   void k(int x, int y, int z, ...);
4721 functionDecl(parameterCountIs(2))
4722   matches g and h
4723 functionProtoType(parameterCountIs(2))
4724   matches g and h
4725 functionProtoType(parameterCountIs(3))
4726   matches k
4727 </pre></td></tr>
4728
4729
4730 <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>
4731 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec1"><pre>Matches functions that have a dynamic exception specification.
4732
4733 Given:
4734   void f();
4735   void g() noexcept;
4736   void h() noexcept(true);
4737   void i() noexcept(false);
4738   void j() throw();
4739   void k() throw(int);
4740   void l() throw(...);
4741 functionDecl(hasDynamicExceptionSpec()) and
4742   functionProtoType(hasDynamicExceptionSpec())
4743   match the declarations of j, k, and l, but not f, g, h, or i.
4744 </pre></td></tr>
4745
4746
4747 <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>
4748 <tr><td colspan="4" class="doc" id="isNoThrow1"><pre>Matches functions that have a non-throwing exception specification.
4749
4750 Given:
4751   void f();
4752   void g() noexcept;
4753   void h() throw();
4754   void i() throw(int);
4755   void j() noexcept(false);
4756 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
4757   match the declarations of g, and h, but not f, i or j.
4758 </pre></td></tr>
4759
4760
4761 <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>
4762 <tr><td colspan="4" class="doc" id="parameterCountIs1"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
4763 specific parameter count.
4764
4765 Given
4766   void f(int i) {}
4767   void g(int i, int j) {}
4768   void h(int i, int j);
4769   void j(int i);
4770   void k(int x, int y, int z, ...);
4771 functionDecl(parameterCountIs(2))
4772   matches g and h
4773 functionProtoType(parameterCountIs(2))
4774   matches g and h
4775 functionProtoType(parameterCountIs(3))
4776   matches k
4777 </pre></td></tr>
4778
4779
4780 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('isConsteval1')"><a name="isConsteval1Anchor">isConsteval</a></td><td></td></tr>
4781 <tr><td colspan="4" class="doc" id="isConsteval1"><pre>Matches consteval function declarations and if consteval/if ! consteval
4782 statements.
4783
4784 Given:
4785   consteval int a();
4786   void b() { if consteval {} }
4787   void c() { if ! consteval {} }
4788   void d() { if ! consteval {} else {} }
4789 functionDecl(isConsteval())
4790   matches the declaration of "int a()".
4791 ifStmt(isConsteval())
4792   matches the if statement in "void b()", "void c()", "void d()".
4793 </pre></td></tr>
4794
4795
4796 <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>
4797 <tr><td colspan="4" class="doc" id="isConstexpr2"><pre>Matches constexpr variable and function declarations,
4798        and if constexpr.
4799
4800 Given:
4801   constexpr int foo = 42;
4802   constexpr int bar();
4803   void baz() { if constexpr(1 &gt; 0) {} }
4804 varDecl(isConstexpr())
4805   matches the declaration of foo.
4806 functionDecl(isConstexpr())
4807   matches the declaration of bar.
4808 ifStmt(isConstexpr())
4809   matches the if statement in baz.
4810 </pre></td></tr>
4811
4812
4813 <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>
4814 <tr><td colspan="4" class="doc" id="equals6"><pre></pre></td></tr>
4815
4816
4817 <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>
4818 <tr><td colspan="4" class="doc" id="equals0"><pre>Matches literals that are equal to the given value of type ValueT.
4819
4820 Given
4821   f('false, 3.14, 42);
4822 characterLiteral(equals(0))
4823   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
4824   match false
4825 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
4826   match 3.14
4827 integerLiteral(equals(42))
4828   matches 42
4829
4830 Note that you cannot directly match a negative numeric literal because the
4831 minus sign is not part of the literal: It is a unary operator whose operand
4832 is the positive numeric literal. Instead, you must use a unaryOperator()
4833 matcher to match the minus sign:
4834
4835 unaryOperator(hasOperatorName("-"),
4836               hasUnaryOperand(integerLiteral(equals(13))))
4837
4838 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;,
4839            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;
4840 </pre></td></tr>
4841
4842
4843 <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>
4844 <tr><td colspan="4" class="doc" id="equals13"><pre></pre></td></tr>
4845
4846
4847 <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>
4848 <tr><td colspan="4" class="doc" id="equals9"><pre></pre></td></tr>
4849
4850
4851 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt;</td><td class="name" onclick="toggle('capturesThis0')"><a name="capturesThis0Anchor">capturesThis</a></td><td></td></tr>
4852 <tr><td colspan="4" class="doc" id="capturesThis0"><pre>Matches a `LambdaCapture` that refers to 'this'.
4853
4854 Given
4855 class C {
4856   int cc;
4857   int f() {
4858     auto l = [this]() { return cc; };
4859     return l();
4860   }
4861 };
4862 lambdaExpr(hasAnyCapture(lambdaCapture(capturesThis())))
4863   matches `[this]() { return cc; }`.
4864 </pre></td></tr>
4865
4866
4867 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt;</td><td class="name" onclick="toggle('isImplicit2')"><a name="isImplicit2Anchor">isImplicit</a></td><td></td></tr>
4868 <tr><td colspan="4" class="doc" id="isImplicit2"><pre>Matches an entity that has been implicitly added by the compiler (e.g.
4869 implicit default/copy constructors).
4870 </pre></td></tr>
4871
4872
4873 <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>
4874 <tr><td colspan="4" class="doc" id="isArrow0"><pre>Matches member expressions that are called with '-&gt;' as opposed
4875 to '.'.
4876
4877 Member calls on the implicit this pointer match as called with '-&gt;'.
4878
4879 Given
4880   class Y {
4881     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
4882     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
4883     int a;
4884     static int b;
4885   };
4886   template &lt;class T&gt;
4887   class Z {
4888     void x() { this-&gt;m; }
4889   };
4890 memberExpr(isArrow())
4891   matches this-&gt;x, x, y.x, a, this-&gt;b
4892 cxxDependentScopeMemberExpr(isArrow())
4893   matches this-&gt;m
4894 unresolvedMemberExpr(isArrow())
4895   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
4896 </pre></td></tr>
4897
4898
4899 <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>
4900 <tr><td colspan="4" class="doc" id="hasAnyName0"><pre>Matches NamedDecl nodes that have any of the specified names.
4901
4902 This matcher is only provided as a performance optimization of hasName.
4903     hasAnyName(a, b, c)
4904  is equivalent to, but faster than
4905     anyOf(hasName(a), hasName(b), hasName(c))
4906 </pre></td></tr>
4907
4908
4909 <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>
4910 <tr><td colspan="4" class="doc" id="hasExternalFormalLinkage0"><pre>Matches a declaration that has external formal linkage.
4911
4912 Example matches only z (matcher = varDecl(hasExternalFormalLinkage()))
4913 void f() {
4914   int x;
4915   static int y;
4916 }
4917 int z;
4918
4919 Example matches f() because it has external formal linkage despite being
4920 unique to the translation unit as though it has internal likage
4921 (matcher = functionDecl(hasExternalFormalLinkage()))
4922
4923 namespace {
4924 void f() {}
4925 }
4926 </pre></td></tr>
4927
4928
4929 <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>
4930 <tr><td colspan="4" class="doc" id="hasName0"><pre>Matches NamedDecl nodes that have the specified name.
4931
4932 Supports specifying enclosing namespaces or classes by prefixing the name
4933 with '&lt;enclosing&gt;::'.
4934 Does not match typedefs of an underlying type with the given name.
4935
4936 Example matches X (Name == "X")
4937   class X;
4938
4939 Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
4940   namespace a { namespace b { class X; } }
4941 </pre></td></tr>
4942
4943
4944 <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>
4945 <tr><td colspan="4" class="doc" id="matchesName0"><pre>Matches NamedDecl nodes whose fully qualified names contain
4946 a substring matched by the given RegExp.
4947
4948 Supports specifying enclosing namespaces or classes by
4949 prefixing the name with '&lt;enclosing&gt;::'.  Does not match typedefs
4950 of an underlying type with the given name.
4951
4952 Example matches X (regexp == "::X")
4953   class X;
4954
4955 Example matches X (regexp is one of "::X", "^foo::.*X", among others)
4956   namespace foo { namespace bar { class X; } }
4957
4958 If the matcher is used in clang-query, RegexFlags parameter
4959 should be passed as a quoted string. e.g: "NoFlags".
4960 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
4961 </pre></td></tr>
4962
4963
4964 <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>
4965 <tr><td colspan="4" class="doc" id="isAnonymous0"><pre>Matches anonymous namespace declarations.
4966
4967 Given
4968   namespace n {
4969   namespace {} // #1
4970   }
4971 namespaceDecl(isAnonymous()) will match #1 but not ::n.
4972 </pre></td></tr>
4973
4974
4975 <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>
4976 <tr><td colspan="4" class="doc" id="isInline0"><pre>Matches functions, variables and namespace declarations that are marked with
4977 the inline keyword.
4978
4979 Given
4980   inline void f();
4981   void g();
4982   namespace n {
4983   inline namespace m {}
4984   }
4985   inline int Foo = 5;
4986 functionDecl(isInline()) will match ::f().
4987 namespaceDecl(isInline()) will match n::m.
4988 varDecl(isInline()) will match Foo;
4989 </pre></td></tr>
4990
4991
4992 <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>
4993 <tr><td colspan="4" class="doc" id="isFirstPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``firstprivate`` kind
4994 specified.
4995
4996 Given
4997
4998   #pragma omp parallel
4999   #pragma omp parallel default(none)
5000   #pragma omp parallel default(shared)
5001   #pragma omp parallel default(private)
5002   #pragma omp parallel default(firstprivate)
5003
5004 ``ompDefaultClause(isFirstPrivateKind())`` matches only
5005 ``default(firstprivate)``.
5006 </pre></td></tr>
5007
5008
5009 <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>
5010 <tr><td colspan="4" class="doc" id="isNoneKind0"><pre>Matches if the OpenMP ``default`` clause has ``none`` kind specified.
5011
5012 Given
5013
5014   #pragma omp parallel
5015   #pragma omp parallel default(none)
5016   #pragma omp parallel default(shared)
5017   #pragma omp parallel default(private)
5018   #pragma omp parallel default(firstprivate)
5019
5020 ``ompDefaultClause(isNoneKind())`` matches only ``default(none)``.
5021 </pre></td></tr>
5022
5023
5024 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isPrivateKind0')"><a name="isPrivateKind0Anchor">isPrivateKind</a></td><td></td></tr>
5025 <tr><td colspan="4" class="doc" id="isPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``private`` kind
5026 specified.
5027
5028 Given
5029
5030   #pragma omp parallel
5031   #pragma omp parallel default(none)
5032   #pragma omp parallel default(shared)
5033   #pragma omp parallel default(private)
5034   #pragma omp parallel default(firstprivate)
5035
5036 ``ompDefaultClause(isPrivateKind())`` matches only
5037 ``default(private)``.
5038 </pre></td></tr>
5039
5040
5041 <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>
5042 <tr><td colspan="4" class="doc" id="isSharedKind0"><pre>Matches if the OpenMP ``default`` clause has ``shared`` kind specified.
5043
5044 Given
5045
5046   #pragma omp parallel
5047   #pragma omp parallel default(none)
5048   #pragma omp parallel default(shared)
5049   #pragma omp parallel default(private)
5050   #pragma omp parallel default(firstprivate)
5051
5052 ``ompDefaultClause(isSharedKind())`` matches only ``default(shared)``.
5053 </pre></td></tr>
5054
5055
5056 <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>
5057 <tr><td colspan="4" class="doc" id="isAllowedToContainClauseKind0"><pre>Matches if the OpenMP directive is allowed to contain the specified OpenMP
5058 clause kind.
5059
5060 Given
5061
5062   #pragma omp parallel
5063   #pragma omp parallel for
5064   #pragma omp          for
5065
5066 `ompExecutableDirective(isAllowedToContainClause(OMPC_default))`` matches
5067 ``omp parallel`` and ``omp parallel for``.
5068
5069 If the matcher is use from clang-query, ``OpenMPClauseKind`` parameter
5070 should be passed as a quoted string. e.g.,
5071 ``isAllowedToContainClauseKind("OMPC_default").``
5072 </pre></td></tr>
5073
5074
5075 <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>
5076 <tr><td colspan="4" class="doc" id="isStandaloneDirective0"><pre>Matches standalone OpenMP directives,
5077 i.e., directives that can't have a structured block.
5078
5079 Given
5080
5081   #pragma omp parallel
5082   {}
5083   #pragma omp taskyield
5084
5085 ``ompExecutableDirective(isStandaloneDirective()))`` matches
5086 ``omp taskyield``.
5087 </pre></td></tr>
5088
5089
5090 <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>
5091 <tr><td colspan="4" class="doc" id="isDerivedFrom3"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
5092 </pre></td></tr>
5093
5094
5095 <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>
5096 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom3"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
5097 </pre></td></tr>
5098
5099
5100 <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>
5101 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom3"><pre>Overloaded method as shortcut for
5102 isSameOrDerivedFrom(hasName(...)).
5103 </pre></td></tr>
5104
5105
5106 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountAtLeast3')"><a name="argumentCountAtLeast3Anchor">argumentCountAtLeast</a></td><td>unsigned N</td></tr>
5107 <tr><td colspan="4" class="doc" id="argumentCountAtLeast3"><pre>Checks that a call expression or a constructor call expression has at least
5108 the specified number of arguments (including absent default arguments).
5109
5110 Example matches f(0, 0) and g(0, 0, 0)
5111 (matcher = callExpr(argumentCountAtLeast(2)))
5112   void f(int x, int y);
5113   void g(int x, int y, int z);
5114   f(0, 0);
5115   g(0, 0, 0);
5116 </pre></td></tr>
5117
5118
5119 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs3')"><a name="argumentCountIs3Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
5120 <tr><td colspan="4" class="doc" id="argumentCountIs3"><pre>Checks that a call expression or a constructor call expression has
5121 a specific number of arguments (including absent default arguments).
5122
5123 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
5124   void f(int x, int y);
5125   f(0, 0);
5126 </pre></td></tr>
5127
5128
5129 <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>
5130 <tr><td colspan="4" class="doc" id="hasAnySelector0"><pre>Matches when at least one of the supplied string equals to the
5131 Selector.getAsString()
5132
5133  matcher = objCMessageExpr(hasSelector("methodA:", "methodB:"));
5134  matches both of the expressions below:
5135     [myObj methodA:argA];
5136     [myObj methodB:argB];
5137 </pre></td></tr>
5138
5139
5140 <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>
5141 <tr><td colspan="4" class="doc" id="hasKeywordSelector0"><pre>Matches when the selector is a keyword selector
5142
5143 objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
5144 message expression in
5145
5146   UIWebView *webView = ...;
5147   CGRect bodyFrame = webView.frame;
5148   bodyFrame.size.height = self.bodyContentHeight;
5149   webView.frame = bodyFrame;
5150   //     ^---- matches here
5151 </pre></td></tr>
5152
5153
5154 <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>
5155 <tr><td colspan="4" class="doc" id="hasNullSelector0"><pre>Matches when the selector is the empty selector
5156
5157 Matches only when the selector of the objCMessageExpr is NULL. This may
5158 represent an error condition in the tree!
5159 </pre></td></tr>
5160
5161
5162 <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>
5163 <tr><td colspan="4" class="doc" id="hasSelector0"><pre>Matches when BaseName == Selector.getAsString()
5164
5165  matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
5166  matches the outer message expr in the code below, but NOT the message
5167  invocation for self.bodyView.
5168     [self.bodyView loadHTMLString:html baseURL:NULL];
5169 </pre></td></tr>
5170
5171
5172 <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>
5173 <tr><td colspan="4" class="doc" id="hasUnarySelector0"><pre>Matches when the selector is a Unary Selector
5174
5175  matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
5176  matches self.bodyView in the code below, but NOT the outer message
5177  invocation of "loadHTMLString:baseURL:".
5178     [self.bodyView loadHTMLString:html baseURL:NULL];
5179 </pre></td></tr>
5180
5181
5182 <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>
5183 <tr><td colspan="4" class="doc" id="isClassMessage0"><pre>Returns true when the Objective-C message is sent to a class.
5184
5185 Example
5186 matcher = objcMessageExpr(isClassMessage())
5187 matches
5188   [NSString stringWithFormat:@"format"];
5189 but not
5190   NSString *x = @"hello";
5191   [x containsString:@"h"];
5192 </pre></td></tr>
5193
5194
5195 <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>
5196 <tr><td colspan="4" class="doc" id="isInstanceMessage0"><pre>Returns true when the Objective-C message is sent to an instance.
5197
5198 Example
5199 matcher = objcMessageExpr(isInstanceMessage())
5200 matches
5201   NSString *x = @"hello";
5202   [x containsString:@"h"];
5203 but not
5204   [NSString stringWithFormat:@"format"];
5205 </pre></td></tr>
5206
5207
5208 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('matchesSelector0')"><a name="matchesSelector0Anchor">matchesSelector</a></td><td>StringRef RegExp, Regex::RegexFlags Flags = NoFlags</td></tr>
5209 <tr><td colspan="4" class="doc" id="matchesSelector0"><pre>Matches ObjC selectors whose name contains
5210 a substring matched by the given RegExp.
5211  matcher = objCMessageExpr(matchesSelector("loadHTMLStringmatches the outer message expr in the code below, but NOT the message
5212  invocation for self.bodyView.
5213     [self.bodyView loadHTMLString:html baseURL:NULL];
5214
5215 If the matcher is used in clang-query, RegexFlags parameter
5216 should be passed as a quoted string. e.g: "NoFlags".
5217 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5218 </pre></td></tr>
5219
5220
5221 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('numSelectorArgs0')"><a name="numSelectorArgs0Anchor">numSelectorArgs</a></td><td>unsigned N</td></tr>
5222 <tr><td colspan="4" class="doc" id="numSelectorArgs0"><pre>Matches when the selector has the specified number of arguments
5223
5224  matcher = objCMessageExpr(numSelectorArgs(0));
5225  matches self.bodyView in the code below
5226
5227  matcher = objCMessageExpr(numSelectorArgs(2));
5228  matches the invocation of "loadHTMLString:baseURL:" but not that
5229  of self.bodyView
5230     [self.bodyView loadHTMLString:html baseURL:NULL];
5231 </pre></td></tr>
5232
5233
5234 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isClassMethod0')"><a name="isClassMethod0Anchor">isClassMethod</a></td><td></td></tr>
5235 <tr><td colspan="4" class="doc" id="isClassMethod0"><pre>Returns true when the Objective-C method declaration is a class method.
5236
5237 Example
5238 matcher = objcMethodDecl(isClassMethod())
5239 matches
5240 @interface I + (void)foo; @end
5241 but not
5242 @interface I - (void)bar; @end
5243 </pre></td></tr>
5244
5245
5246 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition2')"><a name="isDefinition2Anchor">isDefinition</a></td><td></td></tr>
5247 <tr><td colspan="4" class="doc" id="isDefinition2"><pre>Matches if a declaration has a body attached.
5248
5249 Example matches A, va, fa
5250   class A {};
5251   class B;  // Doesn't match, as it has no body.
5252   int va;
5253   extern int vb;  // Doesn't match, as it doesn't define the variable.
5254   void fa() {}
5255   void fb();  // Doesn't match, as it has no body.
5256   @interface X
5257   - (void)ma; // Doesn't match, interface is declaration.
5258   @end
5259   @implementation X
5260   - (void)ma {}
5261   @end
5262
5263 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;,
5264   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
5265 </pre></td></tr>
5266
5267
5268 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isInstanceMethod0')"><a name="isInstanceMethod0Anchor">isInstanceMethod</a></td><td></td></tr>
5269 <tr><td colspan="4" class="doc" id="isInstanceMethod0"><pre>Returns true when the Objective-C method declaration is an instance method.
5270
5271 Example
5272 matcher = objcMethodDecl(isInstanceMethod())
5273 matches
5274 @interface I - (void)bar; @end
5275 but not
5276 @interface I + (void)foo; @end
5277 </pre></td></tr>
5278
5279
5280 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt;</td><td class="name" onclick="toggle('hasDefaultArgument0')"><a name="hasDefaultArgument0Anchor">hasDefaultArgument</a></td><td></td></tr>
5281 <tr><td colspan="4" class="doc" id="hasDefaultArgument0"><pre>Matches a declaration that has default arguments.
5282
5283 Example matches y (matcher = parmVarDecl(hasDefaultArgument()))
5284 void x(int val) {}
5285 void y(int val = 0) {}
5286
5287 Deprecated. Use hasInitializer() instead to be able to
5288 match on the contents of the default argument.  For example:
5289
5290 void x(int val = 7) {}
5291 void y(int val = 42) {}
5292 parmVarDecl(hasInitializer(integerLiteral(equals(42))))
5293   matches the parameter of y
5294
5295 A matcher such as
5296   parmVarDecl(hasInitializer(anything()))
5297 is equivalent to parmVarDecl(hasDefaultArgument()).
5298 </pre></td></tr>
5299
5300
5301 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt;</td><td class="name" onclick="toggle('isAtPosition0')"><a name="isAtPosition0Anchor">isAtPosition</a></td><td>unsigned N</td></tr>
5302 <tr><td colspan="4" class="doc" id="isAtPosition0"><pre>Matches the ParmVarDecl nodes that are at the N'th position in the parameter
5303 list. The parameter list could be that of either a block, function, or
5304 objc-method.
5305
5306
5307 Given
5308
5309 void f(int a, int b, int c) {
5310 }
5311
5312 ``parmVarDecl(isAtPosition(0))`` matches ``int a``.
5313
5314 ``parmVarDecl(isAtPosition(1))`` matches ``int b``.
5315 </pre></td></tr>
5316
5317
5318 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('asString0')"><a name="asString0Anchor">asString</a></td><td>std::string Name</td></tr>
5319 <tr><td colspan="4" class="doc" id="asString0"><pre>Matches if the matched type is represented by the given string.
5320
5321 Given
5322   class Y { public: void x(); };
5323   void z() { Y* y; y-&gt;x(); }
5324 cxxMemberCallExpr(on(hasType(asString("class Y *"))))
5325   matches y-&gt;x()
5326 </pre></td></tr>
5327
5328
5329 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode3')"><a name="equalsBoundNode3Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
5330 <tr><td colspan="4" class="doc" id="equalsBoundNode3"><pre>Matches if a node equals a previously bound node.
5331
5332 Matches a node if it equals the node previously bound to ID.
5333
5334 Given
5335   class X { int a; int b; };
5336 cxxRecordDecl(
5337     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
5338     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
5339   matches the class X, as a and b have the same type.
5340
5341 Note that when multiple matches are involved via forEach* matchers,
5342 equalsBoundNodes acts as a filter.
5343 For example:
5344 compoundStmt(
5345     forEachDescendant(varDecl().bind("d")),
5346     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
5347 will trigger a match for each combination of variable declaration
5348 and reference to that variable declaration within a compound statement.
5349 </pre></td></tr>
5350
5351
5352 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasLocalQualifiers0')"><a name="hasLocalQualifiers0Anchor">hasLocalQualifiers</a></td><td></td></tr>
5353 <tr><td colspan="4" class="doc" id="hasLocalQualifiers0"><pre>Matches QualType nodes that have local CV-qualifiers attached to
5354 the node, not hidden within a typedef.
5355
5356 Given
5357   typedef const int const_int;
5358   const_int i;
5359   int *const j;
5360   int *volatile k;
5361   int m;
5362 varDecl(hasType(hasLocalQualifiers())) matches only j and k.
5363 i is const-qualified but the qualifier is not local.
5364 </pre></td></tr>
5365
5366
5367 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isAnyCharacter0')"><a name="isAnyCharacter0Anchor">isAnyCharacter</a></td><td></td></tr>
5368 <tr><td colspan="4" class="doc" id="isAnyCharacter0"><pre>Matches QualType nodes that are of character type.
5369
5370 Given
5371   void a(char);
5372   void b(wchar_t);
5373   void c(double);
5374 functionDecl(hasAnyParameter(hasType(isAnyCharacter())))
5375 matches "a(char)", "b(wchar_t)", but not "c(double)".
5376 </pre></td></tr>
5377
5378
5379 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isAnyPointer0')"><a name="isAnyPointer0Anchor">isAnyPointer</a></td><td></td></tr>
5380 <tr><td colspan="4" class="doc" id="isAnyPointer0"><pre>Matches QualType nodes that are of any pointer type; this includes
5381 the Objective-C object pointer type, which is different despite being
5382 syntactically similar.
5383
5384 Given
5385   int *i = nullptr;
5386
5387   @interface Foo
5388   @end
5389   Foo *f;
5390
5391   int j;
5392 varDecl(hasType(isAnyPointer()))
5393   matches "int *i" and "Foo *f", but not "int j".
5394 </pre></td></tr>
5395
5396
5397 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isConstQualified0')"><a name="isConstQualified0Anchor">isConstQualified</a></td><td></td></tr>
5398 <tr><td colspan="4" class="doc" id="isConstQualified0"><pre>Matches QualType nodes that are const-qualified, i.e., that
5399 include "top-level" const.
5400
5401 Given
5402   void a(int);
5403   void b(int const);
5404   void c(const int);
5405   void d(const int*);
5406   void e(int const) {};
5407 functionDecl(hasAnyParameter(hasType(isConstQualified())))
5408   matches "void b(int const)", "void c(const int)" and
5409   "void e(int const) {}". It does not match d as there
5410   is no top-level const on the parameter type "const int *".
5411 </pre></td></tr>
5412
5413
5414 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isInteger0')"><a name="isInteger0Anchor">isInteger</a></td><td></td></tr>
5415 <tr><td colspan="4" class="doc" id="isInteger0"><pre>Matches QualType nodes that are of integer type.
5416
5417 Given
5418   void a(int);
5419   void b(long);
5420   void c(double);
5421 functionDecl(hasAnyParameter(hasType(isInteger())))
5422 matches "a(int)", "b(long)", but not "c(double)".
5423 </pre></td></tr>
5424
5425
5426 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isSignedInteger0')"><a name="isSignedInteger0Anchor">isSignedInteger</a></td><td></td></tr>
5427 <tr><td colspan="4" class="doc" id="isSignedInteger0"><pre>Matches QualType nodes that are of signed integer type.
5428
5429 Given
5430   void a(int);
5431   void b(unsigned long);
5432   void c(double);
5433 functionDecl(hasAnyParameter(hasType(isSignedInteger())))
5434 matches "a(int)", but not "b(unsigned long)" and "c(double)".
5435 </pre></td></tr>
5436
5437
5438 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isUnsignedInteger0')"><a name="isUnsignedInteger0Anchor">isUnsignedInteger</a></td><td></td></tr>
5439 <tr><td colspan="4" class="doc" id="isUnsignedInteger0"><pre>Matches QualType nodes that are of unsigned integer type.
5440
5441 Given
5442   void a(int);
5443   void b(unsigned long);
5444   void c(double);
5445 functionDecl(hasAnyParameter(hasType(isUnsignedInteger())))
5446 matches "b(unsigned long)", but not "a(int)" and "c(double)".
5447 </pre></td></tr>
5448
5449
5450 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('isVolatileQualified0')"><a name="isVolatileQualified0Anchor">isVolatileQualified</a></td><td></td></tr>
5451 <tr><td colspan="4" class="doc" id="isVolatileQualified0"><pre>Matches QualType nodes that are volatile-qualified, i.e., that
5452 include "top-level" volatile.
5453
5454 Given
5455   void a(int);
5456   void b(int volatile);
5457   void c(volatile int);
5458   void d(volatile int*);
5459   void e(int volatile) {};
5460 functionDecl(hasAnyParameter(hasType(isVolatileQualified())))
5461   matches "void b(int volatile)", "void c(volatile int)" and
5462   "void e(int volatile) {}". It does not match d as there
5463   is no top-level volatile on the parameter type "volatile int *".
5464 </pre></td></tr>
5465
5466
5467 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode0')"><a name="equalsBoundNode0Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
5468 <tr><td colspan="4" class="doc" id="equalsBoundNode0"><pre>Matches if a node equals a previously bound node.
5469
5470 Matches a node if it equals the node previously bound to ID.
5471
5472 Given
5473   class X { int a; int b; };
5474 cxxRecordDecl(
5475     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
5476     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
5477   matches the class X, as a and b have the same type.
5478
5479 Note that when multiple matches are involved via forEach* matchers,
5480 equalsBoundNodes acts as a filter.
5481 For example:
5482 compoundStmt(
5483     forEachDescendant(varDecl().bind("d")),
5484     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
5485 will trigger a match for each combination of variable declaration
5486 and reference to that variable declaration within a compound statement.
5487 </pre></td></tr>
5488
5489
5490 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('equalsNode1')"><a name="equalsNode1Anchor">equalsNode</a></td><td>const Stmt* Other</td></tr>
5491 <tr><td colspan="4" class="doc" id="equalsNode1"><pre>Matches if a node equals another node.
5492
5493 Stmt has pointer identity in the AST.
5494 </pre></td></tr>
5495
5496
5497 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpandedFromMacro1')"><a name="isExpandedFromMacro1Anchor">isExpandedFromMacro</a></td><td>std::string MacroName</td></tr>
5498 <tr><td colspan="4" class="doc" id="isExpandedFromMacro1"><pre>Matches statements that are (transitively) expanded from the named macro.
5499 Does not match if only part of the statement is expanded from that macro or
5500 if different parts of the statement are expanded from different
5501 appearances of the macro.
5502 </pre></td></tr>
5503
5504
5505 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching1')"><a name="isExpansionInFileMatching1Anchor">isExpansionInFileMatching</a></td><td>StringRef RegExp, Regex::RegexFlags Flags = NoFlags</td></tr>
5506 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching1"><pre>Matches AST nodes that were expanded within files whose name is
5507 partially matching a given regex.
5508
5509 Example matches Y but not X
5510     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
5511   #include "ASTMatcher.h"
5512   class X {};
5513 ASTMatcher.h:
5514   class Y {};
5515
5516 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;
5517
5518 If the matcher is used in clang-query, RegexFlags parameter
5519 should be passed as a quoted string. e.g: "NoFlags".
5520 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5521 </pre></td></tr>
5522
5523
5524 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInMainFile1')"><a name="isExpansionInMainFile1Anchor">isExpansionInMainFile</a></td><td></td></tr>
5525 <tr><td colspan="4" class="doc" id="isExpansionInMainFile1"><pre>Matches AST nodes that were expanded within the main-file.
5526
5527 Example matches X but not Y
5528   (matcher = cxxRecordDecl(isExpansionInMainFile())
5529   #include &lt;Y.h&gt;
5530   class X {};
5531 Y.h:
5532   class Y {};
5533
5534 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;
5535 </pre></td></tr>
5536
5537
5538 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInSystemHeader1')"><a name="isExpansionInSystemHeader1Anchor">isExpansionInSystemHeader</a></td><td></td></tr>
5539 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader1"><pre>Matches AST nodes that were expanded within system-header-files.
5540
5541 Example matches Y but not X
5542     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
5543   #include &lt;SystemHeader.h&gt;
5544   class X {};
5545 SystemHeader.h:
5546   class Y {};
5547
5548 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;
5549 </pre></td></tr>
5550
5551
5552 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isInTemplateInstantiation0')"><a name="isInTemplateInstantiation0Anchor">isInTemplateInstantiation</a></td><td></td></tr>
5553 <tr><td colspan="4" class="doc" id="isInTemplateInstantiation0"><pre>Matches statements inside of a template instantiation.
5554
5555 Given
5556   int j;
5557   template&lt;typename T&gt; void A(T t) { T i; j += 42;}
5558   A(0);
5559   A(0U);
5560 declStmt(isInTemplateInstantiation())
5561   matches 'int i;' and 'unsigned i'.
5562 unless(stmt(isInTemplateInstantiation()))
5563   will NOT match j += 42; as it's shared between the template definition and
5564   instantiation.
5565 </pre></td></tr>
5566
5567
5568 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StringLiteral.html">StringLiteral</a>&gt;</td><td class="name" onclick="toggle('hasSize1')"><a name="hasSize1Anchor">hasSize</a></td><td>unsigned N</td></tr>
5569 <tr><td colspan="4" class="doc" id="hasSize1"><pre>Matches nodes that have the specified size.
5570
5571 Given
5572   int a[42];
5573   int b[2 * 21];
5574   int c[41], d[43];
5575   char *s = "abcd";
5576   wchar_t *ws = L"abcd";
5577   char *w = "a";
5578 constantArrayType(hasSize(42))
5579   matches "int a[42]" and "int b[2 * 21]"
5580 stringLiteral(hasSize(4))
5581   matches "abcd", L"abcd"
5582 </pre></td></tr>
5583
5584
5585 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;</td><td class="name" onclick="toggle('isClass0')"><a name="isClass0Anchor">isClass</a></td><td></td></tr>
5586 <tr><td colspan="4" class="doc" id="isClass0"><pre>Matches TagDecl object that are spelled with "class."
5587
5588 Example matches C, but not S, U or E.
5589   struct S {};
5590   class C {};
5591   union U {};
5592   enum E {};
5593 </pre></td></tr>
5594
5595
5596 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition0')"><a name="isDefinition0Anchor">isDefinition</a></td><td></td></tr>
5597 <tr><td colspan="4" class="doc" id="isDefinition0"><pre>Matches if a declaration has a body attached.
5598
5599 Example matches A, va, fa
5600   class A {};
5601   class B;  // Doesn't match, as it has no body.
5602   int va;
5603   extern int vb;  // Doesn't match, as it doesn't define the variable.
5604   void fa() {}
5605   void fb();  // Doesn't match, as it has no body.
5606   @interface X
5607   - (void)ma; // Doesn't match, interface is declaration.
5608   @end
5609   @implementation X
5610   - (void)ma {}
5611   @end
5612
5613 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;,
5614   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
5615 </pre></td></tr>
5616
5617
5618 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;</td><td class="name" onclick="toggle('isEnum0')"><a name="isEnum0Anchor">isEnum</a></td><td></td></tr>
5619 <tr><td colspan="4" class="doc" id="isEnum0"><pre>Matches TagDecl object that are spelled with "enum."
5620
5621 Example matches E, but not C, S or U.
5622   struct S {};
5623   class C {};
5624   union U {};
5625   enum E {};
5626 </pre></td></tr>
5627
5628
5629 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;</td><td class="name" onclick="toggle('isStruct0')"><a name="isStruct0Anchor">isStruct</a></td><td></td></tr>
5630 <tr><td colspan="4" class="doc" id="isStruct0"><pre>Matches TagDecl object that are spelled with "struct."
5631
5632 Example matches S, but not C, U or E.
5633   struct S {};
5634   class C {};
5635   union U {};
5636   enum E {};
5637 </pre></td></tr>
5638
5639
5640 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;</td><td class="name" onclick="toggle('isUnion0')"><a name="isUnion0Anchor">isUnion</a></td><td></td></tr>
5641 <tr><td colspan="4" class="doc" id="isUnion0"><pre>Matches TagDecl object that are spelled with "union."
5642
5643 Example matches U, but not C, S or E.
5644   struct S {};
5645   class C {};
5646   union U {};
5647   enum E {};
5648 </pre></td></tr>
5649
5650
5651 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('equalsIntegralValue0')"><a name="equalsIntegralValue0Anchor">equalsIntegralValue</a></td><td>std::string Value</td></tr>
5652 <tr><td colspan="4" class="doc" id="equalsIntegralValue0"><pre>Matches a TemplateArgument of integral type with a given value.
5653
5654 Note that 'Value' is a string as the template argument's value is
5655 an arbitrary precision integer. 'Value' must be euqal to the canonical
5656 representation of that integral value in base 10.
5657
5658 Given
5659   template&lt;int T&gt; struct C {};
5660   C&lt;42&gt; c;
5661 classTemplateSpecializationDecl(
5662   hasAnyTemplateArgument(equalsIntegralValue("42")))
5663   matches the implicit instantiation of C in C&lt;42&gt;.
5664 </pre></td></tr>
5665
5666
5667 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('isIntegral0')"><a name="isIntegral0Anchor">isIntegral</a></td><td></td></tr>
5668 <tr><td colspan="4" class="doc" id="isIntegral0"><pre>Matches a TemplateArgument that is an integral value.
5669
5670 Given
5671   template&lt;int T&gt; struct C {};
5672   C&lt;42&gt; c;
5673 classTemplateSpecializationDecl(
5674   hasAnyTemplateArgument(isIntegral()))
5675   matches the implicit instantiation of C in C&lt;42&gt;
5676   with isIntegral() matching 42.
5677 </pre></td></tr>
5678
5679
5680 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('templateArgumentCountIs1')"><a name="templateArgumentCountIs1Anchor">templateArgumentCountIs</a></td><td>unsigned N</td></tr>
5681 <tr><td colspan="4" class="doc" id="templateArgumentCountIs1"><pre>Matches if the number of template arguments equals N.
5682
5683 Given
5684   template&lt;typename T&gt; struct C {};
5685   C&lt;int&gt; c;
5686 classTemplateSpecializationDecl(templateArgumentCountIs(1))
5687   matches C&lt;int&gt;.
5688 </pre></td></tr>
5689
5690
5691 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpandedFromMacro2')"><a name="isExpandedFromMacro2Anchor">isExpandedFromMacro</a></td><td>std::string MacroName</td></tr>
5692 <tr><td colspan="4" class="doc" id="isExpandedFromMacro2"><pre>Matches statements that are (transitively) expanded from the named macro.
5693 Does not match if only part of the statement is expanded from that macro or
5694 if different parts of the statement are expanded from different
5695 appearances of the macro.
5696 </pre></td></tr>
5697
5698
5699 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching2')"><a name="isExpansionInFileMatching2Anchor">isExpansionInFileMatching</a></td><td>StringRef RegExp, Regex::RegexFlags Flags = NoFlags</td></tr>
5700 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching2"><pre>Matches AST nodes that were expanded within files whose name is
5701 partially matching a given regex.
5702
5703 Example matches Y but not X
5704     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
5705   #include "ASTMatcher.h"
5706   class X {};
5707 ASTMatcher.h:
5708   class Y {};
5709
5710 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;
5711
5712 If the matcher is used in clang-query, RegexFlags parameter
5713 should be passed as a quoted string. e.g: "NoFlags".
5714 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5715 </pre></td></tr>
5716
5717
5718 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpansionInMainFile2')"><a name="isExpansionInMainFile2Anchor">isExpansionInMainFile</a></td><td></td></tr>
5719 <tr><td colspan="4" class="doc" id="isExpansionInMainFile2"><pre>Matches AST nodes that were expanded within the main-file.
5720
5721 Example matches X but not Y
5722   (matcher = cxxRecordDecl(isExpansionInMainFile())
5723   #include &lt;Y.h&gt;
5724   class X {};
5725 Y.h:
5726   class Y {};
5727
5728 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;
5729 </pre></td></tr>
5730
5731
5732 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('isExpansionInSystemHeader2')"><a name="isExpansionInSystemHeader2Anchor">isExpansionInSystemHeader</a></td><td></td></tr>
5733 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader2"><pre>Matches AST nodes that were expanded within system-header-files.
5734
5735 Example matches Y but not X
5736     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
5737   #include &lt;SystemHeader.h&gt;
5738   class X {};
5739 SystemHeader.h:
5740   class Y {};
5741
5742 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;
5743 </pre></td></tr>
5744
5745
5746 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('booleanType0')"><a name="booleanType0Anchor">booleanType</a></td><td></td></tr>
5747 <tr><td colspan="4" class="doc" id="booleanType0"><pre>Matches type bool.
5748
5749 Given
5750  struct S { bool func(); };
5751 functionDecl(returns(booleanType()))
5752   matches "bool func();"
5753 </pre></td></tr>
5754
5755
5756 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode2')"><a name="equalsBoundNode2Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
5757 <tr><td colspan="4" class="doc" id="equalsBoundNode2"><pre>Matches if a node equals a previously bound node.
5758
5759 Matches a node if it equals the node previously bound to ID.
5760
5761 Given
5762   class X { int a; int b; };
5763 cxxRecordDecl(
5764     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
5765     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
5766   matches the class X, as a and b have the same type.
5767
5768 Note that when multiple matches are involved via forEach* matchers,
5769 equalsBoundNodes acts as a filter.
5770 For example:
5771 compoundStmt(
5772     forEachDescendant(varDecl().bind("d")),
5773     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
5774 will trigger a match for each combination of variable declaration
5775 and reference to that variable declaration within a compound statement.
5776 </pre></td></tr>
5777
5778
5779 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('equalsNode2')"><a name="equalsNode2Anchor">equalsNode</a></td><td>const Type* Other</td></tr>
5780 <tr><td colspan="4" class="doc" id="equalsNode2"><pre>Matches if a node equals another node.
5781
5782 Type has pointer identity in the AST.
5783 </pre></td></tr>
5784
5785
5786 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('realFloatingPointType0')"><a name="realFloatingPointType0Anchor">realFloatingPointType</a></td><td></td></tr>
5787 <tr><td colspan="4" class="doc" id="realFloatingPointType0"><pre>Matches any real floating-point type (float, double, long double).
5788
5789 Given
5790   int i;
5791   float f;
5792 realFloatingPointType()
5793   matches "float f" but not "int i"
5794 </pre></td></tr>
5795
5796
5797 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('voidType0')"><a name="voidType0Anchor">voidType</a></td><td></td></tr>
5798 <tr><td colspan="4" class="doc" id="voidType0"><pre>Matches type void.
5799
5800 Given
5801  struct S { void func(); };
5802 functionDecl(returns(voidType()))
5803   matches "void func();"
5804 </pre></td></tr>
5805
5806
5807 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;</td><td class="name" onclick="toggle('ofKind0')"><a name="ofKind0Anchor">ofKind</a></td><td>UnaryExprOrTypeTrait Kind</td></tr>
5808 <tr><td colspan="4" class="doc" id="ofKind0"><pre>Matches unary expressions of a certain kind.
5809
5810 Given
5811   int x;
5812   int s = sizeof(x) + alignof(x)
5813 unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
5814   matches sizeof(x)
5815
5816 If the matcher is use from clang-query, UnaryExprOrTypeTrait parameter
5817 should be passed as a quoted string. e.g., ofKind("UETT_SizeOf").
5818 </pre></td></tr>
5819
5820
5821 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasAnyOperatorName3')"><a name="hasAnyOperatorName3Anchor">hasAnyOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
5822 <tr><td colspan="4" class="doc" id="hasAnyOperatorName3"><pre>Matches operator expressions (binary or unary) that have any of the
5823 specified names.
5824
5825    hasAnyOperatorName("+", "-")
5826  Is equivalent to
5827    anyOf(hasOperatorName("+"), hasOperatorName("-"))
5828 </pre></td></tr>
5829
5830
5831 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName4')"><a name="hasOperatorName4Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
5832 <tr><td colspan="4" class="doc" id="hasOperatorName4"><pre>Matches the operator Name of operator expressions and fold expressions
5833 (binary or unary).
5834
5835 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
5836   !(a || b)
5837
5838 Example matches `(0 + ... + args)`
5839     (matcher = cxxFoldExpr(hasOperatorName("+")))
5840   template &lt;typename... Args&gt;
5841   auto sum(Args... args) {
5842       return (0 + ... + args);
5843   }
5844 </pre></td></tr>
5845
5846
5847 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedMemberExpr.html">UnresolvedMemberExpr</a>&gt;</td><td class="name" onclick="toggle('isArrow1')"><a name="isArrow1Anchor">isArrow</a></td><td></td></tr>
5848 <tr><td colspan="4" class="doc" id="isArrow1"><pre>Matches member expressions that are called with '-&gt;' as opposed
5849 to '.'.
5850
5851 Member calls on the implicit this pointer match as called with '-&gt;'.
5852
5853 Given
5854   class Y {
5855     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
5856     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
5857     int a;
5858     static int b;
5859   };
5860   template &lt;class T&gt;
5861   class Z {
5862     void x() { this-&gt;m; }
5863   };
5864 memberExpr(isArrow())
5865   matches this-&gt;x, x, y.x, a, this-&gt;b
5866 cxxDependentScopeMemberExpr(isArrow())
5867   matches this-&gt;m
5868 unresolvedMemberExpr(isArrow())
5869   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
5870 </pre></td></tr>
5871
5872
5873 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasAutomaticStorageDuration0')"><a name="hasAutomaticStorageDuration0Anchor">hasAutomaticStorageDuration</a></td><td></td></tr>
5874 <tr><td colspan="4" class="doc" id="hasAutomaticStorageDuration0"><pre>Matches a variable declaration that has automatic storage duration.
5875
5876 Example matches x, but not y, z, or a.
5877 (matcher = varDecl(hasAutomaticStorageDuration())
5878 void f() {
5879   int x;
5880   static int y;
5881   thread_local int z;
5882 }
5883 int a;
5884 </pre></td></tr>
5885
5886
5887 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasGlobalStorage0')"><a name="hasGlobalStorage0Anchor">hasGlobalStorage</a></td><td></td></tr>
5888 <tr><td colspan="4" class="doc" id="hasGlobalStorage0"><pre>Matches a variable declaration that does not have local storage.
5889
5890 Example matches y and z (matcher = varDecl(hasGlobalStorage())
5891 void f() {
5892   int x;
5893   static int y;
5894 }
5895 int z;
5896 </pre></td></tr>
5897
5898
5899 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasLocalStorage0')"><a name="hasLocalStorage0Anchor">hasLocalStorage</a></td><td></td></tr>
5900 <tr><td colspan="4" class="doc" id="hasLocalStorage0"><pre>Matches a variable declaration that has function scope and is a
5901 non-static local variable.
5902
5903 Example matches x (matcher = varDecl(hasLocalStorage())
5904 void f() {
5905   int x;
5906   static int y;
5907 }
5908 int z;
5909 </pre></td></tr>
5910
5911
5912 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasStaticStorageDuration0')"><a name="hasStaticStorageDuration0Anchor">hasStaticStorageDuration</a></td><td></td></tr>
5913 <tr><td colspan="4" class="doc" id="hasStaticStorageDuration0"><pre>Matches a variable declaration that has static storage duration.
5914 It includes the variable declared at namespace scope and those declared
5915 with "static" and "extern" storage class specifiers.
5916
5917 void f() {
5918   int x;
5919   static int y;
5920   thread_local int z;
5921 }
5922 int a;
5923 static int b;
5924 extern int c;
5925 varDecl(hasStaticStorageDuration())
5926   matches the function declaration y, a, b and c.
5927 </pre></td></tr>
5928
5929
5930 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasThreadStorageDuration0')"><a name="hasThreadStorageDuration0Anchor">hasThreadStorageDuration</a></td><td></td></tr>
5931 <tr><td colspan="4" class="doc" id="hasThreadStorageDuration0"><pre>Matches a variable declaration that has thread storage duration.
5932
5933 Example matches z, but not x, z, or a.
5934 (matcher = varDecl(hasThreadStorageDuration())
5935 void f() {
5936   int x;
5937   static int y;
5938   thread_local int z;
5939 }
5940 int a;
5941 </pre></td></tr>
5942
5943
5944 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isConstexpr0')"><a name="isConstexpr0Anchor">isConstexpr</a></td><td></td></tr>
5945 <tr><td colspan="4" class="doc" id="isConstexpr0"><pre>Matches constexpr variable and function declarations,
5946        and if constexpr.
5947
5948 Given:
5949   constexpr int foo = 42;
5950   constexpr int bar();
5951   void baz() { if constexpr(1 &gt; 0) {} }
5952 varDecl(isConstexpr())
5953   matches the declaration of foo.
5954 functionDecl(isConstexpr())
5955   matches the declaration of bar.
5956 ifStmt(isConstexpr())
5957   matches the if statement in baz.
5958 </pre></td></tr>
5959
5960
5961 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isConstinit0')"><a name="isConstinit0Anchor">isConstinit</a></td><td></td></tr>
5962 <tr><td colspan="4" class="doc" id="isConstinit0"><pre>Matches constinit variable declarations.
5963
5964 Given:
5965   constinit int foo = 42;
5966   constinit const char* bar = "bar";
5967   int baz = 42;
5968   [[clang::require_constant_initialization]] int xyz = 42;
5969 varDecl(isConstinit())
5970   matches the declaration of `foo` and `bar`, but not `baz` and `xyz`.
5971 </pre></td></tr>
5972
5973
5974 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition1')"><a name="isDefinition1Anchor">isDefinition</a></td><td></td></tr>
5975 <tr><td colspan="4" class="doc" id="isDefinition1"><pre>Matches if a declaration has a body attached.
5976
5977 Example matches A, va, fa
5978   class A {};
5979   class B;  // Doesn't match, as it has no body.
5980   int va;
5981   extern int vb;  // Doesn't match, as it doesn't define the variable.
5982   void fa() {}
5983   void fb();  // Doesn't match, as it has no body.
5984   @interface X
5985   - (void)ma; // Doesn't match, interface is declaration.
5986   @end
5987   @implementation X
5988   - (void)ma {}
5989   @end
5990
5991 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;,
5992   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
5993 </pre></td></tr>
5994
5995
5996 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isExceptionVariable0')"><a name="isExceptionVariable0Anchor">isExceptionVariable</a></td><td></td></tr>
5997 <tr><td colspan="4" class="doc" id="isExceptionVariable0"><pre>Matches a variable declaration that is an exception variable from
5998 a C++ catch block, or an Objective-C statement.
5999
6000 Example matches x (matcher = varDecl(isExceptionVariable())
6001 void f(int y) {
6002   try {
6003   } catch (int x) {
6004   }
6005 }
6006 </pre></td></tr>
6007
6008
6009 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicitTemplateSpecialization1')"><a name="isExplicitTemplateSpecialization1Anchor">isExplicitTemplateSpecialization</a></td><td></td></tr>
6010 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization1"><pre>Matches explicit template specializations of function, class, or
6011 static member variable template instantiations.
6012
6013 Given
6014   template&lt;typename T&gt; void A(T t) { }
6015   template&lt;&gt; void A(int N) { }
6016 functionDecl(isExplicitTemplateSpecialization())
6017   matches the specialization A&lt;int&gt;().
6018
6019 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;
6020 </pre></td></tr>
6021
6022
6023 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isExternC1')"><a name="isExternC1Anchor">isExternC</a></td><td></td></tr>
6024 <tr><td colspan="4" class="doc" id="isExternC1"><pre>Matches extern "C" function or variable declarations.
6025
6026 Given:
6027   extern "C" void f() {}
6028   extern "C" { void g() {} }
6029   void h() {}
6030   extern "C" int x = 1;
6031   extern "C" int y = 2;
6032   int z = 3;
6033 functionDecl(isExternC())
6034   matches the declaration of f and g, but not the declaration of h.
6035 varDecl(isExternC())
6036   matches the declaration of x and y, but not the declaration of z.
6037 </pre></td></tr>
6038
6039
6040 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isInitCapture0')"><a name="isInitCapture0Anchor">isInitCapture</a></td><td></td></tr>
6041 <tr><td colspan="4" class="doc" id="isInitCapture0"><pre>Matches a variable serving as the implicit variable for a lambda init-
6042 capture.
6043
6044 Example matches x (matcher = varDecl(isInitCapture()))
6045 auto f = [x=3]() { return x; };
6046 </pre></td></tr>
6047
6048
6049 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isInline2')"><a name="isInline2Anchor">isInline</a></td><td></td></tr>
6050 <tr><td colspan="4" class="doc" id="isInline2"><pre>Matches functions, variables and namespace declarations that are marked with
6051 the inline keyword.
6052
6053 Given
6054   inline void f();
6055   void g();
6056   namespace n {
6057   inline namespace m {}
6058   }
6059   inline int Foo = 5;
6060 functionDecl(isInline()) will match ::f().
6061 namespaceDecl(isInline()) will match n::m.
6062 varDecl(isInline()) will match Foo;
6063 </pre></td></tr>
6064
6065
6066 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isStaticLocal0')"><a name="isStaticLocal0Anchor">isStaticLocal</a></td><td></td></tr>
6067 <tr><td colspan="4" class="doc" id="isStaticLocal0"><pre>Matches a static variable with local scope.
6068
6069 Example matches y (matcher = varDecl(isStaticLocal()))
6070 void f() {
6071   int x;
6072   static int y;
6073 }
6074 static int z;
6075 </pre></td></tr>
6076
6077
6078 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isStaticStorageClass1')"><a name="isStaticStorageClass1Anchor">isStaticStorageClass</a></td><td></td></tr>
6079 <tr><td colspan="4" class="doc" id="isStaticStorageClass1"><pre>Matches variable/function declarations that have "static" storage
6080 class specifier ("static" keyword) written in the source.
6081
6082 Given:
6083   static void f() {}
6084   static int i = 0;
6085   extern int j;
6086   int k;
6087 functionDecl(isStaticStorageClass())
6088   matches the function declaration f.
6089 varDecl(isStaticStorageClass())
6090   matches the variable declaration i.
6091 </pre></td></tr>
6092
6093
6094 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isTemplateInstantiation1')"><a name="isTemplateInstantiation1Anchor">isTemplateInstantiation</a></td><td></td></tr>
6095 <tr><td colspan="4" class="doc" id="isTemplateInstantiation1"><pre>Matches template instantiations of function, class, or static
6096 member variable template instantiations.
6097
6098 Given
6099   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
6100 or
6101   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
6102 or
6103   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
6104 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
6105   matches the template instantiation of X&lt;A&gt;.
6106
6107 But given
6108   template &lt;typename T&gt;  class X {}; class A {};
6109   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
6110 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
6111   does not match, as X&lt;A&gt; is an explicit template specialization.
6112
6113 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;
6114 </pre></td></tr>
6115
6116 <!--END_NARROWING_MATCHERS -->
6117 </table>
6118
6119 <!-- ======================================================================= -->
6120 <h2 id="traversal-matchers">AST Traversal Matchers</h2>
6121 <!-- ======================================================================= -->
6122
6123 <p>Traversal matchers specify the relationship to other nodes that are
6124 reachable from the current node.</p>
6125
6126 <p>Note that there are special traversal matchers (has, hasDescendant, forEach and
6127 forEachDescendant) which work on all nodes and allow users to write more generic
6128 match expressions.</p>
6129
6130 <table>
6131 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
6132 <!-- START_TRAVERSAL_MATCHERS -->
6133
6134 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('binaryOperation0')"><a name="binaryOperation0Anchor">binaryOperation</a></td><td>Matcher&lt;*&gt;...Matcher&lt;*&gt;</td></tr>
6135 <tr><td colspan="4" class="doc" id="binaryOperation0"><pre>Matches nodes which can be used with binary operators.
6136
6137 The code
6138   var1 != var2;
6139 might be represented in the clang AST as a binaryOperator, a
6140 cxxOperatorCallExpr or a cxxRewrittenBinaryOperator, depending on
6141
6142 * whether the types of var1 and var2 are fundamental (binaryOperator) or at
6143   least one is a class type (cxxOperatorCallExpr)
6144 * whether the code appears in a template declaration, if at least one of the
6145   vars is a dependent-type (binaryOperator)
6146 * whether the code relies on a rewritten binary operator, such as a
6147 spaceship operator or an inverted equality operator
6148 (cxxRewrittenBinaryOperator)
6149
6150 This matcher elides details in places where the matchers for the nodes are
6151 compatible.
6152
6153 Given
6154   binaryOperation(
6155     hasOperatorName("!="),
6156     hasLHS(expr().bind("lhs")),
6157     hasRHS(expr().bind("rhs"))
6158   )
6159 matches each use of "!=" in:
6160   struct S{
6161       bool operator!=(const S&amp;) const;
6162   };
6163
6164   void foo()
6165   {
6166      1 != 2;
6167      S() != S();
6168   }
6169
6170   template&lt;typename T&gt;
6171   void templ()
6172   {
6173      1 != 2;
6174      T() != S();
6175   }
6176   struct HasOpEq
6177   {
6178       bool operator==(const HasOpEq &amp;) const;
6179   };
6180
6181   void inverse()
6182   {
6183       HasOpEq s1;
6184       HasOpEq s2;
6185       if (s1 != s2)
6186           return;
6187   }
6188
6189   struct HasSpaceship
6190   {
6191       bool operator&lt;=&gt;(const HasOpEq &amp;) const;
6192   };
6193
6194   void use_spaceship()
6195   {
6196       HasSpaceship s1;
6197       HasSpaceship s2;
6198       if (s1 != s2)
6199           return;
6200   }
6201 </pre></td></tr>
6202
6203
6204 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('eachOf0')"><a name="eachOf0Anchor">eachOf</a></td><td>Matcher&lt;*&gt;, ..., Matcher&lt;*&gt;</td></tr>
6205 <tr><td colspan="4" class="doc" id="eachOf0"><pre>Matches if any of the given matchers matches.
6206
6207 Unlike anyOf, eachOf will generate a match result for each
6208 matching submatcher.
6209
6210 For example, in:
6211   class A { int a; int b; };
6212 The matcher:
6213   cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
6214                        has(fieldDecl(hasName("b")).bind("v"))))
6215 will generate two results binding "v", the first of which binds
6216 the field declaration of a, the second the field declaration of
6217 b.
6218
6219 Usable as: Any Matcher
6220 </pre></td></tr>
6221
6222
6223 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('findAll0')"><a name="findAll0Anchor">findAll</a></td><td>Matcher&lt;*&gt;  Matcher</td></tr>
6224 <tr><td colspan="4" class="doc" id="findAll0"><pre>Matches if the node or any descendant matches.
6225
6226 Generates results for each match.
6227
6228 For example, in:
6229   class A { class B {}; class C {}; };
6230 The matcher:
6231   cxxRecordDecl(hasName("::A"),
6232                 findAll(cxxRecordDecl(isDefinition()).bind("m")))
6233 will generate results for A, B and C.
6234
6235 Usable as: Any Matcher
6236 </pre></td></tr>
6237
6238
6239 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEachDescendant0')"><a name="forEachDescendant0Anchor">forEachDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
6240 <tr><td colspan="4" class="doc" id="forEachDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
6241 provided matcher.
6242
6243 Example matches X, A, A::X, B, B::C, B::C::X
6244   (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X")))))
6245   class X {};
6246   class A { class X {}; };  // Matches A, because A::X is a class of name
6247                             // X inside A.
6248   class B { class C { class X {}; }; };
6249
6250 DescendantT must be an AST base type.
6251
6252 As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
6253 each result that matches instead of only on the first one.
6254
6255 Note: Recursively combined ForEachDescendant can cause many matches:
6256   cxxRecordDecl(forEachDescendant(cxxRecordDecl(
6257     forEachDescendant(cxxRecordDecl())
6258   )))
6259 will match 10 times (plus injected class name matches) on:
6260   class A { class B { class C { class D { class E {}; }; }; }; };
6261
6262 Usable as: Any Matcher
6263 </pre></td></tr>
6264
6265
6266 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEach0')"><a name="forEach0Anchor">forEach</a></td><td>Matcher&lt;*&gt;</td></tr>
6267 <tr><td colspan="4" class="doc" id="forEach0"><pre>Matches AST nodes that have child AST nodes that match the
6268 provided matcher.
6269
6270 Example matches X, Y, Y::X, Z::Y, Z::Y::X
6271   (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X")))
6272   class X {};
6273   class Y { class X {}; };  // Matches Y, because Y::X is a class of name X
6274                             // inside Y.
6275   class Z { class Y { class X {}; }; };  // Does not match Z.
6276
6277 ChildT must be an AST base type.
6278
6279 As opposed to 'has', 'forEach' will cause a match for each result that
6280 matches instead of only on the first one.
6281
6282 Usable as: Any Matcher
6283 </pre></td></tr>
6284
6285
6286 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasAncestor0')"><a name="hasAncestor0Anchor">hasAncestor</a></td><td>Matcher&lt;*&gt;</td></tr>
6287 <tr><td colspan="4" class="doc" id="hasAncestor0"><pre>Matches AST nodes that have an ancestor that matches the provided
6288 matcher.
6289
6290 Given
6291 void f() { if (true) { int x = 42; } }
6292 void g() { for (;;) { int x = 43; } }
6293 expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
6294
6295 Usable as: Any Matcher
6296 </pre></td></tr>
6297
6298
6299 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasDescendant0')"><a name="hasDescendant0Anchor">hasDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
6300 <tr><td colspan="4" class="doc" id="hasDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
6301 provided matcher.
6302
6303 Example matches X, Y, Z
6304     (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))
6305   class X {};  // Matches X, because X::X is a class of name X inside X.
6306   class Y { class X {}; };
6307   class Z { class Y { class X {}; }; };
6308
6309 DescendantT must be an AST base type.
6310
6311 Usable as: Any Matcher
6312 </pre></td></tr>
6313
6314
6315 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('has0')"><a name="has0Anchor">has</a></td><td>Matcher&lt;*&gt;</td></tr>
6316 <tr><td colspan="4" class="doc" id="has0"><pre>Matches AST nodes that have child AST nodes that match the
6317 provided matcher.
6318
6319 Example matches X, Y
6320   (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X")))
6321   class X {};  // Matches X, because X::X is a class of name X inside X.
6322   class Y { class X {}; };
6323   class Z { class Y { class X {}; }; };  // Does not match Z.
6324
6325 ChildT must be an AST base type.
6326
6327 Usable as: Any Matcher
6328 Note that has is direct matcher, so it also matches things like implicit
6329 casts and paren casts. If you are matching with expr then you should
6330 probably consider using ignoringParenImpCasts like:
6331 has(ignoringParenImpCasts(expr())).
6332 </pre></td></tr>
6333
6334
6335 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasParent0')"><a name="hasParent0Anchor">hasParent</a></td><td>Matcher&lt;*&gt;</td></tr>
6336 <tr><td colspan="4" class="doc" id="hasParent0"><pre>Matches AST nodes that have a parent that matches the provided
6337 matcher.
6338
6339 Given
6340 void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
6341 compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
6342
6343 Usable as: Any Matcher
6344 </pre></td></tr>
6345
6346
6347 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('invocation0')"><a name="invocation0Anchor">invocation</a></td><td>Matcher&lt;*&gt;...Matcher&lt;*&gt;</td></tr>
6348 <tr><td colspan="4" class="doc" id="invocation0"><pre>Matches function calls and constructor calls
6349
6350 Because CallExpr and CXXConstructExpr do not share a common
6351 base class with API accessing arguments etc, AST Matchers for code
6352 which should match both are typically duplicated. This matcher
6353 removes the need for duplication.
6354
6355 Given code
6356 struct ConstructorTakesInt
6357 {
6358   ConstructorTakesInt(int i) {}
6359 };
6360
6361 void callTakesInt(int i)
6362 {
6363 }
6364
6365 void doCall()
6366 {
6367   callTakesInt(42);
6368 }
6369
6370 void doConstruct()
6371 {
6372   ConstructorTakesInt cti(42);
6373 }
6374
6375 The matcher
6376 invocation(hasArgument(0, integerLiteral(equals(42))))
6377 matches the expression in both doCall and doConstruct
6378 </pre></td></tr>
6379
6380
6381 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('optionally0')"><a name="optionally0Anchor">optionally</a></td><td>Matcher&lt;*&gt;</td></tr>
6382 <tr><td colspan="4" class="doc" id="optionally0"><pre>Matches any node regardless of the submatcher.
6383
6384 However, optionally will retain any bindings generated by the submatcher.
6385 Useful when additional information which may or may not present about a main
6386 matching node is desired.
6387
6388 For example, in:
6389   class Foo {
6390     int bar;
6391   }
6392 The matcher:
6393   cxxRecordDecl(
6394     optionally(has(
6395       fieldDecl(hasName("bar")).bind("var")
6396   ))).bind("record")
6397 will produce a result binding for both "record" and "var".
6398 The matcher will produce a "record" binding for even if there is no data
6399 member named "bar" in that class.
6400
6401 Usable as: Any Matcher
6402 </pre></td></tr>
6403
6404
6405 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('traverse0')"><a name="traverse0Anchor">traverse</a></td><td>TraversalKind TK, Matcher&lt;*&gt;  InnerMatcher</td></tr>
6406 <tr><td colspan="4" class="doc" id="traverse0"><pre>Causes all nested matchers to be matched with the specified traversal kind.
6407
6408 Given
6409   void foo()
6410   {
6411       int i = 3.0;
6412   }
6413 The matcher
6414   traverse(TK_IgnoreUnlessSpelledInSource,
6415     varDecl(hasInitializer(floatLiteral().bind("init")))
6416   )
6417 matches the variable declaration with "init" bound to the "3.0".
6418 </pre></td></tr>
6419
6420
6421 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AbstractConditionalOperator.html">AbstractConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasCondition5')"><a name="hasCondition5Anchor">hasCondition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6422 <tr><td colspan="4" class="doc" id="hasCondition5"><pre>Matches the condition expression of an if statement, for loop,
6423 switch statement or conditional operator.
6424
6425 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
6426   if (true) {}
6427 </pre></td></tr>
6428
6429
6430 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AbstractConditionalOperator.html">AbstractConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasFalseExpression0')"><a name="hasFalseExpression0Anchor">hasFalseExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6431 <tr><td colspan="4" class="doc" id="hasFalseExpression0"><pre>Matches the false branch expression of a conditional operator
6432 (binary or ternary).
6433
6434 Example matches b
6435   condition ? a : b
6436   condition ?: b
6437 </pre></td></tr>
6438
6439
6440 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AbstractConditionalOperator.html">AbstractConditionalOperator</a>&gt;</td><td class="name" onclick="toggle('hasTrueExpression0')"><a name="hasTrueExpression0Anchor">hasTrueExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6441 <tr><td colspan="4" class="doc" id="hasTrueExpression0"><pre>Matches the true branch expression of a conditional operator.
6442
6443 Example 1 (conditional ternary operator): matches a
6444   condition ? a : b
6445
6446 Example 2 (conditional binary operator): matches opaqueValueExpr(condition)
6447   condition ?: b
6448 </pre></td></tr>
6449
6450
6451 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration15')"><a name="hasDeclaration15Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
6452 <tr><td colspan="4" class="doc" id="hasDeclaration15"><pre>Matches a node if the declaration associated with that node
6453 matches the given matcher.
6454
6455 The associated declaration is:
6456 - for type nodes, the declaration of the underlying type
6457 - for CallExpr, the declaration of the callee
6458 - for MemberExpr, the declaration of the referenced member
6459 - for CXXConstructExpr, the declaration of the constructor
6460 - for CXXNewExpr, the declaration of the operator new
6461 - for ObjCIvarExpr, the declaration of the ivar
6462
6463 For type nodes, hasDeclaration will generally match the declaration of the
6464 sugared type. Given
6465   class X {};
6466   typedef X Y;
6467   Y y;
6468 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
6469 typedefDecl. A common use case is to match the underlying, desugared type.
6470 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
6471   varDecl(hasType(hasUnqualifiedDesugaredType(
6472       recordType(hasDeclaration(decl())))))
6473 In this matcher, the decl will match the CXXRecordDecl of class X.
6474
6475 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
6476   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
6477   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
6478   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
6479   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
6480   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
6481   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
6482 </pre></td></tr>
6483
6484
6485 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasBase0')"><a name="hasBase0Anchor">hasBase</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6486 <tr><td colspan="4" class="doc" id="hasBase0"><pre>Matches the base expression of an array subscript expression.
6487
6488 Given
6489   int i[5];
6490   void f() { i[1] = 42; }
6491 arraySubscriptExpression(hasBase(implicitCastExpr(
6492     hasSourceExpression(declRefExpr()))))
6493   matches i[1] with the declRefExpr() matching i
6494 </pre></td></tr>
6495
6496
6497 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasIndex0')"><a name="hasIndex0Anchor">hasIndex</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6498 <tr><td colspan="4" class="doc" id="hasIndex0"><pre>Matches the index expression of an array subscript expression.
6499
6500 Given
6501   int i[5];
6502   void f() { i[1] = 42; }
6503 arraySubscriptExpression(hasIndex(integerLiteral()))
6504   matches i[1] with the integerLiteral() matching 1
6505 </pre></td></tr>
6506
6507
6508 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasLHS3')"><a name="hasLHS3Anchor">hasLHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6509 <tr><td colspan="4" class="doc" id="hasLHS3"><pre>Matches the left hand side of binary operator expressions.
6510
6511 Example matches a (matcher = binaryOperator(hasLHS()))
6512   a || b
6513 </pre></td></tr>
6514
6515
6516 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;</td><td class="name" onclick="toggle('hasRHS3')"><a name="hasRHS3Anchor">hasRHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6517 <tr><td colspan="4" class="doc" id="hasRHS3"><pre>Matches the right hand side of binary operator expressions.
6518
6519 Example matches b (matcher = binaryOperator(hasRHS()))
6520   a || b
6521 </pre></td></tr>
6522
6523
6524 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;</td><td class="name" onclick="toggle('hasElementType0')"><a name="hasElementType0Anchor">hasElementType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
6525 <tr><td colspan="4" class="doc" id="hasElementType0"><pre>Matches arrays and C99 complex types that have a specific element
6526 type.
6527
6528 Given
6529   struct A {};
6530   A a[7];
6531   int b[7];
6532 arrayType(hasElementType(builtinType()))
6533   matches "int b[7]"
6534
6535 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;
6536 </pre></td></tr>
6537
6538
6539 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;</td><td class="name" onclick="toggle('hasValueType0')"><a name="hasValueType0Anchor">hasValueType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
6540 <tr><td colspan="4" class="doc" id="hasValueType0"><pre>Matches atomic types with a specific value type.
6541
6542 Given
6543   _Atomic(int) i;
6544   _Atomic(float) f;
6545 atomicType(hasValueType(isInteger()))
6546  matches "_Atomic(int) i"
6547
6548 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
6549 </pre></td></tr>
6550
6551
6552 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;</td><td class="name" onclick="toggle('hasDeducedType0')"><a name="hasDeducedType0Anchor">hasDeducedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
6553 <tr><td colspan="4" class="doc" id="hasDeducedType0"><pre>Matches AutoType nodes where the deduced type is a specific type.
6554
6555 Note: There is no TypeLoc for the deduced type and thus no
6556 getDeducedLoc() matcher.
6557
6558 Given
6559   auto a = 1;
6560   auto b = 2.0;
6561 autoType(hasDeducedType(isInteger()))
6562   matches "auto a"
6563
6564 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;
6565 </pre></td></tr>
6566
6567
6568 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BaseUsingDecl.html">BaseUsingDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyUsingShadowDecl0')"><a name="hasAnyUsingShadowDecl0Anchor">hasAnyUsingShadowDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt; InnerMatcher</td></tr>
6569 <tr><td colspan="4" class="doc" id="hasAnyUsingShadowDecl0"><pre>Matches any using shadow declaration.
6570
6571 Given
6572   namespace X { void b(); }
6573   using X::b;
6574 usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
6575   matches using X::b </pre></td></tr>
6576
6577
6578 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasEitherOperand0')"><a name="hasEitherOperand0Anchor">hasEitherOperand</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6579 <tr><td colspan="4" class="doc" id="hasEitherOperand0"><pre>Matches if either the left hand side or the right hand side of a
6580 binary operator or fold expression matches.
6581 </pre></td></tr>
6582
6583
6584 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasLHS0')"><a name="hasLHS0Anchor">hasLHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6585 <tr><td colspan="4" class="doc" id="hasLHS0"><pre>Matches the left hand side of binary operator expressions.
6586
6587 Example matches a (matcher = binaryOperator(hasLHS()))
6588   a || b
6589 </pre></td></tr>
6590
6591
6592 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperands0')"><a name="hasOperands0Anchor">hasOperands</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher1, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher2</td></tr>
6593 <tr><td colspan="4" class="doc" id="hasOperands0"><pre>Matches if both matchers match with opposite sides of the binary operator
6594 or fold expression.
6595
6596 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
6597                                              integerLiteral(equals(2)))
6598   1 + 2 // Match
6599   2 + 1 // Match
6600   1 + 1 // No match
6601   2 + 2 // No match
6602 </pre></td></tr>
6603
6604
6605 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasRHS0')"><a name="hasRHS0Anchor">hasRHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6606 <tr><td colspan="4" class="doc" id="hasRHS0"><pre>Matches the right hand side of binary operator expressions.
6607
6608 Example matches b (matcher = binaryOperator(hasRHS()))
6609   a || b
6610 </pre></td></tr>
6611
6612
6613 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BindingDecl.html">BindingDecl</a>&gt;</td><td class="name" onclick="toggle('forDecomposition0')"><a name="forDecomposition0Anchor">forDecomposition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt; InnerMatcher</td></tr>
6614 <tr><td colspan="4" class="doc" id="forDecomposition0"><pre>Matches the DecompositionDecl the binding belongs to.
6615
6616 For example, in:
6617 void foo()
6618 {
6619     int arr[3];
6620     auto &amp;[f, s, t] = arr;
6621
6622     f = 42;
6623 }
6624 The matcher:
6625   bindingDecl(hasName("f"),
6626                 forDecomposition(decompositionDecl())
6627 matches 'f' in 'auto &amp;[f, s, t]'.
6628 </pre></td></tr>
6629
6630
6631 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyParameter2')"><a name="hasAnyParameter2Anchor">hasAnyParameter</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
6632 <tr><td colspan="4" class="doc" id="hasAnyParameter2"><pre>Matches any parameter of a function or an ObjC method declaration or a
6633 block.
6634
6635 Does not match the 'this' parameter of a method.
6636
6637 Given
6638   class X { void f(int x, int y, int z) {} };
6639 cxxMethodDecl(hasAnyParameter(hasName("y")))
6640   matches f(int x, int y, int z) {}
6641 with hasAnyParameter(...)
6642   matching int y
6643
6644 For ObjectiveC, given
6645   @interface I - (void) f:(int) y; @end
6646
6647 the matcher objcMethodDecl(hasAnyParameter(hasName("y")))
6648 matches the declaration of method f with hasParameter
6649 matching y.
6650
6651 For blocks, given
6652   b = ^(int y) { printf("%d", y) };
6653
6654 the matcher blockDecl(hasAnyParameter(hasName("y")))
6655 matches the declaration of the block b with hasParameter
6656 matching y.
6657 </pre></td></tr>
6658
6659
6660 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;</td><td class="name" onclick="toggle('hasParameter2')"><a name="hasParameter2Anchor">hasParameter</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
6661 <tr><td colspan="4" class="doc" id="hasParameter2"><pre>Matches the n'th parameter of a function or an ObjC method
6662 declaration or a block.
6663
6664 Given
6665   class X { void f(int x) {} };
6666 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
6667   matches f(int x) {}
6668 with hasParameter(...)
6669   matching int x
6670
6671 For ObjectiveC, given
6672   @interface I - (void) f:(int) y; @end
6673
6674 the matcher objcMethodDecl(hasParameter(0, hasName("y")))
6675 matches the declaration of method f with hasParameter
6676 matching y.
6677 </pre></td></tr>
6678
6679
6680 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc0')"><a name="hasTypeLoc0Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
6681 <tr><td colspan="4" class="doc" id="hasTypeLoc0"><pre>Matches if the type location of a node matches the inner matcher.
6682
6683 Examples:
6684   int x;
6685 declaratorDecl(hasTypeLoc(loc(asString("int"))))
6686   matches int x
6687
6688 auto x = int(3);
6689 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
6690   matches int(3)
6691
6692 struct Foo { Foo(int, int); };
6693 auto x = Foo(1, 2);
6694 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
6695   matches Foo(1, 2)
6696
6697 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
6698   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
6699   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
6700   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
6701   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
6702   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
6703   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
6704   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
6705 </pre></td></tr>
6706
6707
6708 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;</td><td class="name" onclick="toggle('pointee0')"><a name="pointee0Anchor">pointee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
6709 <tr><td colspan="4" class="doc" id="pointee0"><pre>Narrows PointerType (and similar) matchers to those where the
6710 pointee matches a given matcher.
6711
6712 Given
6713   int *a;
6714   int const *b;
6715   float const *f;
6716 pointerType(pointee(isConstQualified(), isInteger()))
6717   matches "int const *b"
6718
6719 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
6720   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
6721 </pre></td></tr>
6722
6723
6724 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc1')"><a name="hasTypeLoc1Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
6725 <tr><td colspan="4" class="doc" id="hasTypeLoc1"><pre>Matches if the type location of a node matches the inner matcher.
6726
6727 Examples:
6728   int x;
6729 declaratorDecl(hasTypeLoc(loc(asString("int"))))
6730   matches int x
6731
6732 auto x = int(3);
6733 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
6734   matches int(3)
6735
6736 struct Foo { Foo(int, int); };
6737 auto x = Foo(1, 2);
6738 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
6739   matches Foo(1, 2)
6740
6741 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
6742   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
6743   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
6744   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
6745   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
6746   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
6747   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
6748   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
6749 </pre></td></tr>
6750
6751
6752 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('hasType8')"><a name="hasType8Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
6753 <tr><td colspan="4" class="doc" id="hasType8"><pre>Overloaded to match the declaration of the expression's or value
6754 declaration's type.
6755
6756 In case of a value declaration (for example a variable declaration),
6757 this resolves one layer of indirection. For example, in the value
6758 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
6759 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
6760 declaration of x.
6761
6762 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
6763             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
6764             and friend class X (matcher = friendDecl(hasType("X"))
6765             and public virtual X (matcher = cxxBaseSpecifier(hasType(
6766                                               cxxRecordDecl(hasName("X"))))
6767  class X {};
6768  void y(X &amp;x) { x; X z; }
6769  class Y { friend class X; };
6770  class Z : public virtual X {};
6771
6772 Example matches class Derived
6773 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
6774 class Base {};
6775 class Derived : Base {};
6776
6777 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;,
6778 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
6779 </pre></td></tr>
6780
6781
6782 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('hasType4')"><a name="hasType4Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
6783 <tr><td colspan="4" class="doc" id="hasType4"><pre>Matches if the expression's or declaration's type matches a type
6784 matcher.
6785
6786 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
6787             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
6788             and U (matcher = typedefDecl(hasType(asString("int")))
6789             and friend class X (matcher = friendDecl(hasType("X"))
6790             and public virtual X (matcher = cxxBaseSpecifier(hasType(
6791                                               asString("class X")))
6792  class X {};
6793  void y(X &amp;x) { x; X z; }
6794  typedef int U;
6795  class Y { friend class X; };
6796  class Z : public virtual X {};
6797 </pre></td></tr>
6798
6799
6800 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('forEachArgumentWithParam1')"><a name="forEachArgumentWithParam1Anchor">forEachArgumentWithParam</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; ArgMatcher, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; ParamMatcher</td></tr>
6801 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam1"><pre>Matches all arguments and their respective ParmVarDecl.
6802
6803 Given
6804   void f(int i);
6805   int y;
6806   f(y);
6807 callExpr(
6808   forEachArgumentWithParam(
6809     declRefExpr(to(varDecl(hasName("y")))),
6810     parmVarDecl(hasType(isInteger()))
6811 ))
6812   matches f(y);
6813 with declRefExpr(...)
6814   matching int y
6815 and parmVarDecl(...)
6816   matching int i
6817 </pre></td></tr>
6818
6819
6820 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('forEachArgumentWithParamType1')"><a name="forEachArgumentWithParamType1Anchor">forEachArgumentWithParamType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; ArgMatcher, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; ParamMatcher</td></tr>
6821 <tr><td colspan="4" class="doc" id="forEachArgumentWithParamType1"><pre>Matches all arguments and their respective types for a CallExpr or
6822 CXXConstructExpr. It is very similar to forEachArgumentWithParam but
6823 it works on calls through function pointers as well.
6824
6825 The difference is, that function pointers do not provide access to a
6826 ParmVarDecl, but only the QualType for each argument.
6827
6828 Given
6829   void f(int i);
6830   int y;
6831   f(y);
6832   void (*f_ptr)(int) = f;
6833   f_ptr(y);
6834 callExpr(
6835   forEachArgumentWithParamType(
6836     declRefExpr(to(varDecl(hasName("y")))),
6837     qualType(isInteger()).bind("type)
6838 ))
6839   matches f(y) and f_ptr(y)
6840 with declRefExpr(...)
6841   matching int y
6842 and qualType(...)
6843   matching int
6844 </pre></td></tr>
6845
6846
6847 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyArgument1')"><a name="hasAnyArgument1Anchor">hasAnyArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6848 <tr><td colspan="4" class="doc" id="hasAnyArgument1"><pre>Matches any argument of a call expression or a constructor call
6849 expression, or an ObjC-message-send expression.
6850
6851 Given
6852   void x(int, int, int) { int y; x(1, y, 42); }
6853 callExpr(hasAnyArgument(declRefExpr()))
6854   matches x(1, y, 42)
6855 with hasAnyArgument(...)
6856   matching y
6857
6858 For ObjectiveC, given
6859   @interface I - (void) f:(int) y; @end
6860   void foo(I *i) { [i f:12]; }
6861 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
6862   matches [i f:12]
6863 </pre></td></tr>
6864
6865
6866 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument1')"><a name="hasArgument1Anchor">hasArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6867 <tr><td colspan="4" class="doc" id="hasArgument1"><pre>Matches the n'th argument of a call expression or a constructor
6868 call expression.
6869
6870 Example matches y in x(y)
6871     (matcher = callExpr(hasArgument(0, declRefExpr())))
6872   void x(int) { int y; x(y); }
6873 </pre></td></tr>
6874
6875
6876 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration13')"><a name="hasDeclaration13Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
6877 <tr><td colspan="4" class="doc" id="hasDeclaration13"><pre>Matches a node if the declaration associated with that node
6878 matches the given matcher.
6879
6880 The associated declaration is:
6881 - for type nodes, the declaration of the underlying type
6882 - for CallExpr, the declaration of the callee
6883 - for MemberExpr, the declaration of the referenced member
6884 - for CXXConstructExpr, the declaration of the constructor
6885 - for CXXNewExpr, the declaration of the operator new
6886 - for ObjCIvarExpr, the declaration of the ivar
6887
6888 For type nodes, hasDeclaration will generally match the declaration of the
6889 sugared type. Given
6890   class X {};
6891   typedef X Y;
6892   Y y;
6893 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
6894 typedefDecl. A common use case is to match the underlying, desugared type.
6895 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
6896   varDecl(hasType(hasUnqualifiedDesugaredType(
6897       recordType(hasDeclaration(decl())))))
6898 In this matcher, the decl will match the CXXRecordDecl of class X.
6899
6900 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
6901   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
6902   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
6903   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
6904   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
6905   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
6906   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
6907 </pre></td></tr>
6908
6909
6910 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('forEachConstructorInitializer0')"><a name="forEachConstructorInitializer0Anchor">forEachConstructorInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt; InnerMatcher</td></tr>
6911 <tr><td colspan="4" class="doc" id="forEachConstructorInitializer0"><pre>Matches each constructor initializer in a constructor definition.
6912
6913 Given
6914   class A { A() : i(42), j(42) {} int i; int j; };
6915 cxxConstructorDecl(forEachConstructorInitializer(
6916   forField(decl().bind("x"))
6917 ))
6918   will trigger two matches, binding for 'i' and 'j' respectively.
6919 </pre></td></tr>
6920
6921
6922 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyConstructorInitializer0')"><a name="hasAnyConstructorInitializer0Anchor">hasAnyConstructorInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt; InnerMatcher</td></tr>
6923 <tr><td colspan="4" class="doc" id="hasAnyConstructorInitializer0"><pre>Matches a constructor initializer.
6924
6925 Given
6926   struct Foo {
6927     Foo() : foo_(1) { }
6928     int foo_;
6929   };
6930 cxxRecordDecl(has(cxxConstructorDecl(
6931   hasAnyConstructorInitializer(anything())
6932 )))
6933   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
6934 </pre></td></tr>
6935
6936
6937 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('forField0')"><a name="forField0Anchor">forField</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt; InnerMatcher</td></tr>
6938 <tr><td colspan="4" class="doc" id="forField0"><pre>Matches the field declaration of a constructor initializer.
6939
6940 Given
6941   struct Foo {
6942     Foo() : foo_(1) { }
6943     int foo_;
6944   };
6945 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
6946     forField(hasName("foo_"))))))
6947   matches Foo
6948 with forField matching foo_
6949 </pre></td></tr>
6950
6951
6952 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc2')"><a name="hasTypeLoc2Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
6953 <tr><td colspan="4" class="doc" id="hasTypeLoc2"><pre>Matches if the type location of a node matches the inner matcher.
6954
6955 Examples:
6956   int x;
6957 declaratorDecl(hasTypeLoc(loc(asString("int"))))
6958   matches int x
6959
6960 auto x = int(3);
6961 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
6962   matches int(3)
6963
6964 struct Foo { Foo(int, int); };
6965 auto x = Foo(1, 2);
6966 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
6967   matches Foo(1, 2)
6968
6969 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
6970   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
6971   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
6972   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
6973   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
6974   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
6975   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
6976   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
6977 </pre></td></tr>
6978
6979
6980 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('withInitializer0')"><a name="withInitializer0Anchor">withInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6981 <tr><td colspan="4" class="doc" id="withInitializer0"><pre>Matches the initializer expression of a constructor initializer.
6982
6983 Given
6984   struct Foo {
6985     Foo() : foo_(1) { }
6986     int foo_;
6987   };
6988 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
6989     withInitializer(integerLiteral(equals(1)))))))
6990   matches Foo
6991 with withInitializer matching (1)
6992 </pre></td></tr>
6993
6994
6995 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasObjectExpression2')"><a name="hasObjectExpression2Anchor">hasObjectExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
6996 <tr><td colspan="4" class="doc" id="hasObjectExpression2"><pre>Matches a member expression where the object expression is matched by a
6997 given matcher. Implicit object expressions are included; that is, it matches
6998 use of implicit `this`.
6999
7000 Given
7001   struct X {
7002     int m;
7003     int f(X x) { x.m; return m; }
7004   };
7005 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))
7006   matches `x.m`, but not `m`; however,
7007 memberExpr(hasObjectExpression(hasType(pointsTo(
7008      cxxRecordDecl(hasName("X"))))))
7009   matches `m` (aka. `this-&gt;m`), but not `x.m`.
7010 </pre></td></tr>
7011
7012
7013 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('callee1')"><a name="callee1Anchor">callee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
7014 <tr><td colspan="4" class="doc" id="callee1"><pre>Matches if the call or fold expression's callee expression matches.
7015
7016 Given
7017   class Y { void x() { this-&gt;x(); x(); Y y; y.x(); } };
7018   void f() { f(); }
7019 callExpr(callee(expr()))
7020   matches this-&gt;x(), x(), y.x(), f()
7021 with callee(...)
7022   matching this-&gt;x, x, y.x, f respectively
7023
7024 Given
7025   template &lt;typename... Args&gt;
7026   auto sum(Args... args) {
7027       return (0 + ... + args);
7028   }
7029
7030   template &lt;typename... Args&gt;
7031   auto multiply(Args... args) {
7032       return (args * ... * 1);
7033   }
7034 cxxFoldExpr(callee(expr()))
7035   matches (args * ... * 1)
7036 with callee(...)
7037   matching *
7038
7039 Note: Callee cannot take the more general internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;
7040 because this introduces ambiguous overloads with calls to Callee taking a
7041 internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, as the matcher hierarchy is purely
7042 implemented in terms of implicit casts.
7043 </pre></td></tr>
7044
7045
7046 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasEitherOperand2')"><a name="hasEitherOperand2Anchor">hasEitherOperand</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7047 <tr><td colspan="4" class="doc" id="hasEitherOperand2"><pre>Matches if either the left hand side or the right hand side of a
7048 binary operator or fold expression matches.
7049 </pre></td></tr>
7050
7051
7052 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasFoldInit0')"><a name="hasFoldInit0Anchor">hasFoldInit</a></td><td>ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMacher</td></tr>
7053 <tr><td colspan="4" class="doc" id="hasFoldInit0"><pre>Matches the operand that does not contain the parameter pack.
7054
7055 Example matches `(0 + ... + args)` and `(args * ... * 1)`
7056     (matcher = cxxFoldExpr(hasFoldInit(expr())))
7057   with hasFoldInit(...)
7058     matching `0` and `1` respectively
7059   template &lt;typename... Args&gt;
7060   auto sum(Args... args) {
7061       return (0 + ... + args);
7062   }
7063
7064   template &lt;typename... Args&gt;
7065   auto multiply(Args... args) {
7066       return (args * ... * 1);
7067   }
7068 </pre></td></tr>
7069
7070
7071 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasLHS4')"><a name="hasLHS4Anchor">hasLHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7072 <tr><td colspan="4" class="doc" id="hasLHS4"><pre>Matches the left hand side of binary operator expressions.
7073
7074 Example matches a (matcher = binaryOperator(hasLHS()))
7075   a || b
7076 </pre></td></tr>
7077
7078
7079 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasOperands2')"><a name="hasOperands2Anchor">hasOperands</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher1, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher2</td></tr>
7080 <tr><td colspan="4" class="doc" id="hasOperands2"><pre>Matches if both matchers match with opposite sides of the binary operator
7081 or fold expression.
7082
7083 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
7084                                              integerLiteral(equals(2)))
7085   1 + 2 // Match
7086   2 + 1 // Match
7087   1 + 1 // No match
7088   2 + 2 // No match
7089 </pre></td></tr>
7090
7091
7092 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasPattern0')"><a name="hasPattern0Anchor">hasPattern</a></td><td>ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMacher</td></tr>
7093 <tr><td colspan="4" class="doc" id="hasPattern0"><pre>Matches the operand that contains the parameter pack.
7094
7095 Example matches `(0 + ... + args)`
7096     (matcher = cxxFoldExpr(hasPattern(expr())))
7097   with hasPattern(...)
7098     matching `args`
7099   template &lt;typename... Args&gt;
7100   auto sum(Args... args) {
7101       return (0 + ... + args);
7102   }
7103
7104   template &lt;typename... Args&gt;
7105   auto multiply(Args... args) {
7106       return (args * ... * 1);
7107   }
7108 </pre></td></tr>
7109
7110
7111 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFoldExpr.html">CXXFoldExpr</a>&gt;</td><td class="name" onclick="toggle('hasRHS4')"><a name="hasRHS4Anchor">hasRHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7112 <tr><td colspan="4" class="doc" id="hasRHS4"><pre>Matches the right hand side of binary operator expressions.
7113
7114 Example matches b (matcher = binaryOperator(hasRHS()))
7115   a || b
7116 </pre></td></tr>
7117
7118
7119 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody3')"><a name="hasBody3Anchor">hasBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
7120 <tr><td colspan="4" class="doc" id="hasBody3"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
7121 definition that has a given body. Note that in case of functions or
7122 coroutines this matcher only matches the definition itself and not the
7123 other declarations of the same function or coroutine.
7124
7125 Given
7126   for (;;) {}
7127 forStmt(hasBody(compoundStmt()))
7128   matches 'for (;;) {}'
7129 with compoundStmt()
7130   matching '{}'
7131
7132 Given
7133   void f();
7134   void f() {}
7135 functionDecl(hasBody(compoundStmt()))
7136   matches 'void f() {}'
7137 with compoundStmt()
7138   matching '{}'
7139   but does not match 'void f();'
7140 </pre></td></tr>
7141
7142
7143 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasInitStatement2')"><a name="hasInitStatement2Anchor">hasInitStatement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
7144 <tr><td colspan="4" class="doc" id="hasInitStatement2"><pre>Matches selection statements with initializer.
7145
7146 Given:
7147  void foo() {
7148    if (int i = foobar(); i &gt; 0) {}
7149    switch (int i = foobar(); i) {}
7150    for (auto&amp; a = get_range(); auto&amp; x : a) {}
7151  }
7152  void bar() {
7153    if (foobar() &gt; 0) {}
7154    switch (foobar()) {}
7155    for (auto&amp; x : get_range()) {}
7156  }
7157 ifStmt(hasInitStatement(anything()))
7158   matches the if statement in foo but not in bar.
7159 switchStmt(hasInitStatement(anything()))
7160   matches the switch statement in foo but not in bar.
7161 cxxForRangeStmt(hasInitStatement(anything()))
7162   matches the range for statement in foo but not in bar.
7163 </pre></td></tr>
7164
7165
7166 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasLoopVariable0')"><a name="hasLoopVariable0Anchor">hasLoopVariable</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt; InnerMatcher</td></tr>
7167 <tr><td colspan="4" class="doc" id="hasLoopVariable0"><pre>Matches the initialization statement of a for loop.
7168
7169 Example:
7170     forStmt(hasLoopVariable(anything()))
7171 matches 'int x' in
7172     for (int x : a) { }
7173 </pre></td></tr>
7174
7175
7176 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;</td><td class="name" onclick="toggle('hasRangeInit0')"><a name="hasRangeInit0Anchor">hasRangeInit</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7177 <tr><td colspan="4" class="doc" id="hasRangeInit0"><pre>Matches the range initialization statement of a for loop.
7178
7179 Example:
7180     forStmt(hasRangeInit(anything()))
7181 matches 'a' in
7182     for (int x : a) { }
7183 </pre></td></tr>
7184
7185
7186 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc3')"><a name="hasTypeLoc3Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
7187 <tr><td colspan="4" class="doc" id="hasTypeLoc3"><pre>Matches if the type location of a node matches the inner matcher.
7188
7189 Examples:
7190   int x;
7191 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7192   matches int x
7193
7194 auto x = int(3);
7195 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7196   matches int(3)
7197
7198 struct Foo { Foo(int, int); };
7199 auto x = Foo(1, 2);
7200 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7201   matches Foo(1, 2)
7202
7203 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
7204   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
7205   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
7206   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7207   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7208   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
7209   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
7210   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7211 </pre></td></tr>
7212
7213
7214 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('onImplicitObjectArgument0')"><a name="onImplicitObjectArgument0Anchor">onImplicitObjectArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7215 <tr><td colspan="4" class="doc" id="onImplicitObjectArgument0"><pre>Matches on the implicit object argument of a member call expression. Unlike
7216 `on`, matches the argument directly without stripping away anything.
7217
7218 Given
7219   class Y { public: void m(); };
7220   Y g();
7221   class X : public Y { void g(); };
7222   void z(Y y, X x) { y.m(); x.m(); x.g(); (g()).m(); }
7223 cxxMemberCallExpr(onImplicitObjectArgument(hasType(
7224     cxxRecordDecl(hasName("Y")))))
7225   matches `y.m()`, `x.m()` and (g()).m(), but not `x.g()`.
7226 cxxMemberCallExpr(on(callExpr()))
7227   does not match `(g()).m()`, because the parens are not ignored.
7228
7229 FIXME: Overload to allow directly matching types?
7230 </pre></td></tr>
7231
7232
7233 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('on0')"><a name="on0Anchor">on</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7234 <tr><td colspan="4" class="doc" id="on0"><pre>Matches on the implicit object argument of a member call expression, after
7235 stripping off any parentheses or implicit casts.
7236
7237 Given
7238   class Y { public: void m(); };
7239   Y g();
7240   class X : public Y {};
7241   void z(Y y, X x) { y.m(); (g()).m(); x.m(); }
7242 cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y")))))
7243   matches `y.m()` and `(g()).m()`.
7244 cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("X")))))
7245   matches `x.m()`.
7246 cxxMemberCallExpr(on(callExpr()))
7247   matches `(g()).m()`.
7248
7249 FIXME: Overload to allow directly matching types?
7250 </pre></td></tr>
7251
7252
7253 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType1')"><a name="thisPointerType1Anchor">thisPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
7254 <tr><td colspan="4" class="doc" id="thisPointerType1"><pre>Overloaded to match the type's declaration.
7255 </pre></td></tr>
7256
7257
7258 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType0')"><a name="thisPointerType0Anchor">thisPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
7259 <tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the type of the expression's implicit object argument either
7260 matches the InnerMatcher, or is a pointer to a type that matches the
7261 InnerMatcher.
7262
7263 Given
7264   class Y { public: void m(); };
7265   class X : public Y { void g(); };
7266   void z() { Y y; y.m(); Y *p; p-&gt;m(); X x; x.m(); x.g(); }
7267 cxxMemberCallExpr(thisPointerType(hasDeclaration(
7268     cxxRecordDecl(hasName("Y")))))
7269   matches `y.m()`, `p-&gt;m()` and `x.m()`.
7270 cxxMemberCallExpr(thisPointerType(hasDeclaration(
7271     cxxRecordDecl(hasName("X")))))
7272   matches `x.g()`.
7273 </pre></td></tr>
7274
7275
7276 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('forEachOverridden0')"><a name="forEachOverridden0Anchor">forEachOverridden</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
7277 <tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overridden by the given method. This matcher may
7278 produce multiple matches.
7279
7280 Given
7281   class A { virtual void f(); };
7282   class B : public A { void f(); };
7283   class C : public B { void f(); };
7284 cxxMethodDecl(ofClass(hasName("C")),
7285               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
7286   matches once, with "b" binding "A::f" and "d" binding "C::f" (Note
7287   that B::f is not overridden by C::f).
7288
7289 The check can produce multiple matches in case of multiple inheritance, e.g.
7290   class A1 { virtual void f(); };
7291   class A2 { virtual void f(); };
7292   class C : public A1, public A2 { void f(); };
7293 cxxMethodDecl(ofClass(hasName("C")),
7294               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
7295   matches twice, once with "b" binding "A1::f" and "d" binding "C::f", and
7296   once with "b" binding "A2::f" and "d" binding "C::f".
7297 </pre></td></tr>
7298
7299
7300 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('ofClass0')"><a name="ofClass0Anchor">ofClass</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt; InnerMatcher</td></tr>
7301 <tr><td colspan="4" class="doc" id="ofClass0"><pre>Matches the class declaration that the given method declaration
7302 belongs to.
7303
7304 FIXME: Generalize this for other kinds of declarations.
7305 FIXME: What other kind of declarations would we need to generalize
7306 this to?
7307
7308 Example matches A() in the last line
7309     (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
7310         ofClass(hasName("A"))))))
7311   class A {
7312    public:
7313     A();
7314   };
7315   A a = A();
7316 </pre></td></tr>
7317
7318
7319 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyPlacementArg0')"><a name="hasAnyPlacementArg0Anchor">hasAnyPlacementArg</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7320 <tr><td colspan="4" class="doc" id="hasAnyPlacementArg0"><pre>Matches any placement new expression arguments.
7321
7322 Given:
7323   MyClass *p1 = new (Storage) MyClass();
7324 cxxNewExpr(hasAnyPlacementArg(anything()))
7325   matches the expression 'new (Storage, 16) MyClass()'.
7326 </pre></td></tr>
7327
7328
7329 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('hasArraySize0')"><a name="hasArraySize0Anchor">hasArraySize</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7330 <tr><td colspan="4" class="doc" id="hasArraySize0"><pre>Matches array new expressions with a given array size.
7331
7332 Given:
7333   MyClass *p1 = new MyClass[10];
7334 cxxNewExpr(hasArraySize(integerLiteral(equals(10))))
7335   matches the expression 'new MyClass[10]'.
7336 </pre></td></tr>
7337
7338
7339 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration12')"><a name="hasDeclaration12Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
7340 <tr><td colspan="4" class="doc" id="hasDeclaration12"><pre>Matches a node if the declaration associated with that node
7341 matches the given matcher.
7342
7343 The associated declaration is:
7344 - for type nodes, the declaration of the underlying type
7345 - for CallExpr, the declaration of the callee
7346 - for MemberExpr, the declaration of the referenced member
7347 - for CXXConstructExpr, the declaration of the constructor
7348 - for CXXNewExpr, the declaration of the operator new
7349 - for ObjCIvarExpr, the declaration of the ivar
7350
7351 For type nodes, hasDeclaration will generally match the declaration of the
7352 sugared type. Given
7353   class X {};
7354   typedef X Y;
7355   Y y;
7356 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
7357 typedefDecl. A common use case is to match the underlying, desugared type.
7358 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
7359   varDecl(hasType(hasUnqualifiedDesugaredType(
7360       recordType(hasDeclaration(decl())))))
7361 In this matcher, the decl will match the CXXRecordDecl of class X.
7362
7363 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
7364   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
7365   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
7366   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
7367   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
7368   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
7369   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
7370 </pre></td></tr>
7371
7372
7373 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('hasPlacementArg0')"><a name="hasPlacementArg0Anchor">hasPlacementArg</a></td><td>unsigned Index, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7374 <tr><td colspan="4" class="doc" id="hasPlacementArg0"><pre>Matches placement new expression arguments.
7375
7376 Given:
7377   MyClass *p1 = new (Storage, 16) MyClass();
7378 cxxNewExpr(hasPlacementArg(1, integerLiteral(equals(16))))
7379   matches the expression 'new (Storage, 16) MyClass()'.
7380 </pre></td></tr>
7381
7382
7383 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc4')"><a name="hasTypeLoc4Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
7384 <tr><td colspan="4" class="doc" id="hasTypeLoc4"><pre>Matches if the type location of a node matches the inner matcher.
7385
7386 Examples:
7387   int x;
7388 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7389   matches int x
7390
7391 auto x = int(3);
7392 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7393   matches int(3)
7394
7395 struct Foo { Foo(int, int); };
7396 auto x = Foo(1, 2);
7397 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7398   matches Foo(1, 2)
7399
7400 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
7401   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
7402   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
7403   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7404   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7405   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
7406   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
7407   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7408 </pre></td></tr>
7409
7410
7411 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasEitherOperand1')"><a name="hasEitherOperand1Anchor">hasEitherOperand</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7412 <tr><td colspan="4" class="doc" id="hasEitherOperand1"><pre>Matches if either the left hand side or the right hand side of a
7413 binary operator or fold expression matches.
7414 </pre></td></tr>
7415
7416
7417 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasLHS1')"><a name="hasLHS1Anchor">hasLHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7418 <tr><td colspan="4" class="doc" id="hasLHS1"><pre>Matches the left hand side of binary operator expressions.
7419
7420 Example matches a (matcher = binaryOperator(hasLHS()))
7421   a || b
7422 </pre></td></tr>
7423
7424
7425 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasOperands1')"><a name="hasOperands1Anchor">hasOperands</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher1, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher2</td></tr>
7426 <tr><td colspan="4" class="doc" id="hasOperands1"><pre>Matches if both matchers match with opposite sides of the binary operator
7427 or fold expression.
7428
7429 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
7430                                              integerLiteral(equals(2)))
7431   1 + 2 // Match
7432   2 + 1 // Match
7433   1 + 1 // No match
7434   2 + 2 // No match
7435 </pre></td></tr>
7436
7437
7438 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasRHS1')"><a name="hasRHS1Anchor">hasRHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7439 <tr><td colspan="4" class="doc" id="hasRHS1"><pre>Matches the right hand side of binary operator expressions.
7440
7441 Example matches b (matcher = binaryOperator(hasRHS()))
7442   a || b
7443 </pre></td></tr>
7444
7445
7446 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasUnaryOperand1')"><a name="hasUnaryOperand1Anchor">hasUnaryOperand</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7447 <tr><td colspan="4" class="doc" id="hasUnaryOperand1"><pre>Matches if the operand of a unary operator matches.
7448
7449 Example matches true (matcher = hasUnaryOperand(
7450                                   cxxBoolLiteral(equals(true))))
7451   !true
7452 </pre></td></tr>
7453
7454
7455 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyBase0')"><a name="hasAnyBase0Anchor">hasAnyBase</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt; BaseSpecMatcher</td></tr>
7456 <tr><td colspan="4" class="doc" id="hasAnyBase0"><pre>Matches C++ classes that have a direct or indirect base matching BaseSpecMatcher.
7457
7458 Example:
7459 matcher hasAnyBase(hasType(cxxRecordDecl(hasName("SpecialBase"))))
7460   class Foo;
7461   class Bar : Foo {};
7462   class Baz : Bar {};
7463   class SpecialBase;
7464   class Proxy : SpecialBase {};  // matches Proxy
7465   class IndirectlyDerived : Proxy {};  //matches IndirectlyDerived
7466
7467 FIXME: Refactor this and isDerivedFrom to reuse implementation.
7468 </pre></td></tr>
7469
7470
7471 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasDirectBase0')"><a name="hasDirectBase0Anchor">hasDirectBase</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt; BaseSpecMatcher</td></tr>
7472 <tr><td colspan="4" class="doc" id="hasDirectBase0"><pre>Matches C++ classes that have a direct base matching BaseSpecMatcher.
7473
7474 Example:
7475 matcher hasDirectBase(hasType(cxxRecordDecl(hasName("SpecialBase"))))
7476   class Foo;
7477   class Bar : Foo {};
7478   class Baz : Bar {};
7479   class SpecialBase;
7480   class Proxy : SpecialBase {};  // matches Proxy
7481   class IndirectlyDerived : Proxy {};  // doesn't match
7482 </pre></td></tr>
7483
7484
7485 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasMethod0')"><a name="hasMethod0Anchor">hasMethod</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
7486 <tr><td colspan="4" class="doc" id="hasMethod0"><pre>Matches the first method of a class or struct that satisfies InnerMatcher.
7487
7488 Given:
7489   class A { void func(); };
7490   class B { void member(); };
7491
7492 cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
7493 A but not B.
7494 </pre></td></tr>
7495
7496
7497 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom0')"><a name="isDerivedFrom0Anchor">isDerivedFrom</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
7498 <tr><td colspan="4" class="doc" id="isDerivedFrom0"><pre>Matches C++ classes that are directly or indirectly derived from a class
7499 matching Base, or Objective-C classes that directly or indirectly
7500 subclass a class matching Base.
7501
7502 Note that a class is not considered to be derived from itself.
7503
7504 Example matches Y, Z, C (Base == hasName("X"))
7505   class X;
7506   class Y : public X {};  // directly derived
7507   class Z : public Y {};  // indirectly derived
7508   typedef X A;
7509   typedef A B;
7510   class C : public B {};  // derived from a typedef of X
7511
7512 In the following example, Bar matches isDerivedFrom(hasName("X")):
7513   class Foo;
7514   typedef Foo X;
7515   class Bar : public Foo {};  // derived from a type that X is a typedef of
7516
7517 In the following example, Bar matches isDerivedFrom(hasName("NSObject"))
7518   @interface NSObject @end
7519   @interface Bar : NSObject @end
7520
7521 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;
7522 </pre></td></tr>
7523
7524
7525 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDirectlyDerivedFrom0')"><a name="isDirectlyDerivedFrom0Anchor">isDirectlyDerivedFrom</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
7526 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom0"><pre>Matches C++ or Objective-C classes that are directly derived from a class
7527 matching Base.
7528
7529 Note that a class is not considered to be derived from itself.
7530
7531 Example matches Y, C (Base == hasName("X"))
7532   class X;
7533   class Y : public X {};  // directly derived
7534   class Z : public Y {};  // indirectly derived
7535   typedef X A;
7536   typedef A B;
7537   class C : public B {};  // derived from a typedef of X
7538
7539 In the following example, Bar matches isDerivedFrom(hasName("X")):
7540   class Foo;
7541   typedef Foo X;
7542   class Bar : public Foo {};  // derived from a type that X is a typedef of
7543 </pre></td></tr>
7544
7545
7546 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom0')"><a name="isSameOrDerivedFrom0Anchor">isSameOrDerivedFrom</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
7547 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom0"><pre>Similar to isDerivedFrom(), but also matches classes that directly
7548 match Base.
7549 </pre></td></tr>
7550
7551
7552 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasEitherOperand3')"><a name="hasEitherOperand3Anchor">hasEitherOperand</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7553 <tr><td colspan="4" class="doc" id="hasEitherOperand3"><pre>Matches if either the left hand side or the right hand side of a
7554 binary operator or fold expression matches.
7555 </pre></td></tr>
7556
7557
7558 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasLHS2')"><a name="hasLHS2Anchor">hasLHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7559 <tr><td colspan="4" class="doc" id="hasLHS2"><pre>Matches the left hand side of binary operator expressions.
7560
7561 Example matches a (matcher = binaryOperator(hasLHS()))
7562   a || b
7563 </pre></td></tr>
7564
7565
7566 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperands3')"><a name="hasOperands3Anchor">hasOperands</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher1, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; Matcher2</td></tr>
7567 <tr><td colspan="4" class="doc" id="hasOperands3"><pre>Matches if both matchers match with opposite sides of the binary operator
7568 or fold expression.
7569
7570 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
7571                                              integerLiteral(equals(2)))
7572   1 + 2 // Match
7573   2 + 1 // Match
7574   1 + 1 // No match
7575   2 + 2 // No match
7576 </pre></td></tr>
7577
7578
7579 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRewrittenBinaryOperator.html">CXXRewrittenBinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasRHS2')"><a name="hasRHS2Anchor">hasRHS</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7580 <tr><td colspan="4" class="doc" id="hasRHS2"><pre>Matches the right hand side of binary operator expressions.
7581
7582 Example matches b (matcher = binaryOperator(hasRHS()))
7583   a || b
7584 </pre></td></tr>
7585
7586
7587 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc5')"><a name="hasTypeLoc5Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
7588 <tr><td colspan="4" class="doc" id="hasTypeLoc5"><pre>Matches if the type location of a node matches the inner matcher.
7589
7590 Examples:
7591   int x;
7592 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7593   matches int x
7594
7595 auto x = int(3);
7596 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7597   matches int(3)
7598
7599 struct Foo { Foo(int, int); };
7600 auto x = Foo(1, 2);
7601 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7602   matches Foo(1, 2)
7603
7604 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
7605   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
7606   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
7607   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7608   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7609   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
7610   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
7611   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7612 </pre></td></tr>
7613
7614
7615 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyArgument2')"><a name="hasAnyArgument2Anchor">hasAnyArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7616 <tr><td colspan="4" class="doc" id="hasAnyArgument2"><pre>Matches any argument of a call expression or a constructor call
7617 expression, or an ObjC-message-send expression.
7618
7619 Given
7620   void x(int, int, int) { int y; x(1, y, 42); }
7621 callExpr(hasAnyArgument(declRefExpr()))
7622   matches x(1, y, 42)
7623 with hasAnyArgument(...)
7624   matching y
7625
7626 For ObjectiveC, given
7627   @interface I - (void) f:(int) y; @end
7628   void foo(I *i) { [i f:12]; }
7629 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
7630   matches [i f:12]
7631 </pre></td></tr>
7632
7633
7634 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument2')"><a name="hasArgument2Anchor">hasArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7635 <tr><td colspan="4" class="doc" id="hasArgument2"><pre>Matches the n'th argument of a call expression or a constructor
7636 call expression.
7637
7638 Example matches y in x(y)
7639     (matcher = callExpr(hasArgument(0, declRefExpr())))
7640   void x(int) { int y; x(y); }
7641 </pre></td></tr>
7642
7643
7644 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc6')"><a name="hasTypeLoc6Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
7645 <tr><td colspan="4" class="doc" id="hasTypeLoc6"><pre>Matches if the type location of a node matches the inner matcher.
7646
7647 Examples:
7648   int x;
7649 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7650   matches int x
7651
7652 auto x = int(3);
7653 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7654   matches int(3)
7655
7656 struct Foo { Foo(int, int); };
7657 auto x = Foo(1, 2);
7658 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7659   matches Foo(1, 2)
7660
7661 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
7662   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
7663   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
7664   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7665   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7666   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
7667   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
7668   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7669 </pre></td></tr>
7670
7671
7672 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('callee3')"><a name="callee3Anchor">callee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
7673 <tr><td colspan="4" class="doc" id="callee3"><pre>Matches 1) if the call expression's callee's declaration matches the
7674 given matcher; or 2) if the Obj-C message expression's callee's method
7675 declaration matches the given matcher.
7676
7677 Example matches y.x() (matcher = callExpr(callee(
7678                                    cxxMethodDecl(hasName("x")))))
7679   class Y { public: void x(); };
7680   void z() { Y y; y.x(); }
7681
7682 Example 2. Matches [I foo] with
7683 objcMessageExpr(callee(objcMethodDecl(hasName("foo"))))
7684
7685   @interface I: NSObject
7686   +(void)foo;
7687   @end
7688   ...
7689   [I foo]
7690 </pre></td></tr>
7691
7692
7693 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('callee0')"><a name="callee0Anchor">callee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
7694 <tr><td colspan="4" class="doc" id="callee0"><pre>Matches if the call or fold expression's callee expression matches.
7695
7696 Given
7697   class Y { void x() { this-&gt;x(); x(); Y y; y.x(); } };
7698   void f() { f(); }
7699 callExpr(callee(expr()))
7700   matches this-&gt;x(), x(), y.x(), f()
7701 with callee(...)
7702   matching this-&gt;x, x, y.x, f respectively
7703
7704 Given
7705   template &lt;typename... Args&gt;
7706   auto sum(Args... args) {
7707       return (0 + ... + args);
7708   }
7709
7710   template &lt;typename... Args&gt;
7711   auto multiply(Args... args) {
7712       return (args * ... * 1);
7713   }
7714 cxxFoldExpr(callee(expr()))
7715   matches (args * ... * 1)
7716 with callee(...)
7717   matching *
7718
7719 Note: Callee cannot take the more general internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;
7720 because this introduces ambiguous overloads with calls to Callee taking a
7721 internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, as the matcher hierarchy is purely
7722 implemented in terms of implicit casts.
7723 </pre></td></tr>
7724
7725
7726 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('forEachArgumentWithParam0')"><a name="forEachArgumentWithParam0Anchor">forEachArgumentWithParam</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; ArgMatcher, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; ParamMatcher</td></tr>
7727 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam0"><pre>Matches all arguments and their respective ParmVarDecl.
7728
7729 Given
7730   void f(int i);
7731   int y;
7732   f(y);
7733 callExpr(
7734   forEachArgumentWithParam(
7735     declRefExpr(to(varDecl(hasName("y")))),
7736     parmVarDecl(hasType(isInteger()))
7737 ))
7738   matches f(y);
7739 with declRefExpr(...)
7740   matching int y
7741 and parmVarDecl(...)
7742   matching int i
7743 </pre></td></tr>
7744
7745
7746 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('forEachArgumentWithParamType0')"><a name="forEachArgumentWithParamType0Anchor">forEachArgumentWithParamType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; ArgMatcher, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; ParamMatcher</td></tr>
7747 <tr><td colspan="4" class="doc" id="forEachArgumentWithParamType0"><pre>Matches all arguments and their respective types for a CallExpr or
7748 CXXConstructExpr. It is very similar to forEachArgumentWithParam but
7749 it works on calls through function pointers as well.
7750
7751 The difference is, that function pointers do not provide access to a
7752 ParmVarDecl, but only the QualType for each argument.
7753
7754 Given
7755   void f(int i);
7756   int y;
7757   f(y);
7758   void (*f_ptr)(int) = f;
7759   f_ptr(y);
7760 callExpr(
7761   forEachArgumentWithParamType(
7762     declRefExpr(to(varDecl(hasName("y")))),
7763     qualType(isInteger()).bind("type)
7764 ))
7765   matches f(y) and f_ptr(y)
7766 with declRefExpr(...)
7767   matching int y
7768 and qualType(...)
7769   matching int
7770 </pre></td></tr>
7771
7772
7773 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyArgument0')"><a name="hasAnyArgument0Anchor">hasAnyArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7774 <tr><td colspan="4" class="doc" id="hasAnyArgument0"><pre>Matches any argument of a call expression or a constructor call
7775 expression, or an ObjC-message-send expression.
7776
7777 Given
7778   void x(int, int, int) { int y; x(1, y, 42); }
7779 callExpr(hasAnyArgument(declRefExpr()))
7780   matches x(1, y, 42)
7781 with hasAnyArgument(...)
7782   matching y
7783
7784 For ObjectiveC, given
7785   @interface I - (void) f:(int) y; @end
7786   void foo(I *i) { [i f:12]; }
7787 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
7788   matches [i f:12]
7789 </pre></td></tr>
7790
7791
7792 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument0')"><a name="hasArgument0Anchor">hasArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7793 <tr><td colspan="4" class="doc" id="hasArgument0"><pre>Matches the n'th argument of a call expression or a constructor
7794 call expression.
7795
7796 Example matches y in x(y)
7797     (matcher = callExpr(hasArgument(0, declRefExpr())))
7798   void x(int) { int y; x(y); }
7799 </pre></td></tr>
7800
7801
7802 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration14')"><a name="hasDeclaration14Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
7803 <tr><td colspan="4" class="doc" id="hasDeclaration14"><pre>Matches a node if the declaration associated with that node
7804 matches the given matcher.
7805
7806 The associated declaration is:
7807 - for type nodes, the declaration of the underlying type
7808 - for CallExpr, the declaration of the callee
7809 - for MemberExpr, the declaration of the referenced member
7810 - for CXXConstructExpr, the declaration of the constructor
7811 - for CXXNewExpr, the declaration of the operator new
7812 - for ObjCIvarExpr, the declaration of the ivar
7813
7814 For type nodes, hasDeclaration will generally match the declaration of the
7815 sugared type. Given
7816   class X {};
7817   typedef X Y;
7818   Y y;
7819 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
7820 typedefDecl. A common use case is to match the underlying, desugared type.
7821 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
7822   varDecl(hasType(hasUnqualifiedDesugaredType(
7823       recordType(hasDeclaration(decl())))))
7824 In this matcher, the decl will match the CXXRecordDecl of class X.
7825
7826 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
7827   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
7828   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
7829   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
7830   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
7831   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
7832   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
7833 </pre></td></tr>
7834
7835
7836 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CaseStmt.html">CaseStmt</a>&gt;</td><td class="name" onclick="toggle('hasCaseConstant0')"><a name="hasCaseConstant0Anchor">hasCaseConstant</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7837 <tr><td colspan="4" class="doc" id="hasCaseConstant0"><pre>If the given case statement does not use the GNU case range
7838 extension, matches the constant given in the statement.
7839
7840 Given
7841   switch (1) { case 1: case 1+1: case 3 ... 4: ; }
7842 caseStmt(hasCaseConstant(integerLiteral()))
7843   matches "case 1:"
7844 </pre></td></tr>
7845
7846
7847 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;</td><td class="name" onclick="toggle('hasSourceExpression0')"><a name="hasSourceExpression0Anchor">hasSourceExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
7848 <tr><td colspan="4" class="doc" id="hasSourceExpression0"><pre>Matches if the cast's source expression
7849 or opaque value's source expression matches the given matcher.
7850
7851 Example 1: matches "a string"
7852 (matcher = castExpr(hasSourceExpression(cxxConstructExpr())))
7853 class URL { URL(string); };
7854 URL url = "a string";
7855
7856 Example 2: matches 'b' (matcher =
7857 opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr())))
7858 int a = b ?: 1;
7859 </pre></td></tr>
7860
7861
7862 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument0')"><a name="forEachTemplateArgument0Anchor">forEachTemplateArgument</a></td><td>clang::ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
7863 <tr><td colspan="4" class="doc" id="forEachTemplateArgument0"><pre>Matches classTemplateSpecialization, templateSpecializationType and
7864 functionDecl nodes where the template argument matches the inner matcher.
7865 This matcher may produce multiple matches.
7866
7867 Given
7868   template &lt;typename T, unsigned N, unsigned M&gt;
7869   struct Matrix {};
7870
7871   constexpr unsigned R = 2;
7872   Matrix&lt;int, R * 2, R * 4&gt; M;
7873
7874   template &lt;typename T, typename U&gt;
7875   void f(T&amp;&amp; t, U&amp;&amp; u) {}
7876
7877   bool B = false;
7878   f(R, B);
7879 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
7880   matches twice, with expr() matching 'R * 2' and 'R * 4'
7881 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
7882   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
7883   and 'bool'
7884 </pre></td></tr>
7885
7886
7887 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument0')"><a name="hasAnyTemplateArgument0Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
7888 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches classTemplateSpecializations, templateSpecializationType and
7889 functionDecl that have at least one TemplateArgument matching the given
7890 InnerMatcher.
7891
7892 Given
7893   template&lt;typename T&gt; class A {};
7894   template&lt;&gt; class A&lt;double&gt; {};
7895   A&lt;int&gt; a;
7896
7897   template&lt;typename T&gt; f() {};
7898   void func() { f&lt;int&gt;(); };
7899
7900 classTemplateSpecializationDecl(hasAnyTemplateArgument(
7901     refersToType(asString("int"))))
7902   matches the specialization A&lt;int&gt;
7903
7904 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
7905   matches the specialization f&lt;int&gt;
7906 </pre></td></tr>
7907
7908
7909 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasSpecializedTemplate0')"><a name="hasSpecializedTemplate0Anchor">hasSpecializedTemplate</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateDecl.html">ClassTemplateDecl</a>&gt; InnerMatcher</td></tr>
7910 <tr><td colspan="4" class="doc" id="hasSpecializedTemplate0"><pre>Matches the specialized template of a specialization declaration.
7911
7912 Given
7913   template&lt;typename T&gt; class A {}; #1
7914   template&lt;&gt; class A&lt;int&gt; {}; #2
7915 classTemplateSpecializationDecl(hasSpecializedTemplate(classTemplateDecl()))
7916   matches '#2' with classTemplateDecl() matching the class template
7917   declaration of 'A' at #1.
7918 </pre></td></tr>
7919
7920
7921 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument0')"><a name="hasTemplateArgument0Anchor">hasTemplateArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
7922 <tr><td colspan="4" class="doc" id="hasTemplateArgument0"><pre>Matches classTemplateSpecializations, templateSpecializationType and
7923 functionDecl where the n'th TemplateArgument matches the given InnerMatcher.
7924
7925 Given
7926   template&lt;typename T, typename U&gt; class A {};
7927   A&lt;bool, int&gt; b;
7928   A&lt;int, bool&gt; c;
7929
7930   template&lt;typename T&gt; void f() {}
7931   void func() { f&lt;int&gt;(); };
7932 classTemplateSpecializationDecl(hasTemplateArgument(
7933     1, refersToType(asString("int"))))
7934   matches the specialization A&lt;bool, int&gt;
7935
7936 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
7937   matches the specialization f&lt;int&gt;
7938 </pre></td></tr>
7939
7940
7941 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc7')"><a name="hasTypeLoc7Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
7942 <tr><td colspan="4" class="doc" id="hasTypeLoc7"><pre>Matches if the type location of a node matches the inner matcher.
7943
7944 Examples:
7945   int x;
7946 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7947   matches int x
7948
7949 auto x = int(3);
7950 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7951   matches int(3)
7952
7953 struct Foo { Foo(int, int); };
7954 auto x = Foo(1, 2);
7955 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7956   matches Foo(1, 2)
7957
7958 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
7959   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
7960   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
7961   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7962   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7963   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
7964   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
7965   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7966 </pre></td></tr>
7967
7968
7969 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;</td><td class="name" onclick="toggle('hasElementType1')"><a name="hasElementType1Anchor">hasElementType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
7970 <tr><td colspan="4" class="doc" id="hasElementType1"><pre>Matches arrays and C99 complex types that have a specific element
7971 type.
7972
7973 Given
7974   struct A {};
7975   A a[7];
7976   int b[7];
7977 arrayType(hasElementType(builtinType()))
7978   matches "int b[7]"
7979
7980 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;
7981 </pre></td></tr>
7982
7983
7984 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc8')"><a name="hasTypeLoc8Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
7985 <tr><td colspan="4" class="doc" id="hasTypeLoc8"><pre>Matches if the type location of a node matches the inner matcher.
7986
7987 Examples:
7988   int x;
7989 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7990   matches int x
7991
7992 auto x = int(3);
7993 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7994   matches int(3)
7995
7996 struct Foo { Foo(int, int); };
7997 auto x = Foo(1, 2);
7998 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7999   matches Foo(1, 2)
8000
8001 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
8002   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
8003   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
8004   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
8005   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
8006   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
8007   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
8008   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
8009 </pre></td></tr>
8010
8011
8012 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;</td><td class="name" onclick="toggle('hasAnySubstatement0')"><a name="hasAnySubstatement0Anchor">hasAnySubstatement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8013 <tr><td colspan="4" class="doc" id="hasAnySubstatement0"><pre>Matches compound statements where at least one substatement matches
8014 a given matcher. Also matches StmtExprs that have CompoundStmt as children.
8015
8016 Given
8017   { {}; 1+2; }
8018 hasAnySubstatement(compoundStmt())
8019   matches '{ {}; 1+2; }'
8020 with compoundStmt()
8021   matching '{}'
8022 </pre></td></tr>
8023
8024
8025 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CoroutineBodyStmt.html">CoroutineBodyStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody5')"><a name="hasBody5Anchor">hasBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8026 <tr><td colspan="4" class="doc" id="hasBody5"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8027 definition that has a given body. Note that in case of functions or
8028 coroutines this matcher only matches the definition itself and not the
8029 other declarations of the same function or coroutine.
8030
8031 Given
8032   for (;;) {}
8033 forStmt(hasBody(compoundStmt()))
8034   matches 'for (;;) {}'
8035 with compoundStmt()
8036   matching '{}'
8037
8038 Given
8039   void f();
8040   void f() {}
8041 functionDecl(hasBody(compoundStmt()))
8042   matches 'void f() {}'
8043 with compoundStmt()
8044   matching '{}'
8045   but does not match 'void f();'
8046 </pre></td></tr>
8047
8048
8049 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecayedType.html">DecayedType</a>&gt;</td><td class="name" onclick="toggle('hasDecayedType0')"><a name="hasDecayedType0Anchor">hasDecayedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerType</td></tr>
8050 <tr><td colspan="4" class="doc" id="hasDecayedType0"><pre>Matches the decayed type, whoes decayed type matches InnerMatcher
8051 </pre></td></tr>
8052
8053
8054 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration11')"><a name="hasDeclaration11Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
8055 <tr><td colspan="4" class="doc" id="hasDeclaration11"><pre>Matches a node if the declaration associated with that node
8056 matches the given matcher.
8057
8058 The associated declaration is:
8059 - for type nodes, the declaration of the underlying type
8060 - for CallExpr, the declaration of the callee
8061 - for MemberExpr, the declaration of the referenced member
8062 - for CXXConstructExpr, the declaration of the constructor
8063 - for CXXNewExpr, the declaration of the operator new
8064 - for ObjCIvarExpr, the declaration of the ivar
8065
8066 For type nodes, hasDeclaration will generally match the declaration of the
8067 sugared type. Given
8068   class X {};
8069   typedef X Y;
8070   Y y;
8071 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
8072 typedefDecl. A common use case is to match the underlying, desugared type.
8073 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
8074   varDecl(hasType(hasUnqualifiedDesugaredType(
8075       recordType(hasDeclaration(decl())))))
8076 In this matcher, the decl will match the CXXRecordDecl of class X.
8077
8078 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
8079   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
8080   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
8081   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
8082   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
8083   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
8084   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
8085 </pre></td></tr>
8086
8087
8088 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgumentLoc0')"><a name="hasTemplateArgumentLoc0Anchor">hasTemplateArgumentLoc</a></td><td>unsigned Index, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
8089 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc0"><pre>Matches template specialization `TypeLoc`s where the n'th
8090 `TemplateArgumentLoc` matches the given `InnerMatcher`.
8091
8092 Given
8093   template&lt;typename T, typename U&gt; class A {};
8094   A&lt;double, int&gt; b;
8095   A&lt;int, double&gt; c;
8096 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
8097   hasTypeLoc(loc(asString("double")))))))
8098   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
8099 </pre></td></tr>
8100
8101
8102 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('throughUsingDecl0')"><a name="throughUsingDecl0Anchor">throughUsingDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt; Inner</td></tr>
8103 <tr><td colspan="4" class="doc" id="throughUsingDecl0"><pre>Matches if a node refers to a declaration through a specific
8104 using shadow declaration.
8105
8106 Examples:
8107   namespace a { int f(); }
8108   using a::f;
8109   int x = f();
8110 declRefExpr(throughUsingDecl(anything()))
8111   matches f
8112
8113   namespace a { class X{}; }
8114   using a::X;
8115   X x;
8116 typeLoc(loc(usingType(throughUsingDecl(anything()))))
8117   matches X
8118
8119 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;
8120 </pre></td></tr>
8121
8122
8123 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('to0')"><a name="to0Anchor">to</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
8124 <tr><td colspan="4" class="doc" id="to0"><pre>Matches a DeclRefExpr that refers to a declaration that matches the
8125 specified matcher.
8126
8127 Example matches x in if(x)
8128     (matcher = declRefExpr(to(varDecl(hasName("x")))))
8129   bool x;
8130   if (x) {}
8131 </pre></td></tr>
8132
8133
8134 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;</td><td class="name" onclick="toggle('containsDeclaration0')"><a name="containsDeclaration0Anchor">containsDeclaration</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
8135 <tr><td colspan="4" class="doc" id="containsDeclaration0"><pre>Matches the n'th declaration of a declaration statement.
8136
8137 Note that this does not work for global declarations because the AST
8138 breaks up multiple-declaration DeclStmt's into multiple single-declaration
8139 DeclStmt's.
8140 Example: Given non-global declarations
8141   int a, b = 0;
8142   int c;
8143   int d = 2, e;
8144 declStmt(containsDeclaration(
8145       0, varDecl(hasInitializer(anything()))))
8146   matches only 'int d = 2, e;', and
8147 declStmt(containsDeclaration(1, varDecl()))
8148   matches 'int a, b = 0' as well as 'int d = 2, e;'
8149   but 'int c;' is not matched.
8150 </pre></td></tr>
8151
8152
8153 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;</td><td class="name" onclick="toggle('hasSingleDecl0')"><a name="hasSingleDecl0Anchor">hasSingleDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
8154 <tr><td colspan="4" class="doc" id="hasSingleDecl0"><pre>Matches the Decl of a DeclStmt which has a single declaration.
8155
8156 Given
8157   int a, b;
8158   int c;
8159 declStmt(hasSingleDecl(anything()))
8160   matches 'int c;' but not 'int a, b;'.
8161 </pre></td></tr>
8162
8163
8164 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc9')"><a name="hasTypeLoc9Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
8165 <tr><td colspan="4" class="doc" id="hasTypeLoc9"><pre>Matches if the type location of a node matches the inner matcher.
8166
8167 Examples:
8168   int x;
8169 declaratorDecl(hasTypeLoc(loc(asString("int"))))
8170   matches int x
8171
8172 auto x = int(3);
8173 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
8174   matches int(3)
8175
8176 struct Foo { Foo(int, int); };
8177 auto x = Foo(1, 2);
8178 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
8179   matches Foo(1, 2)
8180
8181 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
8182   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
8183   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
8184   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
8185   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
8186   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
8187   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
8188   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
8189 </pre></td></tr>
8190
8191
8192 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('hasDeclContext0')"><a name="hasDeclContext0Anchor">hasDeclContext</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
8193 <tr><td colspan="4" class="doc" id="hasDeclContext0"><pre>Matches declarations whose declaration context, interpreted as a
8194 Decl, matches InnerMatcher.
8195
8196 Given
8197   namespace N {
8198     namespace M {
8199       class D {};
8200     }
8201   }
8202
8203 cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
8204 declaration of class D.
8205 </pre></td></tr>
8206
8207
8208 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecltypeType.html">DecltypeType</a>&gt;</td><td class="name" onclick="toggle('hasUnderlyingType0')"><a name="hasUnderlyingType0Anchor">hasUnderlyingType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
8209 <tr><td colspan="4" class="doc" id="hasUnderlyingType0"><pre>Matches DecltypeType or UsingType nodes to find the underlying type.
8210
8211 Given
8212   decltype(1) a = 1;
8213   decltype(2.0) b = 2.0;
8214 decltypeType(hasUnderlyingType(isInteger()))
8215   matches the type of "a"
8216
8217 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecltypeType.html">DecltypeType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;
8218 </pre></td></tr>
8219
8220
8221 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecompositionDecl.html">DecompositionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyBinding0')"><a name="hasAnyBinding0Anchor">hasAnyBinding</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BindingDecl.html">BindingDecl</a>&gt; InnerMatcher</td></tr>
8222 <tr><td colspan="4" class="doc" id="hasAnyBinding0"><pre>Matches any binding of a DecompositionDecl.
8223
8224 For example, in:
8225 void foo()
8226 {
8227     int arr[3];
8228     auto &amp;[f, s, t] = arr;
8229
8230     f = 42;
8231 }
8232 The matcher:
8233   decompositionDecl(hasAnyBinding(bindingDecl(hasName("f").bind("fBinding"))))
8234 matches the decomposition decl with 'f' bound to "fBinding".
8235 </pre></td></tr>
8236
8237
8238 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecompositionDecl.html">DecompositionDecl</a>&gt;</td><td class="name" onclick="toggle('hasBinding0')"><a name="hasBinding0Anchor">hasBinding</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BindingDecl.html">BindingDecl</a>&gt; InnerMatcher</td></tr>
8239 <tr><td colspan="4" class="doc" id="hasBinding0"><pre>Matches the Nth binding of a DecompositionDecl.
8240
8241 For example, in:
8242 void foo()
8243 {
8244     int arr[3];
8245     auto &amp;[f, s, t] = arr;
8246
8247     f = 42;
8248 }
8249 The matcher:
8250   decompositionDecl(hasBinding(0,
8251   bindingDecl(hasName("f").bind("fBinding"))))
8252 matches the decomposition decl with 'f' bound to "fBinding".
8253 </pre></td></tr>
8254
8255
8256 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody0')"><a name="hasBody0Anchor">hasBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8257 <tr><td colspan="4" class="doc" id="hasBody0"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8258 definition that has a given body. Note that in case of functions or
8259 coroutines this matcher only matches the definition itself and not the
8260 other declarations of the same function or coroutine.
8261
8262 Given
8263   for (;;) {}
8264 forStmt(hasBody(compoundStmt()))
8265   matches 'for (;;) {}'
8266 with compoundStmt()
8267   matching '{}'
8268
8269 Given
8270   void f();
8271   void f() {}
8272 functionDecl(hasBody(compoundStmt()))
8273   matches 'void f() {}'
8274 with compoundStmt()
8275   matching '{}'
8276   but does not match 'void f();'
8277 </pre></td></tr>
8278
8279
8280 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition3')"><a name="hasCondition3Anchor">hasCondition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8281 <tr><td colspan="4" class="doc" id="hasCondition3"><pre>Matches the condition expression of an if statement, for loop,
8282 switch statement or conditional operator.
8283
8284 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
8285   if (true) {}
8286 </pre></td></tr>
8287
8288
8289 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedTypeLoc.html">ElaboratedTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasNamedTypeLoc0')"><a name="hasNamedTypeLoc0Anchor">hasNamedTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; InnerMatcher</td></tr>
8290 <tr><td colspan="4" class="doc" id="hasNamedTypeLoc0"><pre>Matches elaborated `TypeLoc`s that have a named `TypeLoc` matching
8291 `InnerMatcher`.
8292
8293 Given
8294   template &lt;typename T&gt;
8295   class C {};
8296   class C&lt;int&gt; c;
8297
8298   class D {};
8299   class D d;
8300 elaboratedTypeLoc(hasNamedTypeLoc(templateSpecializationTypeLoc()));
8301   matches the `TypeLoc` of the variable declaration of `c`, but not `d`.
8302 </pre></td></tr>
8303
8304
8305 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;</td><td class="name" onclick="toggle('hasQualifier0')"><a name="hasQualifier0Anchor">hasQualifier</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt; InnerMatcher</td></tr>
8306 <tr><td colspan="4" class="doc" id="hasQualifier0"><pre>Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
8307 matches InnerMatcher if the qualifier exists.
8308
8309 Given
8310   namespace N {
8311     namespace M {
8312       class D {};
8313     }
8314   }
8315   N::M::D d;
8316
8317 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
8318 matches the type of the variable declaration of d.
8319 </pre></td></tr>
8320
8321
8322 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;</td><td class="name" onclick="toggle('namesType0')"><a name="namesType0Anchor">namesType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
8323 <tr><td colspan="4" class="doc" id="namesType0"><pre>Matches ElaboratedTypes whose named type matches InnerMatcher.
8324
8325 Given
8326   namespace N {
8327     namespace M {
8328       class D {};
8329     }
8330   }
8331   N::M::D d;
8332
8333 elaboratedType(namesType(recordType(
8334 hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
8335 declaration of d.
8336 </pre></td></tr>
8337
8338
8339 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration10')"><a name="hasDeclaration10Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
8340 <tr><td colspan="4" class="doc" id="hasDeclaration10"><pre>Matches a node if the declaration associated with that node
8341 matches the given matcher.
8342
8343 The associated declaration is:
8344 - for type nodes, the declaration of the underlying type
8345 - for CallExpr, the declaration of the callee
8346 - for MemberExpr, the declaration of the referenced member
8347 - for CXXConstructExpr, the declaration of the constructor
8348 - for CXXNewExpr, the declaration of the operator new
8349 - for ObjCIvarExpr, the declaration of the ivar
8350
8351 For type nodes, hasDeclaration will generally match the declaration of the
8352 sugared type. Given
8353   class X {};
8354   typedef X Y;
8355   Y y;
8356 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
8357 typedefDecl. A common use case is to match the underlying, desugared type.
8358 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
8359   varDecl(hasType(hasUnqualifiedDesugaredType(
8360       recordType(hasDeclaration(decl())))))
8361 In this matcher, the decl will match the CXXRecordDecl of class X.
8362
8363 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
8364   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
8365   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
8366   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
8367   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
8368   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
8369   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
8370 </pre></td></tr>
8371
8372
8373 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasDestinationType0')"><a name="hasDestinationType0Anchor">hasDestinationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
8374 <tr><td colspan="4" class="doc" id="hasDestinationType0"><pre>Matches casts whose destination type matches a given matcher.
8375
8376 (Note: Clang's AST refers to other conversions as "casts" too, and calls
8377 actual casts "explicit" casts.)
8378 </pre></td></tr>
8379
8380
8381 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc10')"><a name="hasTypeLoc10Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
8382 <tr><td colspan="4" class="doc" id="hasTypeLoc10"><pre>Matches if the type location of a node matches the inner matcher.
8383
8384 Examples:
8385   int x;
8386 declaratorDecl(hasTypeLoc(loc(asString("int"))))
8387   matches int x
8388
8389 auto x = int(3);
8390 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
8391   matches int(3)
8392
8393 struct Foo { Foo(int, int); };
8394 auto x = Foo(1, 2);
8395 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
8396   matches Foo(1, 2)
8397
8398 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
8399   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
8400   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
8401   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
8402   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
8403   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
8404   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
8405   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
8406 </pre></td></tr>
8407
8408
8409 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('hasType5')"><a name="hasType5Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
8410 <tr><td colspan="4" class="doc" id="hasType5"><pre>Overloaded to match the declaration of the expression's or value
8411 declaration's type.
8412
8413 In case of a value declaration (for example a variable declaration),
8414 this resolves one layer of indirection. For example, in the value
8415 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
8416 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
8417 declaration of x.
8418
8419 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8420             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8421             and friend class X (matcher = friendDecl(hasType("X"))
8422             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8423                                               cxxRecordDecl(hasName("X"))))
8424  class X {};
8425  void y(X &amp;x) { x; X z; }
8426  class Y { friend class X; };
8427  class Z : public virtual X {};
8428
8429 Example matches class Derived
8430 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
8431 class Base {};
8432 class Derived : Base {};
8433
8434 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;,
8435 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
8436 </pre></td></tr>
8437
8438
8439 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('hasType0')"><a name="hasType0Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
8440 <tr><td colspan="4" class="doc" id="hasType0"><pre>Matches if the expression's or declaration's type matches a type
8441 matcher.
8442
8443 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8444             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8445             and U (matcher = typedefDecl(hasType(asString("int")))
8446             and friend class X (matcher = friendDecl(hasType("X"))
8447             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8448                                               asString("class X")))
8449  class X {};
8450  void y(X &amp;x) { x; X z; }
8451  typedef int U;
8452  class Y { friend class X; };
8453  class Z : public virtual X {};
8454 </pre></td></tr>
8455
8456
8457 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringElidableConstructorCall0')"><a name="ignoringElidableConstructorCall0Anchor">ignoringElidableConstructorCall</a></td><td>ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8458 <tr><td colspan="4" class="doc" id="ignoringElidableConstructorCall0"><pre>Matches expressions that match InnerMatcher that are possibly wrapped in an
8459 elidable constructor and other corresponding bookkeeping nodes.
8460
8461 In C++17, elidable copy constructors are no longer being generated in the
8462 AST as it is not permitted by the standard. They are, however, part of the
8463 AST in C++14 and earlier. So, a matcher must abstract over these differences
8464 to work in all language modes. This matcher skips elidable constructor-call
8465 AST nodes, `ExprWithCleanups` nodes wrapping elidable constructor-calls and
8466 various implicit nodes inside the constructor calls, all of which will not
8467 appear in the C++17 AST.
8468
8469 Given
8470
8471 struct H {};
8472 H G();
8473 void f() {
8474   H D = G();
8475 }
8476
8477 ``varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr())))``
8478 matches ``H D = G()`` in C++11 through C++17 (and beyond).
8479 </pre></td></tr>
8480
8481
8482 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringImpCasts0')"><a name="ignoringImpCasts0Anchor">ignoringImpCasts</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8483 <tr><td colspan="4" class="doc" id="ignoringImpCasts0"><pre>Matches expressions that match InnerMatcher after any implicit casts
8484 are stripped off.
8485
8486 Parentheses and explicit casts are not discarded.
8487 Given
8488   int arr[5];
8489   int a = 0;
8490   char b = 0;
8491   const int c = a;
8492   int *d = arr;
8493   long e = (long) 0l;
8494 The matchers
8495    varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
8496    varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
8497 would match the declarations for a, b, c, and d, but not e.
8498 While
8499    varDecl(hasInitializer(integerLiteral()))
8500    varDecl(hasInitializer(declRefExpr()))
8501 only match the declarations for a.
8502 </pre></td></tr>
8503
8504
8505 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringImplicit0')"><a name="ignoringImplicit0Anchor">ignoringImplicit</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8506 <tr><td colspan="4" class="doc" id="ignoringImplicit0"><pre>Matches expressions that match InnerMatcher after any implicit AST
8507 nodes are stripped off.
8508
8509 Parentheses and explicit casts are not discarded.
8510 Given
8511   class C {};
8512   C a = C();
8513   C b;
8514   C c = b;
8515 The matchers
8516    varDecl(hasInitializer(ignoringImplicit(cxxConstructExpr())))
8517 would match the declarations for a, b, and c.
8518 While
8519    varDecl(hasInitializer(cxxConstructExpr()))
8520 only match the declarations for b and c.
8521 </pre></td></tr>
8522
8523
8524 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringParenCasts0')"><a name="ignoringParenCasts0Anchor">ignoringParenCasts</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8525 <tr><td colspan="4" class="doc" id="ignoringParenCasts0"><pre>Matches expressions that match InnerMatcher after parentheses and
8526 casts are stripped off.
8527
8528 Implicit and non-C Style casts are also discarded.
8529 Given
8530   int a = 0;
8531   char b = (0);
8532   void* c = reinterpret_cast&lt;char*&gt;(0);
8533   char d = char(0);
8534 The matcher
8535    varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
8536 would match the declarations for a, b, c, and d.
8537 while
8538    varDecl(hasInitializer(integerLiteral()))
8539 only match the declaration for a.
8540 </pre></td></tr>
8541
8542
8543 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringParenImpCasts0')"><a name="ignoringParenImpCasts0Anchor">ignoringParenImpCasts</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8544 <tr><td colspan="4" class="doc" id="ignoringParenImpCasts0"><pre>Matches expressions that match InnerMatcher after implicit casts and
8545 parentheses are stripped off.
8546
8547 Explicit casts are not discarded.
8548 Given
8549   int arr[5];
8550   int a = 0;
8551   char b = (0);
8552   const int c = a;
8553   int *d = (arr);
8554   long e = ((long) 0l);
8555 The matchers
8556    varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
8557    varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
8558 would match the declarations for a, b, c, and d, but not e.
8559 while
8560    varDecl(hasInitializer(integerLiteral()))
8561    varDecl(hasInitializer(declRefExpr()))
8562 would only match the declaration for a.
8563 </pre></td></tr>
8564
8565
8566 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringParens1')"><a name="ignoringParens1Anchor">ignoringParens</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8567 <tr><td colspan="4" class="doc" id="ignoringParens1"><pre>Overload ignoringParens for Expr.
8568
8569 Given
8570   const char* str = ("my-string");
8571 The matcher
8572   implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))
8573 would match the implicit cast resulting from the assignment.
8574 </pre></td></tr>
8575
8576
8577 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('hasInClassInitializer0')"><a name="hasInClassInitializer0Anchor">hasInClassInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8578 <tr><td colspan="4" class="doc" id="hasInClassInitializer0"><pre>Matches non-static data members that have an in-class initializer.
8579
8580 Given
8581   class C {
8582     int a = 2;
8583     int b = 3;
8584     int c;
8585   };
8586 fieldDecl(hasInClassInitializer(integerLiteral(equals(2))))
8587   matches 'int a;' but not 'int b;'.
8588 fieldDecl(hasInClassInitializer(anything()))
8589   matches 'int a;' and 'int b;' but not 'int c;'.
8590 </pre></td></tr>
8591
8592
8593 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody1')"><a name="hasBody1Anchor">hasBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8594 <tr><td colspan="4" class="doc" id="hasBody1"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8595 definition that has a given body. Note that in case of functions or
8596 coroutines this matcher only matches the definition itself and not the
8597 other declarations of the same function or coroutine.
8598
8599 Given
8600   for (;;) {}
8601 forStmt(hasBody(compoundStmt()))
8602   matches 'for (;;) {}'
8603 with compoundStmt()
8604   matching '{}'
8605
8606 Given
8607   void f();
8608   void f() {}
8609 functionDecl(hasBody(compoundStmt()))
8610   matches 'void f() {}'
8611 with compoundStmt()
8612   matching '{}'
8613   but does not match 'void f();'
8614 </pre></td></tr>
8615
8616
8617 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition1')"><a name="hasCondition1Anchor">hasCondition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8618 <tr><td colspan="4" class="doc" id="hasCondition1"><pre>Matches the condition expression of an if statement, for loop,
8619 switch statement or conditional operator.
8620
8621 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
8622   if (true) {}
8623 </pre></td></tr>
8624
8625
8626 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasIncrement0')"><a name="hasIncrement0Anchor">hasIncrement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8627 <tr><td colspan="4" class="doc" id="hasIncrement0"><pre>Matches the increment statement of a for loop.
8628
8629 Example:
8630     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
8631 matches '++x' in
8632     for (x; x &lt; N; ++x) { }
8633 </pre></td></tr>
8634
8635
8636 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;</td><td class="name" onclick="toggle('hasLoopInit0')"><a name="hasLoopInit0Anchor">hasLoopInit</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8637 <tr><td colspan="4" class="doc" id="hasLoopInit0"><pre>Matches the initialization statement of a for loop.
8638
8639 Example:
8640     forStmt(hasLoopInit(declStmt()))
8641 matches 'int x = 0' in
8642     for (int x = 0; x &lt; N; ++x) { }
8643 </pre></td></tr>
8644
8645
8646 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;</td><td class="name" onclick="toggle('hasType6')"><a name="hasType6Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
8647 <tr><td colspan="4" class="doc" id="hasType6"><pre>Overloaded to match the declaration of the expression's or value
8648 declaration's type.
8649
8650 In case of a value declaration (for example a variable declaration),
8651 this resolves one layer of indirection. For example, in the value
8652 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
8653 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
8654 declaration of x.
8655
8656 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8657             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8658             and friend class X (matcher = friendDecl(hasType("X"))
8659             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8660                                               cxxRecordDecl(hasName("X"))))
8661  class X {};
8662  void y(X &amp;x) { x; X z; }
8663  class Y { friend class X; };
8664  class Z : public virtual X {};
8665
8666 Example matches class Derived
8667 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
8668 class Base {};
8669 class Derived : Base {};
8670
8671 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;,
8672 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
8673 </pre></td></tr>
8674
8675
8676 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;</td><td class="name" onclick="toggle('hasType1')"><a name="hasType1Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
8677 <tr><td colspan="4" class="doc" id="hasType1"><pre>Matches if the expression's or declaration's type matches a type
8678 matcher.
8679
8680 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8681             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8682             and U (matcher = typedefDecl(hasType(asString("int")))
8683             and friend class X (matcher = friendDecl(hasType("X"))
8684             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8685                                               asString("class X")))
8686  class X {};
8687  void y(X &amp;x) { x; X z; }
8688  typedef int U;
8689  class Y { friend class X; };
8690  class Z : public virtual X {};
8691 </pre></td></tr>
8692
8693
8694 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument2')"><a name="forEachTemplateArgument2Anchor">forEachTemplateArgument</a></td><td>clang::ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
8695 <tr><td colspan="4" class="doc" id="forEachTemplateArgument2"><pre>Matches classTemplateSpecialization, templateSpecializationType and
8696 functionDecl nodes where the template argument matches the inner matcher.
8697 This matcher may produce multiple matches.
8698
8699 Given
8700   template &lt;typename T, unsigned N, unsigned M&gt;
8701   struct Matrix {};
8702
8703   constexpr unsigned R = 2;
8704   Matrix&lt;int, R * 2, R * 4&gt; M;
8705
8706   template &lt;typename T, typename U&gt;
8707   void f(T&amp;&amp; t, U&amp;&amp; u) {}
8708
8709   bool B = false;
8710   f(R, B);
8711 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
8712   matches twice, with expr() matching 'R * 2' and 'R * 4'
8713 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
8714   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
8715   and 'bool'
8716 </pre></td></tr>
8717
8718
8719 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyBody0')"><a name="hasAnyBody0Anchor">hasAnyBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8720 <tr><td colspan="4" class="doc" id="hasAnyBody0"><pre>Matches a function declaration that has a given body present in the AST.
8721 Note that this matcher matches all the declarations of a function whose
8722 body is present in the AST.
8723
8724 Given
8725   void f();
8726   void f() {}
8727   void g();
8728 functionDecl(hasAnyBody(compoundStmt()))
8729   matches both 'void f();'
8730   and 'void f() {}'
8731 with compoundStmt()
8732   matching '{}'
8733   but does not match 'void g();'
8734 </pre></td></tr>
8735
8736
8737 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyParameter0')"><a name="hasAnyParameter0Anchor">hasAnyParameter</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
8738 <tr><td colspan="4" class="doc" id="hasAnyParameter0"><pre>Matches any parameter of a function or an ObjC method declaration or a
8739 block.
8740
8741 Does not match the 'this' parameter of a method.
8742
8743 Given
8744   class X { void f(int x, int y, int z) {} };
8745 cxxMethodDecl(hasAnyParameter(hasName("y")))
8746   matches f(int x, int y, int z) {}
8747 with hasAnyParameter(...)
8748   matching int y
8749
8750 For ObjectiveC, given
8751   @interface I - (void) f:(int) y; @end
8752
8753 the matcher objcMethodDecl(hasAnyParameter(hasName("y")))
8754 matches the declaration of method f with hasParameter
8755 matching y.
8756
8757 For blocks, given
8758   b = ^(int y) { printf("%d", y) };
8759
8760 the matcher blockDecl(hasAnyParameter(hasName("y")))
8761 matches the declaration of the block b with hasParameter
8762 matching y.
8763 </pre></td></tr>
8764
8765
8766 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument2')"><a name="hasAnyTemplateArgument2Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
8767 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument2"><pre>Matches classTemplateSpecializations, templateSpecializationType and
8768 functionDecl that have at least one TemplateArgument matching the given
8769 InnerMatcher.
8770
8771 Given
8772   template&lt;typename T&gt; class A {};
8773   template&lt;&gt; class A&lt;double&gt; {};
8774   A&lt;int&gt; a;
8775
8776   template&lt;typename T&gt; f() {};
8777   void func() { f&lt;int&gt;(); };
8778
8779 classTemplateSpecializationDecl(hasAnyTemplateArgument(
8780     refersToType(asString("int"))))
8781   matches the specialization A&lt;int&gt;
8782
8783 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
8784   matches the specialization f&lt;int&gt;
8785 </pre></td></tr>
8786
8787
8788 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasBody4')"><a name="hasBody4Anchor">hasBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8789 <tr><td colspan="4" class="doc" id="hasBody4"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8790 definition that has a given body. Note that in case of functions or
8791 coroutines this matcher only matches the definition itself and not the
8792 other declarations of the same function or coroutine.
8793
8794 Given
8795   for (;;) {}
8796 forStmt(hasBody(compoundStmt()))
8797   matches 'for (;;) {}'
8798 with compoundStmt()
8799   matching '{}'
8800
8801 Given
8802   void f();
8803   void f() {}
8804 functionDecl(hasBody(compoundStmt()))
8805   matches 'void f() {}'
8806 with compoundStmt()
8807   matching '{}'
8808   but does not match 'void f();'
8809 </pre></td></tr>
8810
8811
8812 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasExplicitSpecifier0')"><a name="hasExplicitSpecifier0Anchor">hasExplicitSpecifier</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8813 <tr><td colspan="4" class="doc" id="hasExplicitSpecifier0"><pre>Matches the expression in an explicit specifier if present in the given
8814 declaration.
8815
8816 Given
8817   template&lt;bool b&gt;
8818   struct S {
8819     S(int); // #1
8820     explicit S(double); // #2
8821     operator int(); // #3
8822     explicit operator bool(); // #4
8823     explicit(false) S(bool) // # 7
8824     explicit(true) S(char) // # 8
8825     explicit(b) S(S) // # 9
8826   };
8827   S(int) -&gt; S&lt;true&gt; // #5
8828   explicit S(double) -&gt; S&lt;false&gt; // #6
8829 cxxConstructorDecl(hasExplicitSpecifier(constantExpr())) will match #7, #8 and #9, but not #1 or #2.
8830 cxxConversionDecl(hasExplicitSpecifier(constantExpr())) will not match #3 or #4.
8831 cxxDeductionGuideDecl(hasExplicitSpecifier(constantExpr())) will not match #5 or #6.
8832 </pre></td></tr>
8833
8834
8835 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasParameter0')"><a name="hasParameter0Anchor">hasParameter</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
8836 <tr><td colspan="4" class="doc" id="hasParameter0"><pre>Matches the n'th parameter of a function or an ObjC method
8837 declaration or a block.
8838
8839 Given
8840   class X { void f(int x) {} };
8841 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
8842   matches f(int x) {}
8843 with hasParameter(...)
8844   matching int x
8845
8846 For ObjectiveC, given
8847   @interface I - (void) f:(int) y; @end
8848
8849 the matcher objcMethodDecl(hasParameter(0, hasName("y")))
8850 matches the declaration of method f with hasParameter
8851 matching y.
8852 </pre></td></tr>
8853
8854
8855 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasReturnTypeLoc0')"><a name="hasReturnTypeLoc0Anchor">hasReturnTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; ReturnMatcher</td></tr>
8856 <tr><td colspan="4" class="doc" id="hasReturnTypeLoc0"><pre>Matches a function declared with the specified return `TypeLoc`.
8857
8858 Given
8859   int f() { return 5; }
8860   void g() {}
8861 functionDecl(hasReturnTypeLoc(loc(asString("int"))))
8862   matches the declaration of `f`, but not `g`.
8863 </pre></td></tr>
8864
8865
8866 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument2')"><a name="hasTemplateArgument2Anchor">hasTemplateArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
8867 <tr><td colspan="4" class="doc" id="hasTemplateArgument2"><pre>Matches classTemplateSpecializations, templateSpecializationType and
8868 functionDecl where the n'th TemplateArgument matches the given InnerMatcher.
8869
8870 Given
8871   template&lt;typename T, typename U&gt; class A {};
8872   A&lt;bool, int&gt; b;
8873   A&lt;int, bool&gt; c;
8874
8875   template&lt;typename T&gt; void f() {}
8876   void func() { f&lt;int&gt;(); };
8877 classTemplateSpecializationDecl(hasTemplateArgument(
8878     1, refersToType(asString("int"))))
8879   matches the specialization A&lt;bool, int&gt;
8880
8881 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
8882   matches the specialization f&lt;int&gt;
8883 </pre></td></tr>
8884
8885
8886 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('returns0')"><a name="returns0Anchor">returns</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
8887 <tr><td colspan="4" class="doc" id="returns0"><pre>Matches the return type of a function declaration.
8888
8889 Given:
8890   class X { int f() { return 1; } };
8891 cxxMethodDecl(returns(asString("int")))
8892   matches int f() { return 1; }
8893 </pre></td></tr>
8894
8895
8896 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition0')"><a name="hasCondition0Anchor">hasCondition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8897 <tr><td colspan="4" class="doc" id="hasCondition0"><pre>Matches the condition expression of an if statement, for loop,
8898 switch statement or conditional operator.
8899
8900 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
8901   if (true) {}
8902 </pre></td></tr>
8903
8904
8905 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasConditionVariableStatement0')"><a name="hasConditionVariableStatement0Anchor">hasConditionVariableStatement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt; InnerMatcher</td></tr>
8906 <tr><td colspan="4" class="doc" id="hasConditionVariableStatement0"><pre>Matches the condition variable statement in an if statement.
8907
8908 Given
8909   if (A* a = GetAPointer()) {}
8910 hasConditionVariableStatement(...)
8911   matches 'A* a = GetAPointer()'.
8912 </pre></td></tr>
8913
8914
8915 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasElse0')"><a name="hasElse0Anchor">hasElse</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8916 <tr><td colspan="4" class="doc" id="hasElse0"><pre>Matches the else-statement of an if statement.
8917
8918 Examples matches the if statement
8919   (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true)))))
8920   if (false) false; else true;
8921 </pre></td></tr>
8922
8923
8924 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasInitStatement0')"><a name="hasInitStatement0Anchor">hasInitStatement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8925 <tr><td colspan="4" class="doc" id="hasInitStatement0"><pre>Matches selection statements with initializer.
8926
8927 Given:
8928  void foo() {
8929    if (int i = foobar(); i &gt; 0) {}
8930    switch (int i = foobar(); i) {}
8931    for (auto&amp; a = get_range(); auto&amp; x : a) {}
8932  }
8933  void bar() {
8934    if (foobar() &gt; 0) {}
8935    switch (foobar()) {}
8936    for (auto&amp; x : get_range()) {}
8937  }
8938 ifStmt(hasInitStatement(anything()))
8939   matches the if statement in foo but not in bar.
8940 switchStmt(hasInitStatement(anything()))
8941   matches the switch statement in foo but not in bar.
8942 cxxForRangeStmt(hasInitStatement(anything()))
8943   matches the range for statement in foo but not in bar.
8944 </pre></td></tr>
8945
8946
8947 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;</td><td class="name" onclick="toggle('hasThen0')"><a name="hasThen0Anchor">hasThen</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
8948 <tr><td colspan="4" class="doc" id="hasThen0"><pre>Matches the then-statement of an if statement.
8949
8950 Examples matches the if statement
8951   (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true)))))
8952   if (false) true; else false;
8953 </pre></td></tr>
8954
8955
8956 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImplicitCastExpr.html">ImplicitCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasImplicitDestinationType0')"><a name="hasImplicitDestinationType0Anchor">hasImplicitDestinationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
8957 <tr><td colspan="4" class="doc" id="hasImplicitDestinationType0"><pre>Matches implicit casts whose destination type matches a given
8958 matcher.
8959 </pre></td></tr>
8960
8961
8962 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;</td><td class="name" onclick="toggle('hasInit0')"><a name="hasInit0Anchor">hasInit</a></td><td>unsigned N, ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8963 <tr><td colspan="4" class="doc" id="hasInit0"><pre>Matches the n'th item of an initializer list expression.
8964
8965 Example matches y.
8966     (matcher = initListExpr(hasInit(0, expr())))
8967   int x{y}.
8968 </pre></td></tr>
8969
8970
8971 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;</td><td class="name" onclick="toggle('hasSyntacticForm0')"><a name="hasSyntacticForm0Anchor">hasSyntacticForm</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8972 <tr><td colspan="4" class="doc" id="hasSyntacticForm0"><pre>Matches the syntactic form of init list expressions
8973 (if expression have it).
8974 </pre></td></tr>
8975
8976
8977 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration9')"><a name="hasDeclaration9Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
8978 <tr><td colspan="4" class="doc" id="hasDeclaration9"><pre>Matches a node if the declaration associated with that node
8979 matches the given matcher.
8980
8981 The associated declaration is:
8982 - for type nodes, the declaration of the underlying type
8983 - for CallExpr, the declaration of the callee
8984 - for MemberExpr, the declaration of the referenced member
8985 - for CXXConstructExpr, the declaration of the constructor
8986 - for CXXNewExpr, the declaration of the operator new
8987 - for ObjCIvarExpr, the declaration of the ivar
8988
8989 For type nodes, hasDeclaration will generally match the declaration of the
8990 sugared type. Given
8991   class X {};
8992   typedef X Y;
8993   Y y;
8994 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
8995 typedefDecl. A common use case is to match the underlying, desugared type.
8996 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
8997   varDecl(hasType(hasUnqualifiedDesugaredType(
8998       recordType(hasDeclaration(decl())))))
8999 In this matcher, the decl will match the CXXRecordDecl of class X.
9000
9001 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
9002   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
9003   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
9004   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
9005   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
9006   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
9007   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9008 </pre></td></tr>
9009
9010
9011 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration8')"><a name="hasDeclaration8Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
9012 <tr><td colspan="4" class="doc" id="hasDeclaration8"><pre>Matches a node if the declaration associated with that node
9013 matches the given matcher.
9014
9015 The associated declaration is:
9016 - for type nodes, the declaration of the underlying type
9017 - for CallExpr, the declaration of the callee
9018 - for MemberExpr, the declaration of the referenced member
9019 - for CXXConstructExpr, the declaration of the constructor
9020 - for CXXNewExpr, the declaration of the operator new
9021 - for ObjCIvarExpr, the declaration of the ivar
9022
9023 For type nodes, hasDeclaration will generally match the declaration of the
9024 sugared type. Given
9025   class X {};
9026   typedef X Y;
9027   Y y;
9028 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9029 typedefDecl. A common use case is to match the underlying, desugared type.
9030 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9031   varDecl(hasType(hasUnqualifiedDesugaredType(
9032       recordType(hasDeclaration(decl())))))
9033 In this matcher, the decl will match the CXXRecordDecl of class X.
9034
9035 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
9036   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
9037   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
9038   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
9039   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
9040   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
9041   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9042 </pre></td></tr>
9043
9044
9045 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt;</td><td class="name" onclick="toggle('capturesVar0')"><a name="capturesVar0Anchor">capturesVar</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt; InnerMatcher</td></tr>
9046 <tr><td colspan="4" class="doc" id="capturesVar0"><pre>Matches a `LambdaCapture` that refers to the specified `VarDecl`. The
9047 `VarDecl` can be a separate variable that is captured by value or
9048 reference, or a synthesized variable if the capture has an initializer.
9049
9050 Given
9051   void foo() {
9052     int x;
9053     auto f = [x](){};
9054     auto g = [x = 1](){};
9055   }
9056 In the matcher
9057 lambdaExpr(hasAnyCapture(lambdaCapture(capturesVar(hasName("x")))),
9058 capturesVar(hasName("x")) matches `x` and `x = 1`.
9059 </pre></td></tr>
9060
9061
9062 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaExpr.html">LambdaExpr</a>&gt;</td><td class="name" onclick="toggle('forEachLambdaCapture0')"><a name="forEachLambdaCapture0Anchor">forEachLambdaCapture</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt; InnerMatcher</td></tr>
9063 <tr><td colspan="4" class="doc" id="forEachLambdaCapture0"><pre>Matches each lambda capture in a lambda expression.
9064
9065 Given
9066   int main() {
9067     int x, y;
9068     float z;
9069     auto f = [=]() { return x + y + z; };
9070   }
9071 lambdaExpr(forEachLambdaCapture(
9072     lambdaCapture(capturesVar(varDecl(hasType(isInteger()))))))
9073 will trigger two matches, binding for 'x' and 'y' respectively.
9074 </pre></td></tr>
9075
9076
9077 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaExpr.html">LambdaExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyCapture0')"><a name="hasAnyCapture0Anchor">hasAnyCapture</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaCapture.html">LambdaCapture</a>&gt; InnerMatcher</td></tr>
9078 <tr><td colspan="4" class="doc" id="hasAnyCapture0"><pre>Matches any capture in a lambda expression.
9079
9080 Given
9081   void foo() {
9082     int t = 5;
9083     auto f = [=](){ return t; };
9084   }
9085 lambdaExpr(hasAnyCapture(lambdaCapture())) and
9086 lambdaExpr(hasAnyCapture(lambdaCapture(refersToVarDecl(hasName("t")))))
9087   both match `[=](){ return t; }`.
9088 </pre></td></tr>
9089
9090
9091 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration7')"><a name="hasDeclaration7Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
9092 <tr><td colspan="4" class="doc" id="hasDeclaration7"><pre>Matches a node if the declaration associated with that node
9093 matches the given matcher.
9094
9095 The associated declaration is:
9096 - for type nodes, the declaration of the underlying type
9097 - for CallExpr, the declaration of the callee
9098 - for MemberExpr, the declaration of the referenced member
9099 - for CXXConstructExpr, the declaration of the constructor
9100 - for CXXNewExpr, the declaration of the operator new
9101 - for ObjCIvarExpr, the declaration of the ivar
9102
9103 For type nodes, hasDeclaration will generally match the declaration of the
9104 sugared type. Given
9105   class X {};
9106   typedef X Y;
9107   Y y;
9108 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9109 typedefDecl. A common use case is to match the underlying, desugared type.
9110 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9111   varDecl(hasType(hasUnqualifiedDesugaredType(
9112       recordType(hasDeclaration(decl())))))
9113 In this matcher, the decl will match the CXXRecordDecl of class X.
9114
9115 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
9116   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
9117   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
9118   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
9119   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
9120   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
9121   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9122 </pre></td></tr>
9123
9124
9125 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasObjectExpression0')"><a name="hasObjectExpression0Anchor">hasObjectExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9126 <tr><td colspan="4" class="doc" id="hasObjectExpression0"><pre>Matches a member expression where the object expression is matched by a
9127 given matcher. Implicit object expressions are included; that is, it matches
9128 use of implicit `this`.
9129
9130 Given
9131   struct X {
9132     int m;
9133     int f(X x) { x.m; return m; }
9134   };
9135 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))
9136   matches `x.m`, but not `m`; however,
9137 memberExpr(hasObjectExpression(hasType(pointsTo(
9138      cxxRecordDecl(hasName("X"))))))
9139   matches `m` (aka. `this-&gt;m`), but not `x.m`.
9140 </pre></td></tr>
9141
9142
9143 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;</td><td class="name" onclick="toggle('member0')"><a name="member0Anchor">member</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt; InnerMatcher</td></tr>
9144 <tr><td colspan="4" class="doc" id="member0"><pre>Matches a member expression where the member is matched by a
9145 given matcher.
9146
9147 Given
9148   struct { int first, second; } first, second;
9149   int i(second.first);
9150   int j(first.second);
9151 memberExpr(member(hasName("first")))
9152   matches second.first
9153   but not first.second (because the member name there is "second").
9154 </pre></td></tr>
9155
9156
9157 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;</td><td class="name" onclick="toggle('pointee1')"><a name="pointee1Anchor">pointee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
9158 <tr><td colspan="4" class="doc" id="pointee1"><pre>Narrows PointerType (and similar) matchers to those where the
9159 pointee matches a given matcher.
9160
9161 Given
9162   int *a;
9163   int const *b;
9164   float const *f;
9165 pointerType(pointee(isConstQualified(), isInteger()))
9166   matches "int const *b"
9167
9168 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
9169   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
9170 </pre></td></tr>
9171
9172
9173 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasUnderlyingDecl0')"><a name="hasUnderlyingDecl0Anchor">hasUnderlyingDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; InnerMatcher</td></tr>
9174 <tr><td colspan="4" class="doc" id="hasUnderlyingDecl0"><pre>Matches a NamedDecl whose underlying declaration matches the given
9175 matcher.
9176
9177 Given
9178   namespace N { template&lt;class T&gt; void f(T t); }
9179   template &lt;class T&gt; void g() { using N::f; f(T()); }
9180 unresolvedLookupExpr(hasAnyDeclaration(
9181     namedDecl(hasUnderlyingDecl(hasName("::N::f")))))
9182   matches the use of f in g() .
9183 </pre></td></tr>
9184
9185
9186 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('hasPrefix1')"><a name="hasPrefix1Anchor">hasPrefix</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt; InnerMatcher</td></tr>
9187 <tr><td colspan="4" class="doc" id="hasPrefix1"><pre>Matches on the prefix of a NestedNameSpecifierLoc.
9188
9189 Given
9190   struct A { struct B { struct C {}; }; };
9191   A::B::C c;
9192 nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
9193   matches "A::"
9194 </pre></td></tr>
9195
9196
9197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('loc1')"><a name="loc1Anchor">loc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt; InnerMatcher</td></tr>
9198 <tr><td colspan="4" class="doc" id="loc1"><pre>Matches NestedNameSpecifierLocs for which the given inner
9199 NestedNameSpecifier-matcher matches.
9200 </pre></td></tr>
9201
9202
9203 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('specifiesTypeLoc0')"><a name="specifiesTypeLoc0Anchor">specifiesTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; InnerMatcher</td></tr>
9204 <tr><td colspan="4" class="doc" id="specifiesTypeLoc0"><pre>Matches nested name specifier locs that specify a type matching the
9205 given TypeLoc.
9206
9207 Given
9208   struct A { struct B { struct C {}; }; };
9209   A::B::C c;
9210 nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
9211   hasDeclaration(cxxRecordDecl(hasName("A")))))))
9212   matches "A::"
9213 </pre></td></tr>
9214
9215
9216 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('hasPrefix0')"><a name="hasPrefix0Anchor">hasPrefix</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt; InnerMatcher</td></tr>
9217 <tr><td colspan="4" class="doc" id="hasPrefix0"><pre>Matches on the prefix of a NestedNameSpecifier.
9218
9219 Given
9220   struct A { struct B { struct C {}; }; };
9221   A::B::C c;
9222 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
9223   matches "A::"
9224 </pre></td></tr>
9225
9226
9227 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('specifiesNamespace0')"><a name="specifiesNamespace0Anchor">specifiesNamespace</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt; InnerMatcher</td></tr>
9228 <tr><td colspan="4" class="doc" id="specifiesNamespace0"><pre>Matches nested name specifiers that specify a namespace matching the
9229 given namespace matcher.
9230
9231 Given
9232   namespace ns { struct A {}; }
9233   ns::A a;
9234 nestedNameSpecifier(specifiesNamespace(hasName("ns")))
9235   matches "ns::"
9236 </pre></td></tr>
9237
9238
9239 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('specifiesType0')"><a name="specifiesType0Anchor">specifiesType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9240 <tr><td colspan="4" class="doc" id="specifiesType0"><pre>Matches nested name specifiers that specify a type matching the
9241 given QualType matcher without qualifiers.
9242
9243 Given
9244   struct A { struct B { struct C {}; }; };
9245   A::B::C c;
9246 nestedNameSpecifier(specifiesType(
9247   hasDeclaration(cxxRecordDecl(hasName("A")))
9248 ))
9249   matches "A::"
9250 </pre></td></tr>
9251
9252
9253 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPExecutableDirective.html">OMPExecutableDirective</a>&gt;</td><td class="name" onclick="toggle('hasAnyClause0')"><a name="hasAnyClause0Anchor">hasAnyClause</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPClause.html">OMPClause</a>&gt; InnerMatcher</td></tr>
9254 <tr><td colspan="4" class="doc" id="hasAnyClause0"><pre>Matches any clause in an OpenMP directive.
9255
9256 Given
9257
9258   #pragma omp parallel
9259   #pragma omp parallel default(none)
9260
9261 ``ompExecutableDirective(hasAnyClause(anything()))`` matches
9262 ``omp parallel default(none)``.
9263 </pre></td></tr>
9264
9265
9266 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPExecutableDirective.html">OMPExecutableDirective</a>&gt;</td><td class="name" onclick="toggle('hasStructuredBlock0')"><a name="hasStructuredBlock0Anchor">hasStructuredBlock</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
9267 <tr><td colspan="4" class="doc" id="hasStructuredBlock0"><pre>Matches the structured-block of the OpenMP executable directive
9268
9269 Prerequisite: the executable directive must not be standalone directive.
9270 If it is, it will never match.
9271
9272 Given
9273
9274    #pragma omp parallel
9275    ;
9276    #pragma omp parallel
9277    {}
9278
9279 ``ompExecutableDirective(hasStructuredBlock(nullStmt()))`` will match ``;``
9280 </pre></td></tr>
9281
9282
9283 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom1')"><a name="isDerivedFrom1Anchor">isDerivedFrom</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
9284 <tr><td colspan="4" class="doc" id="isDerivedFrom1"><pre>Matches C++ classes that are directly or indirectly derived from a class
9285 matching Base, or Objective-C classes that directly or indirectly
9286 subclass a class matching Base.
9287
9288 Note that a class is not considered to be derived from itself.
9289
9290 Example matches Y, Z, C (Base == hasName("X"))
9291   class X;
9292   class Y : public X {};  // directly derived
9293   class Z : public Y {};  // indirectly derived
9294   typedef X A;
9295   typedef A B;
9296   class C : public B {};  // derived from a typedef of X
9297
9298 In the following example, Bar matches isDerivedFrom(hasName("X")):
9299   class Foo;
9300   typedef Foo X;
9301   class Bar : public Foo {};  // derived from a type that X is a typedef of
9302
9303 In the following example, Bar matches isDerivedFrom(hasName("NSObject"))
9304   @interface NSObject @end
9305   @interface Bar : NSObject @end
9306
9307 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;
9308 </pre></td></tr>
9309
9310
9311 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;</td><td class="name" onclick="toggle('isDirectlyDerivedFrom1')"><a name="isDirectlyDerivedFrom1Anchor">isDirectlyDerivedFrom</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
9312 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom1"><pre>Matches C++ or Objective-C classes that are directly derived from a class
9313 matching Base.
9314
9315 Note that a class is not considered to be derived from itself.
9316
9317 Example matches Y, C (Base == hasName("X"))
9318   class X;
9319   class Y : public X {};  // directly derived
9320   class Z : public Y {};  // indirectly derived
9321   typedef X A;
9322   typedef A B;
9323   class C : public B {};  // derived from a typedef of X
9324
9325 In the following example, Bar matches isDerivedFrom(hasName("X")):
9326   class Foo;
9327   typedef Foo X;
9328   class Bar : public Foo {};  // derived from a type that X is a typedef of
9329 </pre></td></tr>
9330
9331
9332 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom1')"><a name="isSameOrDerivedFrom1Anchor">isSameOrDerivedFrom</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; Base</td></tr>
9333 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom1"><pre>Similar to isDerivedFrom(), but also matches classes that directly
9334 match Base.
9335 </pre></td></tr>
9336
9337
9338 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('callee2')"><a name="callee2Anchor">callee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
9339 <tr><td colspan="4" class="doc" id="callee2"><pre>Matches 1) if the call expression's callee's declaration matches the
9340 given matcher; or 2) if the Obj-C message expression's callee's method
9341 declaration matches the given matcher.
9342
9343 Example matches y.x() (matcher = callExpr(callee(
9344                                    cxxMethodDecl(hasName("x")))))
9345   class Y { public: void x(); };
9346   void z() { Y y; y.x(); }
9347
9348 Example 2. Matches [I foo] with
9349 objcMessageExpr(callee(objcMethodDecl(hasName("foo"))))
9350
9351   @interface I: NSObject
9352   +(void)foo;
9353   @end
9354   ...
9355   [I foo]
9356 </pre></td></tr>
9357
9358
9359 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyArgument3')"><a name="hasAnyArgument3Anchor">hasAnyArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9360 <tr><td colspan="4" class="doc" id="hasAnyArgument3"><pre>Matches any argument of a call expression or a constructor call
9361 expression, or an ObjC-message-send expression.
9362
9363 Given
9364   void x(int, int, int) { int y; x(1, y, 42); }
9365 callExpr(hasAnyArgument(declRefExpr()))
9366   matches x(1, y, 42)
9367 with hasAnyArgument(...)
9368   matching y
9369
9370 For ObjectiveC, given
9371   @interface I - (void) f:(int) y; @end
9372   void foo(I *i) { [i f:12]; }
9373 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
9374   matches [i f:12]
9375 </pre></td></tr>
9376
9377
9378 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgument3')"><a name="hasArgument3Anchor">hasArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9379 <tr><td colspan="4" class="doc" id="hasArgument3"><pre>Matches the n'th argument of a call expression or a constructor
9380 call expression.
9381
9382 Example matches y in x(y)
9383     (matcher = callExpr(hasArgument(0, declRefExpr())))
9384   void x(int) { int y; x(y); }
9385 </pre></td></tr>
9386
9387
9388 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasReceiver0')"><a name="hasReceiver0Anchor">hasReceiver</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9389 <tr><td colspan="4" class="doc" id="hasReceiver0"><pre>Matches if the Objective-C message is sent to an instance,
9390 and the inner matcher matches on that instance.
9391
9392 For example the method call in
9393   NSString *x = @"hello";
9394   [x containsString:@"h"];
9395 is matched by
9396 objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x"))))))
9397 </pre></td></tr>
9398
9399
9400 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasReceiverType0')"><a name="hasReceiverType0Anchor">hasReceiverType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9401 <tr><td colspan="4" class="doc" id="hasReceiverType0"><pre>Matches on the receiver of an ObjectiveC Message expression.
9402
9403 Example
9404 matcher = objCMessageExpr(hasReceiverType(asString("UIWebView *")));
9405 matches the [webView ...] message invocation.
9406   NSString *webViewJavaScript = ...
9407   UIWebView *webView = ...
9408   [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
9409 </pre></td></tr>
9410
9411
9412 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyParameter1')"><a name="hasAnyParameter1Anchor">hasAnyParameter</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
9413 <tr><td colspan="4" class="doc" id="hasAnyParameter1"><pre>Matches any parameter of a function or an ObjC method declaration or a
9414 block.
9415
9416 Does not match the 'this' parameter of a method.
9417
9418 Given
9419   class X { void f(int x, int y, int z) {} };
9420 cxxMethodDecl(hasAnyParameter(hasName("y")))
9421   matches f(int x, int y, int z) {}
9422 with hasAnyParameter(...)
9423   matching int y
9424
9425 For ObjectiveC, given
9426   @interface I - (void) f:(int) y; @end
9427
9428 the matcher objcMethodDecl(hasAnyParameter(hasName("y")))
9429 matches the declaration of method f with hasParameter
9430 matching y.
9431
9432 For blocks, given
9433   b = ^(int y) { printf("%d", y) };
9434
9435 the matcher blockDecl(hasAnyParameter(hasName("y")))
9436 matches the declaration of the block b with hasParameter
9437 matching y.
9438 </pre></td></tr>
9439
9440
9441 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;</td><td class="name" onclick="toggle('hasParameter1')"><a name="hasParameter1Anchor">hasParameter</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
9442 <tr><td colspan="4" class="doc" id="hasParameter1"><pre>Matches the n'th parameter of a function or an ObjC method
9443 declaration or a block.
9444
9445 Given
9446   class X { void f(int x) {} };
9447 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
9448   matches f(int x) {}
9449 with hasParameter(...)
9450   matching int x
9451
9452 For ObjectiveC, given
9453   @interface I - (void) f:(int) y; @end
9454
9455 the matcher objcMethodDecl(hasParameter(0, hasName("y")))
9456 matches the declaration of method f with hasParameter
9457 matching y.
9458 </pre></td></tr>
9459
9460
9461 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc11')"><a name="hasTypeLoc11Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
9462 <tr><td colspan="4" class="doc" id="hasTypeLoc11"><pre>Matches if the type location of a node matches the inner matcher.
9463
9464 Examples:
9465   int x;
9466 declaratorDecl(hasTypeLoc(loc(asString("int"))))
9467   matches int x
9468
9469 auto x = int(3);
9470 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
9471   matches int(3)
9472
9473 struct Foo { Foo(int, int); };
9474 auto x = Foo(1, 2);
9475 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
9476   matches Foo(1, 2)
9477
9478 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
9479   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
9480   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
9481   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
9482   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
9483   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
9484   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
9485   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
9486 </pre></td></tr>
9487
9488
9489 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OpaqueValueExpr.html">OpaqueValueExpr</a>&gt;</td><td class="name" onclick="toggle('hasSourceExpression1')"><a name="hasSourceExpression1Anchor">hasSourceExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9490 <tr><td colspan="4" class="doc" id="hasSourceExpression1"><pre>Matches if the cast's source expression
9491 or opaque value's source expression matches the given matcher.
9492
9493 Example 1: matches "a string"
9494 (matcher = castExpr(hasSourceExpression(cxxConstructExpr())))
9495 class URL { URL(string); };
9496 URL url = "a string";
9497
9498 Example 2: matches 'b' (matcher =
9499 opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr())))
9500 int a = b ?: 1;
9501 </pre></td></tr>
9502
9503
9504 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OverloadExpr.html">OverloadExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyDeclaration0')"><a name="hasAnyDeclaration0Anchor">hasAnyDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
9505 <tr><td colspan="4" class="doc" id="hasAnyDeclaration0"><pre>Matches an OverloadExpr if any of the declarations in the set of
9506 overloads matches the given matcher.
9507
9508 Given
9509   template &lt;typename T&gt; void foo(T);
9510   template &lt;typename T&gt; void bar(T);
9511   template &lt;typename T&gt; void baz(T t) {
9512     foo(t);
9513     bar(t);
9514   }
9515 unresolvedLookupExpr(hasAnyDeclaration(
9516     functionTemplateDecl(hasName("foo"))))
9517   matches foo in foo(t); but not bar in bar(t);
9518 </pre></td></tr>
9519
9520
9521 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;</td><td class="name" onclick="toggle('innerType0')"><a name="innerType0Anchor">innerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
9522 <tr><td colspan="4" class="doc" id="innerType0"><pre>Matches ParenType nodes where the inner type is a specific type.
9523
9524 Given
9525   int (*ptr_to_array)[4];
9526   int (*ptr_to_func)(int);
9527
9528 varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
9529 ptr_to_func but not ptr_to_array.
9530
9531 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;
9532 </pre></td></tr>
9533
9534
9535 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerTypeLoc.html">PointerTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasPointeeLoc0')"><a name="hasPointeeLoc0Anchor">hasPointeeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; PointeeMatcher</td></tr>
9536 <tr><td colspan="4" class="doc" id="hasPointeeLoc0"><pre>Matches pointer `TypeLoc`s that have a pointee `TypeLoc` matching
9537 `PointeeMatcher`.
9538
9539 Given
9540   int* x;
9541 pointerTypeLoc(hasPointeeLoc(loc(asString("int"))))
9542   matches `int*`.
9543 </pre></td></tr>
9544
9545
9546 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;</td><td class="name" onclick="toggle('pointee2')"><a name="pointee2Anchor">pointee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
9547 <tr><td colspan="4" class="doc" id="pointee2"><pre>Narrows PointerType (and similar) matchers to those where the
9548 pointee matches a given matcher.
9549
9550 Given
9551   int *a;
9552   int const *b;
9553   float const *f;
9554 pointerType(pointee(isConstQualified(), isInteger()))
9555   matches "int const *b"
9556
9557 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
9558   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
9559 </pre></td></tr>
9560
9561
9562 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasCanonicalType0')"><a name="hasCanonicalType0Anchor">hasCanonicalType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9563 <tr><td colspan="4" class="doc" id="hasCanonicalType0"><pre>Matches QualTypes whose canonical type matches InnerMatcher.
9564
9565 Given:
9566   typedef int &amp;int_ref;
9567   int a;
9568   int_ref b = a;
9569
9570 varDecl(hasType(qualType(referenceType()))))) will not match the
9571 declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
9572 </pre></td></tr>
9573
9574
9575 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration6')"><a name="hasDeclaration6Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
9576 <tr><td colspan="4" class="doc" id="hasDeclaration6"><pre>Matches a node if the declaration associated with that node
9577 matches the given matcher.
9578
9579 The associated declaration is:
9580 - for type nodes, the declaration of the underlying type
9581 - for CallExpr, the declaration of the callee
9582 - for MemberExpr, the declaration of the referenced member
9583 - for CXXConstructExpr, the declaration of the constructor
9584 - for CXXNewExpr, the declaration of the operator new
9585 - for ObjCIvarExpr, the declaration of the ivar
9586
9587 For type nodes, hasDeclaration will generally match the declaration of the
9588 sugared type. Given
9589   class X {};
9590   typedef X Y;
9591   Y y;
9592 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9593 typedefDecl. A common use case is to match the underlying, desugared type.
9594 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9595   varDecl(hasType(hasUnqualifiedDesugaredType(
9596       recordType(hasDeclaration(decl())))))
9597 In this matcher, the decl will match the CXXRecordDecl of class X.
9598
9599 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
9600   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
9601   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
9602   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
9603   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
9604   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
9605   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9606 </pre></td></tr>
9607
9608
9609 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('ignoringParens0')"><a name="ignoringParens0Anchor">ignoringParens</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9610 <tr><td colspan="4" class="doc" id="ignoringParens0"><pre>Matches types that match InnerMatcher after any parens are stripped.
9611
9612 Given
9613   void (*fp)(void);
9614 The matcher
9615   varDecl(hasType(pointerType(pointee(ignoringParens(functionType())))))
9616 would match the declaration for fp.
9617 </pre></td></tr>
9618
9619
9620 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('pointsTo1')"><a name="pointsTo1Anchor">pointsTo</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
9621 <tr><td colspan="4" class="doc" id="pointsTo1"><pre>Overloaded to match the pointee type's declaration.
9622 </pre></td></tr>
9623
9624
9625 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('pointsTo0')"><a name="pointsTo0Anchor">pointsTo</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9626 <tr><td colspan="4" class="doc" id="pointsTo0"><pre>Matches if the matched type is a pointer type and the pointee type
9627 matches the specified matcher.
9628
9629 Example matches y-&gt;x()
9630   (matcher = cxxMemberCallExpr(on(hasType(pointsTo
9631      cxxRecordDecl(hasName("Y")))))))
9632   class Y { public: void x(); };
9633   void z() { Y *y; y-&gt;x(); }
9634 </pre></td></tr>
9635
9636
9637 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('references1')"><a name="references1Anchor">references</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
9638 <tr><td colspan="4" class="doc" id="references1"><pre>Overloaded to match the referenced type's declaration.
9639 </pre></td></tr>
9640
9641
9642 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('references0')"><a name="references0Anchor">references</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9643 <tr><td colspan="4" class="doc" id="references0"><pre>Matches if the matched type is a reference type and the referenced
9644 type matches the specified matcher.
9645
9646 Example matches X &amp;x and const X &amp;y
9647     (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X"))))))
9648   class X {
9649     void a(X b) {
9650       X &amp;x = b;
9651       const X &amp;y = b;
9652     }
9653   };
9654 </pre></td></tr>
9655
9656
9657 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualifiedTypeLoc.html">QualifiedTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasUnqualifiedLoc0')"><a name="hasUnqualifiedLoc0Anchor">hasUnqualifiedLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; InnerMatcher</td></tr>
9658 <tr><td colspan="4" class="doc" id="hasUnqualifiedLoc0"><pre>Matches `QualifiedTypeLoc`s that have an unqualified `TypeLoc` matching
9659 `InnerMatcher`.
9660
9661 Given
9662   int* const x;
9663   const int y;
9664 qualifiedTypeLoc(hasUnqualifiedLoc(pointerTypeLoc()))
9665   matches the `TypeLoc` of the variable declaration of `x`, but not `y`.
9666 </pre></td></tr>
9667
9668
9669 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration5')"><a name="hasDeclaration5Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
9670 <tr><td colspan="4" class="doc" id="hasDeclaration5"><pre>Matches a node if the declaration associated with that node
9671 matches the given matcher.
9672
9673 The associated declaration is:
9674 - for type nodes, the declaration of the underlying type
9675 - for CallExpr, the declaration of the callee
9676 - for MemberExpr, the declaration of the referenced member
9677 - for CXXConstructExpr, the declaration of the constructor
9678 - for CXXNewExpr, the declaration of the operator new
9679 - for ObjCIvarExpr, the declaration of the ivar
9680
9681 For type nodes, hasDeclaration will generally match the declaration of the
9682 sugared type. Given
9683   class X {};
9684   typedef X Y;
9685   Y y;
9686 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9687 typedefDecl. A common use case is to match the underlying, desugared type.
9688 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9689   varDecl(hasType(hasUnqualifiedDesugaredType(
9690       recordType(hasDeclaration(decl())))))
9691 In this matcher, the decl will match the CXXRecordDecl of class X.
9692
9693 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
9694   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
9695   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
9696   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
9697   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
9698   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
9699   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9700 </pre></td></tr>
9701
9702
9703 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceTypeLoc.html">ReferenceTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasReferentLoc0')"><a name="hasReferentLoc0Anchor">hasReferentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; ReferentMatcher</td></tr>
9704 <tr><td colspan="4" class="doc" id="hasReferentLoc0"><pre>Matches reference `TypeLoc`s that have a referent `TypeLoc` matching
9705 `ReferentMatcher`.
9706
9707 Given
9708   int x = 3;
9709   int&amp; xx = x;
9710 referenceTypeLoc(hasReferentLoc(loc(asString("int"))))
9711   matches `int&amp;`.
9712 </pre></td></tr>
9713
9714
9715 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;</td><td class="name" onclick="toggle('pointee3')"><a name="pointee3Anchor">pointee</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
9716 <tr><td colspan="4" class="doc" id="pointee3"><pre>Narrows PointerType (and similar) matchers to those where the
9717 pointee matches a given matcher.
9718
9719 Given
9720   int *a;
9721   int const *b;
9722   float const *f;
9723 pointerType(pointee(isConstQualified(), isInteger()))
9724   matches "int const *b"
9725
9726 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;,
9727   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;
9728 </pre></td></tr>
9729
9730
9731 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReturnStmt.html">ReturnStmt</a>&gt;</td><td class="name" onclick="toggle('hasReturnValue0')"><a name="hasReturnValue0Anchor">hasReturnValue</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9732 <tr><td colspan="4" class="doc" id="hasReturnValue0"><pre>Matches the return value expression of a return statement
9733
9734 Given
9735   return a + b;
9736 hasReturnValue(binaryOperator())
9737   matches 'return a + b'
9738 with binaryOperator()
9739   matching 'a + b'
9740 </pre></td></tr>
9741
9742
9743 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StmtExpr.html">StmtExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnySubstatement1')"><a name="hasAnySubstatement1Anchor">hasAnySubstatement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
9744 <tr><td colspan="4" class="doc" id="hasAnySubstatement1"><pre>Matches compound statements where at least one substatement matches
9745 a given matcher. Also matches StmtExprs that have CompoundStmt as children.
9746
9747 Given
9748   { {}; 1+2; }
9749 hasAnySubstatement(compoundStmt())
9750   matches '{ {}; 1+2; }'
9751 with compoundStmt()
9752   matching '{}'
9753 </pre></td></tr>
9754
9755
9756 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('alignOfExpr0')"><a name="alignOfExpr0Anchor">alignOfExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;  InnerMatcher</td></tr>
9757 <tr><td colspan="4" class="doc" id="alignOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
9758 alignof.
9759 </pre></td></tr>
9760
9761
9762 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forCallable0')"><a name="forCallable0Anchor">forCallable</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
9763 <tr><td colspan="4" class="doc" id="forCallable0"><pre>Matches declaration of the function, method, or block the statement
9764 belongs to.
9765
9766 Given:
9767 F&amp; operator=(const F&amp; o) {
9768   std::copy_if(o.begin(), o.end(), begin(), [](V v) { return v &gt; 0; });
9769   return *this;
9770 }
9771 returnStmt(forCallable(functionDecl(hasName("operator="))))
9772   matches 'return *this'
9773   but does not match 'return v &gt; 0'
9774
9775 Given:
9776 -(void) foo {
9777   int x = 1;
9778   dispatch_sync(queue, ^{ int y = 2; });
9779 }
9780 declStmt(forCallable(objcMethodDecl()))
9781   matches 'int x = 1'
9782   but does not match 'int y = 2'.
9783 whereas declStmt(forCallable(blockDecl()))
9784   matches 'int y = 2'
9785   but does not match 'int x = 1'.
9786 </pre></td></tr>
9787
9788
9789 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forFunction0')"><a name="forFunction0Anchor">forFunction</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt; InnerMatcher</td></tr>
9790 <tr><td colspan="4" class="doc" id="forFunction0"><pre>Matches declaration of the function the statement belongs to.
9791
9792 Deprecated. Use forCallable() to correctly handle the situation when
9793 the declaration is not a function (but a block or an Objective-C method).
9794 forFunction() not only fails to take non-functions into account but also
9795 may match the wrong declaration in their presence.
9796
9797 Given:
9798 F&amp; operator=(const F&amp; o) {
9799   std::copy_if(o.begin(), o.end(), begin(), [](V v) { return v &gt; 0; });
9800   return *this;
9801 }
9802 returnStmt(forFunction(hasName("operator=")))
9803   matches 'return *this'
9804   but does not match 'return v &gt; 0'
9805 </pre></td></tr>
9806
9807
9808 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('sizeOfExpr0')"><a name="sizeOfExpr0Anchor">sizeOfExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;  InnerMatcher</td></tr>
9809 <tr><td colspan="4" class="doc" id="sizeOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
9810 sizeof.
9811 </pre></td></tr>
9812
9813
9814 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SubstTemplateTypeParmType.html">SubstTemplateTypeParmType</a>&gt;</td><td class="name" onclick="toggle('hasReplacementType0')"><a name="hasReplacementType0Anchor">hasReplacementType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
9815 <tr><td colspan="4" class="doc" id="hasReplacementType0"><pre>Matches template type parameter substitutions that have a replacement
9816 type that matches the provided matcher.
9817
9818 Given
9819   template &lt;typename T&gt;
9820   double F(T t);
9821   int i;
9822   double j = F(i);
9823
9824 substTemplateTypeParmType(hasReplacementType(type())) matches int
9825 </pre></td></tr>
9826
9827
9828 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;</td><td class="name" onclick="toggle('forEachSwitchCase0')"><a name="forEachSwitchCase0Anchor">forEachSwitchCase</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SwitchCase.html">SwitchCase</a>&gt; InnerMatcher</td></tr>
9829 <tr><td colspan="4" class="doc" id="forEachSwitchCase0"><pre>Matches each case or default statement belonging to the given switch
9830 statement. This matcher may produce multiple matches.
9831
9832 Given
9833   switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
9834 switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
9835   matches four times, with "c" binding each of "case 1:", "case 2:",
9836 "case 3:" and "case 4:", and "s" respectively binding "switch (1)",
9837 "switch (1)", "switch (2)" and "switch (2)".
9838 </pre></td></tr>
9839
9840
9841 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition4')"><a name="hasCondition4Anchor">hasCondition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9842 <tr><td colspan="4" class="doc" id="hasCondition4"><pre>Matches the condition expression of an if statement, for loop,
9843 switch statement or conditional operator.
9844
9845 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
9846   if (true) {}
9847 </pre></td></tr>
9848
9849
9850 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;</td><td class="name" onclick="toggle('hasInitStatement1')"><a name="hasInitStatement1Anchor">hasInitStatement</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
9851 <tr><td colspan="4" class="doc" id="hasInitStatement1"><pre>Matches selection statements with initializer.
9852
9853 Given:
9854  void foo() {
9855    if (int i = foobar(); i &gt; 0) {}
9856    switch (int i = foobar(); i) {}
9857    for (auto&amp; a = get_range(); auto&amp; x : a) {}
9858  }
9859  void bar() {
9860    if (foobar() &gt; 0) {}
9861    switch (foobar()) {}
9862    for (auto&amp; x : get_range()) {}
9863  }
9864 ifStmt(hasInitStatement(anything()))
9865   matches the if statement in foo but not in bar.
9866 switchStmt(hasInitStatement(anything()))
9867   matches the switch statement in foo but not in bar.
9868 cxxForRangeStmt(hasInitStatement(anything()))
9869   matches the range for statement in foo but not in bar.
9870 </pre></td></tr>
9871
9872
9873 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration4')"><a name="hasDeclaration4Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
9874 <tr><td colspan="4" class="doc" id="hasDeclaration4"><pre>Matches a node if the declaration associated with that node
9875 matches the given matcher.
9876
9877 The associated declaration is:
9878 - for type nodes, the declaration of the underlying type
9879 - for CallExpr, the declaration of the callee
9880 - for MemberExpr, the declaration of the referenced member
9881 - for CXXConstructExpr, the declaration of the constructor
9882 - for CXXNewExpr, the declaration of the operator new
9883 - for ObjCIvarExpr, the declaration of the ivar
9884
9885 For type nodes, hasDeclaration will generally match the declaration of the
9886 sugared type. Given
9887   class X {};
9888   typedef X Y;
9889   Y y;
9890 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9891 typedefDecl. A common use case is to match the underlying, desugared type.
9892 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9893   varDecl(hasType(hasUnqualifiedDesugaredType(
9894       recordType(hasDeclaration(decl())))))
9895 In this matcher, the decl will match the CXXRecordDecl of class X.
9896
9897 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
9898   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
9899   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
9900   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
9901   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
9902   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
9903   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9904 </pre></td></tr>
9905
9906
9907 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc12')"><a name="hasTypeLoc12Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
9908 <tr><td colspan="4" class="doc" id="hasTypeLoc12"><pre>Matches if the type location of a node matches the inner matcher.
9909
9910 Examples:
9911   int x;
9912 declaratorDecl(hasTypeLoc(loc(asString("int"))))
9913   matches int x
9914
9915 auto x = int(3);
9916 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
9917   matches int(3)
9918
9919 struct Foo { Foo(int, int); };
9920 auto x = Foo(1, 2);
9921 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
9922   matches Foo(1, 2)
9923
9924 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
9925   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
9926   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
9927   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
9928   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
9929   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
9930   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
9931   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
9932 </pre></td></tr>
9933
9934
9935 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('isExpr0')"><a name="isExpr0Anchor">isExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9936 <tr><td colspan="4" class="doc" id="isExpr0"><pre>Matches a sugar TemplateArgument that refers to a certain expression.
9937
9938 Given
9939   struct B { int next; };
9940   template&lt;int(B::*next_ptr)&gt; struct A {};
9941   A&lt;&amp;B::next&gt; a;
9942 templateSpecializationType(hasAnyTemplateArgument(
9943   isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
9944   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
9945     B::next
9946 </pre></td></tr>
9947
9948
9949 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToDeclaration0')"><a name="refersToDeclaration0Anchor">refersToDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
9950 <tr><td colspan="4" class="doc" id="refersToDeclaration0"><pre>Matches a canonical TemplateArgument that refers to a certain
9951 declaration.
9952
9953 Given
9954   struct B { int next; };
9955   template&lt;int(B::*next_ptr)&gt; struct A {};
9956   A&lt;&amp;B::next&gt; a;
9957 classTemplateSpecializationDecl(hasAnyTemplateArgument(
9958     refersToDeclaration(fieldDecl(hasName("next")))))
9959   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
9960     B::next
9961 </pre></td></tr>
9962
9963
9964 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToIntegralType0')"><a name="refersToIntegralType0Anchor">refersToIntegralType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9965 <tr><td colspan="4" class="doc" id="refersToIntegralType0"><pre>Matches a TemplateArgument that refers to an integral type.
9966
9967 Given
9968   template&lt;int T&gt; struct C {};
9969   C&lt;42&gt; c;
9970 classTemplateSpecializationDecl(
9971   hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
9972   matches the implicit instantiation of C in C&lt;42&gt;.
9973 </pre></td></tr>
9974
9975
9976 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToTemplate0')"><a name="refersToTemplate0Anchor">refersToTemplate</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt; InnerMatcher</td></tr>
9977 <tr><td colspan="4" class="doc" id="refersToTemplate0"><pre>Matches a TemplateArgument that refers to a certain template.
9978
9979 Given
9980   template&lt;template &lt;typename&gt; class S&gt; class X {};
9981   template&lt;typename T&gt; class Y {};
9982   X&lt;Y&gt; xi;
9983 classTemplateSpecializationDecl(hasAnyTemplateArgument(
9984     refersToTemplate(templateName())))
9985   matches the specialization X&lt;Y&gt;
9986 </pre></td></tr>
9987
9988
9989 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('refersToType0')"><a name="refersToType0Anchor">refersToType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
9990 <tr><td colspan="4" class="doc" id="refersToType0"><pre>Matches a TemplateArgument that refers to a certain type.
9991
9992 Given
9993   struct X {};
9994   template&lt;typename T&gt; struct A {};
9995   A&lt;X&gt; a;
9996 classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
9997   recordType(hasDeclaration(recordDecl(hasName("X")))))))
9998 matches the specialization of struct A generated by A&lt;X&gt;.
9999 </pre></td></tr>
10000
10001
10002 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationTypeLoc.html">TemplateSpecializationTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgumentLoc0')"><a name="hasAnyTemplateArgumentLoc0Anchor">hasAnyTemplateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
10003 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgumentLoc0"><pre>Matches template specialization `TypeLoc`s that have at least one
10004 `TemplateArgumentLoc` matching the given `InnerMatcher`.
10005
10006 Given
10007   template&lt;typename T&gt; class A {};
10008   A&lt;int&gt; a;
10009 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
10010   hasTypeLoc(loc(asString("int")))))))
10011   matches `A&lt;int&gt; a`.
10012 </pre></td></tr>
10013
10014
10015 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationTypeLoc.html">TemplateSpecializationTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgumentLoc1')"><a name="hasTemplateArgumentLoc1Anchor">hasTemplateArgumentLoc</a></td><td>unsigned Index, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
10016 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc1"><pre>Matches template specialization `TypeLoc`s where the n'th
10017 `TemplateArgumentLoc` matches the given `InnerMatcher`.
10018
10019 Given
10020   template&lt;typename T, typename U&gt; class A {};
10021   A&lt;double, int&gt; b;
10022   A&lt;int, double&gt; c;
10023 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
10024   hasTypeLoc(loc(asString("double")))))))
10025   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
10026 </pre></td></tr>
10027
10028
10029 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument1')"><a name="forEachTemplateArgument1Anchor">forEachTemplateArgument</a></td><td>clang::ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
10030 <tr><td colspan="4" class="doc" id="forEachTemplateArgument1"><pre>Matches classTemplateSpecialization, templateSpecializationType and
10031 functionDecl nodes where the template argument matches the inner matcher.
10032 This matcher may produce multiple matches.
10033
10034 Given
10035   template &lt;typename T, unsigned N, unsigned M&gt;
10036   struct Matrix {};
10037
10038   constexpr unsigned R = 2;
10039   Matrix&lt;int, R * 2, R * 4&gt; M;
10040
10041   template &lt;typename T, typename U&gt;
10042   void f(T&amp;&amp; t, U&amp;&amp; u) {}
10043
10044   bool B = false;
10045   f(R, B);
10046 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
10047   matches twice, with expr() matching 'R * 2' and 'R * 4'
10048 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
10049   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
10050   and 'bool'
10051 </pre></td></tr>
10052
10053
10054 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument1')"><a name="hasAnyTemplateArgument1Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
10055 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument1"><pre>Matches classTemplateSpecializations, templateSpecializationType and
10056 functionDecl that have at least one TemplateArgument matching the given
10057 InnerMatcher.
10058
10059 Given
10060   template&lt;typename T&gt; class A {};
10061   template&lt;&gt; class A&lt;double&gt; {};
10062   A&lt;int&gt; a;
10063
10064   template&lt;typename T&gt; f() {};
10065   void func() { f&lt;int&gt;(); };
10066
10067 classTemplateSpecializationDecl(hasAnyTemplateArgument(
10068     refersToType(asString("int"))))
10069   matches the specialization A&lt;int&gt;
10070
10071 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
10072   matches the specialization f&lt;int&gt;
10073 </pre></td></tr>
10074
10075
10076 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration3')"><a name="hasDeclaration3Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
10077 <tr><td colspan="4" class="doc" id="hasDeclaration3"><pre>Matches a node if the declaration associated with that node
10078 matches the given matcher.
10079
10080 The associated declaration is:
10081 - for type nodes, the declaration of the underlying type
10082 - for CallExpr, the declaration of the callee
10083 - for MemberExpr, the declaration of the referenced member
10084 - for CXXConstructExpr, the declaration of the constructor
10085 - for CXXNewExpr, the declaration of the operator new
10086 - for ObjCIvarExpr, the declaration of the ivar
10087
10088 For type nodes, hasDeclaration will generally match the declaration of the
10089 sugared type. Given
10090   class X {};
10091   typedef X Y;
10092   Y y;
10093 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10094 typedefDecl. A common use case is to match the underlying, desugared type.
10095 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10096   varDecl(hasType(hasUnqualifiedDesugaredType(
10097       recordType(hasDeclaration(decl())))))
10098 In this matcher, the decl will match the CXXRecordDecl of class X.
10099
10100 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
10101   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
10102   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
10103   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
10104   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
10105   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
10106   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10107 </pre></td></tr>
10108
10109
10110 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument1')"><a name="hasTemplateArgument1Anchor">hasTemplateArgument</a></td><td>unsigned N, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
10111 <tr><td colspan="4" class="doc" id="hasTemplateArgument1"><pre>Matches classTemplateSpecializations, templateSpecializationType and
10112 functionDecl where the n'th TemplateArgument matches the given InnerMatcher.
10113
10114 Given
10115   template&lt;typename T, typename U&gt; class A {};
10116   A&lt;bool, int&gt; b;
10117   A&lt;int, bool&gt; c;
10118
10119   template&lt;typename T&gt; void f() {}
10120   void func() { f&lt;int&gt;(); };
10121 classTemplateSpecializationDecl(hasTemplateArgument(
10122     1, refersToType(asString("int"))))
10123   matches the specialization A&lt;bool, int&gt;
10124
10125 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
10126   matches the specialization f&lt;int&gt;
10127 </pre></td></tr>
10128
10129
10130 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration2')"><a name="hasDeclaration2Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
10131 <tr><td colspan="4" class="doc" id="hasDeclaration2"><pre>Matches a node if the declaration associated with that node
10132 matches the given matcher.
10133
10134 The associated declaration is:
10135 - for type nodes, the declaration of the underlying type
10136 - for CallExpr, the declaration of the callee
10137 - for MemberExpr, the declaration of the referenced member
10138 - for CXXConstructExpr, the declaration of the constructor
10139 - for CXXNewExpr, the declaration of the operator new
10140 - for ObjCIvarExpr, the declaration of the ivar
10141
10142 For type nodes, hasDeclaration will generally match the declaration of the
10143 sugared type. Given
10144   class X {};
10145   typedef X Y;
10146   Y y;
10147 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10148 typedefDecl. A common use case is to match the underlying, desugared type.
10149 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10150   varDecl(hasType(hasUnqualifiedDesugaredType(
10151       recordType(hasDeclaration(decl())))))
10152 In this matcher, the decl will match the CXXRecordDecl of class X.
10153
10154 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
10155   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
10156   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
10157   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
10158   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
10159   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
10160   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10161 </pre></td></tr>
10162
10163
10164 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('loc0')"><a name="loc0Anchor">loc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
10165 <tr><td colspan="4" class="doc" id="loc0"><pre>Matches TypeLocs for which the given inner
10166 QualType-matcher matches.
10167 </pre></td></tr>
10168
10169
10170 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc13')"><a name="hasTypeLoc13Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
10171 <tr><td colspan="4" class="doc" id="hasTypeLoc13"><pre>Matches if the type location of a node matches the inner matcher.
10172
10173 Examples:
10174   int x;
10175 declaratorDecl(hasTypeLoc(loc(asString("int"))))
10176   matches int x
10177
10178 auto x = int(3);
10179 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
10180   matches int(3)
10181
10182 struct Foo { Foo(int, int); };
10183 auto x = Foo(1, 2);
10184 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
10185   matches Foo(1, 2)
10186
10187 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;,
10188   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;,
10189   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;,
10190   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
10191   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
10192   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;,
10193   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;,
10194   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
10195 </pre></td></tr>
10196
10197
10198 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;</td><td class="name" onclick="toggle('hasType2')"><a name="hasType2Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
10199 <tr><td colspan="4" class="doc" id="hasType2"><pre>Matches if the expression's or declaration's type matches a type
10200 matcher.
10201
10202 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
10203             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
10204             and U (matcher = typedefDecl(hasType(asString("int")))
10205             and friend class X (matcher = friendDecl(hasType("X"))
10206             and public virtual X (matcher = cxxBaseSpecifier(hasType(
10207                                               asString("class X")))
10208  class X {};
10209  void y(X &amp;x) { x; X z; }
10210  typedef int U;
10211  class Y { friend class X; };
10212  class Z : public virtual X {};
10213 </pre></td></tr>
10214
10215
10216 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration1')"><a name="hasDeclaration1Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
10217 <tr><td colspan="4" class="doc" id="hasDeclaration1"><pre>Matches a node if the declaration associated with that node
10218 matches the given matcher.
10219
10220 The associated declaration is:
10221 - for type nodes, the declaration of the underlying type
10222 - for CallExpr, the declaration of the callee
10223 - for MemberExpr, the declaration of the referenced member
10224 - for CXXConstructExpr, the declaration of the constructor
10225 - for CXXNewExpr, the declaration of the operator new
10226 - for ObjCIvarExpr, the declaration of the ivar
10227
10228 For type nodes, hasDeclaration will generally match the declaration of the
10229 sugared type. Given
10230   class X {};
10231   typedef X Y;
10232   Y y;
10233 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10234 typedefDecl. A common use case is to match the underlying, desugared type.
10235 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10236   varDecl(hasType(hasUnqualifiedDesugaredType(
10237       recordType(hasDeclaration(decl())))))
10238 In this matcher, the decl will match the CXXRecordDecl of class X.
10239
10240 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
10241   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
10242   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
10243   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
10244   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
10245   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
10246   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10247 </pre></td></tr>
10248
10249
10250 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('hasUnqualifiedDesugaredType0')"><a name="hasUnqualifiedDesugaredType0Anchor">hasUnqualifiedDesugaredType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt; InnerMatcher</td></tr>
10251 <tr><td colspan="4" class="doc" id="hasUnqualifiedDesugaredType0"><pre>Matches if the matched type matches the unqualified desugared
10252 type of the matched node.
10253
10254 For example, in:
10255   class A {};
10256   using B = A;
10257 The matcher type(hasUnqualifiedDesugaredType(recordType())) matches
10258 both B and A.
10259 </pre></td></tr>
10260
10261
10262 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;</td><td class="name" onclick="toggle('hasArgumentOfType0')"><a name="hasArgumentOfType0Anchor">hasArgumentOfType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
10263 <tr><td colspan="4" class="doc" id="hasArgumentOfType0"><pre>Matches unary expressions that have a specific type of argument.
10264
10265 Given
10266   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
10267 unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
10268   matches sizeof(a) and alignof(c)
10269 </pre></td></tr>
10270
10271
10272 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasUnaryOperand0')"><a name="hasUnaryOperand0Anchor">hasUnaryOperand</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
10273 <tr><td colspan="4" class="doc" id="hasUnaryOperand0"><pre>Matches if the operand of a unary operator matches.
10274
10275 Example matches true (matcher = hasUnaryOperand(
10276                                   cxxBoolLiteral(equals(true))))
10277   !true
10278 </pre></td></tr>
10279
10280
10281 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedMemberExpr.html">UnresolvedMemberExpr</a>&gt;</td><td class="name" onclick="toggle('hasObjectExpression1')"><a name="hasObjectExpression1Anchor">hasObjectExpression</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
10282 <tr><td colspan="4" class="doc" id="hasObjectExpression1"><pre>Matches a member expression where the object expression is matched by a
10283 given matcher. Implicit object expressions are included; that is, it matches
10284 use of implicit `this`.
10285
10286 Given
10287   struct X {
10288     int m;
10289     int f(X x) { x.m; return m; }
10290   };
10291 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))
10292   matches `x.m`, but not `m`; however,
10293 memberExpr(hasObjectExpression(hasType(pointsTo(
10294      cxxRecordDecl(hasName("X"))))))
10295   matches `m` (aka. `this-&gt;m`), but not `x.m`.
10296 </pre></td></tr>
10297
10298
10299 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration0')"><a name="hasDeclaration0Anchor">hasDeclaration</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
10300 <tr><td colspan="4" class="doc" id="hasDeclaration0"><pre>Matches a node if the declaration associated with that node
10301 matches the given matcher.
10302
10303 The associated declaration is:
10304 - for type nodes, the declaration of the underlying type
10305 - for CallExpr, the declaration of the callee
10306 - for MemberExpr, the declaration of the referenced member
10307 - for CXXConstructExpr, the declaration of the constructor
10308 - for CXXNewExpr, the declaration of the operator new
10309 - for ObjCIvarExpr, the declaration of the ivar
10310
10311 For type nodes, hasDeclaration will generally match the declaration of the
10312 sugared type. Given
10313   class X {};
10314   typedef X Y;
10315   Y y;
10316 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10317 typedefDecl. A common use case is to match the underlying, desugared type.
10318 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10319   varDecl(hasType(hasUnqualifiedDesugaredType(
10320       recordType(hasDeclaration(decl())))))
10321 In this matcher, the decl will match the CXXRecordDecl of class X.
10322
10323 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;,
10324   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;,
10325   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;,
10326   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;,
10327   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;,
10328   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;,
10329   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10330 </pre></td></tr>
10331
10332
10333 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt;</td><td class="name" onclick="toggle('hasTargetDecl0')"><a name="hasTargetDecl0Anchor">hasTargetDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt; InnerMatcher</td></tr>
10334 <tr><td colspan="4" class="doc" id="hasTargetDecl0"><pre>Matches a using shadow declaration where the target declaration is
10335 matched by the given matcher.
10336
10337 Given
10338   namespace X { int a; void b(); }
10339   using X::a;
10340   using X::b;
10341 usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
10342   matches using X::b but not using X::a </pre></td></tr>
10343
10344
10345 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;</td><td class="name" onclick="toggle('hasUnderlyingType1')"><a name="hasUnderlyingType1Anchor">hasUnderlyingType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td></tr>
10346 <tr><td colspan="4" class="doc" id="hasUnderlyingType1"><pre>Matches DecltypeType or UsingType nodes to find the underlying type.
10347
10348 Given
10349   decltype(1) a = 1;
10350   decltype(2.0) b = 2.0;
10351 decltypeType(hasUnderlyingType(isInteger()))
10352   matches the type of "a"
10353
10354 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecltypeType.html">DecltypeType</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;
10355 </pre></td></tr>
10356
10357
10358 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;</td><td class="name" onclick="toggle('throughUsingDecl1')"><a name="throughUsingDecl1Anchor">throughUsingDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingShadowDecl.html">UsingShadowDecl</a>&gt; Inner</td></tr>
10359 <tr><td colspan="4" class="doc" id="throughUsingDecl1"><pre>Matches if a node refers to a declaration through a specific
10360 using shadow declaration.
10361
10362 Examples:
10363   namespace a { int f(); }
10364   using a::f;
10365   int x = f();
10366 declRefExpr(throughUsingDecl(anything()))
10367   matches f
10368
10369   namespace a { class X{}; }
10370   using a::X;
10371   X x;
10372 typeLoc(loc(usingType(throughUsingDecl(anything()))))
10373   matches X
10374
10375 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingType.html">UsingType</a>&gt;
10376 </pre></td></tr>
10377
10378
10379 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;</td><td class="name" onclick="toggle('hasType7')"><a name="hasType7Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt; InnerMatcher</td></tr>
10380 <tr><td colspan="4" class="doc" id="hasType7"><pre>Overloaded to match the declaration of the expression's or value
10381 declaration's type.
10382
10383 In case of a value declaration (for example a variable declaration),
10384 this resolves one layer of indirection. For example, in the value
10385 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
10386 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
10387 declaration of x.
10388
10389 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
10390             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
10391             and friend class X (matcher = friendDecl(hasType("X"))
10392             and public virtual X (matcher = cxxBaseSpecifier(hasType(
10393                                               cxxRecordDecl(hasName("X"))))
10394  class X {};
10395  void y(X &amp;x) { x; X z; }
10396  class Y { friend class X; };
10397  class Z : public virtual X {};
10398
10399 Example matches class Derived
10400 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
10401 class Base {};
10402 class Derived : Base {};
10403
10404 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;,
10405 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
10406 </pre></td></tr>
10407
10408
10409 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;</td><td class="name" onclick="toggle('hasType3')"><a name="hasType3Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
10410 <tr><td colspan="4" class="doc" id="hasType3"><pre>Matches if the expression's or declaration's type matches a type
10411 matcher.
10412
10413 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
10414             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
10415             and U (matcher = typedefDecl(hasType(asString("int")))
10416             and friend class X (matcher = friendDecl(hasType("X"))
10417             and public virtual X (matcher = cxxBaseSpecifier(hasType(
10418                                               asString("class X")))
10419  class X {};
10420  void y(X &amp;x) { x; X z; }
10421  typedef int U;
10422  class Y { friend class X; };
10423  class Z : public virtual X {};
10424 </pre></td></tr>
10425
10426
10427 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('hasInitializer0')"><a name="hasInitializer0Anchor">hasInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
10428 <tr><td colspan="4" class="doc" id="hasInitializer0"><pre>Matches a variable declaration that has an initializer expression
10429 that matches the given matcher.
10430
10431 Example matches x (matcher = varDecl(hasInitializer(callExpr())))
10432   bool y() { return true; }
10433   bool x = y();
10434 </pre></td></tr>
10435
10436
10437 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VariableArrayType.html">VariableArrayType</a>&gt;</td><td class="name" onclick="toggle('hasSizeExpr0')"><a name="hasSizeExpr0Anchor">hasSizeExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
10438 <tr><td colspan="4" class="doc" id="hasSizeExpr0"><pre>Matches VariableArrayType nodes that have a specific size
10439 expression.
10440
10441 Given
10442   void f(int b) {
10443     int a[b];
10444   }
10445 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
10446   varDecl(hasName("b")))))))
10447   matches "int a[b]"
10448 </pre></td></tr>
10449
10450
10451 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;</td><td class="name" onclick="toggle('hasBody2')"><a name="hasBody2Anchor">hasBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
10452 <tr><td colspan="4" class="doc" id="hasBody2"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
10453 definition that has a given body. Note that in case of functions or
10454 coroutines this matcher only matches the definition itself and not the
10455 other declarations of the same function or coroutine.
10456
10457 Given
10458   for (;;) {}
10459 forStmt(hasBody(compoundStmt()))
10460   matches 'for (;;) {}'
10461 with compoundStmt()
10462   matching '{}'
10463
10464 Given
10465   void f();
10466   void f() {}
10467 functionDecl(hasBody(compoundStmt()))
10468   matches 'void f() {}'
10469 with compoundStmt()
10470   matching '{}'
10471   but does not match 'void f();'
10472 </pre></td></tr>
10473
10474
10475 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;</td><td class="name" onclick="toggle('hasCondition2')"><a name="hasCondition2Anchor">hasCondition</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
10476 <tr><td colspan="4" class="doc" id="hasCondition2"><pre>Matches the condition expression of an if statement, for loop,
10477 switch statement or conditional operator.
10478
10479 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
10480   if (true) {}
10481 </pre></td></tr>
10482
10483 <!--END_TRAVERSAL_MATCHERS -->
10484 </table>
10485
10486 </div>
10487 </body>
10488 </html>
10489
10490