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('exportDecl0')"><a name="exportDecl0Anchor">exportDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExportDecl.html">ExportDecl</a>&gt;...</td></tr>
 808 <tr><td colspan="4" class="doc" id="exportDecl0"><pre>Matches any export declaration.
 809
 810 Example matches following declarations.
 811   export void foo();
 812   export { void foo(); }
 813   export namespace { void foo(); }
 814   export int v;
 815 </pre></td></tr>
 816
 817
 818 <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>
 819 <tr><td colspan="4" class="doc" id="fieldDecl0"><pre>Matches field declarations.
 820
 821 Given
 822   class X { int m; };
 823 fieldDecl()
 824   matches 'm'.
 825 </pre></td></tr>
 826
 827
 828 <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>
 829 <tr><td colspan="4" class="doc" id="friendDecl0"><pre>Matches friend declarations.
 830
 831 Given
 832   class X { friend void foo(); };
 833 friendDecl()
 834   matches 'friend void foo()'.
 835 </pre></td></tr>
 836
 837
 838 <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>
 839 <tr><td colspan="4" class="doc" id="functionDecl0"><pre>Matches function declarations.
 840
 841 Example matches f
 842   void f();
 843 </pre></td></tr>
 844
 845
 846 <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>
 847 <tr><td colspan="4" class="doc" id="functionTemplateDecl0"><pre>Matches C++ function template declarations.
 848
 849 Example matches f
 850   template&lt;class T&gt; void f(T t) {}
 851 </pre></td></tr>
 852
 853
 854 <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>
 855 <tr><td colspan="4" class="doc" id="indirectFieldDecl0"><pre>Matches indirect field declarations.
 856
 857 Given
 858   struct X { struct { int a; }; };
 859 indirectFieldDecl()
 860   matches 'a'.
 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('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>
 865 <tr><td colspan="4" class="doc" id="labelDecl0"><pre>Matches a declaration of label.
 866
 867 Given
 868   goto FOO;
 869   FOO: bar();
 870 labelDecl()
 871   matches 'FOO:'
 872 </pre></td></tr>
 873
 874
 875 <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>
 876 <tr><td colspan="4" class="doc" id="linkageSpecDecl0"><pre>Matches a declaration of a linkage specification.
 877
 878 Given
 879   extern "C" {}
 880 linkageSpecDecl()
 881   matches "extern "C" {}"
 882 </pre></td></tr>
 883
 884
 885 <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>
 886 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
 887
 888 Example matches X, S, the anonymous union type, i, and U;
 889   typedef int X;
 890   struct S {
 891     union {
 892       int i;
 893     } U;
 894   };
 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('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>
 899 <tr><td colspan="4" class="doc" id="namespaceAliasDecl0"><pre>Matches a declaration of a namespace alias.
 900
 901 Given
 902   namespace test {}
 903   namespace alias = ::test;
 904 namespaceAliasDecl()
 905   matches "namespace alias" but not "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('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>
 910 <tr><td colspan="4" class="doc" id="namespaceDecl0"><pre>Matches a declaration of a namespace.
 911
 912 Given
 913   namespace {}
 914   namespace test {}
 915 namespaceDecl()
 916   matches "namespace {}" and "namespace test {}"
 917 </pre></td></tr>
 918
 919
 920 <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>
 921 <tr><td colspan="4" class="doc" id="nonTypeTemplateParmDecl0"><pre>Matches non-type template parameter declarations.
 922
 923 Given
 924   template &lt;typename T, int N&gt; struct C {};
 925 nonTypeTemplateParmDecl()
 926   matches 'N', but not 'T'.
 927 </pre></td></tr>
 928
 929
 930 <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>
 931 <tr><td colspan="4" class="doc" id="objcCategoryDecl0"><pre>Matches Objective-C category declarations.
 932
 933 Example matches Foo (Additions)
 934   @interface Foo (Additions)
 935   @end
 936 </pre></td></tr>
 937
 938
 939 <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>
 940 <tr><td colspan="4" class="doc" id="objcCategoryImplDecl0"><pre>Matches Objective-C category definitions.
 941
 942 Example matches Foo (Additions)
 943   @implementation Foo (Additions)
 944   @end
 945 </pre></td></tr>
 946
 947
 948 <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>
 949 <tr><td colspan="4" class="doc" id="objcImplementationDecl0"><pre>Matches Objective-C implementation declarations.
 950
 951 Example matches Foo
 952   @implementation Foo
 953   @end
 954 </pre></td></tr>
 955
 956
 957 <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>
 958 <tr><td colspan="4" class="doc" id="objcInterfaceDecl0"><pre>Matches Objective-C interface declarations.
 959
 960 Example matches Foo
 961   @interface Foo
 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('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>
 967 <tr><td colspan="4" class="doc" id="objcIvarDecl0"><pre>Matches Objective-C instance variable declarations.
 968
 969 Example matches _enabled
 970   @implementation Foo {
 971     BOOL _enabled;
 972   }
 973   @end
 974 </pre></td></tr>
 975
 976
 977 <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>
 978 <tr><td colspan="4" class="doc" id="objcMethodDecl0"><pre>Matches Objective-C method declarations.
 979
 980 Example matches both declaration and definition of -[Foo method]
 981   @interface Foo
 982   - (void)method;
 983   @end
 984
 985   @implementation Foo
 986   - (void)method {}
 987   @end
 988 </pre></td></tr>
 989
 990
 991 <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>
 992 <tr><td colspan="4" class="doc" id="objcPropertyDecl0"><pre>Matches Objective-C property declarations.
 993
 994 Example matches enabled
 995   @interface Foo
 996   @property BOOL enabled;
 997   @end
 998 </pre></td></tr>
 999
1000
1001 <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>
1002 <tr><td colspan="4" class="doc" id="objcProtocolDecl0"><pre>Matches Objective-C protocol declarations.
1003
1004 Example matches FooDelegate
1005   @protocol FooDelegate
1006   @end
1007 </pre></td></tr>
1008
1009
1010 <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>
1011 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
1012
1013 Given
1014   void f(int x);
1015 parmVarDecl()
1016   matches int x.
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('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>
1021 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches class, struct, and union declarations.
1022
1023 Example matches X, Z, U, and S
1024   class X;
1025   template&lt;class T&gt; class Z {};
1026   struct S {};
1027   union U {};
1028 </pre></td></tr>
1029
1030
1031 <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>
1032 <tr><td colspan="4" class="doc" id="staticAssertDecl0"><pre>Matches a C++ static_assert declaration.
1033
1034 Example:
1035   staticAssertDecl()
1036 matches
1037   static_assert(sizeof(S) == sizeof(int))
1038 in
1039   struct S {
1040     int x;
1041   };
1042   static_assert(sizeof(S) == sizeof(int));
1043 </pre></td></tr>
1044
1045
1046 <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>
1047 <tr><td colspan="4" class="doc" id="tagDecl0"><pre>Matches tag declarations.
1048
1049 Example matches X, Z, U, S, E
1050   class X;
1051   template&lt;class T&gt; class Z {};
1052   struct S {};
1053   union U {};
1054   enum E {
1055     A, B, C
1056   };
1057 </pre></td></tr>
1058
1059
1060 <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>
1061 <tr><td colspan="4" class="doc" id="templateTemplateParmDecl0"><pre>Matches template template parameter declarations.
1062
1063 Given
1064   template &lt;template &lt;typename&gt; class Z, int N&gt; struct C {};
1065 templateTypeParmDecl()
1066   matches 'Z', but not 'N'.
1067 </pre></td></tr>
1068
1069
1070 <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>
1071 <tr><td colspan="4" class="doc" id="templateTypeParmDecl0"><pre>Matches template type parameter declarations.
1072
1073 Given
1074   template &lt;typename T, int N&gt; struct C {};
1075 templateTypeParmDecl()
1076   matches 'T', but not 'N'.
1077 </pre></td></tr>
1078
1079
1080 <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>
1081 <tr><td colspan="4" class="doc" id="translationUnitDecl0"><pre>Matches the top declaration context.
1082
1083 Given
1084   int X;
1085   namespace NS {
1086   int Y;
1087   }  // namespace NS
1088 decl(hasDeclContext(translationUnitDecl()))
1089   matches "int X", but not "int Y".
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('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>
1094 <tr><td colspan="4" class="doc" id="typeAliasDecl0"><pre>Matches type alias declarations.
1095
1096 Given
1097   typedef int X;
1098   using Y = int;
1099 typeAliasDecl()
1100   matches "using Y = int", but not "typedef int X"
1101 </pre></td></tr>
1102
1103
1104 <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>
1105 <tr><td colspan="4" class="doc" id="typeAliasTemplateDecl0"><pre>Matches type alias template declarations.
1106
1107 typeAliasTemplateDecl() matches
1108   template &lt;typename T&gt;
1109   using Y = X&lt;T&gt;;
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('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>
1114 <tr><td colspan="4" class="doc" id="typedefDecl0"><pre>Matches typedef declarations.
1115
1116 Given
1117   typedef int X;
1118   using Y = int;
1119 typedefDecl()
1120   matches "typedef int X", but not "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('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>
1125 <tr><td colspan="4" class="doc" id="typedefNameDecl0"><pre>Matches typedef name declarations.
1126
1127 Given
1128   typedef int X;
1129   using Y = int;
1130 typedefNameDecl()
1131   matches "typedef int X" and "using Y = int"
1132 </pre></td></tr>
1133
1134
1135 <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>
1136 <tr><td colspan="4" class="doc" id="unresolvedUsingTypenameDecl0"><pre>Matches unresolved using value declarations that involve the
1137 typename.
1138
1139 Given
1140   template &lt;typename T&gt;
1141   struct Base { typedef T Foo; };
1142
1143   template&lt;typename T&gt;
1144   struct S : private Base&lt;T&gt; {
1145     using typename Base&lt;T&gt;::Foo;
1146   };
1147 unresolvedUsingTypenameDecl()
1148   matches using Base&lt;T&gt;::Foo </pre></td></tr>
1149
1150
1151 <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>
1152 <tr><td colspan="4" class="doc" id="unresolvedUsingValueDecl0"><pre>Matches unresolved using value declarations.
1153
1154 Given
1155   template&lt;typename X&gt;
1156   class C : private X {
1157     using X::x;
1158   };
1159 unresolvedUsingValueDecl()
1160   matches using X::x </pre></td></tr>
1161
1162
1163 <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>
1164 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
1165
1166 Given
1167   namespace X { int x; }
1168   using X::x;
1169 usingDecl()
1170   matches using X::x </pre></td></tr>
1171
1172
1173 <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>
1174 <tr><td colspan="4" class="doc" id="usingDirectiveDecl0"><pre>Matches using namespace declarations.
1175
1176 Given
1177   namespace X { int x; }
1178   using namespace X;
1179 usingDirectiveDecl()
1180   matches using namespace X </pre></td></tr>
1181
1182
1183 <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>
1184 <tr><td colspan="4" class="doc" id="usingEnumDecl0"><pre>Matches using-enum declarations.
1185
1186 Given
1187   namespace X { enum x {...}; }
1188   using enum X::x;
1189 usingEnumDecl()
1190   matches using enum X::x </pre></td></tr>
1191
1192
1193 <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>
1194 <tr><td colspan="4" class="doc" id="valueDecl0"><pre>Matches any value declaration.
1195
1196 Example matches A, B, C and F
1197   enum X { A, B, C };
1198   void F();
1199 </pre></td></tr>
1200
1201
1202 <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>
1203 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
1204
1205 Note: this does not match declarations of member variables, which are
1206 "field" declarations in Clang parlance.
1207
1208 Example matches a
1209   int a;
1210 </pre></td></tr>
1211
1212
1213 <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>
1214 <tr><td colspan="4" class="doc" id="lambdaCapture0"><pre>Matches lambda captures.
1215
1216 Given
1217   int main() {
1218     int x;
1219     auto f = [x](){};
1220     auto g = [x = 1](){};
1221   }
1222 In the matcher `lambdaExpr(hasAnyCapture(lambdaCapture()))`,
1223 `lambdaCapture()` matches `x` and `x=1`.
1224 </pre></td></tr>
1225
1226
1227 <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>
1228 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
1229 </pre></td></tr>
1230
1231
1232 <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>
1233 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
1234
1235 Given
1236   namespace ns {
1237     struct A { static void f(); };
1238     void A::f() {}
1239     void g() { A::f(); }
1240   }
1241   ns::A a;
1242 nestedNameSpecifier()
1243   matches "ns::" and both "A::"
1244 </pre></td></tr>
1245
1246
1247 <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>
1248 <tr><td colspan="4" class="doc" id="ompDefaultClause0"><pre>Matches OpenMP ``default`` clause.
1249
1250 Given
1251
1252   #pragma omp parallel default(none)
1253   #pragma omp parallel default(shared)
1254   #pragma omp parallel default(private)
1255   #pragma omp parallel default(firstprivate)
1256   #pragma omp parallel
1257
1258 ``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``,
1259 `` default(private)`` and ``default(firstprivate)``
1260 </pre></td></tr>
1261
1262
1263 <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>
1264 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
1265 </pre></td></tr>
1266
1267
1268 <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>
1269 <tr><td colspan="4" class="doc" id="addrLabelExpr0"><pre>Matches address of label statements (GNU extension).
1270
1271 Given
1272   FOO: bar();
1273   void *ptr = &amp;&amp;FOO;
1274   goto *bar;
1275 addrLabelExpr()
1276   matches '&amp;&amp;FOO'
1277 </pre></td></tr>
1278
1279
1280 <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>
1281 <tr><td colspan="4" class="doc" id="arrayInitIndexExpr0"><pre>The arrayInitIndexExpr consists of two subexpressions: a common expression
1282 (the source array) that is evaluated once up-front, and a per-element initializer
1283 that runs once for each array element. Within the per-element initializer,
1284 the current index may be obtained via an ArrayInitIndexExpr.
1285
1286 Given
1287   void testStructBinding() {
1288     int a[2] = {1, 2};
1289     auto [x, y] = a;
1290   }
1291 arrayInitIndexExpr() matches the array index that implicitly iterates
1292 over the array `a` to copy each element to the anonymous array
1293 that backs the structured binding `[x, y]` elements of which are
1294 referred to by their aliases `x` and `y`.
1295 </pre></td></tr>
1296
1297
1298 <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>
1299 <tr><td colspan="4" class="doc" id="arrayInitLoopExpr0"><pre>Matches a loop initializing the elements of an array in a number of contexts:
1300  * in the implicit copy/move constructor for a class with an array member
1301  * when a lambda-expression captures an array by value
1302  * when a decomposition declaration decomposes an array
1303
1304 Given
1305   void testLambdaCapture() {
1306     int a[10];
1307     auto Lam1 = [a]() {
1308       return;
1309     };
1310   }
1311 arrayInitLoopExpr() matches the implicit loop that initializes each element of
1312 the implicit array field inside the lambda object, that represents the array `a`
1313 captured by value.
1314 </pre></td></tr>
1315
1316
1317 <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>
1318 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
1319
1320 Given
1321   int i = a[1];
1322 arraySubscriptExpr()
1323   matches "a[1]"
1324 </pre></td></tr>
1325
1326
1327 <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>
1328 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
1329
1330  int i = 100;
1331   __asm("mov al, 2");
1332 asmStmt()
1333   matches '__asm("mov al, 2")'
1334 </pre></td></tr>
1335
1336
1337 <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>
1338 <tr><td colspan="4" class="doc" id="atomicExpr0"><pre>Matches atomic builtins.
1339 Example matches __atomic_load_n(ptr, 1)
1340   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
1341 </pre></td></tr>
1342
1343
1344 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('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>
1345 <tr><td colspan="4" class="doc" id="autoreleasePoolStmt0"><pre>Matches an Objective-C autorelease pool statement.
1346
1347 Given
1348   @autoreleasepool {
1349     int x = 0;
1350   }
1351 autoreleasePoolStmt(stmt()) matches the declaration of "x"
1352 inside the autorelease pool.
1353 </pre></td></tr>
1354
1355
1356 <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>
1357 <tr><td colspan="4" class="doc" id="binaryConditionalOperator0"><pre>Matches binary conditional operator expressions (GNU extension).
1358
1359 Example matches a ?: b
1360   (a ?: b) + 42;
1361 </pre></td></tr>
1362
1363
1364 <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>
1365 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
1366
1367 Example matches a || b
1368   !(a || b)
1369 See also the binaryOperation() matcher for more-general matching.
1370 </pre></td></tr>
1371
1372
1373 <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>
1374 <tr><td colspan="4" class="doc" id="blockExpr0"><pre>Matches a reference to a block.
1375
1376 Example: matches "^{}":
1377   void f() { ^{}(); }
1378 </pre></td></tr>
1379
1380
1381 <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>
1382 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
1383
1384 Given
1385   while (true) { break; }
1386 breakStmt()
1387   matches 'break'
1388 </pre></td></tr>
1389
1390
1391 <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>
1392 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
1393
1394 Example: Matches (int) 2.2f in
1395   int i = (int) 2.2f;
1396 </pre></td></tr>
1397
1398
1399 <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>
1400 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
1401
1402 Example matches x.y() and y()
1403   X x;
1404   x.y();
1405   y();
1406 </pre></td></tr>
1407
1408
1409 <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>
1410 <tr><td colspan="4" class="doc" id="caseStmt0"><pre>Matches case statements inside switch statements.
1411
1412 Given
1413   switch(a) { case 42: break; default: break; }
1414 caseStmt()
1415   matches 'case 42:'.
1416 </pre></td></tr>
1417
1418
1419 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('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>
1420 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
1421
1422 Example: castExpr() matches each of the following:
1423   (int) 3;
1424   const_cast&lt;Expr *&gt;(SubExpr);
1425   char c = 0;
1426 but does not match
1427   int i = (0);
1428   int k = 0;
1429 </pre></td></tr>
1430
1431
1432 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('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>
1433 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
1434
1435 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
1436 though.
1437
1438 Example matches 'a', L'a'
1439   char ch = 'a';
1440   wchar_t chw = L'a';
1441 </pre></td></tr>
1442
1443
1444 <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>
1445 <tr><td colspan="4" class="doc" id="chooseExpr0"><pre>Matches GNU __builtin_choose_expr.
1446 </pre></td></tr>
1447
1448
1449 <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>
1450 <tr><td colspan="4" class="doc" id="coawaitExpr0"><pre>Matches co_await expressions.
1451
1452 Given
1453   co_await 1;
1454 coawaitExpr()
1455   matches 'co_await 1'
1456 </pre></td></tr>
1457
1458
1459 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('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>
1460 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
1461
1462 Example match: {1}, (1, 2)
1463   int array[4] = {1};
1464   vector int myvec = (vector int)(1, 2);
1465 </pre></td></tr>
1466
1467
1468 <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>
1469 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
1470
1471 Example matches '{}' and '{{}}' in 'for (;;) {{}}'
1472   for (;;) {{}}
1473 </pre></td></tr>
1474
1475
1476 <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>
1477 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
1478
1479 Example matches a ? b : c
1480   (a ? b : c) + 42
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('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>
1485 <tr><td colspan="4" class="doc" id="constantExpr0"><pre>Matches a constant expression wrapper.
1486
1487 Example matches the constant in the case statement:
1488     (matcher = constantExpr())
1489   switch (a) {
1490   case 37: break;
1491   }
1492 </pre></td></tr>
1493
1494
1495 <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>
1496 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
1497
1498 Given
1499   while (true) { continue; }
1500 continueStmt()
1501   matches 'continue'
1502 </pre></td></tr>
1503
1504
1505 <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>
1506 <tr><td colspan="4" class="doc" id="convertVectorExpr0"><pre>Matches builtin function __builtin_convertvector.
1507 </pre></td></tr>
1508
1509
1510 <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>
1511 <tr><td colspan="4" class="doc" id="coreturnStmt0"><pre>Matches co_return statements.
1512
1513 Given
1514   while (true) { co_return; }
1515 coreturnStmt()
1516   matches 'co_return'
1517 </pre></td></tr>
1518
1519
1520 <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>
1521 <tr><td colspan="4" class="doc" id="coroutineBodyStmt0"><pre>Matches coroutine body statements.
1522
1523 coroutineBodyStmt() matches the coroutine below
1524   generator&lt;int&gt; gen() {
1525     co_return;
1526   }
1527 </pre></td></tr>
1528
1529
1530 <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>
1531 <tr><td colspan="4" class="doc" id="coyieldExpr0"><pre>Matches co_yield expressions.
1532
1533 Given
1534   co_yield 1;
1535 coyieldExpr()
1536   matches 'co_yield 1'
1537 </pre></td></tr>
1538
1539
1540 <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>
1541 <tr><td colspan="4" class="doc" id="cudaKernelCallExpr0"><pre>Matches CUDA kernel call expression.
1542
1543 Example matches,
1544   kernel&lt;&lt;&lt;i,j&gt;&gt;&gt;();
1545 </pre></td></tr>
1546
1547
1548 <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>
1549 <tr><td colspan="4" class="doc" id="cxxBindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
1550
1551 Example matches FunctionTakesString(GetStringByValue())
1552     (matcher = cxxBindTemporaryExpr())
1553   FunctionTakesString(GetStringByValue());
1554   FunctionTakesStringByPointer(GetStringPointer());
1555 </pre></td></tr>
1556
1557
1558 <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>
1559 <tr><td colspan="4" class="doc" id="cxxBoolLiteral0"><pre>Matches bool literals.
1560
1561 Example matches true
1562   true
1563 </pre></td></tr>
1564
1565
1566 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('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>
1567 <tr><td colspan="4" class="doc" id="cxxCatchStmt0"><pre>Matches catch statements.
1568
1569   try {} catch(int i) {}
1570 cxxCatchStmt()
1571   matches 'catch(int i)'
1572 </pre></td></tr>
1573
1574
1575 <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>
1576 <tr><td colspan="4" class="doc" id="cxxConstCastExpr0"><pre>Matches a const_cast expression.
1577
1578 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
1579   int n = 42;
1580   const int &amp;r(n);
1581   int* p = const_cast&lt;int*&gt;(&amp;r);
1582 </pre></td></tr>
1583
1584
1585 <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>
1586 <tr><td colspan="4" class="doc" id="cxxConstructExpr0"><pre>Matches constructor call expressions (including implicit ones).
1587
1588 Example matches string(ptr, n) and ptr within arguments of f
1589     (matcher = cxxConstructExpr())
1590   void f(const string &amp;a, const string &amp;b);
1591   char *ptr;
1592   int n;
1593   f(string(ptr, n), ptr);
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('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>
1598 <tr><td colspan="4" class="doc" id="cxxDefaultArgExpr0"><pre>Matches the value of a default argument at the call site.
1599
1600 Example matches the CXXDefaultArgExpr placeholder inserted for the
1601     default value of the second parameter in the call expression f(42)
1602     (matcher = cxxDefaultArgExpr())
1603   void f(int x, int y = 0);
1604   f(42);
1605 </pre></td></tr>
1606
1607
1608 <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>
1609 <tr><td colspan="4" class="doc" id="cxxDeleteExpr0"><pre>Matches delete expressions.
1610
1611 Given
1612   delete X;
1613 cxxDeleteExpr()
1614   matches 'delete X'.
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('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>
1619 <tr><td colspan="4" class="doc" id="cxxDependentScopeMemberExpr0"><pre>Matches member expressions where the actual member referenced could not be
1620 resolved because the base expression or the member name was dependent.
1621
1622 Given
1623   template &lt;class T&gt; void f() { T t; t.g(); }
1624 cxxDependentScopeMemberExpr()
1625   matches t.g
1626 </pre></td></tr>
1627
1628
1629 <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>
1630 <tr><td colspan="4" class="doc" id="cxxDynamicCastExpr0"><pre>Matches a dynamic_cast expression.
1631
1632 Example:
1633   cxxDynamicCastExpr()
1634 matches
1635   dynamic_cast&lt;D*&gt;(&amp;b);
1636 in
1637   struct B { virtual ~B() {} }; struct D : B {};
1638   B b;
1639   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
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('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>
1644 <tr><td colspan="4" class="doc" id="cxxFoldExpr0"><pre>Matches C++17 fold expressions.
1645
1646 Example matches `(0 + ... + args)`:
1647   template &lt;typename... Args&gt;
1648   auto sum(Args... args) {
1649       return (0 + ... + args);
1650   }
1651 </pre></td></tr>
1652
1653
1654 <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>
1655 <tr><td colspan="4" class="doc" id="cxxForRangeStmt0"><pre>Matches range-based for statements.
1656
1657 cxxForRangeStmt() matches 'for (auto a : i)'
1658   int i[] =  {1, 2, 3}; for (auto a : i);
1659   for(int j = 0; j &lt; 5; ++j);
1660 </pre></td></tr>
1661
1662
1663 <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>
1664 <tr><td colspan="4" class="doc" id="cxxFunctionalCastExpr0"><pre>Matches functional cast expressions
1665
1666 Example: Matches Foo(bar);
1667   Foo f = bar;
1668   Foo g = (Foo) bar;
1669   Foo h = Foo(bar);
1670 </pre></td></tr>
1671
1672
1673 <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>
1674 <tr><td colspan="4" class="doc" id="cxxMemberCallExpr0"><pre>Matches member call expressions.
1675
1676 Example matches x.y()
1677   X x;
1678   x.y();
1679 </pre></td></tr>
1680
1681
1682 <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>
1683 <tr><td colspan="4" class="doc" id="cxxNewExpr0"><pre>Matches new expressions.
1684
1685 Given
1686   new X;
1687 cxxNewExpr()
1688   matches 'new X'.
1689 </pre></td></tr>
1690
1691
1692 <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>
1693 <tr><td colspan="4" class="doc" id="cxxNoexceptExpr0"><pre>Matches noexcept expressions.
1694
1695 Given
1696   bool a() noexcept;
1697   bool b() noexcept(true);
1698   bool c() noexcept(false);
1699   bool d() noexcept(noexcept(a()));
1700   bool e = noexcept(b()) || noexcept(c());
1701 cxxNoexceptExpr()
1702   matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`.
1703   doesn't match the noexcept specifier in the declarations a, b, c or d.
1704 </pre></td></tr>
1705
1706
1707 <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>
1708 <tr><td colspan="4" class="doc" id="cxxNullPtrLiteralExpr0"><pre>Matches nullptr literal.
1709 </pre></td></tr>
1710
1711
1712 <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>
1713 <tr><td colspan="4" class="doc" id="cxxOperatorCallExpr0"><pre>Matches overloaded operator calls.
1714
1715 Note that if an operator isn't overloaded, it won't match. Instead, use
1716 binaryOperator matcher.
1717 Currently it does not match operators such as new delete.
1718 FIXME: figure out why these do not match?
1719
1720 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
1721     (matcher = cxxOperatorCallExpr())
1722   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
1723   ostream &amp;o; int b = 1, c = 1;
1724   o &lt;&lt; b &lt;&lt; c;
1725 See also the binaryOperation() matcher for more-general matching of binary
1726 uses of this AST node.
1727 </pre></td></tr>
1728
1729
1730 <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>
1731 <tr><td colspan="4" class="doc" id="cxxReinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
1732
1733 Either the source expression or the destination type can be matched
1734 using has(), but hasDestinationType() is more specific and can be
1735 more readable.
1736
1737 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
1738   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
1739 </pre></td></tr>
1740
1741
1742 <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>
1743 <tr><td colspan="4" class="doc" id="cxxRewrittenBinaryOperator0"><pre>Matches rewritten binary operators
1744
1745 Example matches use of "&lt;":
1746   #include &lt;compare&gt;
1747   struct HasSpaceshipMem {
1748     int a;
1749     constexpr auto operator&lt;=&gt;(const HasSpaceshipMem&amp;) const = default;
1750   };
1751   void compare() {
1752     HasSpaceshipMem hs1, hs2;
1753     if (hs1 &lt; hs2)
1754         return;
1755   }
1756 See also the binaryOperation() matcher for more-general matching
1757 of this AST node.
1758 </pre></td></tr>
1759
1760
1761 <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>
1762 <tr><td colspan="4" class="doc" id="cxxStaticCastExpr0"><pre>Matches a C++ static_cast expression.
1763
1764 See also: hasDestinationType
1765 See also: reinterpretCast
1766
1767 Example:
1768   cxxStaticCastExpr()
1769 matches
1770   static_cast&lt;long&gt;(8)
1771 in
1772   long eight(static_cast&lt;long&gt;(8));
1773 </pre></td></tr>
1774
1775
1776 <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>
1777 <tr><td colspan="4" class="doc" id="cxxStdInitializerListExpr0"><pre>Matches C++ initializer list expressions.
1778
1779 Given
1780   std::vector&lt;int&gt; a({ 1, 2, 3 });
1781   std::vector&lt;int&gt; b = { 4, 5 };
1782   int c[] = { 6, 7 };
1783   std::pair&lt;int, int&gt; d = { 8, 9 };
1784 cxxStdInitializerListExpr()
1785   matches "{ 1, 2, 3 }" and "{ 4, 5 }"
1786 </pre></td></tr>
1787
1788
1789 <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>
1790 <tr><td colspan="4" class="doc" id="cxxTemporaryObjectExpr0"><pre>Matches functional cast expressions having N != 1 arguments
1791
1792 Example: Matches Foo(bar, bar)
1793   Foo h = Foo(bar, bar);
1794 </pre></td></tr>
1795
1796
1797 <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>
1798 <tr><td colspan="4" class="doc" id="cxxThisExpr0"><pre>Matches implicit and explicit this expressions.
1799
1800 Example matches the implicit this expression in "return i".
1801     (matcher = cxxThisExpr())
1802 struct foo {
1803   int i;
1804   int f() { return i; }
1805 };
1806 </pre></td></tr>
1807
1808
1809 <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>
1810 <tr><td colspan="4" class="doc" id="cxxThrowExpr0"><pre>Matches throw expressions.
1811
1812   try { throw 5; } catch(int i) {}
1813 cxxThrowExpr()
1814   matches 'throw 5'
1815 </pre></td></tr>
1816
1817
1818 <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>
1819 <tr><td colspan="4" class="doc" id="cxxTryStmt0"><pre>Matches try statements.
1820
1821   try {} catch(int i) {}
1822 cxxTryStmt()
1823   matches 'try {}'
1824 </pre></td></tr>
1825
1826
1827 <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>
1828 <tr><td colspan="4" class="doc" id="cxxUnresolvedConstructExpr0"><pre>Matches unresolved constructor call expressions.
1829
1830 Example matches T(t) in return statement of f
1831     (matcher = cxxUnresolvedConstructExpr())
1832   template &lt;typename T&gt;
1833   void f(const T&amp; t) { return T(t); }
1834 </pre></td></tr>
1835
1836
1837 <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>
1838 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
1839
1840 Example matches x in if (x)
1841   bool x;
1842   if (x) {}
1843 </pre></td></tr>
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('dependentScopeDeclRefExpr0')"><a name="dependentScopeDeclRefExpr0Anchor">dependentScopeDeclRefExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentScopeDeclRefExpr.html">DependentScopeDeclRefExpr</a>&gt;...</td></tr>
1846 <tr><td colspan="4" class="doc" id="dependentScopeDeclRefExpr0"><pre>Matches expressions that refer to dependent scope declarations.
1847
1848 Example matches T::v
1849    template <class T> class X : T { void f() { T::v; } };
1850 </pre></td></tr>
1851
1852 <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>
1853 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
1854
1855 Given
1856   int a;
1857 declStmt()
1858   matches 'int a'.
1859 </pre></td></tr>
1860
1861
1862 <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>
1863 <tr><td colspan="4" class="doc" id="defaultStmt0"><pre>Matches default statements inside switch statements.
1864
1865 Given
1866   switch(a) { case 42: break; default: break; }
1867 defaultStmt()
1868   matches 'default:'.
1869 </pre></td></tr>
1870
1871
1872 <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>
1873 <tr><td colspan="4" class="doc" id="dependentCoawaitExpr0"><pre>Matches co_await expressions where the type of the promise is dependent
1874 </pre></td></tr>
1875
1876
1877 <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>
1878 <tr><td colspan="4" class="doc" id="designatedInitExpr0"><pre>Matches C99 designated initializer expressions [C99 6.7.8].
1879
1880 Example: Matches { [2].y = 1.0, [0].x = 1.0 }
1881   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
1882 </pre></td></tr>
1883
1884
1885 <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>
1886 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
1887
1888 Given
1889   do {} while (true);
1890 doStmt()
1891   matches 'do {} while(true)'
1892 </pre></td></tr>
1893
1894
1895 <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>
1896 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
1897
1898 Matches any cast expression written in user code, whether it be a
1899 C-style cast, a functional-style cast, or a keyword cast.
1900
1901 Does not match implicit conversions.
1902
1903 Note: the name "explicitCast" is chosen to match Clang's terminology, as
1904 Clang uses the term "cast" to apply to implicit conversions as well as to
1905 actual cast expressions.
1906
1907 See also: hasDestinationType.
1908
1909 Example: matches all five of the casts in
1910   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
1911 but does not match the implicit conversion in
1912   long ell = 42;
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('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>
1917 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
1918
1919 Example matches x()
1920   void f() { x(); }
1921 </pre></td></tr>
1922
1923
1924 <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>
1925 <tr><td colspan="4" class="doc" id="exprWithCleanups0"><pre>Matches expressions that introduce cleanups to be run at the end
1926 of the sub-expression's evaluation.
1927
1928 Example matches std::string()
1929   const std::string str = std::string();
1930 </pre></td></tr>
1931
1932
1933 <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>
1934 <tr><td colspan="4" class="doc" id="fixedPointLiteral0"><pre>Matches fixed point literals
1935 </pre></td></tr>
1936
1937
1938 <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>
1939 <tr><td colspan="4" class="doc" id="floatLiteral0"><pre>Matches float literals of all sizes / encodings, e.g.
1940 1.0, 1.0f, 1.0L and 1e10.
1941
1942 Does not match implicit conversions such as
1943   float a = 10;
1944 </pre></td></tr>
1945
1946
1947 <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>
1948 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
1949
1950 Example matches 'for (;;) {}'
1951   for (;;) {}
1952   int i[] =  {1, 2, 3}; for (auto a : i);
1953 </pre></td></tr>
1954
1955
1956 <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>
1957 <tr><td colspan="4" class="doc" id="genericSelectionExpr0"><pre>Matches C11 _Generic expression.
1958 </pre></td></tr>
1959
1960
1961 <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>
1962 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
1963 </pre></td></tr>
1964
1965
1966 <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>
1967 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
1968
1969 Given
1970   goto FOO;
1971   FOO: bar();
1972 gotoStmt()
1973   matches 'goto FOO'
1974 </pre></td></tr>
1975
1976
1977 <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>
1978 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
1979
1980 Example matches 'if (x) {}'
1981   if (x) {}
1982 </pre></td></tr>
1983
1984
1985 <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>
1986 <tr><td colspan="4" class="doc" id="imaginaryLiteral0"><pre>Matches imaginary literals, which are based on integer and floating
1987 point literals e.g.: 1i, 1.0i
1988 </pre></td></tr>
1989
1990
1991 <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>
1992 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
1993
1994 This matches many different places, including function call return value
1995 eliding, as well as any type conversions.
1996 </pre></td></tr>
1997
1998
1999 <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>
2000 <tr><td colspan="4" class="doc" id="implicitValueInitExpr0"><pre>Matches implicit initializers of init list expressions.
2001
2002 Given
2003   point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
2004 implicitValueInitExpr()
2005   matches "[0].y" (implicitly)
2006 </pre></td></tr>
2007
2008
2009 <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>
2010 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
2011
2012 Given
2013   int a[] = { 1, 2 };
2014   struct B { int x, y; };
2015   B b = { 5, 6 };
2016 initListExpr()
2017   matches "{ 1, 2 }" and "{ 5, 6 }"
2018 </pre></td></tr>
2019
2020
2021 <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>
2022 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes / encodings, e.g.
2023 1, 1L, 0x1 and 1U.
2024
2025 Does not match character-encoded integers such as L'a'.
2026 </pre></td></tr>
2027
2028
2029 <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>
2030 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
2031
2032 Given
2033   goto FOO;
2034   FOO: bar();
2035 labelStmt()
2036   matches 'FOO:'
2037 </pre></td></tr>
2038
2039
2040 <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>
2041 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
2042
2043 Example matches [&amp;](){return 5;}
2044   [&amp;](){return 5;}
2045 </pre></td></tr>
2046
2047
2048 <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>
2049 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
2050
2051 Example: Given
2052   struct T {void func();};
2053   T f();
2054   void g(T);
2055 materializeTemporaryExpr() matches 'f()' in these statements
2056   T u(f());
2057   g(f());
2058   f().func();
2059 but does not match
2060   f();
2061 </pre></td></tr>
2062
2063
2064 <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>
2065 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
2066
2067 Given
2068   class Y {
2069     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
2070     int a; static int b;
2071   };
2072 memberExpr()
2073   matches this-&gt;x, x, y.x, a, this-&gt;b
2074 </pre></td></tr>
2075
2076
2077 <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>
2078 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
2079
2080   foo();;
2081 nullStmt()
2082   matches the second ';'
2083 </pre></td></tr>
2084
2085
2086 <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>
2087 <tr><td colspan="4" class="doc" id="objcCatchStmt0"><pre>Matches Objective-C @catch statements.
2088
2089 Example matches @catch
2090   @try {}
2091   @catch (...) {}
2092 </pre></td></tr>
2093
2094
2095 <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>
2096 <tr><td colspan="4" class="doc" id="objcFinallyStmt0"><pre>Matches Objective-C @finally statements.
2097
2098 Example matches @finally
2099   @try {}
2100   @finally {}
2101 </pre></td></tr>
2102
2103
2104 <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>
2105 <tr><td colspan="4" class="doc" id="objcIvarRefExpr0"><pre>Matches a reference to an ObjCIvar.
2106
2107 Example: matches "a" in "init" method:
2108 @implementation A {
2109   NSString *a;
2110 }
2111 - (void) init {
2112   a = @"hello";
2113 }
2114 </pre></td></tr>
2115
2116
2117 <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>
2118 <tr><td colspan="4" class="doc" id="objcMessageExpr0"><pre>Matches ObjectiveC Message invocation expressions.
2119
2120 The innermost message send invokes the "alloc" class method on the
2121 NSString class, while the outermost message send invokes the
2122 "initWithString" instance method on the object returned from
2123 NSString's "alloc". This matcher should match both message sends.
2124   [[NSString alloc] initWithString:@"Hello"]
2125 </pre></td></tr>
2126
2127
2128 <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>
2129 <tr><td colspan="4" class="doc" id="objcStringLiteral0"><pre>Matches ObjectiveC String literal expressions.
2130
2131 Example matches @"abcd"
2132   NSString *s = @"abcd";
2133 </pre></td></tr>
2134
2135
2136 <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>
2137 <tr><td colspan="4" class="doc" id="objcThrowStmt0"><pre>Matches Objective-C statements.
2138
2139 Example matches @throw obj;
2140 </pre></td></tr>
2141
2142
2143 <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>
2144 <tr><td colspan="4" class="doc" id="objcTryStmt0"><pre>Matches Objective-C @try statements.
2145
2146 Example matches @try
2147   @try {}
2148   @catch (...) {}
2149 </pre></td></tr>
2150
2151
2152 <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>
2153 <tr><td colspan="4" class="doc" id="ompExecutableDirective0"><pre>Matches any ``#pragma omp`` executable directive.
2154
2155 Given
2156
2157   #pragma omp parallel
2158   #pragma omp parallel default(none)
2159   #pragma omp taskyield
2160
2161 ``ompExecutableDirective()`` matches ``omp parallel``,
2162 ``omp parallel default(none)`` and ``omp taskyield``.
2163 </pre></td></tr>
2164
2165
2166 <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>
2167 <tr><td colspan="4" class="doc" id="opaqueValueExpr0"><pre>Matches opaque value expressions. They are used as helpers
2168 to reference another expressions and can be met
2169 in BinaryConditionalOperators, for example.
2170
2171 Example matches 'a'
2172   (a ?: c) + 42;
2173 </pre></td></tr>
2174
2175
2176 <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>
2177 <tr><td colspan="4" class="doc" id="parenExpr0"><pre>Matches parentheses used in expressions.
2178
2179 Example matches (foo() + 1)
2180   int foo() { return 1; }
2181   int a = (foo() + 1);
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('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>
2186 <tr><td colspan="4" class="doc" id="parenListExpr0"><pre>Matches paren list expressions.
2187 ParenListExprs don't have a predefined type and are used for late parsing.
2188 In the final AST, they can be met in template declarations.
2189
2190 Given
2191   template&lt;typename T&gt; class X {
2192     void f() {
2193       X x(*this);
2194       int a = 0, b = 1; int i = (a, b);
2195     }
2196   };
2197 parenListExpr() matches "*this" but NOT matches (a, b) because (a, b)
2198 has a predefined type and is a ParenExpr, not a ParenListExpr.
2199 </pre></td></tr>
2200
2201
2202 <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>
2203 <tr><td colspan="4" class="doc" id="predefinedExpr0"><pre>Matches predefined identifier expressions [C99 6.4.2.2].
2204
2205 Example: Matches __func__
2206   printf("%s", __func__);
2207 </pre></td></tr>
2208
2209
2210 <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>
2211 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
2212
2213 Given
2214   return 1;
2215 returnStmt()
2216   matches 'return 1'
2217 </pre></td></tr>
2218
2219
2220 <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>
2221 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
2222
2223 Given
2224   { ++a; }
2225 stmt()
2226   matches both the compound statement '{ ++a; }' and '++a'.
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('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>
2231 <tr><td colspan="4" class="doc" id="stmtExpr0"><pre>Matches statement expression (GNU extension).
2232
2233 Example match: ({ int X = 4; X; })
2234   int C = ({ int X = 4; X; });
2235 </pre></td></tr>
2236
2237
2238 <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>
2239 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
2240
2241 Example matches "abcd", L"abcd"
2242   char *s = "abcd";
2243   wchar_t *ws = L"abcd";
2244 </pre></td></tr>
2245
2246
2247 <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>
2248 <tr><td colspan="4" class="doc" id="substNonTypeTemplateParmExpr0"><pre>Matches substitutions of non-type template parameters.
2249
2250 Given
2251   template &lt;int N&gt;
2252   struct A { static const int n = N; };
2253   struct B : public A&lt;42&gt; {};
2254 substNonTypeTemplateParmExpr()
2255   matches "N" in the right-hand side of "static const int n = N;"
2256 </pre></td></tr>
2257
2258
2259 <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>
2260 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
2261
2262 Given
2263   switch(a) { case 42: break; default: break; }
2264 switchCase()
2265   matches 'case 42:' and 'default:'.
2266 </pre></td></tr>
2267
2268
2269 <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>
2270 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
2271
2272 Given
2273   switch(a) { case 42: break; default: break; }
2274 switchStmt()
2275   matches 'switch(a)'.
2276 </pre></td></tr>
2277
2278
2279 <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>
2280 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
2281
2282 Given
2283   Foo x = bar;
2284   int y = sizeof(x) + alignof(x);
2285 unaryExprOrTypeTraitExpr()
2286   matches sizeof(x) and alignof(x)
2287 </pre></td></tr>
2288
2289
2290 <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>
2291 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
2292
2293 Example matches !a
2294   !a || b
2295 </pre></td></tr>
2296
2297
2298 <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>
2299 <tr><td colspan="4" class="doc" id="unresolvedLookupExpr0"><pre>Matches reference to a name that can be looked up during parsing
2300 but could not be resolved to a specific declaration.
2301
2302 Given
2303   template&lt;typename T&gt;
2304   T foo() { T a; return a; }
2305   template&lt;typename T&gt;
2306   void bar() {
2307     foo&lt;T&gt;();
2308   }
2309 unresolvedLookupExpr()
2310   matches foo&lt;T&gt;() </pre></td></tr>
2311
2312
2313 <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>
2314 <tr><td colspan="4" class="doc" id="unresolvedMemberExpr0"><pre>Matches unresolved member expressions.
2315
2316 Given
2317   struct X {
2318     template &lt;class T&gt; void f();
2319     void g();
2320   };
2321   template &lt;class T&gt; void h() { X x; x.f&lt;T&gt;(); x.g(); }
2322 unresolvedMemberExpr()
2323   matches x.f&lt;T&gt;
2324 </pre></td></tr>
2325
2326
2327 <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>
2328 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
2329
2330 Example match: "foo"_suffix
2331 </pre></td></tr>
2332
2333
2334 <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>
2335 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
2336
2337 Given
2338   while (true) {}
2339 whileStmt()
2340   matches 'while (true) {}'.
2341 </pre></td></tr>
2342
2343
2344 <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>
2345 <tr><td colspan="4" class="doc" id="templateArgumentLoc0"><pre>Matches template arguments (with location info).
2346
2347 Given
2348   template &lt;typename T&gt; struct C {};
2349   C&lt;int&gt; c;
2350 templateArgumentLoc()
2351   matches 'int' in C&lt;int&gt;.
2352 </pre></td></tr>
2353
2354
2355 <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>
2356 <tr><td colspan="4" class="doc" id="templateArgument0"><pre>Matches template arguments.
2357
2358 Given
2359   template &lt;typename T&gt; struct C {};
2360   C&lt;int&gt; c;
2361 templateArgument()
2362   matches 'int' in C&lt;int&gt;.
2363 </pre></td></tr>
2364
2365
2366 <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>
2367 <tr><td colspan="4" class="doc" id="templateName0"><pre>Matches template name.
2368
2369 Given
2370   template &lt;typename T&gt; class X { };
2371   X&lt;int&gt; xi;
2372 templateName()
2373   matches 'X' in X&lt;int&gt;.
2374 </pre></td></tr>
2375
2376
2377 <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>
2378 <tr><td colspan="4" class="doc" id="elaboratedTypeLoc0"><pre>Matches C or C++ elaborated `TypeLoc`s.
2379
2380 Given
2381   struct s {};
2382   struct s ss;
2383 elaboratedTypeLoc()
2384   matches the `TypeLoc` of the variable declaration of `ss`.
2385 </pre></td></tr>
2386
2387
2388 <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>
2389 <tr><td colspan="4" class="doc" id="pointerTypeLoc0"><pre>Matches pointer `TypeLoc`s.
2390
2391 Given
2392   int* x;
2393 pointerTypeLoc()
2394   matches `int*`.
2395 </pre></td></tr>
2396
2397
2398 <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>
2399 <tr><td colspan="4" class="doc" id="qualifiedTypeLoc0"><pre>Matches `QualifiedTypeLoc`s in the clang AST.
2400
2401 Given
2402   const int x = 0;
2403 qualifiedTypeLoc()
2404   matches `const int`.
2405 </pre></td></tr>
2406
2407
2408 <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>
2409 <tr><td colspan="4" class="doc" id="referenceTypeLoc0"><pre>Matches reference `TypeLoc`s.
2410
2411 Given
2412   int x = 3;
2413   int&amp; l = x;
2414   int&amp;&amp; r = 3;
2415 referenceTypeLoc()
2416   matches `int&amp;` and `int&amp;&amp;`.
2417 </pre></td></tr>
2418
2419
2420 <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>
2421 <tr><td colspan="4" class="doc" id="templateSpecializationTypeLoc0"><pre>Matches template specialization `TypeLoc`s.
2422
2423 Given
2424   template &lt;typename T&gt; class C {};
2425   C&lt;char&gt; var;
2426 varDecl(hasTypeLoc(templateSpecializationTypeLoc(typeLoc())))
2427   matches `C&lt;char&gt; var`.
2428 </pre></td></tr>
2429
2430
2431 <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>
2432 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
2433 </pre></td></tr>
2434
2435
2436 <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>
2437 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
2438
2439 Given
2440   int a[] = { 2, 3 };
2441   int b[4];
2442   void f() { int c[a[0]]; }
2443 arrayType()
2444   matches "int a[]", "int b[4]" and "int c[a[0]]";
2445 </pre></td></tr>
2446
2447
2448 <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>
2449 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
2450
2451 Given
2452   _Atomic(int) i;
2453 atomicType()
2454   matches "_Atomic(int) i"
2455 </pre></td></tr>
2456
2457
2458 <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>
2459 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
2460
2461 Given:
2462   auto n = 4;
2463   int v[] = { 2, 3 }
2464   for (auto i : v) { }
2465 autoType()
2466   matches "auto n" and "auto i"
2467 </pre></td></tr>
2468
2469
2470 <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>
2471 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
2472 "void (^)(int)".
2473
2474 The pointee is always required to be a FunctionType.
2475 </pre></td></tr>
2476
2477
2478 <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>
2479 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
2480
2481 Given
2482   struct A {};
2483   A a;
2484   int b;
2485   float c;
2486   bool d;
2487 builtinType()
2488   matches "int b", "float c" and "bool d"
2489 </pre></td></tr>
2490
2491
2492 <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>
2493 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
2494
2495 Given
2496   _Complex float f;
2497 complexType()
2498   matches "_Complex float f"
2499 </pre></td></tr>
2500
2501
2502 <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>
2503 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
2504
2505 Given
2506   void() {
2507     int a[2];
2508     int b[] = { 2, 3 };
2509     int c[b[0]];
2510   }
2511 constantArrayType()
2512   matches "int a[2]"
2513 </pre></td></tr>
2514
2515
2516 <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>
2517 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
2518 Example matches i[] in declaration of f.
2519     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
2520 Example matches i[1].
2521     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
2522   void f(int i[]) {
2523     i[1] = 0;
2524   }
2525 </pre></td></tr>
2526
2527
2528 <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>
2529 <tr><td colspan="4" class="doc" id="decltypeType0"><pre>Matches types nodes representing C++11 decltype(&lt;expr&gt;) types.
2530
2531 Given:
2532   short i = 1;
2533   int j = 42;
2534   decltype(i + j) result = i + j;
2535 decltypeType()
2536   matches "decltype(i + j)"
2537 </pre></td></tr>
2538
2539 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentNameType0')"><a name="dependentNameType0Anchor">dependentNameType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentNameType.html">DependentNameType</a>&gt;...</td></tr>
2540 <tr><td colspan="4" class="doc" id="dependentNameType0"><pre>Matches a dependent name type.
2541
2542 Example matches T::type
2543
2544   template <typename T> struct declToImport {
2545     typedef typename T::type dependent_name;
2546   };
2547 </pre></td></tr>
2548
2549 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentTemplateSpecializationType0')"><a name="dependentTemplateSpecializationType0Anchor">dependentTemplateSpecializationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentTemplateSpecializationType.html">DependentTemplateSpecializationType</a>&gt;...</td></tr>
2550 <tr><td colspan="4" class="doc" id="dependentTemplateSpecializationType0"><pre>Matches a dependent template specialization type.
2551
2552 Example matches A<T>::template B<T>
2553
2554   template<typename T> struct A;
2555   template<typename T> struct declToImport {
2556     typename A<T>::template B<T> a;
2557   };
2558 </pre></td></tr>
2559
2560 <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>
2561 <tr><td colspan="4" class="doc" id="deducedTemplateSpecializationType0"><pre>Matches C++17 deduced template specialization types, e.g. deduced class
2562 template types.
2563
2564 Given
2565   template &lt;typename T&gt;
2566   class C { public: C(T); };
2567
2568   C c(123);
2569 deducedTemplateSpecializationType() matches the type in the declaration
2570 of the variable c.
2571 </pre></td></tr>
2572
2573
2574 <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>
2575 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
2576
2577 Given
2578   template&lt;typename T, int Size&gt;
2579   class array {
2580     T data[Size];
2581   };
2582 dependentSizedArrayType()
2583   matches "T data[Size]"
2584 </pre></td></tr>
2585
2586
2587 <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>
2588 <tr><td colspan="4" class="doc" id="dependentSizedExtVectorType0"><pre>Matches C++ extended vector type where either the type or size is
2589 dependent.
2590
2591 Given
2592   template&lt;typename T, int Size&gt;
2593   class vector {
2594     typedef T __attribute__((ext_vector_type(Size))) type;
2595   };
2596 dependentSizedExtVectorType()
2597   matches "T __attribute__((ext_vector_type(Size)))"
2598 </pre></td></tr>
2599
2600
2601 <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>
2602 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
2603 qualified name.
2604
2605 Given
2606   namespace N {
2607     namespace M {
2608       class D {};
2609     }
2610   }
2611   class C {};
2612
2613   class C c;
2614   N::M::D d;
2615
2616 elaboratedType() matches the type of the variable declarations of both
2617 c and d.
2618 </pre></td></tr>
2619
2620
2621 <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>
2622 <tr><td colspan="4" class="doc" id="enumType0"><pre>Matches enum types.
2623
2624 Given
2625   enum C { Green };
2626   enum class S { Red };
2627
2628   C c;
2629   S s;
2630
2631 enumType() matches the type of the variable declarations of both c and
2632 s.
2633 </pre></td></tr>
2634
2635
2636 <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>
2637 <tr><td colspan="4" class="doc" id="functionProtoType0"><pre>Matches FunctionProtoType nodes.
2638
2639 Given
2640   int (*f)(int);
2641   void g();
2642 functionProtoType()
2643   matches "int (*f)(int)" and the type of "g" in C++ mode.
2644   In C mode, "g" is not matched because it does not contain a prototype.
2645 </pre></td></tr>
2646
2647
2648 <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>
2649 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
2650
2651 Given
2652   int (*f)(int);
2653   void g();
2654 functionType()
2655   matches "int (*f)(int)" and the type of "g".
2656 </pre></td></tr>
2657
2658
2659 <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>
2660 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
2661
2662 Given
2663   int a[] = { 2, 3 };
2664   int b[42];
2665   void f(int c[]) { int d[a[0]]; };
2666 incompleteArrayType()
2667   matches "int a[]" and "int c[]"
2668 </pre></td></tr>
2669
2670
2671 <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>
2672 <tr><td colspan="4" class="doc" id="injectedClassNameType0"><pre>Matches injected class name types.
2673
2674 Example matches S s, but not S&lt;T&gt; s.
2675     (matcher = parmVarDecl(hasType(injectedClassNameType())))
2676   template &lt;typename T&gt; struct S {
2677     void f(S s);
2678     void g(S&lt;T&gt; s);
2679   };
2680 </pre></td></tr>
2681
2682
2683 <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>
2684 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
2685
2686 Given:
2687   int *a;
2688   int &amp;b = *a;
2689   int &amp;&amp;c = 1;
2690   auto &amp;d = b;
2691   auto &amp;&amp;e = c;
2692   auto &amp;&amp;f = 2;
2693   int g = 5;
2694
2695 lValueReferenceType() matches the types of b, d, and e. e is
2696 matched since the type is deduced as int&amp; by reference collapsing rules.
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('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>
2701 <tr><td colspan="4" class="doc" id="macroQualifiedType0"><pre>Matches qualified types when the qualifier is applied via a macro.
2702
2703 Given
2704   #define CDECL __attribute__((cdecl))
2705   typedef void (CDECL *X)();
2706   typedef void (__attribute__((cdecl)) *Y)();
2707 macroQualifiedType()
2708   matches the type of the typedef declaration of X but not Y.
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('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>
2713 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
2714 Given
2715   struct A { int i; }
2716   A::* ptr = A::i;
2717 memberPointerType()
2718   matches "A::* ptr"
2719 </pre></td></tr>
2720
2721
2722 <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>
2723 <tr><td colspan="4" class="doc" id="objcObjectPointerType0"><pre>Matches an Objective-C object pointer type, which is different from
2724 a pointer type, despite being syntactically similar.
2725
2726 Given
2727   int *a;
2728
2729   @interface Foo
2730   @end
2731   Foo *f;
2732 pointerType()
2733   matches "Foo *f", but does not match "int *a".
2734 </pre></td></tr>
2735
2736
2737 <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>
2738 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
2739
2740 Given
2741   int (*ptr_to_array)[4];
2742   int *array_of_ptrs[4];
2743
2744 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
2745 array_of_ptrs.
2746 </pre></td></tr>
2747
2748
2749 <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>
2750 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
2751 types.
2752
2753 Given
2754   int *a;
2755   int &amp;b = *a;
2756   int c = 5;
2757
2758   @interface Foo
2759   @end
2760   Foo *f;
2761 pointerType()
2762   matches "int *a", but does not match "Foo *f".
2763 </pre></td></tr>
2764
2765
2766 <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>
2767 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
2768
2769 Given:
2770   int *a;
2771   int &amp;b = *a;
2772   int &amp;&amp;c = 1;
2773   auto &amp;d = b;
2774   auto &amp;&amp;e = c;
2775   auto &amp;&amp;f = 2;
2776   int g = 5;
2777
2778 rValueReferenceType() matches the types of c and f. e is not
2779 matched as it is deduced to int&amp; by reference collapsing rules.
2780 </pre></td></tr>
2781
2782
2783 <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>
2784 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
2785
2786 Given
2787   class C {};
2788   struct S {};
2789
2790   C c;
2791   S s;
2792
2793 recordType() matches the type of the variable declarations of both c
2794 and s.
2795 </pre></td></tr>
2796
2797
2798 <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>
2799 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
2800
2801 Given
2802   int *a;
2803   int &amp;b = *a;
2804   int &amp;&amp;c = 1;
2805   auto &amp;d = b;
2806   auto &amp;&amp;e = c;
2807   auto &amp;&amp;f = 2;
2808   int g = 5;
2809
2810 referenceType() matches the types of b, c, d, e, and f.
2811 </pre></td></tr>
2812
2813
2814 <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>
2815 <tr><td colspan="4" class="doc" id="substTemplateTypeParmType0"><pre>Matches types that represent the result of substituting a type for a
2816 template type parameter.
2817
2818 Given
2819   template &lt;typename T&gt;
2820   void F(T t) {
2821     int i = 1 + t;
2822   }
2823
2824 substTemplateTypeParmType() matches the type of 't' but not '1'
2825 </pre></td></tr>
2826
2827
2828 <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>
2829 <tr><td colspan="4" class="doc" id="tagType0"><pre>Matches tag types (record and enum types).
2830
2831 Given
2832   enum E {};
2833   class C {};
2834
2835   E e;
2836   C c;
2837
2838 tagType() matches the type of the variable declarations of both e
2839 and c.
2840 </pre></td></tr>
2841
2842
2843 <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>
2844 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
2845
2846 Given
2847   template &lt;typename T&gt;
2848   class C { };
2849
2850   template class C&lt;int&gt;;  // A
2851   C&lt;char&gt; var;            // B
2852
2853 templateSpecializationType() matches the type of the explicit
2854 instantiation in A and the type of the variable declaration in B.
2855 </pre></td></tr>
2856
2857
2858 <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>
2859 <tr><td colspan="4" class="doc" id="templateTypeParmType0"><pre>Matches template type parameter types.
2860
2861 Example matches T, but not int.
2862     (matcher = templateTypeParmType())
2863   template &lt;typename T&gt; void f(int i);
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('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>
2868 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
2869 </pre></td></tr>
2870
2871
2872 <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>
2873 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
2874
2875 Given
2876   typedef int X;
2877 typedefType()
2878   matches "typedef int X"
2879 </pre></td></tr>
2880
2881
2882 <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>
2883 <tr><td colspan="4" class="doc" id="unaryTransformType0"><pre>Matches types nodes representing unary type transformations.
2884
2885 Given:
2886   typedef __underlying_type(T) type;
2887 unaryTransformType()
2888   matches "__underlying_type(T)"
2889 </pre></td></tr>
2890
2891
2892 <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>
2893 <tr><td colspan="4" class="doc" id="usingType0"><pre>Matches types specified through a using declaration.
2894
2895 Given
2896   namespace a { struct S {}; }
2897   using a::S;
2898   S s;
2899
2900 usingType() matches the type of the variable declaration of s.
2901 </pre></td></tr>
2902
2903
2904 <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>
2905 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
2906 integer-constant-expression.
2907
2908 Given
2909   void f() {
2910     int a[] = { 2, 3 }
2911     int b[42];
2912     int c[a[0]];
2913   }
2914 variableArrayType()
2915   matches "int c[a[0]]"
2916 </pre></td></tr>
2917
2918 <!--END_DECL_MATCHERS -->
2919 </table>
2920
2921 <!-- ======================================================================= -->
2922 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
2923 <!-- ======================================================================= -->
2924
2925 <p>Narrowing matchers match certain attributes on the current node, thus
2926 narrowing down the set of nodes of the current type to match on.</p>
2927
2928 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
2929 which allow users to create more powerful match expressions.</p>
2930
2931 <table>
2932 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
2933 <!-- START_NARROWING_MATCHERS -->
2934
2935 <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>
2936 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
2937
2938 Usable as: Any Matcher
2939 </pre></td></tr>
2940
2941
2942 <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>
2943 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
2944
2945 Usable as: Any Matcher
2946 </pre></td></tr>
2947
2948
2949 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
2950 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
2951
2952 Useful when another matcher requires a child matcher, but there's no
2953 additional constraint. This will often be used with an explicit conversion
2954 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
2955
2956 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
2957 "int* p" and "void f()" in
2958   int* p;
2959   void f();
2960
2961 Usable as: Any Matcher
2962 </pre></td></tr>
2963
2964
2965 <tr><td><em>unspecified</em></td><td class="name" onclick="toggle('mapAnyOf0')"><a name="mapAnyOf0Anchor">mapAnyOf</a></td><td>nodeMatcherFunction...</td></tr>
2966 <tr><td colspan="4" class="doc" id="mapAnyOf0"><pre>Matches any of the NodeMatchers with InnerMatchers nested within
2967
2968 Given
2969   if (true);
2970   for (; true; );
2971 with the matcher
2972   mapAnyOf(ifStmt, forStmt).with(
2973     hasCondition(cxxBoolLiteralExpr(equals(true)))
2974     ).bind("trueCond")
2975 matches the if and the for. It is equivalent to:
2976   auto trueCond = hasCondition(cxxBoolLiteralExpr(equals(true)));
2977   anyOf(
2978     ifStmt(trueCond).bind("trueCond"),
2979     forStmt(trueCond).bind("trueCond")
2980     );
2981
2982 The with() chain-call accepts zero or more matchers which are combined
2983 as-if with allOf() in each of the node matchers.
2984 Usable as: Any Matcher
2985 </pre></td></tr>
2986
2987
2988 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;</td></tr>
2989 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
2990
2991 Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
2992   class X {};
2993   class Y {};
2994
2995 Usable as: Any Matcher
2996 </pre></td></tr>
2997
2998
2999 <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>
3000 <tr><td colspan="4" class="doc" id="isImplicit1"><pre>Matches an entity that has been implicitly added by the compiler (e.g.
3001 implicit default/copy constructors).
3002 </pre></td></tr>
3003
3004
3005 <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>
3006 <tr><td colspan="4" class="doc" id="hasAnyOperatorName0"><pre>Matches operator expressions (binary or unary) that have any of the
3007 specified names.
3008
3009    hasAnyOperatorName("+", "-")
3010  Is equivalent to
3011    anyOf(hasOperatorName("+"), hasOperatorName("-"))
3012 </pre></td></tr>
3013
3014
3015 <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>
3016 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions and fold expressions
3017 (binary or unary).
3018
3019 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3020   !(a || b)
3021
3022 Example matches `(0 + ... + args)`
3023     (matcher = cxxFoldExpr(hasOperatorName("+")))
3024   template &lt;typename... Args&gt;
3025   auto sum(Args... args) {
3026       return (0 + ... + args);
3027   }
3028 </pre></td></tr>
3029
3030
3031 <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>
3032 <tr><td colspan="4" class="doc" id="isAssignmentOperator0"><pre>Matches all kinds of assignment operators.
3033
3034 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
3035   if (a == b)
3036     a += b;
3037
3038 Example 2: matches s1 = s2
3039            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
3040   struct S { S&amp; operator=(const S&amp;); };
3041   void x() { S s1, s2; s1 = s2; }
3042 </pre></td></tr>
3043
3044
3045 <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>
3046 <tr><td colspan="4" class="doc" id="isComparisonOperator0"><pre>Matches comparison operators.
3047
3048 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
3049   if (a == b)
3050     a += b;
3051
3052 Example 2: matches s1 &lt; s2
3053            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
3054   struct S { bool operator&lt;(const S&amp; other); };
3055   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
3056 </pre></td></tr>
3057
3058
3059 <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>
3060 <tr><td colspan="4" class="doc" id="isPrivate1"><pre>Matches private C++ declarations and C++ base specifers that specify private
3061 inheritance.
3062
3063 Examples:
3064   class C {
3065   public:    int a;
3066   protected: int b;
3067   private:   int c; // fieldDecl(isPrivate()) matches 'c'
3068   };
3069
3070   struct Base {};
3071   struct Derived1 : private Base {}; // matches 'Base'
3072   class Derived2 : Base {}; // matches 'Base'
3073 </pre></td></tr>
3074
3075
3076 <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>
3077 <tr><td colspan="4" class="doc" id="isProtected1"><pre>Matches protected C++ declarations and C++ base specifers that specify
3078 protected inheritance.
3079
3080 Examples:
3081   class C {
3082   public:    int a;
3083   protected: int b; // fieldDecl(isProtected()) matches 'b'
3084   private:   int c;
3085   };
3086
3087   class Base {};
3088   class Derived : protected Base {}; // matches 'Base'
3089 </pre></td></tr>
3090
3091
3092 <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>
3093 <tr><td colspan="4" class="doc" id="isPublic1"><pre>Matches public C++ declarations and C++ base specifers that specify public
3094 inheritance.
3095
3096 Examples:
3097   class C {
3098   public:    int a; // fieldDecl(isPublic()) matches 'a'
3099   protected: int b;
3100   private:   int c;
3101   };
3102
3103   class Base {};
3104   class Derived1 : public Base {}; // matches 'Base'
3105   struct Derived2 : Base {}; // matches 'Base'
3106 </pre></td></tr>
3107
3108
3109 <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>
3110 <tr><td colspan="4" class="doc" id="isVirtual1"><pre>Matches declarations of virtual methods and C++ base specifers that specify
3111 virtual inheritance.
3112
3113 Example:
3114   class A {
3115    public:
3116     virtual void x(); // matches x
3117   };
3118
3119 Example:
3120   class Base {};
3121   class DirectlyDerived : virtual Base {}; // matches Base
3122   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
3123
3124 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;
3125 </pre></td></tr>
3126
3127
3128 <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>
3129 <tr><td colspan="4" class="doc" id="equals5"><pre></pre></td></tr>
3130
3131
3132 <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>
3133 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value of type ValueT.
3134
3135 Given
3136   f('false, 3.14, 42);
3137 characterLiteral(equals(0))
3138   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
3139   match false
3140 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
3141   match 3.14
3142 integerLiteral(equals(42))
3143   matches 42
3144
3145 Note that you cannot directly match a negative numeric literal because the
3146 minus sign is not part of the literal: It is a unary operator whose operand
3147 is the positive numeric literal. Instead, you must use a unaryOperator()
3148 matcher to match the minus sign:
3149
3150 unaryOperator(hasOperatorName("-"),
3151               hasUnaryOperand(integerLiteral(equals(13))))
3152
3153 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;,
3154            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;
3155 </pre></td></tr>
3156
3157
3158 <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>
3159 <tr><td colspan="4" class="doc" id="equals11"><pre></pre></td></tr>
3160
3161
3162 <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>
3163 <tr><td colspan="4" class="doc" id="equals8"><pre></pre></td></tr>
3164
3165
3166 <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>
3167 <tr><td colspan="4" class="doc" id="isCatchAll0"><pre>Matches a C++ catch statement that has a catch-all handler.
3168
3169 Given
3170   try {
3171     // ...
3172   } catch (int) {
3173     // ...
3174   } catch (...) {
3175     // ...
3176   }
3177 cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
3178 </pre></td></tr>
3179
3180
3181 <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>
3182 <tr><td colspan="4" class="doc" id="argumentCountAtLeast1"><pre>Checks that a call expression or a constructor call expression has at least
3183 the specified number of arguments (including absent default arguments).
3184
3185 Example matches f(0, 0) and g(0, 0, 0)
3186 (matcher = callExpr(argumentCountAtLeast(2)))
3187   void f(int x, int y);
3188   void g(int x, int y, int z);
3189   f(0, 0);
3190   g(0, 0, 0);
3191 </pre></td></tr>
3192
3193
3194 <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>
3195 <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has
3196 a specific number of arguments (including absent default arguments).
3197
3198 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
3199   void f(int x, int y);
3200   f(0, 0);
3201 </pre></td></tr>
3202
3203
3204 <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>
3205 <tr><td colspan="4" class="doc" id="isListInitialization0"><pre>Matches a constructor call expression which uses list initialization.
3206 </pre></td></tr>
3207
3208
3209 <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>
3210 <tr><td colspan="4" class="doc" id="requiresZeroInitialization0"><pre>Matches a constructor call expression which requires
3211 zero initialization.
3212
3213 Given
3214 void foo() {
3215   struct point { double x; double y; };
3216   point pt[2] = { { 1.0, 2.0 } };
3217 }
3218 initListExpr(has(cxxConstructExpr(requiresZeroInitialization()))
3219 will match the implicit array filler for pt[1].
3220 </pre></td></tr>
3221
3222
3223 <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>
3224 <tr><td colspan="4" class="doc" id="isCopyConstructor0"><pre>Matches constructor declarations that are copy constructors.
3225
3226 Given
3227   struct S {
3228     S(); // #1
3229     S(const S &amp;); // #2
3230     S(S &amp;&amp;); // #3
3231   };
3232 cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
3233 </pre></td></tr>
3234
3235
3236 <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>
3237 <tr><td colspan="4" class="doc" id="isDefaultConstructor0"><pre>Matches constructor declarations that are default constructors.
3238
3239 Given
3240   struct S {
3241     S(); // #1
3242     S(const S &amp;); // #2
3243     S(S &amp;&amp;); // #3
3244   };
3245 cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
3246 </pre></td></tr>
3247
3248
3249 <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>
3250 <tr><td colspan="4" class="doc" id="isDelegatingConstructor0"><pre>Matches constructors that delegate to another constructor.
3251
3252 Given
3253   struct S {
3254     S(); // #1
3255     S(int) {} // #2
3256     S(S &amp;&amp;) : S() {} // #3
3257   };
3258   S::S() : S(0) {} // #4
3259 cxxConstructorDecl(isDelegatingConstructor()) will match #3 and #4, but not
3260 #1 or #2.
3261 </pre></td></tr>
3262
3263
3264 <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>
3265 <tr><td colspan="4" class="doc" id="isExplicit0"><pre>Matches constructor, conversion function, and deduction guide declarations
3266 that have an explicit specifier if this explicit specifier is resolved to
3267 true.
3268
3269 Given
3270   template&lt;bool b&gt;
3271   struct S {
3272     S(int); // #1
3273     explicit S(double); // #2
3274     operator int(); // #3
3275     explicit operator bool(); // #4
3276     explicit(false) S(bool) // # 7
3277     explicit(true) S(char) // # 8
3278     explicit(b) S(S) // # 9
3279   };
3280   S(int) -&gt; S&lt;true&gt; // #5
3281   explicit S(double) -&gt; S&lt;false&gt; // #6
3282 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
3283 cxxConversionDecl(isExplicit()) will match #4, but not #3.
3284 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
3285 </pre></td></tr>
3286
3287
3288 <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>
3289 <tr><td colspan="4" class="doc" id="isInheritingConstructor0"><pre></pre></td></tr>
3290
3291
3292 <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>
3293 <tr><td colspan="4" class="doc" id="isMoveConstructor0"><pre>Matches constructor declarations that are move constructors.
3294
3295 Given
3296   struct S {
3297     S(); // #1
3298     S(const S &amp;); // #2
3299     S(S &amp;&amp;); // #3
3300   };
3301 cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
3302 </pre></td></tr>
3303
3304
3305 <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>
3306 <tr><td colspan="4" class="doc" id="isExplicit1"><pre>Matches constructor, conversion function, and deduction guide declarations
3307 that have an explicit specifier if this explicit specifier is resolved to
3308 true.
3309
3310 Given
3311   template&lt;bool b&gt;
3312   struct S {
3313     S(int); // #1
3314     explicit S(double); // #2
3315     operator int(); // #3
3316     explicit operator bool(); // #4
3317     explicit(false) S(bool) // # 7
3318     explicit(true) S(char) // # 8
3319     explicit(b) S(S) // # 9
3320   };
3321   S(int) -&gt; S&lt;true&gt; // #5
3322   explicit S(double) -&gt; S&lt;false&gt; // #6
3323 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
3324 cxxConversionDecl(isExplicit()) will match #4, but not #3.
3325 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
3326 </pre></td></tr>
3327
3328
3329 <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>
3330 <tr><td colspan="4" class="doc" id="isBaseInitializer0"><pre>Matches a constructor initializer if it is initializing a base, as
3331 opposed to a member.
3332
3333 Given
3334   struct B {};
3335   struct D : B {
3336     int I;
3337     D(int i) : I(i) {}
3338   };
3339   struct E : B {
3340     E() : B() {}
3341   };
3342 cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
3343   will match E(), but not match D(int).
3344 </pre></td></tr>
3345
3346
3347 <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>
3348 <tr><td colspan="4" class="doc" id="isMemberInitializer0"><pre>Matches a constructor initializer if it is initializing a member, as
3349 opposed to a base.
3350
3351 Given
3352   struct B {};
3353   struct D : B {
3354     int I;
3355     D(int i) : I(i) {}
3356   };
3357   struct E : B {
3358     E() : B() {}
3359   };
3360 cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
3361   will match D(int), but not match E().
3362 </pre></td></tr>
3363
3364
3365 <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>
3366 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a constructor initializer if it is explicitly written in
3367 code (as opposed to implicitly added by the compiler).
3368
3369 Given
3370   struct Foo {
3371     Foo() { }
3372     Foo(int) : foo_("A") { }
3373     string foo_;
3374   };
3375 cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
3376   will match Foo(int), but not Foo()
3377 </pre></td></tr>
3378
3379
3380 <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>
3381 <tr><td colspan="4" class="doc" id="isExplicit2"><pre>Matches constructor, conversion function, and deduction guide declarations
3382 that have an explicit specifier if this explicit specifier is resolved to
3383 true.
3384
3385 Given
3386   template&lt;bool b&gt;
3387   struct S {
3388     S(int); // #1
3389     explicit S(double); // #2
3390     operator int(); // #3
3391     explicit operator bool(); // #4
3392     explicit(false) S(bool) // # 7
3393     explicit(true) S(char) // # 8
3394     explicit(b) S(S) // # 9
3395   };
3396   S(int) -&gt; S&lt;true&gt; // #5
3397   explicit S(double) -&gt; S&lt;false&gt; // #6
3398 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
3399 cxxConversionDecl(isExplicit()) will match #4, but not #3.
3400 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
3401 </pre></td></tr>
3402
3403
3404 <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>
3405 <tr><td colspan="4" class="doc" id="hasMemberName0"><pre>Matches template-dependent, but known, member names.
3406
3407 In template declarations, dependent members are not resolved and so can
3408 not be matched to particular named declarations.
3409
3410 This matcher allows to match on the known name of members.
3411
3412 Given
3413   template &lt;typename T&gt;
3414   struct S {
3415       void mem();
3416   };
3417   template &lt;typename T&gt;
3418   void x() {
3419       S&lt;T&gt; s;
3420       s.mem();
3421   }
3422 cxxDependentScopeMemberExpr(hasMemberName("mem")) matches `s.mem()`
3423 </pre></td></tr>
3424
3425
3426 <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>
3427 <tr><td colspan="4" class="doc" id="isArrow2"><pre>Matches member expressions that are called with '-&gt;' as opposed
3428 to '.'.
3429
3430 Member calls on the implicit this pointer match as called with '-&gt;'.
3431
3432 Given
3433   class Y {
3434     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
3435     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
3436     int a;
3437     static int b;
3438   };
3439   template &lt;class T&gt;
3440   class Z {
3441     void x() { this-&gt;m; }
3442   };
3443 memberExpr(isArrow())
3444   matches this-&gt;x, x, y.x, a, this-&gt;b
3445 cxxDependentScopeMemberExpr(isArrow())
3446   matches this-&gt;m
3447 unresolvedMemberExpr(isArrow())
3448   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
3449 </pre></td></tr>
3450
3451
3452 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentScopeDeclRefExpr.html">DependentScopeDeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('hasDependentName0')"><a name="hasDependentName0Anchor">hasDependentName</a></td><td>std::string N</td></tr>
3453 <tr><td colspan="4" class="doc" id="hasDependentName0"><pre>Matches the dependent name of a DependentScopeDeclRefExpr.
3454
3455 Matches the dependent name of a DependentScopeDeclRefExpr
3456
3457 Given:
3458
3459   template &lt;class T&lt; class X : T { void f() { T::v; } };
3460
3461 dependentScopeDeclRefExpr(hasDependentName("v")) matches `T::v`
3462 </pre></td></tr>
3463
3464
3465 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentNameType.html">DependentNameType</a>&gt;</td><td class="name" onclick="toggle('hasDependentName1')"><a name="hasDependentName1Anchor">hasDependentName</a></td><td>std::string N</td></tr>
3466 <tr><td colspan="4" class="doc" id="hasDependentName1"><pre>Matches the dependent name of a DependentNameType.
3467
3468 Matches the dependent name of a DependentNameType
3469
3470 Given:
3471
3472   template &lt;typename T&lt; struct declToImport {
3473     typedef typename T::type dependent_name;
3474   };
3475
3476 dependentNameType(hasDependentName("type")) matches `T::type`
3477 </pre></td></tr>
3478
3479
3480 <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>
3481 <tr><td colspan="4" class="doc" id="memberHasSameNameAsBoundNode0"><pre>Matches template-dependent, but known, member names against an already-bound
3482 node
3483
3484 In template declarations, dependent members are not resolved and so can
3485 not be matched to particular named declarations.
3486
3487 This matcher allows to match on the name of already-bound VarDecl, FieldDecl
3488 and CXXMethodDecl nodes.
3489
3490 Given
3491   template &lt;typename T&gt;
3492   struct S {
3493       void mem();
3494   };
3495   template &lt;typename T&gt;
3496   void x() {
3497       S&lt;T&gt; s;
3498       s.mem();
3499   }
3500 The matcher
3501 @code
3502 cxxDependentScopeMemberExpr(
3503   hasObjectExpression(declRefExpr(hasType(templateSpecializationType(
3504       hasDeclaration(classTemplateDecl(has(cxxRecordDecl(has(
3505           cxxMethodDecl(hasName("mem")).bind("templMem")
3506           )))))
3507       )))),
3508   memberHasSameNameAsBoundNode("templMem")
3509   )
3510 @endcode
3511 first matches and binds the @c mem member of the @c S template, then
3512 compares its name to the usage in @c s.mem() in the @c x function template
3513 </pre></td></tr>
3514
3515
3516 <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>
3517 <tr><td colspan="4" class="doc" id="hasOperatorName3"><pre>Matches the operator Name of operator expressions and fold expressions
3518 (binary or unary).
3519
3520 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3521   !(a || b)
3522
3523 Example matches `(0 + ... + args)`
3524     (matcher = cxxFoldExpr(hasOperatorName("+")))
3525   template &lt;typename... Args&gt;
3526   auto sum(Args... args) {
3527       return (0 + ... + args);
3528   }
3529 </pre></td></tr>
3530
3531
3532 <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>
3533 <tr><td colspan="4" class="doc" id="isBinaryFold0"><pre>Matches binary fold expressions, i.e. fold expressions with an initializer.
3534
3535 Example matches `(0 + ... + args)`
3536     (matcher = cxxFoldExpr(isBinaryFold()))
3537   template &lt;typename... Args&gt;
3538   auto sum(Args... args) {
3539       return (0 + ... + args);
3540   }
3541
3542   template &lt;typename... Args&gt;
3543   auto multiply(Args... args) {
3544       return (args * ...);
3545   }
3546 </pre></td></tr>
3547
3548
3549 <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>
3550 <tr><td colspan="4" class="doc" id="isLeftFold0"><pre>Matches left-folding fold expressions.
3551
3552 Example matches `(0 + ... + args)`
3553     (matcher = cxxFoldExpr(isLeftFold()))
3554   template &lt;typename... Args&gt;
3555   auto sum(Args... args) {
3556       return (0 + ... + args);
3557   }
3558
3559   template &lt;typename... Args&gt;
3560   auto multiply(Args... args) {
3561       return (args * ... * 1);
3562   }
3563 </pre></td></tr>
3564
3565
3566 <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>
3567 <tr><td colspan="4" class="doc" id="isRightFold0"><pre>Matches right-folding fold expressions.
3568
3569 Example matches `(args * ... * 1)`
3570     (matcher = cxxFoldExpr(isRightFold()))
3571   template &lt;typename... Args&gt;
3572   auto sum(Args... args) {
3573       return (0 + ... + args);
3574   }
3575
3576   template &lt;typename... Args&gt;
3577   auto multiply(Args... args) {
3578       return (args * ... * 1);
3579   }
3580 </pre></td></tr>
3581
3582
3583 <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>
3584 <tr><td colspan="4" class="doc" id="isUnaryFold0"><pre>Matches unary fold expressions, i.e. fold expressions without an
3585 initializer.
3586
3587 Example matches `(args * ...)`
3588     (matcher = cxxFoldExpr(isUnaryFold()))
3589   template &lt;typename... Args&gt;
3590   auto sum(Args... args) {
3591       return (0 + ... + args);
3592   }
3593
3594   template &lt;typename... Args&gt;
3595   auto multiply(Args... args) {
3596       return (args * ...);
3597   }
3598 </pre></td></tr>
3599
3600
3601 <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>
3602 <tr><td colspan="4" class="doc" id="isConst0"><pre>Matches if the given method declaration is const.
3603
3604 Given
3605 struct A {
3606   void foo() const;
3607   void bar();
3608 };
3609
3610 cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
3611 </pre></td></tr>
3612
3613
3614 <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>
3615 <tr><td colspan="4" class="doc" id="isCopyAssignmentOperator0"><pre>Matches if the given method declaration declares a copy assignment
3616 operator.
3617
3618 Given
3619 struct A {
3620   A &amp;operator=(const A &amp;);
3621   A &amp;operator=(A &amp;&amp;);
3622 };
3623
3624 cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
3625 the second one.
3626 </pre></td></tr>
3627
3628
3629 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicitObjectMemberFunction0')"><a name="isExplicitObjectMemberFunction0Anchor">isExplicitObjectMemberFunction</a></td><td></td></tr>
3630 <tr><td colspan="4" class="doc" id="isExplicitObjectMemberFunction0"><pre>Matches if the given method declaration declares a member function with an
3631 explicit object parameter.
3632
3633 Given
3634 struct A {
3635  int operator-(this A, int);
3636  void fun(this A &amp;&amp;self);
3637  static int operator()(int);
3638  int operator+(int);
3639 };
3640
3641 cxxMethodDecl(isExplicitObjectMemberFunction()) matches the first two
3642 methods but not the last two.
3643 </pre></td></tr>
3644
3645
3646 <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>
3647 <tr><td colspan="4" class="doc" id="isFinal1"><pre>Matches if the given method or class declaration is final.
3648
3649 Given:
3650   class A final {};
3651
3652   struct B {
3653     virtual void f();
3654   };
3655
3656   struct C : B {
3657     void f() final;
3658   };
3659 matches A and C::f, but not B, C, or B::f
3660 </pre></td></tr>
3661
3662
3663 <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>
3664 <tr><td colspan="4" class="doc" id="isMoveAssignmentOperator0"><pre>Matches if the given method declaration declares a move assignment
3665 operator.
3666
3667 Given
3668 struct A {
3669   A &amp;operator=(const A &amp;);
3670   A &amp;operator=(A &amp;&amp;);
3671 };
3672
3673 cxxMethodDecl(isMoveAssignmentOperator()) matches the second method but not
3674 the first one.
3675 </pre></td></tr>
3676
3677
3678 <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>
3679 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
3680
3681 Given
3682   class A {
3683    public:
3684     virtual void x();
3685   };
3686   class B : public A {
3687    public:
3688     virtual void x();
3689   };
3690   matches B::x
3691 </pre></td></tr>
3692
3693
3694 <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>
3695 <tr><td colspan="4" class="doc" id="isPure0"><pre>Matches if the given method declaration is pure.
3696
3697 Given
3698   class A {
3699    public:
3700     virtual void x() = 0;
3701   };
3702   matches A::x
3703 </pre></td></tr>
3704
3705
3706 <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>
3707 <tr><td colspan="4" class="doc" id="isUserProvided0"><pre>Matches method declarations that are user-provided.
3708
3709 Given
3710   struct S {
3711     S(); // #1
3712     S(const S &amp;) = default; // #2
3713     S(S &amp;&amp;) = delete; // #3
3714   };
3715 cxxConstructorDecl(isUserProvided()) will match #1, but not #2 or #3.
3716 </pre></td></tr>
3717
3718
3719 <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>
3720 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches declarations of virtual methods and C++ base specifers that specify
3721 virtual inheritance.
3722
3723 Example:
3724   class A {
3725    public:
3726     virtual void x(); // matches x
3727   };
3728
3729 Example:
3730   class Base {};
3731   class DirectlyDerived : virtual Base {}; // matches Base
3732   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
3733
3734 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;
3735 </pre></td></tr>
3736
3737
3738 <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>
3739 <tr><td colspan="4" class="doc" id="isVirtualAsWritten0"><pre>Matches if the given method declaration has an explicit "virtual".
3740
3741 Given
3742   class A {
3743    public:
3744     virtual void x();
3745   };
3746   class B : public A {
3747    public:
3748     void x();
3749   };
3750   matches A::x but not B::x
3751 </pre></td></tr>
3752
3753
3754 <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>
3755 <tr><td colspan="4" class="doc" id="isArray0"><pre>Matches array new expressions.
3756
3757 Given:
3758   MyClass *p1 = new MyClass[10];
3759 cxxNewExpr(isArray())
3760   matches the expression 'new MyClass[10]'.
3761 </pre></td></tr>
3762
3763
3764 <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>
3765 <tr><td colspan="4" class="doc" id="hasAnyOperatorName1"><pre>Matches operator expressions (binary or unary) that have any of the
3766 specified names.
3767
3768    hasAnyOperatorName("+", "-")
3769  Is equivalent to
3770    anyOf(hasOperatorName("+"), hasOperatorName("-"))
3771 </pre></td></tr>
3772
3773
3774 <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>
3775 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName0"><pre>Matches overloaded operator names.
3776
3777 Matches overloaded operator names specified in strings without the
3778 "operator" prefix: e.g. "&lt;&lt;".
3779
3780   hasAnyOverloadedOperatorName("+", "-")
3781 Is equivalent to
3782   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
3783 </pre></td></tr>
3784
3785
3786 <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>
3787 <tr><td colspan="4" class="doc" id="hasOperatorName1"><pre>Matches the operator Name of operator expressions and fold expressions
3788 (binary or unary).
3789
3790 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3791   !(a || b)
3792
3793 Example matches `(0 + ... + args)`
3794     (matcher = cxxFoldExpr(hasOperatorName("+")))
3795   template &lt;typename... Args&gt;
3796   auto sum(Args... args) {
3797       return (0 + ... + args);
3798   }
3799 </pre></td></tr>
3800
3801
3802 <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>
3803 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
3804
3805 Matches overloaded operator names specified in strings without the
3806 "operator" prefix: e.g. "&lt;&lt;".
3807
3808 Given:
3809   class A { int operator*(); };
3810   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
3811   A a;
3812   a &lt;&lt; a;   // &lt;-- This matches
3813
3814 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
3815 specified line and
3816 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
3817 matches the declaration of A.
3818
3819 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;
3820 </pre></td></tr>
3821
3822
3823 <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>
3824 <tr><td colspan="4" class="doc" id="isAssignmentOperator1"><pre>Matches all kinds of assignment operators.
3825
3826 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
3827   if (a == b)
3828     a += b;
3829
3830 Example 2: matches s1 = s2
3831            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
3832   struct S { S&amp; operator=(const S&amp;); };
3833   void x() { S s1, s2; s1 = s2; }
3834 </pre></td></tr>
3835
3836
3837 <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>
3838 <tr><td colspan="4" class="doc" id="isComparisonOperator1"><pre>Matches comparison operators.
3839
3840 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
3841   if (a == b)
3842     a += b;
3843
3844 Example 2: matches s1 &lt; s2
3845            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
3846   struct S { bool operator&lt;(const S&amp; other); };
3847   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
3848 </pre></td></tr>
3849
3850
3851 <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>
3852 <tr><td colspan="4" class="doc" id="hasDefinition0"><pre>Matches a class declaration that is defined.
3853
3854 Example matches x (matcher = cxxRecordDecl(hasDefinition()))
3855 class x {};
3856 class y;
3857 </pre></td></tr>
3858
3859
3860 <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>
3861 <tr><td colspan="4" class="doc" id="isDerivedFrom2"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
3862 </pre></td></tr>
3863
3864
3865 <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>
3866 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom2"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
3867 </pre></td></tr>
3868
3869
3870 <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>
3871 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
3872 static member variable template instantiations.
3873
3874 Given
3875   template&lt;typename T&gt; void A(T t) { }
3876   template&lt;&gt; void A(int N) { }
3877 functionDecl(isExplicitTemplateSpecialization())
3878   matches the specialization A&lt;int&gt;().
3879
3880 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;
3881 </pre></td></tr>
3882
3883
3884 <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>
3885 <tr><td colspan="4" class="doc" id="isFinal0"><pre>Matches if the given method or class declaration is final.
3886
3887 Given:
3888   class A final {};
3889
3890   struct B {
3891     virtual void f();
3892   };
3893
3894   struct C : B {
3895     void f() final;
3896   };
3897 matches A and C::f, but not B, C, or B::f
3898 </pre></td></tr>
3899
3900
3901 <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>
3902 <tr><td colspan="4" class="doc" id="isLambda0"><pre>Matches the generated class of lambda expressions.
3903
3904 Given:
3905   auto x = []{};
3906
3907 cxxRecordDecl(isLambda()) matches the implicit class declaration of
3908 decltype(x)
3909 </pre></td></tr>
3910
3911
3912 <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>
3913 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom2"><pre>Overloaded method as shortcut for
3914 isSameOrDerivedFrom(hasName(...)).
3915 </pre></td></tr>
3916
3917
3918 <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>
3919 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
3920 member variable template instantiations.
3921
3922 Given
3923   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
3924 or
3925   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
3926 or
3927   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
3928 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3929   matches the template instantiation of X&lt;A&gt;.
3930
3931 But given
3932   template &lt;typename T&gt;  class X {}; class A {};
3933   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
3934 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
3935   does not match, as X&lt;A&gt; is an explicit template specialization.
3936
3937 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;
3938 </pre></td></tr>
3939
3940
3941 <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>
3942 <tr><td colspan="4" class="doc" id="hasAnyOperatorName2"><pre>Matches operator expressions (binary or unary) that have any of the
3943 specified names.
3944
3945    hasAnyOperatorName("+", "-")
3946  Is equivalent to
3947    anyOf(hasOperatorName("+"), hasOperatorName("-"))
3948 </pre></td></tr>
3949
3950
3951 <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>
3952 <tr><td colspan="4" class="doc" id="hasOperatorName2"><pre>Matches the operator Name of operator expressions and fold expressions
3953 (binary or unary).
3954
3955 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
3956   !(a || b)
3957
3958 Example matches `(0 + ... + args)`
3959     (matcher = cxxFoldExpr(hasOperatorName("+")))
3960   template &lt;typename... Args&gt;
3961   auto sum(Args... args) {
3962       return (0 + ... + args);
3963   }
3964 </pre></td></tr>
3965
3966
3967 <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>
3968 <tr><td colspan="4" class="doc" id="isAssignmentOperator2"><pre>Matches all kinds of assignment operators.
3969
3970 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
3971   if (a == b)
3972     a += b;
3973
3974 Example 2: matches s1 = s2
3975            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
3976   struct S { S&amp; operator=(const S&amp;); };
3977   void x() { S s1, s2; s1 = s2; }
3978 </pre></td></tr>
3979
3980
3981 <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>
3982 <tr><td colspan="4" class="doc" id="isComparisonOperator2"><pre>Matches comparison operators.
3983
3984 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
3985   if (a == b)
3986     a += b;
3987
3988 Example 2: matches s1 &lt; s2
3989            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
3990   struct S { bool operator&lt;(const S&amp; other); };
3991   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
3992 </pre></td></tr>
3993
3994
3995 <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>
3996 <tr><td colspan="4" class="doc" id="argumentCountAtLeast2"><pre>Checks that a call expression or a constructor call expression has at least
3997 the specified number of arguments (including absent default arguments).
3998
3999 Example matches f(0, 0) and g(0, 0, 0)
4000 (matcher = callExpr(argumentCountAtLeast(2)))
4001   void f(int x, int y);
4002   void g(int x, int y, int z);
4003   f(0, 0);
4004   g(0, 0, 0);
4005 </pre></td></tr>
4006
4007
4008 <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>
4009 <tr><td colspan="4" class="doc" id="argumentCountIs2"><pre>Checks that a call expression or a constructor call expression has
4010 a specific number of arguments (including absent default arguments).
4011
4012 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
4013   void f(int x, int y);
4014   f(0, 0);
4015 </pre></td></tr>
4016
4017
4018 <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>
4019 <tr><td colspan="4" class="doc" id="argumentCountAtLeast0"><pre>Checks that a call expression or a constructor call expression has at least
4020 the specified number of arguments (including absent default arguments).
4021
4022 Example matches f(0, 0) and g(0, 0, 0)
4023 (matcher = callExpr(argumentCountAtLeast(2)))
4024   void f(int x, int y);
4025   void g(int x, int y, int z);
4026   f(0, 0);
4027   g(0, 0, 0);
4028 </pre></td></tr>
4029
4030
4031 <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>
4032 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
4033 a specific number of arguments (including absent default arguments).
4034
4035 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
4036   void f(int x, int y);
4037   f(0, 0);
4038 </pre></td></tr>
4039
4040
4041 <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>
4042 <tr><td colspan="4" class="doc" id="usesADL0"><pre>Matches call expressions which were resolved using ADL.
4043
4044 Example matches y(x) but not y(42) or NS::y(x).
4045   namespace NS {
4046     struct X {};
4047     void y(X);
4048   }
4049
4050   void y(...);
4051
4052   void test() {
4053     NS::X x;
4054     y(x); // Matches
4055     NS::y(x); // Doesn't match
4056     y(42); // Doesn't match
4057     using NS::y;
4058     y(x); // Found by both unqualified lookup and ADL, doesn't match
4059    }
4060 </pre></td></tr>
4061
4062
4063 <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>
4064 <tr><td colspan="4" class="doc" id="hasCastKind0"><pre>Matches casts that has a given cast kind.
4065
4066 Example: matches the implicit cast around 0
4067 (matcher = castExpr(hasCastKind(CK_NullToPointer)))
4068   int *p = 0;
4069
4070 If the matcher is use from clang-query, CastKind parameter
4071 should be passed as a quoted string. e.g., hasCastKind("CK_NullToPointer").
4072 </pre></td></tr>
4073
4074
4075 <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>
4076 <tr><td colspan="4" class="doc" id="equals4"><pre></pre></td></tr>
4077
4078
4079 <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>
4080 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value of type ValueT.
4081
4082 Given
4083   f('false, 3.14, 42);
4084 characterLiteral(equals(0))
4085   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
4086   match false
4087 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
4088   match 3.14
4089 integerLiteral(equals(42))
4090   matches 42
4091
4092 Note that you cannot directly match a negative numeric literal because the
4093 minus sign is not part of the literal: It is a unary operator whose operand
4094 is the positive numeric literal. Instead, you must use a unaryOperator()
4095 matcher to match the minus sign:
4096
4097 unaryOperator(hasOperatorName("-"),
4098               hasUnaryOperand(integerLiteral(equals(13))))
4099
4100 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;,
4101            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;
4102 </pre></td></tr>
4103
4104
4105 <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>
4106 <tr><td colspan="4" class="doc" id="equals10"><pre></pre></td></tr>
4107
4108
4109 <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>
4110 <tr><td colspan="4" class="doc" id="equals7"><pre></pre></td></tr>
4111
4112
4113 <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>
4114 <tr><td colspan="4" class="doc" id="templateArgumentCountIs0"><pre>Matches if the number of template arguments equals N.
4115
4116 Given
4117   template&lt;typename T&gt; struct C {};
4118   C&lt;int&gt; c;
4119 classTemplateSpecializationDecl(templateArgumentCountIs(1))
4120   matches C&lt;int&gt;.
4121 </pre></td></tr>
4122
4123
4124 <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>
4125 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
4126 child statements.
4127
4128 Example: Given
4129   { for (;;) {} }
4130 compoundStmt(statementCountIs(0)))
4131   matches '{}'
4132   but does not match the outer compound statement.
4133 </pre></td></tr>
4134
4135
4136 <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>
4137 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches nodes that have the specified size.
4138
4139 Given
4140   int a[42];
4141   int b[2 * 21];
4142   int c[41], d[43];
4143   char *s = "abcd";
4144   wchar_t *ws = L"abcd";
4145   char *w = "a";
4146 constantArrayType(hasSize(42))
4147   matches "int a[42]" and "int b[2 * 21]"
4148 stringLiteral(hasSize(4))
4149   matches "abcd", L"abcd"
4150 </pre></td></tr>
4151
4152
4153 <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>
4154 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
4155 declarations.
4156
4157 Example: Given
4158   int a, b;
4159   int c;
4160   int d = 2, e;
4161 declCountIs(2)
4162   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
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('equalsBoundNode1')"><a name="equalsBoundNode1Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
4167 <tr><td colspan="4" class="doc" id="equalsBoundNode1"><pre>Matches if a node equals a previously bound node.
4168
4169 Matches a node if it equals the node previously bound to ID.
4170
4171 Given
4172   class X { int a; int b; };
4173 cxxRecordDecl(
4174     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
4175     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
4176   matches the class X, as a and b have the same type.
4177
4178 Note that when multiple matches are involved via forEach* matchers,
4179 equalsBoundNodes acts as a filter.
4180 For example:
4181 compoundStmt(
4182     forEachDescendant(varDecl().bind("d")),
4183     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
4184 will trigger a match for each combination of variable declaration
4185 and reference to that variable declaration within a compound statement.
4186 </pre></td></tr>
4187
4188
4189 <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>
4190 <tr><td colspan="4" class="doc" id="equalsNode0"><pre>Matches if a node equals another node.
4191
4192 Decl has pointer identity in the AST.
4193 </pre></td></tr>
4194
4195
4196 <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>
4197 <tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
4198
4199 Given
4200   __attribute__((device)) void f() { ... }
4201 decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
4202 f. If the matcher is used from clang-query, attr::Kind parameter should be
4203 passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
4204 </pre></td></tr>
4205
4206
4207 <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>
4208 <tr><td colspan="4" class="doc" id="isExpandedFromMacro0"><pre>Matches statements that are (transitively) expanded from the named macro.
4209 Does not match if only part of the statement is expanded from that macro or
4210 if different parts of the statement are expanded from different
4211 appearances of the macro.
4212 </pre></td></tr>
4213
4214
4215 <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>
4216 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching0"><pre>Matches AST nodes that were expanded within files whose name is
4217 partially matching a given regex.
4218
4219 Example matches Y but not X
4220     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
4221   #include "ASTMatcher.h"
4222   class X {};
4223 ASTMatcher.h:
4224   class Y {};
4225
4226 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;
4227
4228 If the matcher is used in clang-query, RegexFlags parameter
4229 should be passed as a quoted string. e.g: "NoFlags".
4230 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
4231 </pre></td></tr>
4232
4233
4234 <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>
4235 <tr><td colspan="4" class="doc" id="isExpansionInMainFile0"><pre>Matches AST nodes that were expanded within the main-file.
4236
4237 Example matches X but not Y
4238   (matcher = cxxRecordDecl(isExpansionInMainFile())
4239   #include &lt;Y.h&gt;
4240   class X {};
4241 Y.h:
4242   class Y {};
4243
4244 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;
4245 </pre></td></tr>
4246
4247
4248 <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>
4249 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader0"><pre>Matches AST nodes that were expanded within system-header-files.
4250
4251 Example matches Y but not X
4252     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
4253   #include &lt;SystemHeader.h&gt;
4254   class X {};
4255 SystemHeader.h:
4256   class Y {};
4257
4258 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;
4259 </pre></td></tr>
4260
4261
4262 <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>
4263 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches an entity that has been implicitly added by the compiler (e.g.
4264 implicit default/copy constructors).
4265 </pre></td></tr>
4266
4267
4268 <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>
4269 <tr><td colspan="4" class="doc" id="isInAnonymousNamespace0"><pre>Matches declarations in an anonymous namespace.
4270
4271 Given
4272   class vector {};
4273   namespace foo {
4274     class vector {};
4275     namespace {
4276       class vector {}; // #1
4277     }
4278   }
4279   namespace {
4280     class vector {}; // #2
4281     namespace foo {
4282       class vector{}; // #3
4283     }
4284   }
4285 cxxRecordDecl(hasName("vector"), isInAnonymousNamespace()) will match
4286 #1, #2 and #3.
4287 </pre></td></tr>
4288
4289
4290 <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>
4291 <tr><td colspan="4" class="doc" id="isInStdNamespace0"><pre>Matches declarations in the namespace `std`, but not in nested namespaces.
4292
4293 Given
4294   class vector {};
4295   namespace foo {
4296     class vector {};
4297     namespace std {
4298       class vector {};
4299     }
4300   }
4301   namespace std {
4302     inline namespace __1 {
4303       class vector {}; // #1
4304       namespace experimental {
4305         class vector {};
4306       }
4307     }
4308   }
4309 cxxRecordDecl(hasName("vector"), isInStdNamespace()) will match only #1.
4310 </pre></td></tr>
4311
4312
4313 <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>
4314 <tr><td colspan="4" class="doc" id="isInstantiated0"><pre>Matches declarations that are template instantiations or are inside
4315 template instantiations.
4316
4317 Given
4318   template&lt;typename T&gt; void A(T t) { T i; }
4319   A(0);
4320   A(0U);
4321 functionDecl(isInstantiated())
4322   matches 'A(int) {...};' and 'A(unsigned) {...}'.
4323 </pre></td></tr>
4324
4325
4326 <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>
4327 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations and C++ base specifers that specify private
4328 inheritance.
4329
4330 Examples:
4331   class C {
4332   public:    int a;
4333   protected: int b;
4334   private:   int c; // fieldDecl(isPrivate()) matches 'c'
4335   };
4336
4337   struct Base {};
4338   struct Derived1 : private Base {}; // matches 'Base'
4339   class Derived2 : Base {}; // matches 'Base'
4340 </pre></td></tr>
4341
4342
4343 <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>
4344 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations and C++ base specifers that specify
4345 protected inheritance.
4346
4347 Examples:
4348   class C {
4349   public:    int a;
4350   protected: int b; // fieldDecl(isProtected()) matches 'b'
4351   private:   int c;
4352   };
4353
4354   class Base {};
4355   class Derived : protected Base {}; // matches 'Base'
4356 </pre></td></tr>
4357
4358
4359 <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>
4360 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations and C++ base specifers that specify public
4361 inheritance.
4362
4363 Examples:
4364   class C {
4365   public:    int a; // fieldDecl(isPublic()) matches 'a'
4366   protected: int b;
4367   private:   int c;
4368   };
4369
4370   class Base {};
4371   class Derived1 : public Base {}; // matches 'Base'
4372   struct Derived2 : Base {}; // matches 'Base'
4373 </pre></td></tr>
4374
4375
4376 <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>
4377 <tr><td colspan="4" class="doc" id="designatorCountIs0"><pre>Matches designated initializer expressions that contain
4378 a specific number of designators.
4379
4380 Example: Given
4381   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
4382   point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 };
4383 designatorCountIs(2)
4384   matches '{ [2].y = 1.0, [0].x = 1.0 }',
4385   but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'.
4386 </pre></td></tr>
4387
4388
4389 <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>
4390 <tr><td colspan="4" class="doc" id="isScoped0"><pre>Matches C++11 scoped enum declaration.
4391
4392 Example matches Y (matcher = enumDecl(isScoped()))
4393 enum X {};
4394 enum class Y {};
4395 </pre></td></tr>
4396
4397
4398 <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>
4399 <tr><td colspan="4" class="doc" id="isInstantiationDependent0"><pre>Matches expressions that are instantiation-dependent even if it is
4400 neither type- nor value-dependent.
4401
4402 In the following example, the expression sizeof(sizeof(T() + T()))
4403 is instantiation-dependent (since it involves a template parameter T),
4404 but is neither type- nor value-dependent, since the type of the inner
4405 sizeof is known (std::size_t) and therefore the size of the outer
4406 sizeof is known.
4407   template&lt;typename T&gt;
4408   void f(T x, T y) { sizeof(sizeof(T() + T()); }
4409 expr(isInstantiationDependent()) matches sizeof(sizeof(T() + T())
4410 </pre></td></tr>
4411
4412
4413 <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>
4414 <tr><td colspan="4" class="doc" id="isTypeDependent0"><pre>Matches expressions that are type-dependent because the template type
4415 is not yet instantiated.
4416
4417 For example, the expressions "x" and "x + y" are type-dependent in
4418 the following code, but "y" is not type-dependent:
4419   template&lt;typename T&gt;
4420   void add(T x, int y) {
4421     x + y;
4422   }
4423 expr(isTypeDependent()) matches x + y
4424 </pre></td></tr>
4425
4426
4427 <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>
4428 <tr><td colspan="4" class="doc" id="isValueDependent0"><pre>Matches expression that are value-dependent because they contain a
4429 non-type template parameter.
4430
4431 For example, the array bound of "Chars" in the following example is
4432 value-dependent.
4433   template&lt;int Size&gt; int f() { return Size; }
4434 expr(isValueDependent()) matches return Size
4435 </pre></td></tr>
4436
4437
4438 <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>
4439 <tr><td colspan="4" class="doc" id="nullPointerConstant0"><pre>Matches expressions that resolve to a null pointer constant, such as
4440 GNU's __null, C++11's nullptr, or C's NULL macro.
4441
4442 Given:
4443   void *v1 = NULL;
4444   void *v2 = nullptr;
4445   void *v3 = __null; // GNU extension
4446   char *cp = (char *)0;
4447   int *ip = 0;
4448   int i = 0;
4449 expr(nullPointerConstant())
4450   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
4451   initializer for i.
4452 </pre></td></tr>
4453
4454
4455 <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>
4456 <tr><td colspan="4" class="doc" id="hasBitWidth0"><pre>Matches non-static data members that are bit-fields of the specified
4457 bit width.
4458
4459 Given
4460   class C {
4461     int a : 2;
4462     int b : 4;
4463     int c : 2;
4464   };
4465 fieldDecl(hasBitWidth(2))
4466   matches 'int a;' and 'int c;' but not 'int b;'.
4467 </pre></td></tr>
4468
4469
4470 <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>
4471 <tr><td colspan="4" class="doc" id="isBitField0"><pre>Matches non-static data members that are bit-fields.
4472
4473 Given
4474   class C {
4475     int a : 2;
4476     int b;
4477   };
4478 fieldDecl(isBitField())
4479   matches 'int a;' but not 'int b;'.
4480 </pre></td></tr>
4481
4482
4483 <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>
4484 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value of type ValueT.
4485
4486 Given
4487   f('false, 3.14, 42);
4488 characterLiteral(equals(0))
4489   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
4490   match false
4491 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
4492   match 3.14
4493 integerLiteral(equals(42))
4494   matches 42
4495
4496 Note that you cannot directly match a negative numeric literal because the
4497 minus sign is not part of the literal: It is a unary operator whose operand
4498 is the positive numeric literal. Instead, you must use a unaryOperator()
4499 matcher to match the minus sign:
4500
4501 unaryOperator(hasOperatorName("-"),
4502               hasUnaryOperand(integerLiteral(equals(13))))
4503
4504 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;,
4505            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;
4506 </pre></td></tr>
4507
4508
4509 <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>
4510 <tr><td colspan="4" class="doc" id="equals12"><pre></pre></td></tr>
4511
4512
4513 <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>
4514 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName1"><pre>Matches overloaded operator names.
4515
4516 Matches overloaded operator names specified in strings without the
4517 "operator" prefix: e.g. "&lt;&lt;".
4518
4519   hasAnyOverloadedOperatorName("+", "-")
4520 Is equivalent to
4521   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
4522 </pre></td></tr>
4523
4524
4525 <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>
4526 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec0"><pre>Matches functions that have a dynamic exception specification.
4527
4528 Given:
4529   void f();
4530   void g() noexcept;
4531   void h() noexcept(true);
4532   void i() noexcept(false);
4533   void j() throw();
4534   void k() throw(int);
4535   void l() throw(...);
4536 functionDecl(hasDynamicExceptionSpec()) and
4537   functionProtoType(hasDynamicExceptionSpec())
4538   match the declarations of j, k, and l, but not f, g, h, or i.
4539 </pre></td></tr>
4540
4541
4542 <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>
4543 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
4544
4545 Matches overloaded operator names specified in strings without the
4546 "operator" prefix: e.g. "&lt;&lt;".
4547
4548 Given:
4549   class A { int operator*(); };
4550   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
4551   A a;
4552   a &lt;&lt; a;   // &lt;-- This matches
4553
4554 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
4555 specified line and
4556 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
4557 matches the declaration of A.
4558
4559 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;
4560 </pre></td></tr>
4561
4562
4563 <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>
4564 <tr><td colspan="4" class="doc" id="hasTrailingReturn0"><pre>Matches a function declared with a trailing return type.
4565
4566 Example matches Y (matcher = functionDecl(hasTrailingReturn()))
4567 int X() {}
4568 auto Y() -&gt; int {}
4569 </pre></td></tr>
4570
4571
4572 <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>
4573 <tr><td colspan="4" class="doc" id="isConsteval0"><pre>Matches consteval function declarations and if consteval/if ! consteval
4574 statements.
4575
4576 Given:
4577   consteval int a();
4578   void b() { if consteval {} }
4579   void c() { if ! consteval {} }
4580   void d() { if ! consteval {} else {} }
4581 functionDecl(isConsteval())
4582   matches the declaration of "int a()".
4583 ifStmt(isConsteval())
4584   matches the if statement in "void b()", "void c()", "void d()".
4585 </pre></td></tr>
4586
4587
4588 <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>
4589 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations,
4590        and if constexpr.
4591
4592 Given:
4593   constexpr int foo = 42;
4594   constexpr int bar();
4595   void baz() { if constexpr(1 &gt; 0) {} }
4596 varDecl(isConstexpr())
4597   matches the declaration of foo.
4598 functionDecl(isConstexpr())
4599   matches the declaration of bar.
4600 ifStmt(isConstexpr())
4601   matches the if statement in baz.
4602 </pre></td></tr>
4603
4604
4605 <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>
4606 <tr><td colspan="4" class="doc" id="isDefaulted0"><pre>Matches defaulted function declarations.
4607
4608 Given:
4609   class A { ~A(); };
4610   class B { ~B() = default; };
4611 functionDecl(isDefaulted())
4612   matches the declaration of ~B, but not ~A.
4613 </pre></td></tr>
4614
4615
4616 <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>
4617 <tr><td colspan="4" class="doc" id="isDefinition3"><pre>Matches if a declaration has a body attached.
4618
4619 Example matches A, va, fa
4620   class A {};
4621   class B;  // Doesn't match, as it has no body.
4622   int va;
4623   extern int vb;  // Doesn't match, as it doesn't define the variable.
4624   void fa() {}
4625   void fb();  // Doesn't match, as it has no body.
4626   @interface X
4627   - (void)ma; // Doesn't match, interface is declaration.
4628   @end
4629   @implementation X
4630   - (void)ma {}
4631   @end
4632
4633 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;,
4634   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
4635 </pre></td></tr>
4636
4637
4638 <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>
4639 <tr><td colspan="4" class="doc" id="isDeleted0"><pre>Matches deleted function declarations.
4640
4641 Given:
4642   void Func();
4643   void DeletedFunc() = delete;
4644 functionDecl(isDeleted())
4645   matches the declaration of DeletedFunc, but not Func.
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('isExplicitTemplateSpecialization0')"><a name="isExplicitTemplateSpecialization0Anchor">isExplicitTemplateSpecialization</a></td><td></td></tr>
4650 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization0"><pre>Matches explicit template specializations of function, class, or
4651 static member variable template instantiations.
4652
4653 Given
4654   template&lt;typename T&gt; void A(T t) { }
4655   template&lt;&gt; void A(int N) { }
4656 functionDecl(isExplicitTemplateSpecialization())
4657   matches the specialization A&lt;int&gt;().
4658
4659 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;
4660 </pre></td></tr>
4661
4662
4663 <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>
4664 <tr><td colspan="4" class="doc" id="isExternC0"><pre>Matches extern "C" function or variable declarations.
4665
4666 Given:
4667   extern "C" void f() {}
4668   extern "C" { void g() {} }
4669   void h() {}
4670   extern "C" int x = 1;
4671   extern "C" int y = 2;
4672   int z = 3;
4673 functionDecl(isExternC())
4674   matches the declaration of f and g, but not the declaration of h.
4675 varDecl(isExternC())
4676   matches the declaration of x and y, but not the declaration of z.
4677 </pre></td></tr>
4678
4679
4680 <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>
4681 <tr><td colspan="4" class="doc" id="isInline1"><pre>Matches functions, variables and namespace declarations that are marked with
4682 the inline keyword.
4683
4684 Given
4685   inline void f();
4686   void g();
4687   namespace n {
4688   inline namespace m {}
4689   }
4690   inline int Foo = 5;
4691 functionDecl(isInline()) will match ::f().
4692 namespaceDecl(isInline()) will match n::m.
4693 varDecl(isInline()) will match Foo;
4694 </pre></td></tr>
4695
4696
4697 <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>
4698 <tr><td colspan="4" class="doc" id="isMain0"><pre>Determines whether the function is "main", which is the entry point
4699 into an executable program.
4700 </pre></td></tr>
4701
4702
4703 <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>
4704 <tr><td colspan="4" class="doc" id="isNoReturn0"><pre>Matches FunctionDecls that have a noreturn attribute.
4705
4706 Given
4707   void nope();
4708   [[noreturn]] void a();
4709   __attribute__((noreturn)) void b();
4710   struct c { [[noreturn]] c(); };
4711 functionDecl(isNoReturn())
4712   matches all of those except
4713   void nope();
4714 </pre></td></tr>
4715
4716
4717 <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>
4718 <tr><td colspan="4" class="doc" id="isNoThrow0"><pre>Matches functions that have a non-throwing exception specification.
4719
4720 Given:
4721   void f();
4722   void g() noexcept;
4723   void h() throw();
4724   void i() throw(int);
4725   void j() noexcept(false);
4726 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
4727   match the declarations of g, and h, but not f, i or j.
4728 </pre></td></tr>
4729
4730
4731 <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>
4732 <tr><td colspan="4" class="doc" id="isStaticStorageClass0"><pre>Matches variable/function declarations that have "static" storage
4733 class specifier ("static" keyword) written in the source.
4734
4735 Given:
4736   static void f() {}
4737   static int i = 0;
4738   extern int j;
4739   int k;
4740 functionDecl(isStaticStorageClass())
4741   matches the function declaration f.
4742 varDecl(isStaticStorageClass())
4743   matches the variable declaration i.
4744 </pre></td></tr>
4745
4746
4747 <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>
4748 <tr><td colspan="4" class="doc" id="isTemplateInstantiation0"><pre>Matches template instantiations of function, class, or static
4749 member variable template instantiations.
4750
4751 Given
4752   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
4753 or
4754   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
4755 or
4756   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
4757 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
4758   matches the template instantiation of X&lt;A&gt;.
4759
4760 But given
4761   template &lt;typename T&gt;  class X {}; class A {};
4762   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
4763 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
4764   does not match, as X&lt;A&gt; is an explicit template specialization.
4765
4766 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;
4767 </pre></td></tr>
4768
4769
4770 <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>
4771 <tr><td colspan="4" class="doc" id="isVariadic0"><pre>Matches if a function declaration is variadic.
4772
4773 Example matches f, but not g or h. The function i will not match, even when
4774 compiled in C mode.
4775   void f(...);
4776   void g(int);
4777   template &lt;typename... Ts&gt; void h(Ts...);
4778   void i();
4779 </pre></td></tr>
4780
4781
4782 <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>
4783 <tr><td colspan="4" class="doc" id="isWeak0"><pre>Matches weak function declarations.
4784
4785 Given:
4786   void foo() __attribute__((__weakref__("__foo")));
4787   void bar();
4788 functionDecl(isWeak())
4789   matches the weak declaration "foo", but not "bar".
4790 </pre></td></tr>
4791
4792
4793 <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>
4794 <tr><td colspan="4" class="doc" id="parameterCountIs0"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
4795 specific parameter count.
4796
4797 Given
4798   void f(int i) {}
4799   void g(int i, int j) {}
4800   void h(int i, int j);
4801   void j(int i);
4802   void k(int x, int y, int z, ...);
4803 functionDecl(parameterCountIs(2))
4804   matches g and h
4805 functionProtoType(parameterCountIs(2))
4806   matches g and h
4807 functionProtoType(parameterCountIs(3))
4808   matches k
4809 </pre></td></tr>
4810
4811
4812 <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>
4813 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec1"><pre>Matches functions that have a dynamic exception specification.
4814
4815 Given:
4816   void f();
4817   void g() noexcept;
4818   void h() noexcept(true);
4819   void i() noexcept(false);
4820   void j() throw();
4821   void k() throw(int);
4822   void l() throw(...);
4823 functionDecl(hasDynamicExceptionSpec()) and
4824   functionProtoType(hasDynamicExceptionSpec())
4825   match the declarations of j, k, and l, but not f, g, h, or i.
4826 </pre></td></tr>
4827
4828
4829 <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>
4830 <tr><td colspan="4" class="doc" id="isNoThrow1"><pre>Matches functions that have a non-throwing exception specification.
4831
4832 Given:
4833   void f();
4834   void g() noexcept;
4835   void h() throw();
4836   void i() throw(int);
4837   void j() noexcept(false);
4838 functionDecl(isNoThrow()) and functionProtoType(isNoThrow())
4839   match the declarations of g, and h, but not f, i or j.
4840 </pre></td></tr>
4841
4842
4843 <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>
4844 <tr><td colspan="4" class="doc" id="parameterCountIs1"><pre>Matches FunctionDecls and FunctionProtoTypes that have a
4845 specific parameter count.
4846
4847 Given
4848   void f(int i) {}
4849   void g(int i, int j) {}
4850   void h(int i, int j);
4851   void j(int i);
4852   void k(int x, int y, int z, ...);
4853 functionDecl(parameterCountIs(2))
4854   matches g and h
4855 functionProtoType(parameterCountIs(2))
4856   matches g and h
4857 functionProtoType(parameterCountIs(3))
4858   matches k
4859 </pre></td></tr>
4860
4861
4862 <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>
4863 <tr><td colspan="4" class="doc" id="isConsteval1"><pre>Matches consteval function declarations and if consteval/if ! consteval
4864 statements.
4865
4866 Given:
4867   consteval int a();
4868   void b() { if consteval {} }
4869   void c() { if ! consteval {} }
4870   void d() { if ! consteval {} else {} }
4871 functionDecl(isConsteval())
4872   matches the declaration of "int a()".
4873 ifStmt(isConsteval())
4874   matches the if statement in "void b()", "void c()", "void d()".
4875 </pre></td></tr>
4876
4877
4878 <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>
4879 <tr><td colspan="4" class="doc" id="isConstexpr2"><pre>Matches constexpr variable and function declarations,
4880        and if constexpr.
4881
4882 Given:
4883   constexpr int foo = 42;
4884   constexpr int bar();
4885   void baz() { if constexpr(1 &gt; 0) {} }
4886 varDecl(isConstexpr())
4887   matches the declaration of foo.
4888 functionDecl(isConstexpr())
4889   matches the declaration of bar.
4890 ifStmt(isConstexpr())
4891   matches the if statement in baz.
4892 </pre></td></tr>
4893
4894
4895 <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>
4896 <tr><td colspan="4" class="doc" id="equals6"><pre></pre></td></tr>
4897
4898
4899 <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>
4900 <tr><td colspan="4" class="doc" id="equals0"><pre>Matches literals that are equal to the given value of type ValueT.
4901
4902 Given
4903   f('false, 3.14, 42);
4904 characterLiteral(equals(0))
4905   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
4906   match false
4907 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
4908   match 3.14
4909 integerLiteral(equals(42))
4910   matches 42
4911
4912 Note that you cannot directly match a negative numeric literal because the
4913 minus sign is not part of the literal: It is a unary operator whose operand
4914 is the positive numeric literal. Instead, you must use a unaryOperator()
4915 matcher to match the minus sign:
4916
4917 unaryOperator(hasOperatorName("-"),
4918               hasUnaryOperand(integerLiteral(equals(13))))
4919
4920 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;,
4921            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;
4922 </pre></td></tr>
4923
4924
4925 <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>
4926 <tr><td colspan="4" class="doc" id="equals13"><pre></pre></td></tr>
4927
4928
4929 <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>
4930 <tr><td colspan="4" class="doc" id="equals9"><pre></pre></td></tr>
4931
4932
4933 <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>
4934 <tr><td colspan="4" class="doc" id="capturesThis0"><pre>Matches a `LambdaCapture` that refers to 'this'.
4935
4936 Given
4937 class C {
4938   int cc;
4939   int f() {
4940     auto l = [this]() { return cc; };
4941     return l();
4942   }
4943 };
4944 lambdaExpr(hasAnyCapture(lambdaCapture(capturesThis())))
4945   matches `[this]() { return cc; }`.
4946 </pre></td></tr>
4947
4948
4949 <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>
4950 <tr><td colspan="4" class="doc" id="isImplicit2"><pre>Matches an entity that has been implicitly added by the compiler (e.g.
4951 implicit default/copy constructors).
4952 </pre></td></tr>
4953
4954
4955 <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>
4956 <tr><td colspan="4" class="doc" id="isArrow0"><pre>Matches member expressions that are called with '-&gt;' as opposed
4957 to '.'.
4958
4959 Member calls on the implicit this pointer match as called with '-&gt;'.
4960
4961 Given
4962   class Y {
4963     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
4964     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
4965     int a;
4966     static int b;
4967   };
4968   template &lt;class T&gt;
4969   class Z {
4970     void x() { this-&gt;m; }
4971   };
4972 memberExpr(isArrow())
4973   matches this-&gt;x, x, y.x, a, this-&gt;b
4974 cxxDependentScopeMemberExpr(isArrow())
4975   matches this-&gt;m
4976 unresolvedMemberExpr(isArrow())
4977   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
4978 </pre></td></tr>
4979
4980
4981 <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>
4982 <tr><td colspan="4" class="doc" id="hasAnyName0"><pre>Matches NamedDecl nodes that have any of the specified names.
4983
4984 This matcher is only provided as a performance optimization of hasName.
4985     hasAnyName(a, b, c)
4986  is equivalent to, but faster than
4987     anyOf(hasName(a), hasName(b), hasName(c))
4988 </pre></td></tr>
4989
4990
4991 <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>
4992 <tr><td colspan="4" class="doc" id="hasExternalFormalLinkage0"><pre>Matches a declaration that has external formal linkage.
4993
4994 Example matches only z (matcher = varDecl(hasExternalFormalLinkage()))
4995 void f() {
4996   int x;
4997   static int y;
4998 }
4999 int z;
5000
5001 Example matches f() because it has external formal linkage despite being
5002 unique to the translation unit as though it has internal likage
5003 (matcher = functionDecl(hasExternalFormalLinkage()))
5004
5005 namespace {
5006 void f() {}
5007 }
5008 </pre></td></tr>
5009
5010
5011 <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>
5012 <tr><td colspan="4" class="doc" id="hasName0"><pre>Matches NamedDecl nodes that have the specified name.
5013
5014 Supports specifying enclosing namespaces or classes by prefixing the name
5015 with '&lt;enclosing&gt;::'.
5016 Does not match typedefs of an underlying type with the given name.
5017
5018 Example matches X (Name == "X")
5019   class X;
5020
5021 Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
5022   namespace a { namespace b { class X; } }
5023 </pre></td></tr>
5024
5025
5026 <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>
5027 <tr><td colspan="4" class="doc" id="matchesName0"><pre>Matches NamedDecl nodes whose fully qualified names contain
5028 a substring matched by the given RegExp.
5029
5030 Supports specifying enclosing namespaces or classes by
5031 prefixing the name with '&lt;enclosing&gt;::'.  Does not match typedefs
5032 of an underlying type with the given name.
5033
5034 Example matches X (regexp == "::X")
5035   class X;
5036
5037 Example matches X (regexp is one of "::X", "^foo::.*X", among others)
5038   namespace foo { namespace bar { class X; } }
5039
5040 If the matcher is used in clang-query, RegexFlags parameter
5041 should be passed as a quoted string. e.g: "NoFlags".
5042 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5043 </pre></td></tr>
5044
5045
5046 <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>
5047 <tr><td colspan="4" class="doc" id="isAnonymous0"><pre>Matches anonymous namespace declarations.
5048
5049 Given
5050   namespace n {
5051   namespace {} // #1
5052   }
5053 namespaceDecl(isAnonymous()) will match #1 but not ::n.
5054 </pre></td></tr>
5055
5056
5057 <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>
5058 <tr><td colspan="4" class="doc" id="isInline0"><pre>Matches functions, variables and namespace declarations that are marked with
5059 the inline keyword.
5060
5061 Given
5062   inline void f();
5063   void g();
5064   namespace n {
5065   inline namespace m {}
5066   }
5067   inline int Foo = 5;
5068 functionDecl(isInline()) will match ::f().
5069 namespaceDecl(isInline()) will match n::m.
5070 varDecl(isInline()) will match Foo;
5071 </pre></td></tr>
5072
5073
5074 <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>
5075 <tr><td colspan="4" class="doc" id="isFirstPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``firstprivate`` kind
5076 specified.
5077
5078 Given
5079
5080   #pragma omp parallel
5081   #pragma omp parallel default(none)
5082   #pragma omp parallel default(shared)
5083   #pragma omp parallel default(private)
5084   #pragma omp parallel default(firstprivate)
5085
5086 ``ompDefaultClause(isFirstPrivateKind())`` matches only
5087 ``default(firstprivate)``.
5088 </pre></td></tr>
5089
5090
5091 <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>
5092 <tr><td colspan="4" class="doc" id="isNoneKind0"><pre>Matches if the OpenMP ``default`` clause has ``none`` kind specified.
5093
5094 Given
5095
5096   #pragma omp parallel
5097   #pragma omp parallel default(none)
5098   #pragma omp parallel default(shared)
5099   #pragma omp parallel default(private)
5100   #pragma omp parallel default(firstprivate)
5101
5102 ``ompDefaultClause(isNoneKind())`` matches only ``default(none)``.
5103 </pre></td></tr>
5104
5105
5106 <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>
5107 <tr><td colspan="4" class="doc" id="isPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``private`` kind
5108 specified.
5109
5110 Given
5111
5112   #pragma omp parallel
5113   #pragma omp parallel default(none)
5114   #pragma omp parallel default(shared)
5115   #pragma omp parallel default(private)
5116   #pragma omp parallel default(firstprivate)
5117
5118 ``ompDefaultClause(isPrivateKind())`` matches only
5119 ``default(private)``.
5120 </pre></td></tr>
5121
5122
5123 <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>
5124 <tr><td colspan="4" class="doc" id="isSharedKind0"><pre>Matches if the OpenMP ``default`` clause has ``shared`` kind specified.
5125
5126 Given
5127
5128   #pragma omp parallel
5129   #pragma omp parallel default(none)
5130   #pragma omp parallel default(shared)
5131   #pragma omp parallel default(private)
5132   #pragma omp parallel default(firstprivate)
5133
5134 ``ompDefaultClause(isSharedKind())`` matches only ``default(shared)``.
5135 </pre></td></tr>
5136
5137
5138 <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>
5139 <tr><td colspan="4" class="doc" id="isAllowedToContainClauseKind0"><pre>Matches if the OpenMP directive is allowed to contain the specified OpenMP
5140 clause kind.
5141
5142 Given
5143
5144   #pragma omp parallel
5145   #pragma omp parallel for
5146   #pragma omp          for
5147
5148 `ompExecutableDirective(isAllowedToContainClause(OMPC_default))`` matches
5149 ``omp parallel`` and ``omp parallel for``.
5150
5151 If the matcher is use from clang-query, ``OpenMPClauseKind`` parameter
5152 should be passed as a quoted string. e.g.,
5153 ``isAllowedToContainClauseKind("OMPC_default").``
5154 </pre></td></tr>
5155
5156
5157 <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>
5158 <tr><td colspan="4" class="doc" id="isStandaloneDirective0"><pre>Matches standalone OpenMP directives,
5159 i.e., directives that can't have a structured block.
5160
5161 Given
5162
5163   #pragma omp parallel
5164   {}
5165   #pragma omp taskyield
5166
5167 ``ompExecutableDirective(isStandaloneDirective()))`` matches
5168 ``omp taskyield``.
5169 </pre></td></tr>
5170
5171
5172 <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>
5173 <tr><td colspan="4" class="doc" id="isDerivedFrom3"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
5174 </pre></td></tr>
5175
5176
5177 <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>
5178 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom3"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
5179 </pre></td></tr>
5180
5181
5182 <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>
5183 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom3"><pre>Overloaded method as shortcut for
5184 isSameOrDerivedFrom(hasName(...)).
5185 </pre></td></tr>
5186
5187
5188 <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>
5189 <tr><td colspan="4" class="doc" id="argumentCountAtLeast3"><pre>Checks that a call expression or a constructor call expression has at least
5190 the specified number of arguments (including absent default arguments).
5191
5192 Example matches f(0, 0) and g(0, 0, 0)
5193 (matcher = callExpr(argumentCountAtLeast(2)))
5194   void f(int x, int y);
5195   void g(int x, int y, int z);
5196   f(0, 0);
5197   g(0, 0, 0);
5198 </pre></td></tr>
5199
5200
5201 <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>
5202 <tr><td colspan="4" class="doc" id="argumentCountIs3"><pre>Checks that a call expression or a constructor call expression has
5203 a specific number of arguments (including absent default arguments).
5204
5205 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
5206   void f(int x, int y);
5207   f(0, 0);
5208 </pre></td></tr>
5209
5210
5211 <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>
5212 <tr><td colspan="4" class="doc" id="hasAnySelector0"><pre>Matches when at least one of the supplied string equals to the
5213 Selector.getAsString()
5214
5215  matcher = objCMessageExpr(hasSelector("methodA:", "methodB:"));
5216  matches both of the expressions below:
5217     [myObj methodA:argA];
5218     [myObj methodB:argB];
5219 </pre></td></tr>
5220
5221
5222 <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>
5223 <tr><td colspan="4" class="doc" id="hasKeywordSelector0"><pre>Matches when the selector is a keyword selector
5224
5225 objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
5226 message expression in
5227
5228   UIWebView *webView = ...;
5229   CGRect bodyFrame = webView.frame;
5230   bodyFrame.size.height = self.bodyContentHeight;
5231   webView.frame = bodyFrame;
5232   //     ^---- matches here
5233 </pre></td></tr>
5234
5235
5236 <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>
5237 <tr><td colspan="4" class="doc" id="hasNullSelector0"><pre>Matches when the selector is the empty selector
5238
5239 Matches only when the selector of the objCMessageExpr is NULL. This may
5240 represent an error condition in the tree!
5241 </pre></td></tr>
5242
5243
5244 <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>
5245 <tr><td colspan="4" class="doc" id="hasSelector0"><pre>Matches when BaseName == Selector.getAsString()
5246
5247  matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
5248  matches the outer message expr in the code below, but NOT the message
5249  invocation for self.bodyView.
5250     [self.bodyView loadHTMLString:html baseURL:NULL];
5251 </pre></td></tr>
5252
5253
5254 <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>
5255 <tr><td colspan="4" class="doc" id="hasUnarySelector0"><pre>Matches when the selector is a Unary Selector
5256
5257  matcher = objCMessageExpr(matchesSelector(hasUnarySelector());
5258  matches self.bodyView in the code below, but NOT the outer message
5259  invocation of "loadHTMLString:baseURL:".
5260     [self.bodyView loadHTMLString:html baseURL:NULL];
5261 </pre></td></tr>
5262
5263
5264 <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>
5265 <tr><td colspan="4" class="doc" id="isClassMessage0"><pre>Returns true when the Objective-C message is sent to a class.
5266
5267 Example
5268 matcher = objcMessageExpr(isClassMessage())
5269 matches
5270   [NSString stringWithFormat:@"format"];
5271 but not
5272   NSString *x = @"hello";
5273   [x containsString:@"h"];
5274 </pre></td></tr>
5275
5276
5277 <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>
5278 <tr><td colspan="4" class="doc" id="isInstanceMessage0"><pre>Returns true when the Objective-C message is sent to an instance.
5279
5280 Example
5281 matcher = objcMessageExpr(isInstanceMessage())
5282 matches
5283   NSString *x = @"hello";
5284   [x containsString:@"h"];
5285 but not
5286   [NSString stringWithFormat:@"format"];
5287 </pre></td></tr>
5288
5289
5290 <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>
5291 <tr><td colspan="4" class="doc" id="matchesSelector0"><pre>Matches ObjC selectors whose name contains
5292 a substring matched by the given RegExp.
5293  matcher = objCMessageExpr(matchesSelector("loadHTMLStringmatches the outer message expr in the code below, but NOT the message
5294  invocation for self.bodyView.
5295     [self.bodyView loadHTMLString:html baseURL:NULL];
5296
5297 If the matcher is used in clang-query, RegexFlags parameter
5298 should be passed as a quoted string. e.g: "NoFlags".
5299 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5300 </pre></td></tr>
5301
5302
5303 <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>
5304 <tr><td colspan="4" class="doc" id="numSelectorArgs0"><pre>Matches when the selector has the specified number of arguments
5305
5306  matcher = objCMessageExpr(numSelectorArgs(0));
5307  matches self.bodyView in the code below
5308
5309  matcher = objCMessageExpr(numSelectorArgs(2));
5310  matches the invocation of "loadHTMLString:baseURL:" but not that
5311  of self.bodyView
5312     [self.bodyView loadHTMLString:html baseURL:NULL];
5313 </pre></td></tr>
5314
5315
5316 <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>
5317 <tr><td colspan="4" class="doc" id="isClassMethod0"><pre>Returns true when the Objective-C method declaration is a class method.
5318
5319 Example
5320 matcher = objcMethodDecl(isClassMethod())
5321 matches
5322 @interface I + (void)foo; @end
5323 but not
5324 @interface I - (void)bar; @end
5325 </pre></td></tr>
5326
5327
5328 <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>
5329 <tr><td colspan="4" class="doc" id="isDefinition2"><pre>Matches if a declaration has a body attached.
5330
5331 Example matches A, va, fa
5332   class A {};
5333   class B;  // Doesn't match, as it has no body.
5334   int va;
5335   extern int vb;  // Doesn't match, as it doesn't define the variable.
5336   void fa() {}
5337   void fb();  // Doesn't match, as it has no body.
5338   @interface X
5339   - (void)ma; // Doesn't match, interface is declaration.
5340   @end
5341   @implementation X
5342   - (void)ma {}
5343   @end
5344
5345 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;,
5346   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
5347 </pre></td></tr>
5348
5349
5350 <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>
5351 <tr><td colspan="4" class="doc" id="isInstanceMethod0"><pre>Returns true when the Objective-C method declaration is an instance method.
5352
5353 Example
5354 matcher = objcMethodDecl(isInstanceMethod())
5355 matches
5356 @interface I - (void)bar; @end
5357 but not
5358 @interface I + (void)foo; @end
5359 </pre></td></tr>
5360
5361
5362 <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>
5363 <tr><td colspan="4" class="doc" id="hasDefaultArgument0"><pre>Matches a declaration that has default arguments.
5364
5365 Example matches y (matcher = parmVarDecl(hasDefaultArgument()))
5366 void x(int val) {}
5367 void y(int val = 0) {}
5368
5369 Deprecated. Use hasInitializer() instead to be able to
5370 match on the contents of the default argument.  For example:
5371
5372 void x(int val = 7) {}
5373 void y(int val = 42) {}
5374 parmVarDecl(hasInitializer(integerLiteral(equals(42))))
5375   matches the parameter of y
5376
5377 A matcher such as
5378   parmVarDecl(hasInitializer(anything()))
5379 is equivalent to parmVarDecl(hasDefaultArgument()).
5380 </pre></td></tr>
5381
5382
5383 <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>
5384 <tr><td colspan="4" class="doc" id="isAtPosition0"><pre>Matches the ParmVarDecl nodes that are at the N'th position in the parameter
5385 list. The parameter list could be that of either a block, function, or
5386 objc-method.
5387
5388
5389 Given
5390
5391 void f(int a, int b, int c) {
5392 }
5393
5394 ``parmVarDecl(isAtPosition(0))`` matches ``int a``.
5395
5396 ``parmVarDecl(isAtPosition(1))`` matches ``int b``.
5397 </pre></td></tr>
5398
5399
5400 <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>
5401 <tr><td colspan="4" class="doc" id="asString0"><pre>Matches if the matched type is represented by the given string.
5402
5403 Given
5404   class Y { public: void x(); };
5405   void z() { Y* y; y-&gt;x(); }
5406 cxxMemberCallExpr(on(hasType(asString("class Y *"))))
5407   matches y-&gt;x()
5408 </pre></td></tr>
5409
5410
5411 <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>
5412 <tr><td colspan="4" class="doc" id="equalsBoundNode3"><pre>Matches if a node equals a previously bound node.
5413
5414 Matches a node if it equals the node previously bound to ID.
5415
5416 Given
5417   class X { int a; int b; };
5418 cxxRecordDecl(
5419     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
5420     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
5421   matches the class X, as a and b have the same type.
5422
5423 Note that when multiple matches are involved via forEach* matchers,
5424 equalsBoundNodes acts as a filter.
5425 For example:
5426 compoundStmt(
5427     forEachDescendant(varDecl().bind("d")),
5428     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
5429 will trigger a match for each combination of variable declaration
5430 and reference to that variable declaration within a compound statement.
5431 </pre></td></tr>
5432
5433
5434 <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>
5435 <tr><td colspan="4" class="doc" id="hasLocalQualifiers0"><pre>Matches QualType nodes that have local CV-qualifiers attached to
5436 the node, not hidden within a typedef.
5437
5438 Given
5439   typedef const int const_int;
5440   const_int i;
5441   int *const j;
5442   int *volatile k;
5443   int m;
5444 varDecl(hasType(hasLocalQualifiers())) matches only j and k.
5445 i is const-qualified but the qualifier is not local.
5446 </pre></td></tr>
5447
5448
5449 <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>
5450 <tr><td colspan="4" class="doc" id="isAnyCharacter0"><pre>Matches QualType nodes that are of character type.
5451
5452 Given
5453   void a(char);
5454   void b(wchar_t);
5455   void c(double);
5456 functionDecl(hasAnyParameter(hasType(isAnyCharacter())))
5457 matches "a(char)", "b(wchar_t)", but not "c(double)".
5458 </pre></td></tr>
5459
5460
5461 <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>
5462 <tr><td colspan="4" class="doc" id="isAnyPointer0"><pre>Matches QualType nodes that are of any pointer type; this includes
5463 the Objective-C object pointer type, which is different despite being
5464 syntactically similar.
5465
5466 Given
5467   int *i = nullptr;
5468
5469   @interface Foo
5470   @end
5471   Foo *f;
5472
5473   int j;
5474 varDecl(hasType(isAnyPointer()))
5475   matches "int *i" and "Foo *f", but not "int j".
5476 </pre></td></tr>
5477
5478
5479 <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>
5480 <tr><td colspan="4" class="doc" id="isConstQualified0"><pre>Matches QualType nodes that are const-qualified, i.e., that
5481 include "top-level" const.
5482
5483 Given
5484   void a(int);
5485   void b(int const);
5486   void c(const int);
5487   void d(const int*);
5488   void e(int const) {};
5489 functionDecl(hasAnyParameter(hasType(isConstQualified())))
5490   matches "void b(int const)", "void c(const int)" and
5491   "void e(int const) {}". It does not match d as there
5492   is no top-level const on the parameter type "const int *".
5493 </pre></td></tr>
5494
5495
5496 <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>
5497 <tr><td colspan="4" class="doc" id="isInteger0"><pre>Matches QualType nodes that are of integer type.
5498
5499 Given
5500   void a(int);
5501   void b(long);
5502   void c(double);
5503 functionDecl(hasAnyParameter(hasType(isInteger())))
5504 matches "a(int)", "b(long)", but not "c(double)".
5505 </pre></td></tr>
5506
5507
5508 <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>
5509 <tr><td colspan="4" class="doc" id="isSignedInteger0"><pre>Matches QualType nodes that are of signed integer type.
5510
5511 Given
5512   void a(int);
5513   void b(unsigned long);
5514   void c(double);
5515 functionDecl(hasAnyParameter(hasType(isSignedInteger())))
5516 matches "a(int)", but not "b(unsigned long)" and "c(double)".
5517 </pre></td></tr>
5518
5519
5520 <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>
5521 <tr><td colspan="4" class="doc" id="isUnsignedInteger0"><pre>Matches QualType nodes that are of unsigned integer type.
5522
5523 Given
5524   void a(int);
5525   void b(unsigned long);
5526   void c(double);
5527 functionDecl(hasAnyParameter(hasType(isUnsignedInteger())))
5528 matches "b(unsigned long)", but not "a(int)" and "c(double)".
5529 </pre></td></tr>
5530
5531
5532 <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>
5533 <tr><td colspan="4" class="doc" id="isVolatileQualified0"><pre>Matches QualType nodes that are volatile-qualified, i.e., that
5534 include "top-level" volatile.
5535
5536 Given
5537   void a(int);
5538   void b(int volatile);
5539   void c(volatile int);
5540   void d(volatile int*);
5541   void e(int volatile) {};
5542 functionDecl(hasAnyParameter(hasType(isVolatileQualified())))
5543   matches "void b(int volatile)", "void c(volatile int)" and
5544   "void e(int volatile) {}". It does not match d as there
5545   is no top-level volatile on the parameter type "volatile int *".
5546 </pre></td></tr>
5547
5548
5549 <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>
5550 <tr><td colspan="4" class="doc" id="equalsBoundNode0"><pre>Matches if a node equals a previously bound node.
5551
5552 Matches a node if it equals the node previously bound to ID.
5553
5554 Given
5555   class X { int a; int b; };
5556 cxxRecordDecl(
5557     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
5558     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
5559   matches the class X, as a and b have the same type.
5560
5561 Note that when multiple matches are involved via forEach* matchers,
5562 equalsBoundNodes acts as a filter.
5563 For example:
5564 compoundStmt(
5565     forEachDescendant(varDecl().bind("d")),
5566     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
5567 will trigger a match for each combination of variable declaration
5568 and reference to that variable declaration within a compound statement.
5569 </pre></td></tr>
5570
5571
5572 <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>
5573 <tr><td colspan="4" class="doc" id="equalsNode1"><pre>Matches if a node equals another node.
5574
5575 Stmt has pointer identity in the AST.
5576 </pre></td></tr>
5577
5578
5579 <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>
5580 <tr><td colspan="4" class="doc" id="isExpandedFromMacro1"><pre>Matches statements that are (transitively) expanded from the named macro.
5581 Does not match if only part of the statement is expanded from that macro or
5582 if different parts of the statement are expanded from different
5583 appearances of the macro.
5584 </pre></td></tr>
5585
5586
5587 <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>
5588 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching1"><pre>Matches AST nodes that were expanded within files whose name is
5589 partially matching a given regex.
5590
5591 Example matches Y but not X
5592     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
5593   #include "ASTMatcher.h"
5594   class X {};
5595 ASTMatcher.h:
5596   class Y {};
5597
5598 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;
5599
5600 If the matcher is used in clang-query, RegexFlags parameter
5601 should be passed as a quoted string. e.g: "NoFlags".
5602 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5603 </pre></td></tr>
5604
5605
5606 <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>
5607 <tr><td colspan="4" class="doc" id="isExpansionInMainFile1"><pre>Matches AST nodes that were expanded within the main-file.
5608
5609 Example matches X but not Y
5610   (matcher = cxxRecordDecl(isExpansionInMainFile())
5611   #include &lt;Y.h&gt;
5612   class X {};
5613 Y.h:
5614   class Y {};
5615
5616 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;
5617 </pre></td></tr>
5618
5619
5620 <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>
5621 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader1"><pre>Matches AST nodes that were expanded within system-header-files.
5622
5623 Example matches Y but not X
5624     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
5625   #include &lt;SystemHeader.h&gt;
5626   class X {};
5627 SystemHeader.h:
5628   class Y {};
5629
5630 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;
5631 </pre></td></tr>
5632
5633
5634 <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>
5635 <tr><td colspan="4" class="doc" id="isInTemplateInstantiation0"><pre>Matches statements inside of a template instantiation.
5636
5637 Given
5638   int j;
5639   template&lt;typename T&gt; void A(T t) { T i; j += 42;}
5640   A(0);
5641   A(0U);
5642 declStmt(isInTemplateInstantiation())
5643   matches 'int i;' and 'unsigned i'.
5644 unless(stmt(isInTemplateInstantiation()))
5645   will NOT match j += 42; as it's shared between the template definition and
5646   instantiation.
5647 </pre></td></tr>
5648
5649
5650 <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>
5651 <tr><td colspan="4" class="doc" id="hasSize1"><pre>Matches nodes that have the specified size.
5652
5653 Given
5654   int a[42];
5655   int b[2 * 21];
5656   int c[41], d[43];
5657   char *s = "abcd";
5658   wchar_t *ws = L"abcd";
5659   char *w = "a";
5660 constantArrayType(hasSize(42))
5661   matches "int a[42]" and "int b[2 * 21]"
5662 stringLiteral(hasSize(4))
5663   matches "abcd", L"abcd"
5664 </pre></td></tr>
5665
5666
5667 <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>
5668 <tr><td colspan="4" class="doc" id="isClass0"><pre>Matches TagDecl object that are spelled with "class."
5669
5670 Example matches C, but not S, U or E.
5671   struct S {};
5672   class C {};
5673   union U {};
5674   enum E {};
5675 </pre></td></tr>
5676
5677
5678 <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>
5679 <tr><td colspan="4" class="doc" id="isDefinition0"><pre>Matches if a declaration has a body attached.
5680
5681 Example matches A, va, fa
5682   class A {};
5683   class B;  // Doesn't match, as it has no body.
5684   int va;
5685   extern int vb;  // Doesn't match, as it doesn't define the variable.
5686   void fa() {}
5687   void fb();  // Doesn't match, as it has no body.
5688   @interface X
5689   - (void)ma; // Doesn't match, interface is declaration.
5690   @end
5691   @implementation X
5692   - (void)ma {}
5693   @end
5694
5695 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;,
5696   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
5697 </pre></td></tr>
5698
5699
5700 <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>
5701 <tr><td colspan="4" class="doc" id="isEnum0"><pre>Matches TagDecl object that are spelled with "enum."
5702
5703 Example matches E, but not C, S or U.
5704   struct S {};
5705   class C {};
5706   union U {};
5707   enum E {};
5708 </pre></td></tr>
5709
5710
5711 <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>
5712 <tr><td colspan="4" class="doc" id="isStruct0"><pre>Matches TagDecl object that are spelled with "struct."
5713
5714 Example matches S, but not C, U or E.
5715   struct S {};
5716   class C {};
5717   union U {};
5718   enum E {};
5719 </pre></td></tr>
5720
5721
5722 <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>
5723 <tr><td colspan="4" class="doc" id="isUnion0"><pre>Matches TagDecl object that are spelled with "union."
5724
5725 Example matches U, but not C, S or E.
5726   struct S {};
5727   class C {};
5728   union U {};
5729   enum E {};
5730 </pre></td></tr>
5731
5732
5733 <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>
5734 <tr><td colspan="4" class="doc" id="equalsIntegralValue0"><pre>Matches a TemplateArgument of integral type with a given value.
5735
5736 Note that 'Value' is a string as the template argument's value is
5737 an arbitrary precision integer. 'Value' must be euqal to the canonical
5738 representation of that integral value in base 10.
5739
5740 Given
5741   template&lt;int T&gt; struct C {};
5742   C&lt;42&gt; c;
5743 classTemplateSpecializationDecl(
5744   hasAnyTemplateArgument(equalsIntegralValue("42")))
5745   matches the implicit instantiation of C in C&lt;42&gt;.
5746 </pre></td></tr>
5747
5748
5749 <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>
5750 <tr><td colspan="4" class="doc" id="isIntegral0"><pre>Matches a TemplateArgument that is an integral value.
5751
5752 Given
5753   template&lt;int T&gt; struct C {};
5754   C&lt;42&gt; c;
5755 classTemplateSpecializationDecl(
5756   hasAnyTemplateArgument(isIntegral()))
5757   matches the implicit instantiation of C in C&lt;42&gt;
5758   with isIntegral() matching 42.
5759 </pre></td></tr>
5760
5761
5762 <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>
5763 <tr><td colspan="4" class="doc" id="templateArgumentCountIs1"><pre>Matches if the number of template arguments equals N.
5764
5765 Given
5766   template&lt;typename T&gt; struct C {};
5767   C&lt;int&gt; c;
5768 classTemplateSpecializationDecl(templateArgumentCountIs(1))
5769   matches C&lt;int&gt;.
5770 </pre></td></tr>
5771
5772
5773 <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>
5774 <tr><td colspan="4" class="doc" id="isExpandedFromMacro2"><pre>Matches statements that are (transitively) expanded from the named macro.
5775 Does not match if only part of the statement is expanded from that macro or
5776 if different parts of the statement are expanded from different
5777 appearances of the macro.
5778 </pre></td></tr>
5779
5780
5781 <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>
5782 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching2"><pre>Matches AST nodes that were expanded within files whose name is
5783 partially matching a given regex.
5784
5785 Example matches Y but not X
5786     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
5787   #include "ASTMatcher.h"
5788   class X {};
5789 ASTMatcher.h:
5790   class Y {};
5791
5792 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;
5793
5794 If the matcher is used in clang-query, RegexFlags parameter
5795 should be passed as a quoted string. e.g: "NoFlags".
5796 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
5797 </pre></td></tr>
5798
5799
5800 <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>
5801 <tr><td colspan="4" class="doc" id="isExpansionInMainFile2"><pre>Matches AST nodes that were expanded within the main-file.
5802
5803 Example matches X but not Y
5804   (matcher = cxxRecordDecl(isExpansionInMainFile())
5805   #include &lt;Y.h&gt;
5806   class X {};
5807 Y.h:
5808   class Y {};
5809
5810 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;
5811 </pre></td></tr>
5812
5813
5814 <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>
5815 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader2"><pre>Matches AST nodes that were expanded within system-header-files.
5816
5817 Example matches Y but not X
5818     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
5819   #include &lt;SystemHeader.h&gt;
5820   class X {};
5821 SystemHeader.h:
5822   class Y {};
5823
5824 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;
5825 </pre></td></tr>
5826
5827
5828 <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>
5829 <tr><td colspan="4" class="doc" id="booleanType0"><pre>Matches type bool.
5830
5831 Given
5832  struct S { bool func(); };
5833 functionDecl(returns(booleanType()))
5834   matches "bool func();"
5835 </pre></td></tr>
5836
5837
5838 <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>
5839 <tr><td colspan="4" class="doc" id="equalsBoundNode2"><pre>Matches if a node equals a previously bound node.
5840
5841 Matches a node if it equals the node previously bound to ID.
5842
5843 Given
5844   class X { int a; int b; };
5845 cxxRecordDecl(
5846     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
5847     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
5848   matches the class X, as a and b have the same type.
5849
5850 Note that when multiple matches are involved via forEach* matchers,
5851 equalsBoundNodes acts as a filter.
5852 For example:
5853 compoundStmt(
5854     forEachDescendant(varDecl().bind("d")),
5855     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
5856 will trigger a match for each combination of variable declaration
5857 and reference to that variable declaration within a compound statement.
5858 </pre></td></tr>
5859
5860
5861 <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>
5862 <tr><td colspan="4" class="doc" id="equalsNode2"><pre>Matches if a node equals another node.
5863
5864 Type has pointer identity in the AST.
5865 </pre></td></tr>
5866
5867
5868 <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>
5869 <tr><td colspan="4" class="doc" id="realFloatingPointType0"><pre>Matches any real floating-point type (float, double, long double).
5870
5871 Given
5872   int i;
5873   float f;
5874 realFloatingPointType()
5875   matches "float f" but not "int i"
5876 </pre></td></tr>
5877
5878
5879 <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>
5880 <tr><td colspan="4" class="doc" id="voidType0"><pre>Matches type void.
5881
5882 Given
5883  struct S { void func(); };
5884 functionDecl(returns(voidType()))
5885   matches "void func();"
5886 </pre></td></tr>
5887
5888
5889 <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>
5890 <tr><td colspan="4" class="doc" id="ofKind0"><pre>Matches unary expressions of a certain kind.
5891
5892 Given
5893   int x;
5894   int s = sizeof(x) + alignof(x)
5895 unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
5896   matches sizeof(x)
5897
5898 If the matcher is use from clang-query, UnaryExprOrTypeTrait parameter
5899 should be passed as a quoted string. e.g., ofKind("UETT_SizeOf").
5900 </pre></td></tr>
5901
5902
5903 <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>
5904 <tr><td colspan="4" class="doc" id="hasAnyOperatorName3"><pre>Matches operator expressions (binary or unary) that have any of the
5905 specified names.
5906
5907    hasAnyOperatorName("+", "-")
5908  Is equivalent to
5909    anyOf(hasOperatorName("+"), hasOperatorName("-"))
5910 </pre></td></tr>
5911
5912
5913 <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>
5914 <tr><td colspan="4" class="doc" id="hasOperatorName4"><pre>Matches the operator Name of operator expressions and fold expressions
5915 (binary or unary).
5916
5917 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
5918   !(a || b)
5919
5920 Example matches `(0 + ... + args)`
5921     (matcher = cxxFoldExpr(hasOperatorName("+")))
5922   template &lt;typename... Args&gt;
5923   auto sum(Args... args) {
5924       return (0 + ... + args);
5925   }
5926 </pre></td></tr>
5927
5928
5929 <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>
5930 <tr><td colspan="4" class="doc" id="isArrow1"><pre>Matches member expressions that are called with '-&gt;' as opposed
5931 to '.'.
5932
5933 Member calls on the implicit this pointer match as called with '-&gt;'.
5934
5935 Given
5936   class Y {
5937     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
5938     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
5939     int a;
5940     static int b;
5941   };
5942   template &lt;class T&gt;
5943   class Z {
5944     void x() { this-&gt;m; }
5945   };
5946 memberExpr(isArrow())
5947   matches this-&gt;x, x, y.x, a, this-&gt;b
5948 cxxDependentScopeMemberExpr(isArrow())
5949   matches this-&gt;m
5950 unresolvedMemberExpr(isArrow())
5951   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
5952 </pre></td></tr>
5953
5954
5955 <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>
5956 <tr><td colspan="4" class="doc" id="hasAutomaticStorageDuration0"><pre>Matches a variable declaration that has automatic storage duration.
5957
5958 Example matches x, but not y, z, or a.
5959 (matcher = varDecl(hasAutomaticStorageDuration())
5960 void f() {
5961   int x;
5962   static int y;
5963   thread_local int z;
5964 }
5965 int a;
5966 </pre></td></tr>
5967
5968
5969 <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>
5970 <tr><td colspan="4" class="doc" id="hasGlobalStorage0"><pre>Matches a variable declaration that does not have local storage.
5971
5972 Example matches y and z (matcher = varDecl(hasGlobalStorage())
5973 void f() {
5974   int x;
5975   static int y;
5976 }
5977 int z;
5978 </pre></td></tr>
5979
5980
5981 <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>
5982 <tr><td colspan="4" class="doc" id="hasLocalStorage0"><pre>Matches a variable declaration that has function scope and is a
5983 non-static local variable.
5984
5985 Example matches x (matcher = varDecl(hasLocalStorage())
5986 void f() {
5987   int x;
5988   static int y;
5989 }
5990 int z;
5991 </pre></td></tr>
5992
5993
5994 <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>
5995 <tr><td colspan="4" class="doc" id="hasStaticStorageDuration0"><pre>Matches a variable declaration that has static storage duration.
5996 It includes the variable declared at namespace scope and those declared
5997 with "static" and "extern" storage class specifiers.
5998
5999 void f() {
6000   int x;
6001   static int y;
6002   thread_local int z;
6003 }
6004 int a;
6005 static int b;
6006 extern int c;
6007 varDecl(hasStaticStorageDuration())
6008   matches the function declaration y, a, b and c.
6009 </pre></td></tr>
6010
6011
6012 <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>
6013 <tr><td colspan="4" class="doc" id="hasThreadStorageDuration0"><pre>Matches a variable declaration that has thread storage duration.
6014
6015 Example matches z, but not x, z, or a.
6016 (matcher = varDecl(hasThreadStorageDuration())
6017 void f() {
6018   int x;
6019   static int y;
6020   thread_local int z;
6021 }
6022 int a;
6023 </pre></td></tr>
6024
6025
6026 <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>
6027 <tr><td colspan="4" class="doc" id="isConstexpr0"><pre>Matches constexpr variable and function declarations,
6028        and if constexpr.
6029
6030 Given:
6031   constexpr int foo = 42;
6032   constexpr int bar();
6033   void baz() { if constexpr(1 &gt; 0) {} }
6034 varDecl(isConstexpr())
6035   matches the declaration of foo.
6036 functionDecl(isConstexpr())
6037   matches the declaration of bar.
6038 ifStmt(isConstexpr())
6039   matches the if statement in baz.
6040 </pre></td></tr>
6041
6042
6043 <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>
6044 <tr><td colspan="4" class="doc" id="isConstinit0"><pre>Matches constinit variable declarations.
6045
6046 Given:
6047   constinit int foo = 42;
6048   constinit const char* bar = "bar";
6049   int baz = 42;
6050   [[clang::require_constant_initialization]] int xyz = 42;
6051 varDecl(isConstinit())
6052   matches the declaration of `foo` and `bar`, but not `baz` and `xyz`.
6053 </pre></td></tr>
6054
6055
6056 <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>
6057 <tr><td colspan="4" class="doc" id="isDefinition1"><pre>Matches if a declaration has a body attached.
6058
6059 Example matches A, va, fa
6060   class A {};
6061   class B;  // Doesn't match, as it has no body.
6062   int va;
6063   extern int vb;  // Doesn't match, as it doesn't define the variable.
6064   void fa() {}
6065   void fb();  // Doesn't match, as it has no body.
6066   @interface X
6067   - (void)ma; // Doesn't match, interface is declaration.
6068   @end
6069   @implementation X
6070   - (void)ma {}
6071   @end
6072
6073 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;,
6074   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;
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('isExceptionVariable0')"><a name="isExceptionVariable0Anchor">isExceptionVariable</a></td><td></td></tr>
6079 <tr><td colspan="4" class="doc" id="isExceptionVariable0"><pre>Matches a variable declaration that is an exception variable from
6080 a C++ catch block, or an Objective-C statement.
6081
6082 Example matches x (matcher = varDecl(isExceptionVariable())
6083 void f(int y) {
6084   try {
6085   } catch (int x) {
6086   }
6087 }
6088 </pre></td></tr>
6089
6090
6091 <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>
6092 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization1"><pre>Matches explicit template specializations of function, class, or
6093 static member variable template instantiations.
6094
6095 Given
6096   template&lt;typename T&gt; void A(T t) { }
6097   template&lt;&gt; void A(int N) { }
6098 functionDecl(isExplicitTemplateSpecialization())
6099   matches the specialization A&lt;int&gt;().
6100
6101 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;
6102 </pre></td></tr>
6103
6104
6105 <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>
6106 <tr><td colspan="4" class="doc" id="isExternC1"><pre>Matches extern "C" function or variable declarations.
6107
6108 Given:
6109   extern "C" void f() {}
6110   extern "C" { void g() {} }
6111   void h() {}
6112   extern "C" int x = 1;
6113   extern "C" int y = 2;
6114   int z = 3;
6115 functionDecl(isExternC())
6116   matches the declaration of f and g, but not the declaration of h.
6117 varDecl(isExternC())
6118   matches the declaration of x and y, but not the declaration of z.
6119 </pre></td></tr>
6120
6121
6122 <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>
6123 <tr><td colspan="4" class="doc" id="isInitCapture0"><pre>Matches a variable serving as the implicit variable for a lambda init-
6124 capture.
6125
6126 Example matches x (matcher = varDecl(isInitCapture()))
6127 auto f = [x=3]() { return x; };
6128 </pre></td></tr>
6129
6130
6131 <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>
6132 <tr><td colspan="4" class="doc" id="isInline2"><pre>Matches functions, variables and namespace declarations that are marked with
6133 the inline keyword.
6134
6135 Given
6136   inline void f();
6137   void g();
6138   namespace n {
6139   inline namespace m {}
6140   }
6141   inline int Foo = 5;
6142 functionDecl(isInline()) will match ::f().
6143 namespaceDecl(isInline()) will match n::m.
6144 varDecl(isInline()) will match Foo;
6145 </pre></td></tr>
6146
6147
6148 <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>
6149 <tr><td colspan="4" class="doc" id="isStaticLocal0"><pre>Matches a static variable with local scope.
6150
6151 Example matches y (matcher = varDecl(isStaticLocal()))
6152 void f() {
6153   int x;
6154   static int y;
6155 }
6156 static int z;
6157 </pre></td></tr>
6158
6159
6160 <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>
6161 <tr><td colspan="4" class="doc" id="isStaticStorageClass1"><pre>Matches variable/function declarations that have "static" storage
6162 class specifier ("static" keyword) written in the source.
6163
6164 Given:
6165   static void f() {}
6166   static int i = 0;
6167   extern int j;
6168   int k;
6169 functionDecl(isStaticStorageClass())
6170   matches the function declaration f.
6171 varDecl(isStaticStorageClass())
6172   matches the variable declaration i.
6173 </pre></td></tr>
6174
6175
6176 <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>
6177 <tr><td colspan="4" class="doc" id="isTemplateInstantiation1"><pre>Matches template instantiations of function, class, or static
6178 member variable template instantiations.
6179
6180 Given
6181   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
6182 or
6183   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
6184 or
6185   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
6186 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
6187   matches the template instantiation of X&lt;A&gt;.
6188
6189 But given
6190   template &lt;typename T&gt;  class X {}; class A {};
6191   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
6192 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
6193   does not match, as X&lt;A&gt; is an explicit template specialization.
6194
6195 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;
6196 </pre></td></tr>
6197
6198 <!--END_NARROWING_MATCHERS -->
6199 </table>
6200
6201 <!-- ======================================================================= -->
6202 <h2 id="traversal-matchers">AST Traversal Matchers</h2>
6203 <!-- ======================================================================= -->
6204
6205 <p>Traversal matchers specify the relationship to other nodes that are
6206 reachable from the current node.</p>
6207
6208 <p>Note that there are special traversal matchers (has, hasDescendant, forEach and
6209 forEachDescendant) which work on all nodes and allow users to write more generic
6210 match expressions.</p>
6211
6212 <table>
6213 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
6214 <!-- START_TRAVERSAL_MATCHERS -->
6215
6216 <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>
6217 <tr><td colspan="4" class="doc" id="binaryOperation0"><pre>Matches nodes which can be used with binary operators.
6218
6219 The code
6220   var1 != var2;
6221 might be represented in the clang AST as a binaryOperator, a
6222 cxxOperatorCallExpr or a cxxRewrittenBinaryOperator, depending on
6223
6224 * whether the types of var1 and var2 are fundamental (binaryOperator) or at
6225   least one is a class type (cxxOperatorCallExpr)
6226 * whether the code appears in a template declaration, if at least one of the
6227   vars is a dependent-type (binaryOperator)
6228 * whether the code relies on a rewritten binary operator, such as a
6229 spaceship operator or an inverted equality operator
6230 (cxxRewrittenBinaryOperator)
6231
6232 This matcher elides details in places where the matchers for the nodes are
6233 compatible.
6234
6235 Given
6236   binaryOperation(
6237     hasOperatorName("!="),
6238     hasLHS(expr().bind("lhs")),
6239     hasRHS(expr().bind("rhs"))
6240   )
6241 matches each use of "!=" in:
6242   struct S{
6243       bool operator!=(const S&amp;) const;
6244   };
6245
6246   void foo()
6247   {
6248      1 != 2;
6249      S() != S();
6250   }
6251
6252   template&lt;typename T&gt;
6253   void templ()
6254   {
6255      1 != 2;
6256      T() != S();
6257   }
6258   struct HasOpEq
6259   {
6260       bool operator==(const HasOpEq &amp;) const;
6261   };
6262
6263   void inverse()
6264   {
6265       HasOpEq s1;
6266       HasOpEq s2;
6267       if (s1 != s2)
6268           return;
6269   }
6270
6271   struct HasSpaceship
6272   {
6273       bool operator&lt;=&gt;(const HasOpEq &amp;) const;
6274   };
6275
6276   void use_spaceship()
6277   {
6278       HasSpaceship s1;
6279       HasSpaceship s2;
6280       if (s1 != s2)
6281           return;
6282   }
6283 </pre></td></tr>
6284
6285
6286 <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>
6287 <tr><td colspan="4" class="doc" id="eachOf0"><pre>Matches if any of the given matchers matches.
6288
6289 Unlike anyOf, eachOf will generate a match result for each
6290 matching submatcher.
6291
6292 For example, in:
6293   class A { int a; int b; };
6294 The matcher:
6295   cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
6296                        has(fieldDecl(hasName("b")).bind("v"))))
6297 will generate two results binding "v", the first of which binds
6298 the field declaration of a, the second the field declaration of
6299 b.
6300
6301 Usable as: Any Matcher
6302 </pre></td></tr>
6303
6304
6305 <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>
6306 <tr><td colspan="4" class="doc" id="findAll0"><pre>Matches if the node or any descendant matches.
6307
6308 Generates results for each match.
6309
6310 For example, in:
6311   class A { class B {}; class C {}; };
6312 The matcher:
6313   cxxRecordDecl(hasName("::A"),
6314                 findAll(cxxRecordDecl(isDefinition()).bind("m")))
6315 will generate results for A, B and C.
6316
6317 Usable as: Any Matcher
6318 </pre></td></tr>
6319
6320
6321 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEachDescendant0')"><a name="forEachDescendant0Anchor">forEachDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
6322 <tr><td colspan="4" class="doc" id="forEachDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
6323 provided matcher.
6324
6325 Example matches X, A, A::X, B, B::C, B::C::X
6326   (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X")))))
6327   class X {};
6328   class A { class X {}; };  // Matches A, because A::X is a class of name
6329                             // X inside A.
6330   class B { class C { class X {}; }; };
6331
6332 DescendantT must be an AST base type.
6333
6334 As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
6335 each result that matches instead of only on the first one.
6336
6337 Note: Recursively combined ForEachDescendant can cause many matches:
6338   cxxRecordDecl(forEachDescendant(cxxRecordDecl(
6339     forEachDescendant(cxxRecordDecl())
6340   )))
6341 will match 10 times (plus injected class name matches) on:
6342   class A { class B { class C { class D { class E {}; }; }; }; };
6343
6344 Usable as: Any Matcher
6345 </pre></td></tr>
6346
6347
6348 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('forEach0')"><a name="forEach0Anchor">forEach</a></td><td>Matcher&lt;*&gt;</td></tr>
6349 <tr><td colspan="4" class="doc" id="forEach0"><pre>Matches AST nodes that have child AST nodes that match the
6350 provided matcher.
6351
6352 Example matches X, Y, Y::X, Z::Y, Z::Y::X
6353   (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X")))
6354   class X {};
6355   class Y { class X {}; };  // Matches Y, because Y::X is a class of name X
6356                             // inside Y.
6357   class Z { class Y { class X {}; }; };  // Does not match Z.
6358
6359 ChildT must be an AST base type.
6360
6361 As opposed to 'has', 'forEach' will cause a match for each result that
6362 matches instead of only on the first one.
6363
6364 Usable as: Any Matcher
6365 </pre></td></tr>
6366
6367
6368 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasAncestor0')"><a name="hasAncestor0Anchor">hasAncestor</a></td><td>Matcher&lt;*&gt;</td></tr>
6369 <tr><td colspan="4" class="doc" id="hasAncestor0"><pre>Matches AST nodes that have an ancestor that matches the provided
6370 matcher.
6371
6372 Given
6373 void f() { if (true) { int x = 42; } }
6374 void g() { for (;;) { int x = 43; } }
6375 expr(integerLiteral(hasAncestor(ifStmt()))) matches 42, but not 43.
6376
6377 Usable as: Any Matcher
6378 </pre></td></tr>
6379
6380
6381 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasDescendant0')"><a name="hasDescendant0Anchor">hasDescendant</a></td><td>Matcher&lt;*&gt;</td></tr>
6382 <tr><td colspan="4" class="doc" id="hasDescendant0"><pre>Matches AST nodes that have descendant AST nodes that match the
6383 provided matcher.
6384
6385 Example matches X, Y, Z
6386     (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))
6387   class X {};  // Matches X, because X::X is a class of name X inside X.
6388   class Y { class X {}; };
6389   class Z { class Y { class X {}; }; };
6390
6391 DescendantT must be an AST base type.
6392
6393 Usable as: Any Matcher
6394 </pre></td></tr>
6395
6396
6397 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('has0')"><a name="has0Anchor">has</a></td><td>Matcher&lt;*&gt;</td></tr>
6398 <tr><td colspan="4" class="doc" id="has0"><pre>Matches AST nodes that have child AST nodes that match the
6399 provided matcher.
6400
6401 Example matches X, Y
6402   (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X")))
6403   class X {};  // Matches X, because X::X is a class of name X inside X.
6404   class Y { class X {}; };
6405   class Z { class Y { class X {}; }; };  // Does not match Z.
6406
6407 ChildT must be an AST base type.
6408
6409 Usable as: Any Matcher
6410 Note that has is direct matcher, so it also matches things like implicit
6411 casts and paren casts. If you are matching with expr then you should
6412 probably consider using ignoringParenImpCasts like:
6413 has(ignoringParenImpCasts(expr())).
6414 </pre></td></tr>
6415
6416
6417 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('hasParent0')"><a name="hasParent0Anchor">hasParent</a></td><td>Matcher&lt;*&gt;</td></tr>
6418 <tr><td colspan="4" class="doc" id="hasParent0"><pre>Matches AST nodes that have a parent that matches the provided
6419 matcher.
6420
6421 Given
6422 void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
6423 compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
6424
6425 Usable as: Any Matcher
6426 </pre></td></tr>
6427
6428
6429 <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>
6430 <tr><td colspan="4" class="doc" id="invocation0"><pre>Matches function calls and constructor calls
6431
6432 Because CallExpr and CXXConstructExpr do not share a common
6433 base class with API accessing arguments etc, AST Matchers for code
6434 which should match both are typically duplicated. This matcher
6435 removes the need for duplication.
6436
6437 Given code
6438 struct ConstructorTakesInt
6439 {
6440   ConstructorTakesInt(int i) {}
6441 };
6442
6443 void callTakesInt(int i)
6444 {
6445 }
6446
6447 void doCall()
6448 {
6449   callTakesInt(42);
6450 }
6451
6452 void doConstruct()
6453 {
6454   ConstructorTakesInt cti(42);
6455 }
6456
6457 The matcher
6458 invocation(hasArgument(0, integerLiteral(equals(42))))
6459 matches the expression in both doCall and doConstruct
6460 </pre></td></tr>
6461
6462
6463 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('optionally0')"><a name="optionally0Anchor">optionally</a></td><td>Matcher&lt;*&gt;</td></tr>
6464 <tr><td colspan="4" class="doc" id="optionally0"><pre>Matches any node regardless of the submatcher.
6465
6466 However, optionally will retain any bindings generated by the submatcher.
6467 Useful when additional information which may or may not present about a main
6468 matching node is desired.
6469
6470 For example, in:
6471   class Foo {
6472     int bar;
6473   }
6474 The matcher:
6475   cxxRecordDecl(
6476     optionally(has(
6477       fieldDecl(hasName("bar")).bind("var")
6478   ))).bind("record")
6479 will produce a result binding for both "record" and "var".
6480 The matcher will produce a "record" binding for even if there is no data
6481 member named "bar" in that class.
6482
6483 Usable as: Any Matcher
6484 </pre></td></tr>
6485
6486
6487 <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>
6488 <tr><td colspan="4" class="doc" id="traverse0"><pre>Causes all nested matchers to be matched with the specified traversal kind.
6489
6490 Given
6491   void foo()
6492   {
6493       int i = 3.0;
6494   }
6495 The matcher
6496   traverse(TK_IgnoreUnlessSpelledInSource,
6497     varDecl(hasInitializer(floatLiteral().bind("init")))
6498   )
6499 matches the variable declaration with "init" bound to the "3.0".
6500 </pre></td></tr>
6501
6502
6503 <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>
6504 <tr><td colspan="4" class="doc" id="hasCondition5"><pre>Matches the condition expression of an if statement, for loop,
6505 switch statement or conditional operator.
6506
6507 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
6508   if (true) {}
6509 </pre></td></tr>
6510
6511
6512 <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>
6513 <tr><td colspan="4" class="doc" id="hasFalseExpression0"><pre>Matches the false branch expression of a conditional operator
6514 (binary or ternary).
6515
6516 Example matches b
6517   condition ? a : b
6518   condition ?: b
6519 </pre></td></tr>
6520
6521
6522 <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>
6523 <tr><td colspan="4" class="doc" id="hasTrueExpression0"><pre>Matches the true branch expression of a conditional operator.
6524
6525 Example 1 (conditional ternary operator): matches a
6526   condition ? a : b
6527
6528 Example 2 (conditional binary operator): matches opaqueValueExpr(condition)
6529   condition ?: b
6530 </pre></td></tr>
6531
6532
6533 <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>
6534 <tr><td colspan="4" class="doc" id="hasDeclaration15"><pre>Matches a node if the declaration associated with that node
6535 matches the given matcher.
6536
6537 The associated declaration is:
6538 - for type nodes, the declaration of the underlying type
6539 - for CallExpr, the declaration of the callee
6540 - for MemberExpr, the declaration of the referenced member
6541 - for CXXConstructExpr, the declaration of the constructor
6542 - for CXXNewExpr, the declaration of the operator new
6543 - for ObjCIvarExpr, the declaration of the ivar
6544
6545 For type nodes, hasDeclaration will generally match the declaration of the
6546 sugared type. Given
6547   class X {};
6548   typedef X Y;
6549   Y y;
6550 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
6551 typedefDecl. A common use case is to match the underlying, desugared type.
6552 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
6553   varDecl(hasType(hasUnqualifiedDesugaredType(
6554       recordType(hasDeclaration(decl())))))
6555 In this matcher, the decl will match the CXXRecordDecl of class X.
6556
6557 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;,
6558   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;,
6559   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;,
6560   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;,
6561   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;,
6562   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;,
6563   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
6564 </pre></td></tr>
6565
6566
6567 <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>
6568 <tr><td colspan="4" class="doc" id="hasBase0"><pre>Matches the base expression of an array subscript expression.
6569
6570 Given
6571   int i[5];
6572   void f() { i[1] = 42; }
6573 arraySubscriptExpression(hasBase(implicitCastExpr(
6574     hasSourceExpression(declRefExpr()))))
6575   matches i[1] with the declRefExpr() matching i
6576 </pre></td></tr>
6577
6578
6579 <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>
6580 <tr><td colspan="4" class="doc" id="hasIndex0"><pre>Matches the index expression of an array subscript expression.
6581
6582 Given
6583   int i[5];
6584   void f() { i[1] = 42; }
6585 arraySubscriptExpression(hasIndex(integerLiteral()))
6586   matches i[1] with the integerLiteral() matching 1
6587 </pre></td></tr>
6588
6589
6590 <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>
6591 <tr><td colspan="4" class="doc" id="hasLHS3"><pre>Matches the left hand side of binary operator expressions.
6592
6593 Example matches a (matcher = binaryOperator(hasLHS()))
6594   a || b
6595 </pre></td></tr>
6596
6597
6598 <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>
6599 <tr><td colspan="4" class="doc" id="hasRHS3"><pre>Matches the right hand side of binary operator expressions.
6600
6601 Example matches b (matcher = binaryOperator(hasRHS()))
6602   a || b
6603 </pre></td></tr>
6604
6605
6606 <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>
6607 <tr><td colspan="4" class="doc" id="hasElementType0"><pre>Matches arrays and C99 complex types that have a specific element
6608 type.
6609
6610 Given
6611   struct A {};
6612   A a[7];
6613   int b[7];
6614 arrayType(hasElementType(builtinType()))
6615   matches "int b[7]"
6616
6617 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;
6618 </pre></td></tr>
6619
6620
6621 <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>
6622 <tr><td colspan="4" class="doc" id="hasValueType0"><pre>Matches atomic types with a specific value type.
6623
6624 Given
6625   _Atomic(int) i;
6626   _Atomic(float) f;
6627 atomicType(hasValueType(isInteger()))
6628  matches "_Atomic(int) i"
6629
6630 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;
6631 </pre></td></tr>
6632
6633
6634 <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>
6635 <tr><td colspan="4" class="doc" id="hasDeducedType0"><pre>Matches AutoType nodes where the deduced type is a specific type.
6636
6637 Note: There is no TypeLoc for the deduced type and thus no
6638 getDeducedLoc() matcher.
6639
6640 Given
6641   auto a = 1;
6642   auto b = 2.0;
6643 autoType(hasDeducedType(isInteger()))
6644   matches "auto a"
6645
6646 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;
6647 </pre></td></tr>
6648
6649
6650 <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>
6651 <tr><td colspan="4" class="doc" id="hasAnyUsingShadowDecl0"><pre>Matches any using shadow declaration.
6652
6653 Given
6654   namespace X { void b(); }
6655   using X::b;
6656 usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
6657   matches using X::b </pre></td></tr>
6658
6659
6660 <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>
6661 <tr><td colspan="4" class="doc" id="hasEitherOperand0"><pre>Matches if either the left hand side or the right hand side of a
6662 binary operator or fold expression matches.
6663 </pre></td></tr>
6664
6665
6666 <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>
6667 <tr><td colspan="4" class="doc" id="hasLHS0"><pre>Matches the left hand side of binary operator expressions.
6668
6669 Example matches a (matcher = binaryOperator(hasLHS()))
6670   a || b
6671 </pre></td></tr>
6672
6673
6674 <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>
6675 <tr><td colspan="4" class="doc" id="hasOperands0"><pre>Matches if both matchers match with opposite sides of the binary operator
6676 or fold expression.
6677
6678 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
6679                                              integerLiteral(equals(2)))
6680   1 + 2 // Match
6681   2 + 1 // Match
6682   1 + 1 // No match
6683   2 + 2 // No match
6684 </pre></td></tr>
6685
6686
6687 <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>
6688 <tr><td colspan="4" class="doc" id="hasRHS0"><pre>Matches the right hand side of binary operator expressions.
6689
6690 Example matches b (matcher = binaryOperator(hasRHS()))
6691   a || b
6692 </pre></td></tr>
6693
6694
6695 <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>
6696 <tr><td colspan="4" class="doc" id="forDecomposition0"><pre>Matches the DecompositionDecl the binding belongs to.
6697
6698 For example, in:
6699 void foo()
6700 {
6701     int arr[3];
6702     auto &amp;[f, s, t] = arr;
6703
6704     f = 42;
6705 }
6706 The matcher:
6707   bindingDecl(hasName("f"),
6708                 forDecomposition(decompositionDecl())
6709 matches 'f' in 'auto &amp;[f, s, t]'.
6710 </pre></td></tr>
6711
6712
6713 <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>
6714 <tr><td colspan="4" class="doc" id="hasAnyParameter2"><pre>Matches any parameter of a function or an ObjC method declaration or a
6715 block.
6716
6717 Does not match the 'this' parameter of a method.
6718
6719 Given
6720   class X { void f(int x, int y, int z) {} };
6721 cxxMethodDecl(hasAnyParameter(hasName("y")))
6722   matches f(int x, int y, int z) {}
6723 with hasAnyParameter(...)
6724   matching int y
6725
6726 For ObjectiveC, given
6727   @interface I - (void) f:(int) y; @end
6728
6729 the matcher objcMethodDecl(hasAnyParameter(hasName("y")))
6730 matches the declaration of method f with hasParameter
6731 matching y.
6732
6733 For blocks, given
6734   b = ^(int y) { printf("%d", y) };
6735
6736 the matcher blockDecl(hasAnyParameter(hasName("y")))
6737 matches the declaration of the block b with hasParameter
6738 matching y.
6739 </pre></td></tr>
6740
6741
6742 <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>
6743 <tr><td colspan="4" class="doc" id="hasParameter2"><pre>Matches the n'th parameter of a function or an ObjC method
6744 declaration or a block.
6745
6746 Given
6747   class X { void f(int x) {} };
6748 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
6749   matches f(int x) {}
6750 with hasParameter(...)
6751   matching int x
6752
6753 For ObjectiveC, given
6754   @interface I - (void) f:(int) y; @end
6755
6756 the matcher objcMethodDecl(hasParameter(0, hasName("y")))
6757 matches the declaration of method f with hasParameter
6758 matching y.
6759 </pre></td></tr>
6760
6761
6762 <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>
6763 <tr><td colspan="4" class="doc" id="hasTypeLoc0"><pre>Matches if the type location of a node matches the inner matcher.
6764
6765 Examples:
6766   int x;
6767 declaratorDecl(hasTypeLoc(loc(asString("int"))))
6768   matches int x
6769
6770 auto x = int(3);
6771 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
6772   matches int(3)
6773
6774 struct Foo { Foo(int, int); };
6775 auto x = Foo(1, 2);
6776 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
6777   matches Foo(1, 2)
6778
6779 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;,
6780   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;,
6781   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;,
6782   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
6783   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
6784   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;,
6785   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;,
6786   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
6787 </pre></td></tr>
6788
6789
6790 <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>
6791 <tr><td colspan="4" class="doc" id="pointee0"><pre>Narrows PointerType (and similar) matchers to those where the
6792 pointee matches a given matcher.
6793
6794 Given
6795   int *a;
6796   int const *b;
6797   float const *f;
6798 pointerType(pointee(isConstQualified(), isInteger()))
6799   matches "int const *b"
6800
6801 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;,
6802   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;
6803 </pre></td></tr>
6804
6805
6806 <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>
6807 <tr><td colspan="4" class="doc" id="hasTypeLoc1"><pre>Matches if the type location of a node matches the inner matcher.
6808
6809 Examples:
6810   int x;
6811 declaratorDecl(hasTypeLoc(loc(asString("int"))))
6812   matches int x
6813
6814 auto x = int(3);
6815 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
6816   matches int(3)
6817
6818 struct Foo { Foo(int, int); };
6819 auto x = Foo(1, 2);
6820 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
6821   matches Foo(1, 2)
6822
6823 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;,
6824   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;,
6825   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;,
6826   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
6827   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
6828   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;,
6829   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;,
6830   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
6831 </pre></td></tr>
6832
6833
6834 <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>
6835 <tr><td colspan="4" class="doc" id="hasType8"><pre>Overloaded to match the declaration of the expression's or value
6836 declaration's type.
6837
6838 In case of a value declaration (for example a variable declaration),
6839 this resolves one layer of indirection. For example, in the value
6840 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
6841 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
6842 declaration of x.
6843
6844 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
6845             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
6846             and friend class X (matcher = friendDecl(hasType("X"))
6847             and public virtual X (matcher = cxxBaseSpecifier(hasType(
6848                                               cxxRecordDecl(hasName("X"))))
6849  class X {};
6850  void y(X &amp;x) { x; X z; }
6851  class Y { friend class X; };
6852  class Z : public virtual X {};
6853
6854 Example matches class Derived
6855 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
6856 class Base {};
6857 class Derived : Base {};
6858
6859 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;,
6860 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
6861 </pre></td></tr>
6862
6863
6864 <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>
6865 <tr><td colspan="4" class="doc" id="hasType4"><pre>Matches if the expression's or declaration's type matches a type
6866 matcher.
6867
6868 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
6869             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
6870             and U (matcher = typedefDecl(hasType(asString("int")))
6871             and friend class X (matcher = friendDecl(hasType("X"))
6872             and public virtual X (matcher = cxxBaseSpecifier(hasType(
6873                                               asString("class X")))
6874  class X {};
6875  void y(X &amp;x) { x; X z; }
6876  typedef int U;
6877  class Y { friend class X; };
6878  class Z : public virtual X {};
6879 </pre></td></tr>
6880
6881
6882 <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>
6883 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam1"><pre>Matches all arguments and their respective ParmVarDecl.
6884
6885 Given
6886   void f(int i);
6887   int y;
6888   f(y);
6889 callExpr(
6890   forEachArgumentWithParam(
6891     declRefExpr(to(varDecl(hasName("y")))),
6892     parmVarDecl(hasType(isInteger()))
6893 ))
6894   matches f(y);
6895 with declRefExpr(...)
6896   matching int y
6897 and parmVarDecl(...)
6898   matching int i
6899 </pre></td></tr>
6900
6901
6902 <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>
6903 <tr><td colspan="4" class="doc" id="forEachArgumentWithParamType1"><pre>Matches all arguments and their respective types for a CallExpr or
6904 CXXConstructExpr. It is very similar to forEachArgumentWithParam but
6905 it works on calls through function pointers as well.
6906
6907 The difference is, that function pointers do not provide access to a
6908 ParmVarDecl, but only the QualType for each argument.
6909
6910 Given
6911   void f(int i);
6912   int y;
6913   f(y);
6914   void (*f_ptr)(int) = f;
6915   f_ptr(y);
6916 callExpr(
6917   forEachArgumentWithParamType(
6918     declRefExpr(to(varDecl(hasName("y")))),
6919     qualType(isInteger()).bind("type)
6920 ))
6921   matches f(y) and f_ptr(y)
6922 with declRefExpr(...)
6923   matching int y
6924 and qualType(...)
6925   matching int
6926 </pre></td></tr>
6927
6928
6929 <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>
6930 <tr><td colspan="4" class="doc" id="hasAnyArgument1"><pre>Matches any argument of a call expression or a constructor call
6931 expression, or an ObjC-message-send expression.
6932
6933 Given
6934   void x(int, int, int) { int y; x(1, y, 42); }
6935 callExpr(hasAnyArgument(declRefExpr()))
6936   matches x(1, y, 42)
6937 with hasAnyArgument(...)
6938   matching y
6939
6940 For ObjectiveC, given
6941   @interface I - (void) f:(int) y; @end
6942   void foo(I *i) { [i f:12]; }
6943 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
6944   matches [i f:12]
6945 </pre></td></tr>
6946
6947
6948 <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>
6949 <tr><td colspan="4" class="doc" id="hasArgument1"><pre>Matches the n'th argument of a call expression or a constructor
6950 call expression.
6951
6952 Example matches y in x(y)
6953     (matcher = callExpr(hasArgument(0, declRefExpr())))
6954   void x(int) { int y; x(y); }
6955 </pre></td></tr>
6956
6957
6958 <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>
6959 <tr><td colspan="4" class="doc" id="hasDeclaration13"><pre>Matches a node if the declaration associated with that node
6960 matches the given matcher.
6961
6962 The associated declaration is:
6963 - for type nodes, the declaration of the underlying type
6964 - for CallExpr, the declaration of the callee
6965 - for MemberExpr, the declaration of the referenced member
6966 - for CXXConstructExpr, the declaration of the constructor
6967 - for CXXNewExpr, the declaration of the operator new
6968 - for ObjCIvarExpr, the declaration of the ivar
6969
6970 For type nodes, hasDeclaration will generally match the declaration of the
6971 sugared type. Given
6972   class X {};
6973   typedef X Y;
6974   Y y;
6975 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
6976 typedefDecl. A common use case is to match the underlying, desugared type.
6977 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
6978   varDecl(hasType(hasUnqualifiedDesugaredType(
6979       recordType(hasDeclaration(decl())))))
6980 In this matcher, the decl will match the CXXRecordDecl of class X.
6981
6982 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;,
6983   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;,
6984   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;,
6985   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;,
6986   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;,
6987   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;,
6988   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
6989 </pre></td></tr>
6990
6991
6992 <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>
6993 <tr><td colspan="4" class="doc" id="forEachConstructorInitializer0"><pre>Matches each constructor initializer in a constructor definition.
6994
6995 Given
6996   class A { A() : i(42), j(42) {} int i; int j; };
6997 cxxConstructorDecl(forEachConstructorInitializer(
6998   forField(decl().bind("x"))
6999 ))
7000   will trigger two matches, binding for 'i' and 'j' respectively.
7001 </pre></td></tr>
7002
7003
7004 <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>
7005 <tr><td colspan="4" class="doc" id="hasAnyConstructorInitializer0"><pre>Matches a constructor initializer.
7006
7007 Given
7008   struct Foo {
7009     Foo() : foo_(1) { }
7010     int foo_;
7011   };
7012 cxxRecordDecl(has(cxxConstructorDecl(
7013   hasAnyConstructorInitializer(anything())
7014 )))
7015   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
7016 </pre></td></tr>
7017
7018
7019 <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>
7020 <tr><td colspan="4" class="doc" id="forField0"><pre>Matches the field declaration of a constructor initializer.
7021
7022 Given
7023   struct Foo {
7024     Foo() : foo_(1) { }
7025     int foo_;
7026   };
7027 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
7028     forField(hasName("foo_"))))))
7029   matches Foo
7030 with forField matching foo_
7031 </pre></td></tr>
7032
7033
7034 <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>
7035 <tr><td colspan="4" class="doc" id="hasTypeLoc2"><pre>Matches if the type location of a node matches the inner matcher.
7036
7037 Examples:
7038   int x;
7039 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7040   matches int x
7041
7042 auto x = int(3);
7043 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7044   matches int(3)
7045
7046 struct Foo { Foo(int, int); };
7047 auto x = Foo(1, 2);
7048 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7049   matches Foo(1, 2)
7050
7051 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;,
7052   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;,
7053   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;,
7054   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7055   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7056   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;,
7057   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;,
7058   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7059 </pre></td></tr>
7060
7061
7062 <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>
7063 <tr><td colspan="4" class="doc" id="withInitializer0"><pre>Matches the initializer expression of a constructor initializer.
7064
7065 Given
7066   struct Foo {
7067     Foo() : foo_(1) { }
7068     int foo_;
7069   };
7070 cxxRecordDecl(has(cxxConstructorDecl(hasAnyConstructorInitializer(
7071     withInitializer(integerLiteral(equals(1)))))))
7072   matches Foo
7073 with withInitializer matching (1)
7074 </pre></td></tr>
7075
7076
7077 <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>
7078 <tr><td colspan="4" class="doc" id="hasObjectExpression2"><pre>Matches a member expression where the object expression is matched by a
7079 given matcher. Implicit object expressions are included; that is, it matches
7080 use of implicit `this`.
7081
7082 Given
7083   struct X {
7084     int m;
7085     int f(X x) { x.m; return m; }
7086   };
7087 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))
7088   matches `x.m`, but not `m`; however,
7089 memberExpr(hasObjectExpression(hasType(pointsTo(
7090      cxxRecordDecl(hasName("X"))))))
7091   matches `m` (aka. `this-&gt;m`), but not `x.m`.
7092 </pre></td></tr>
7093
7094
7095 <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>
7096 <tr><td colspan="4" class="doc" id="callee1"><pre>Matches if the call or fold expression's callee expression matches.
7097
7098 Given
7099   class Y { void x() { this-&gt;x(); x(); Y y; y.x(); } };
7100   void f() { f(); }
7101 callExpr(callee(expr()))
7102   matches this-&gt;x(), x(), y.x(), f()
7103 with callee(...)
7104   matching this-&gt;x, x, y.x, f respectively
7105
7106 Given
7107   template &lt;typename... Args&gt;
7108   auto sum(Args... args) {
7109       return (0 + ... + args);
7110   }
7111
7112   template &lt;typename... Args&gt;
7113   auto multiply(Args... args) {
7114       return (args * ... * 1);
7115   }
7116 cxxFoldExpr(callee(expr()))
7117   matches (args * ... * 1)
7118 with callee(...)
7119   matching *
7120
7121 Note: Callee cannot take the more general internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;
7122 because this introduces ambiguous overloads with calls to Callee taking a
7123 internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, as the matcher hierarchy is purely
7124 implemented in terms of implicit casts.
7125 </pre></td></tr>
7126
7127
7128 <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>
7129 <tr><td colspan="4" class="doc" id="hasEitherOperand2"><pre>Matches if either the left hand side or the right hand side of a
7130 binary operator or fold expression matches.
7131 </pre></td></tr>
7132
7133
7134 <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>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMacher</td></tr>
7135 <tr><td colspan="4" class="doc" id="hasFoldInit0"><pre>Matches the operand that does not contain the parameter pack.
7136
7137 Example matches `(0 + ... + args)` and `(args * ... * 1)`
7138     (matcher = cxxFoldExpr(hasFoldInit(expr())))
7139   with hasFoldInit(...)
7140     matching `0` and `1` respectively
7141   template &lt;typename... Args&gt;
7142   auto sum(Args... args) {
7143       return (0 + ... + args);
7144   }
7145
7146   template &lt;typename... Args&gt;
7147   auto multiply(Args... args) {
7148       return (args * ... * 1);
7149   }
7150 </pre></td></tr>
7151
7152
7153 <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>
7154 <tr><td colspan="4" class="doc" id="hasLHS4"><pre>Matches the left hand side of binary operator expressions.
7155
7156 Example matches a (matcher = binaryOperator(hasLHS()))
7157   a || b
7158 </pre></td></tr>
7159
7160
7161 <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>
7162 <tr><td colspan="4" class="doc" id="hasOperands2"><pre>Matches if both matchers match with opposite sides of the binary operator
7163 or fold expression.
7164
7165 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
7166                                              integerLiteral(equals(2)))
7167   1 + 2 // Match
7168   2 + 1 // Match
7169   1 + 1 // No match
7170   2 + 2 // No match
7171 </pre></td></tr>
7172
7173
7174 <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>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMacher</td></tr>
7175 <tr><td colspan="4" class="doc" id="hasPattern0"><pre>Matches the operand that contains the parameter pack.
7176
7177 Example matches `(0 + ... + args)`
7178     (matcher = cxxFoldExpr(hasPattern(expr())))
7179   with hasPattern(...)
7180     matching `args`
7181   template &lt;typename... Args&gt;
7182   auto sum(Args... args) {
7183       return (0 + ... + args);
7184   }
7185
7186   template &lt;typename... Args&gt;
7187   auto multiply(Args... args) {
7188       return (args * ... * 1);
7189   }
7190 </pre></td></tr>
7191
7192
7193 <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>
7194 <tr><td colspan="4" class="doc" id="hasRHS4"><pre>Matches the right hand side of binary operator expressions.
7195
7196 Example matches b (matcher = binaryOperator(hasRHS()))
7197   a || b
7198 </pre></td></tr>
7199
7200
7201 <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>
7202 <tr><td colspan="4" class="doc" id="hasBody3"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
7203 definition that has a given body. Note that in case of functions or
7204 coroutines this matcher only matches the definition itself and not the
7205 other declarations of the same function or coroutine.
7206
7207 Given
7208   for (;;) {}
7209 forStmt(hasBody(compoundStmt()))
7210   matches 'for (;;) {}'
7211 with compoundStmt()
7212   matching '{}'
7213
7214 Given
7215   void f();
7216   void f() {}
7217 functionDecl(hasBody(compoundStmt()))
7218   matches 'void f() {}'
7219 with compoundStmt()
7220   matching '{}'
7221   but does not match 'void f();'
7222 </pre></td></tr>
7223
7224
7225 <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>
7226 <tr><td colspan="4" class="doc" id="hasInitStatement2"><pre>Matches selection statements with initializer.
7227
7228 Given:
7229  void foo() {
7230    if (int i = foobar(); i &gt; 0) {}
7231    switch (int i = foobar(); i) {}
7232    for (auto&amp; a = get_range(); auto&amp; x : a) {}
7233  }
7234  void bar() {
7235    if (foobar() &gt; 0) {}
7236    switch (foobar()) {}
7237    for (auto&amp; x : get_range()) {}
7238  }
7239 ifStmt(hasInitStatement(anything()))
7240   matches the if statement in foo but not in bar.
7241 switchStmt(hasInitStatement(anything()))
7242   matches the switch statement in foo but not in bar.
7243 cxxForRangeStmt(hasInitStatement(anything()))
7244   matches the range for statement in foo but not in bar.
7245 </pre></td></tr>
7246
7247
7248 <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>
7249 <tr><td colspan="4" class="doc" id="hasLoopVariable0"><pre>Matches the initialization statement of a for loop.
7250
7251 Example:
7252     forStmt(hasLoopVariable(anything()))
7253 matches 'int x' in
7254     for (int x : a) { }
7255 </pre></td></tr>
7256
7257
7258 <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>
7259 <tr><td colspan="4" class="doc" id="hasRangeInit0"><pre>Matches the range initialization statement of a for loop.
7260
7261 Example:
7262     forStmt(hasRangeInit(anything()))
7263 matches 'a' in
7264     for (int x : a) { }
7265 </pre></td></tr>
7266
7267
7268 <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>
7269 <tr><td colspan="4" class="doc" id="hasTypeLoc3"><pre>Matches if the type location of a node matches the inner matcher.
7270
7271 Examples:
7272   int x;
7273 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7274   matches int x
7275
7276 auto x = int(3);
7277 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7278   matches int(3)
7279
7280 struct Foo { Foo(int, int); };
7281 auto x = Foo(1, 2);
7282 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7283   matches Foo(1, 2)
7284
7285 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;,
7286   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;,
7287   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;,
7288   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7289   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7290   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;,
7291   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;,
7292   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7293 </pre></td></tr>
7294
7295
7296 <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>
7297 <tr><td colspan="4" class="doc" id="onImplicitObjectArgument0"><pre>Matches on the implicit object argument of a member call expression. Unlike
7298 `on`, matches the argument directly without stripping away anything.
7299
7300 Given
7301   class Y { public: void m(); };
7302   Y g();
7303   class X : public Y { void g(); };
7304   void z(Y y, X x) { y.m(); x.m(); x.g(); (g()).m(); }
7305 cxxMemberCallExpr(onImplicitObjectArgument(hasType(
7306     cxxRecordDecl(hasName("Y")))))
7307   matches `y.m()`, `x.m()` and (`g()).m()`, but not `x.g()`).
7308 cxxMemberCallExpr(on(callExpr()))
7309   only matches `(g()).m()` (the parens are ignored).
7310
7311 FIXME: Overload to allow directly matching types?
7312 </pre></td></tr>
7313
7314
7315 <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>
7316 <tr><td colspan="4" class="doc" id="on0"><pre>Matches on the implicit object argument of a member call expression, after
7317 stripping off any parentheses or implicit casts.
7318
7319 Given
7320   class Y { public: void m(); };
7321   Y g();
7322   class X : public Y {};
7323   void z(Y y, X x) { y.m(); (g()).m(); x.m(); }
7324 cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y")))))
7325   matches `y.m()` and `(g()).m()`.
7326 cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("X")))))
7327   matches `x.m()`.
7328 cxxMemberCallExpr(on(callExpr()))
7329   matches `(g()).m()`.
7330
7331 FIXME: Overload to allow directly matching types?
7332 </pre></td></tr>
7333
7334
7335 <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>
7336 <tr><td colspan="4" class="doc" id="thisPointerType1"><pre>Overloaded to match the type's declaration.
7337 </pre></td></tr>
7338
7339
7340 <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>
7341 <tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the type of the expression's implicit object argument either
7342 matches the InnerMatcher, or is a pointer to a type that matches the
7343 InnerMatcher.
7344
7345 Given
7346   class Y { public: void m(); };
7347   class X : public Y { void g(); };
7348   void z() { Y y; y.m(); Y *p; p-&gt;m(); X x; x.m(); x.g(); }
7349 cxxMemberCallExpr(thisPointerType(hasDeclaration(
7350     cxxRecordDecl(hasName("Y")))))
7351   matches `y.m()`, `p-&gt;m()` and `x.m()`.
7352 cxxMemberCallExpr(thisPointerType(hasDeclaration(
7353     cxxRecordDecl(hasName("X")))))
7354   matches `x.g()`.
7355 </pre></td></tr>
7356
7357
7358 <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>
7359 <tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overridden by the given method. This matcher may
7360 produce multiple matches.
7361
7362 Given
7363   class A { virtual void f(); };
7364   class B : public A { void f(); };
7365   class C : public B { void f(); };
7366 cxxMethodDecl(ofClass(hasName("C")),
7367               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
7368   matches once, with "b" binding "A::f" and "d" binding "C::f" (Note
7369   that B::f is not overridden by C::f).
7370
7371 The check can produce multiple matches in case of multiple inheritance, e.g.
7372   class A1 { virtual void f(); };
7373   class A2 { virtual void f(); };
7374   class C : public A1, public A2 { void f(); };
7375 cxxMethodDecl(ofClass(hasName("C")),
7376               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
7377   matches twice, once with "b" binding "A1::f" and "d" binding "C::f", and
7378   once with "b" binding "A2::f" and "d" binding "C::f".
7379 </pre></td></tr>
7380
7381
7382 <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>
7383 <tr><td colspan="4" class="doc" id="ofClass0"><pre>Matches the class declaration that the given method declaration
7384 belongs to.
7385
7386 FIXME: Generalize this for other kinds of declarations.
7387 FIXME: What other kind of declarations would we need to generalize
7388 this to?
7389
7390 Example matches A() in the last line
7391     (matcher = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
7392         ofClass(hasName("A"))))))
7393   class A {
7394    public:
7395     A();
7396   };
7397   A a = A();
7398 </pre></td></tr>
7399
7400
7401 <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>
7402 <tr><td colspan="4" class="doc" id="hasAnyPlacementArg0"><pre>Matches any placement new expression arguments.
7403
7404 Given:
7405   MyClass *p1 = new (Storage) MyClass();
7406 cxxNewExpr(hasAnyPlacementArg(anything()))
7407   matches the expression 'new (Storage, 16) MyClass()'.
7408 </pre></td></tr>
7409
7410
7411 <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>
7412 <tr><td colspan="4" class="doc" id="hasArraySize0"><pre>Matches array new expressions with a given array size.
7413
7414 Given:
7415   MyClass *p1 = new MyClass[10];
7416 cxxNewExpr(hasArraySize(integerLiteral(equals(10))))
7417   matches the expression 'new MyClass[10]'.
7418 </pre></td></tr>
7419
7420
7421 <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>
7422 <tr><td colspan="4" class="doc" id="hasDeclaration12"><pre>Matches a node if the declaration associated with that node
7423 matches the given matcher.
7424
7425 The associated declaration is:
7426 - for type nodes, the declaration of the underlying type
7427 - for CallExpr, the declaration of the callee
7428 - for MemberExpr, the declaration of the referenced member
7429 - for CXXConstructExpr, the declaration of the constructor
7430 - for CXXNewExpr, the declaration of the operator new
7431 - for ObjCIvarExpr, the declaration of the ivar
7432
7433 For type nodes, hasDeclaration will generally match the declaration of the
7434 sugared type. Given
7435   class X {};
7436   typedef X Y;
7437   Y y;
7438 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
7439 typedefDecl. A common use case is to match the underlying, desugared type.
7440 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
7441   varDecl(hasType(hasUnqualifiedDesugaredType(
7442       recordType(hasDeclaration(decl())))))
7443 In this matcher, the decl will match the CXXRecordDecl of class X.
7444
7445 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;,
7446   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;,
7447   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;,
7448   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;,
7449   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;,
7450   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;,
7451   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
7452 </pre></td></tr>
7453
7454
7455 <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>
7456 <tr><td colspan="4" class="doc" id="hasPlacementArg0"><pre>Matches placement new expression arguments.
7457
7458 Given:
7459   MyClass *p1 = new (Storage, 16) MyClass();
7460 cxxNewExpr(hasPlacementArg(1, integerLiteral(equals(16))))
7461   matches the expression 'new (Storage, 16) MyClass()'.
7462 </pre></td></tr>
7463
7464
7465 <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>
7466 <tr><td colspan="4" class="doc" id="hasTypeLoc4"><pre>Matches if the type location of a node matches the inner matcher.
7467
7468 Examples:
7469   int x;
7470 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7471   matches int x
7472
7473 auto x = int(3);
7474 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7475   matches int(3)
7476
7477 struct Foo { Foo(int, int); };
7478 auto x = Foo(1, 2);
7479 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7480   matches Foo(1, 2)
7481
7482 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;,
7483   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;,
7484   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;,
7485   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7486   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7487   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;,
7488   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;,
7489   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7490 </pre></td></tr>
7491
7492
7493 <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>
7494 <tr><td colspan="4" class="doc" id="hasEitherOperand1"><pre>Matches if either the left hand side or the right hand side of a
7495 binary operator or fold expression matches.
7496 </pre></td></tr>
7497
7498
7499 <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>
7500 <tr><td colspan="4" class="doc" id="hasLHS1"><pre>Matches the left hand side of binary operator expressions.
7501
7502 Example matches a (matcher = binaryOperator(hasLHS()))
7503   a || b
7504 </pre></td></tr>
7505
7506
7507 <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>
7508 <tr><td colspan="4" class="doc" id="hasOperands1"><pre>Matches if both matchers match with opposite sides of the binary operator
7509 or fold expression.
7510
7511 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
7512                                              integerLiteral(equals(2)))
7513   1 + 2 // Match
7514   2 + 1 // Match
7515   1 + 1 // No match
7516   2 + 2 // No match
7517 </pre></td></tr>
7518
7519
7520 <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>
7521 <tr><td colspan="4" class="doc" id="hasRHS1"><pre>Matches the right hand side of binary operator expressions.
7522
7523 Example matches b (matcher = binaryOperator(hasRHS()))
7524   a || b
7525 </pre></td></tr>
7526
7527
7528 <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>
7529 <tr><td colspan="4" class="doc" id="hasUnaryOperand1"><pre>Matches if the operand of a unary operator matches.
7530
7531 Example matches true (matcher = hasUnaryOperand(
7532                                   cxxBoolLiteral(equals(true))))
7533   !true
7534 </pre></td></tr>
7535
7536
7537 <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>
7538 <tr><td colspan="4" class="doc" id="hasAnyBase0"><pre>Matches C++ classes that have a direct or indirect base matching BaseSpecMatcher.
7539
7540 Example:
7541 matcher hasAnyBase(hasType(cxxRecordDecl(hasName("SpecialBase"))))
7542   class Foo;
7543   class Bar : Foo {};
7544   class Baz : Bar {};
7545   class SpecialBase;
7546   class Proxy : SpecialBase {};  // matches Proxy
7547   class IndirectlyDerived : Proxy {};  //matches IndirectlyDerived
7548
7549 FIXME: Refactor this and isDerivedFrom to reuse implementation.
7550 </pre></td></tr>
7551
7552
7553 <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>
7554 <tr><td colspan="4" class="doc" id="hasDirectBase0"><pre>Matches C++ classes that have a direct base matching BaseSpecMatcher.
7555
7556 Example:
7557 matcher hasDirectBase(hasType(cxxRecordDecl(hasName("SpecialBase"))))
7558   class Foo;
7559   class Bar : Foo {};
7560   class Baz : Bar {};
7561   class SpecialBase;
7562   class Proxy : SpecialBase {};  // matches Proxy
7563   class IndirectlyDerived : Proxy {};  // doesn't match
7564 </pre></td></tr>
7565
7566
7567 <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>
7568 <tr><td colspan="4" class="doc" id="hasMethod0"><pre>Matches the first method of a class or struct that satisfies InnerMatcher.
7569
7570 Given:
7571   class A { void func(); };
7572   class B { void member(); };
7573
7574 cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
7575 A but not B.
7576 </pre></td></tr>
7577
7578
7579 <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>
7580 <tr><td colspan="4" class="doc" id="isDerivedFrom0"><pre>Matches C++ classes that are directly or indirectly derived from a class
7581 matching Base, or Objective-C classes that directly or indirectly
7582 subclass a class matching Base.
7583
7584 Note that a class is not considered to be derived from itself.
7585
7586 Example matches Y, Z, C (Base == hasName("X"))
7587   class X;
7588   class Y : public X {};  // directly derived
7589   class Z : public Y {};  // indirectly derived
7590   typedef X A;
7591   typedef A B;
7592   class C : public B {};  // derived from a typedef of X
7593
7594 In the following example, Bar matches isDerivedFrom(hasName("X")):
7595   class Foo;
7596   typedef Foo X;
7597   class Bar : public Foo {};  // derived from a type that X is a typedef of
7598
7599 In the following example, Bar matches isDerivedFrom(hasName("NSObject"))
7600   @interface NSObject @end
7601   @interface Bar : NSObject @end
7602
7603 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;
7604 </pre></td></tr>
7605
7606
7607 <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>
7608 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom0"><pre>Matches C++ or Objective-C classes that are directly derived from a class
7609 matching Base.
7610
7611 Note that a class is not considered to be derived from itself.
7612
7613 Example matches Y, C (Base == hasName("X"))
7614   class X;
7615   class Y : public X {};  // directly derived
7616   class Z : public Y {};  // indirectly derived
7617   typedef X A;
7618   typedef A B;
7619   class C : public B {};  // derived from a typedef of X
7620
7621 In the following example, Bar matches isDerivedFrom(hasName("X")):
7622   class Foo;
7623   typedef Foo X;
7624   class Bar : public Foo {};  // derived from a type that X is a typedef of
7625 </pre></td></tr>
7626
7627
7628 <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>
7629 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom0"><pre>Similar to isDerivedFrom(), but also matches classes that directly
7630 match Base.
7631 </pre></td></tr>
7632
7633
7634 <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>
7635 <tr><td colspan="4" class="doc" id="hasEitherOperand3"><pre>Matches if either the left hand side or the right hand side of a
7636 binary operator or fold expression matches.
7637 </pre></td></tr>
7638
7639
7640 <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>
7641 <tr><td colspan="4" class="doc" id="hasLHS2"><pre>Matches the left hand side of binary operator expressions.
7642
7643 Example matches a (matcher = binaryOperator(hasLHS()))
7644   a || b
7645 </pre></td></tr>
7646
7647
7648 <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>
7649 <tr><td colspan="4" class="doc" id="hasOperands3"><pre>Matches if both matchers match with opposite sides of the binary operator
7650 or fold expression.
7651
7652 Example matcher = binaryOperator(hasOperands(integerLiteral(equals(1),
7653                                              integerLiteral(equals(2)))
7654   1 + 2 // Match
7655   2 + 1 // Match
7656   1 + 1 // No match
7657   2 + 2 // No match
7658 </pre></td></tr>
7659
7660
7661 <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>
7662 <tr><td colspan="4" class="doc" id="hasRHS2"><pre>Matches the right hand side of binary operator expressions.
7663
7664 Example matches b (matcher = binaryOperator(hasRHS()))
7665   a || b
7666 </pre></td></tr>
7667
7668
7669 <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>
7670 <tr><td colspan="4" class="doc" id="hasTypeLoc5"><pre>Matches if the type location of a node matches the inner matcher.
7671
7672 Examples:
7673   int x;
7674 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7675   matches int x
7676
7677 auto x = int(3);
7678 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7679   matches int(3)
7680
7681 struct Foo { Foo(int, int); };
7682 auto x = Foo(1, 2);
7683 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7684   matches Foo(1, 2)
7685
7686 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;,
7687   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;,
7688   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;,
7689   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7690   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7691   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;,
7692   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;,
7693   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7694 </pre></td></tr>
7695
7696
7697 <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>
7698 <tr><td colspan="4" class="doc" id="hasAnyArgument2"><pre>Matches any argument of a call expression or a constructor call
7699 expression, or an ObjC-message-send expression.
7700
7701 Given
7702   void x(int, int, int) { int y; x(1, y, 42); }
7703 callExpr(hasAnyArgument(declRefExpr()))
7704   matches x(1, y, 42)
7705 with hasAnyArgument(...)
7706   matching y
7707
7708 For ObjectiveC, given
7709   @interface I - (void) f:(int) y; @end
7710   void foo(I *i) { [i f:12]; }
7711 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
7712   matches [i f:12]
7713 </pre></td></tr>
7714
7715
7716 <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>
7717 <tr><td colspan="4" class="doc" id="hasArgument2"><pre>Matches the n'th argument of a call expression or a constructor
7718 call expression.
7719
7720 Example matches y in x(y)
7721     (matcher = callExpr(hasArgument(0, declRefExpr())))
7722   void x(int) { int y; x(y); }
7723 </pre></td></tr>
7724
7725
7726 <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>
7727 <tr><td colspan="4" class="doc" id="hasTypeLoc6"><pre>Matches if the type location of a node matches the inner matcher.
7728
7729 Examples:
7730   int x;
7731 declaratorDecl(hasTypeLoc(loc(asString("int"))))
7732   matches int x
7733
7734 auto x = int(3);
7735 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
7736   matches int(3)
7737
7738 struct Foo { Foo(int, int); };
7739 auto x = Foo(1, 2);
7740 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
7741   matches Foo(1, 2)
7742
7743 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;,
7744   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;,
7745   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;,
7746   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
7747   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
7748   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;,
7749   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;,
7750   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
7751 </pre></td></tr>
7752
7753
7754 <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>
7755 <tr><td colspan="4" class="doc" id="callee3"><pre>Matches 1) if the call expression's callee's declaration matches the
7756 given matcher; or 2) if the Obj-C message expression's callee's method
7757 declaration matches the given matcher.
7758
7759 Example matches y.x() (matcher = callExpr(callee(
7760                                    cxxMethodDecl(hasName("x")))))
7761   class Y { public: void x(); };
7762   void z() { Y y; y.x(); }
7763
7764 Example 2. Matches [I foo] with
7765 objcMessageExpr(callee(objcMethodDecl(hasName("foo"))))
7766
7767   @interface I: NSObject
7768   +(void)foo;
7769   @end
7770   ...
7771   [I foo]
7772 </pre></td></tr>
7773
7774
7775 <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>
7776 <tr><td colspan="4" class="doc" id="callee0"><pre>Matches if the call or fold expression's callee expression matches.
7777
7778 Given
7779   class Y { void x() { this-&gt;x(); x(); Y y; y.x(); } };
7780   void f() { f(); }
7781 callExpr(callee(expr()))
7782   matches this-&gt;x(), x(), y.x(), f()
7783 with callee(...)
7784   matching this-&gt;x, x, y.x, f respectively
7785
7786 Given
7787   template &lt;typename... Args&gt;
7788   auto sum(Args... args) {
7789       return (0 + ... + args);
7790   }
7791
7792   template &lt;typename... Args&gt;
7793   auto multiply(Args... args) {
7794       return (args * ... * 1);
7795   }
7796 cxxFoldExpr(callee(expr()))
7797   matches (args * ... * 1)
7798 with callee(...)
7799   matching *
7800
7801 Note: Callee cannot take the more general internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;
7802 because this introduces ambiguous overloads with calls to Callee taking a
7803 internal::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, as the matcher hierarchy is purely
7804 implemented in terms of implicit casts.
7805 </pre></td></tr>
7806
7807
7808 <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>
7809 <tr><td colspan="4" class="doc" id="forEachArgumentWithParam0"><pre>Matches all arguments and their respective ParmVarDecl.
7810
7811 Given
7812   void f(int i);
7813   int y;
7814   f(y);
7815 callExpr(
7816   forEachArgumentWithParam(
7817     declRefExpr(to(varDecl(hasName("y")))),
7818     parmVarDecl(hasType(isInteger()))
7819 ))
7820   matches f(y);
7821 with declRefExpr(...)
7822   matching int y
7823 and parmVarDecl(...)
7824   matching int i
7825 </pre></td></tr>
7826
7827
7828 <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>
7829 <tr><td colspan="4" class="doc" id="forEachArgumentWithParamType0"><pre>Matches all arguments and their respective types for a CallExpr or
7830 CXXConstructExpr. It is very similar to forEachArgumentWithParam but
7831 it works on calls through function pointers as well.
7832
7833 The difference is, that function pointers do not provide access to a
7834 ParmVarDecl, but only the QualType for each argument.
7835
7836 Given
7837   void f(int i);
7838   int y;
7839   f(y);
7840   void (*f_ptr)(int) = f;
7841   f_ptr(y);
7842 callExpr(
7843   forEachArgumentWithParamType(
7844     declRefExpr(to(varDecl(hasName("y")))),
7845     qualType(isInteger()).bind("type)
7846 ))
7847   matches f(y) and f_ptr(y)
7848 with declRefExpr(...)
7849   matching int y
7850 and qualType(...)
7851   matching int
7852 </pre></td></tr>
7853
7854
7855 <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>
7856 <tr><td colspan="4" class="doc" id="hasAnyArgument0"><pre>Matches any argument of a call expression or a constructor call
7857 expression, or an ObjC-message-send expression.
7858
7859 Given
7860   void x(int, int, int) { int y; x(1, y, 42); }
7861 callExpr(hasAnyArgument(declRefExpr()))
7862   matches x(1, y, 42)
7863 with hasAnyArgument(...)
7864   matching y
7865
7866 For ObjectiveC, given
7867   @interface I - (void) f:(int) y; @end
7868   void foo(I *i) { [i f:12]; }
7869 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
7870   matches [i f:12]
7871 </pre></td></tr>
7872
7873
7874 <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>
7875 <tr><td colspan="4" class="doc" id="hasArgument0"><pre>Matches the n'th argument of a call expression or a constructor
7876 call expression.
7877
7878 Example matches y in x(y)
7879     (matcher = callExpr(hasArgument(0, declRefExpr())))
7880   void x(int) { int y; x(y); }
7881 </pre></td></tr>
7882
7883
7884 <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>
7885 <tr><td colspan="4" class="doc" id="hasDeclaration14"><pre>Matches a node if the declaration associated with that node
7886 matches the given matcher.
7887
7888 The associated declaration is:
7889 - for type nodes, the declaration of the underlying type
7890 - for CallExpr, the declaration of the callee
7891 - for MemberExpr, the declaration of the referenced member
7892 - for CXXConstructExpr, the declaration of the constructor
7893 - for CXXNewExpr, the declaration of the operator new
7894 - for ObjCIvarExpr, the declaration of the ivar
7895
7896 For type nodes, hasDeclaration will generally match the declaration of the
7897 sugared type. Given
7898   class X {};
7899   typedef X Y;
7900   Y y;
7901 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
7902 typedefDecl. A common use case is to match the underlying, desugared type.
7903 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
7904   varDecl(hasType(hasUnqualifiedDesugaredType(
7905       recordType(hasDeclaration(decl())))))
7906 In this matcher, the decl will match the CXXRecordDecl of class X.
7907
7908 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;,
7909   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;,
7910   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;,
7911   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;,
7912   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;,
7913   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;,
7914   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
7915 </pre></td></tr>
7916
7917
7918 <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>
7919 <tr><td colspan="4" class="doc" id="hasCaseConstant0"><pre>If the given case statement does not use the GNU case range
7920 extension, matches the constant given in the statement.
7921
7922 Given
7923   switch (1) { case 1: case 1+1: case 3 ... 4: ; }
7924 caseStmt(hasCaseConstant(integerLiteral()))
7925   matches "case 1:"
7926 </pre></td></tr>
7927
7928
7929 <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>
7930 <tr><td colspan="4" class="doc" id="hasSourceExpression0"><pre>Matches if the cast's source expression
7931 or opaque value's source expression matches the given matcher.
7932
7933 Example 1: matches "a string"
7934 (matcher = castExpr(hasSourceExpression(cxxConstructExpr())))
7935 class URL { URL(string); };
7936 URL url = "a string";
7937
7938 Example 2: matches 'b' (matcher =
7939 opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr())))
7940 int a = b ?: 1;
7941 </pre></td></tr>
7942
7943
7944 <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>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
7945 <tr><td colspan="4" class="doc" id="forEachTemplateArgument0"><pre>Matches templateSpecializationType, class template specialization,
7946 variable template specialization, and function template specialization
7947 nodes where the template argument matches the inner matcher. This matcher
7948 may produce multiple matches.
7949
7950 Given
7951   template &lt;typename T, unsigned N, unsigned M&gt;
7952   struct Matrix {};
7953
7954   constexpr unsigned R = 2;
7955   Matrix&lt;int, R * 2, R * 4&gt; M;
7956
7957   template &lt;typename T, typename U&gt;
7958   void f(T&amp;&amp; t, U&amp;&amp; u) {}
7959
7960   bool B = false;
7961   f(R, B);
7962 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
7963   matches twice, with expr() matching 'R * 2' and 'R * 4'
7964 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
7965   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
7966   and 'bool'
7967 </pre></td></tr>
7968
7969
7970 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</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>
7971 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgumentLoc0"><pre>Matches template specialization `TypeLoc`s, class template specializations,
7972 variable template specializations, and function template specializations
7973 that have at least one `TemplateArgumentLoc` matching the given
7974 `InnerMatcher`.
7975
7976 Given
7977   template&lt;typename T&gt; class A {};
7978   A&lt;int&gt; a;
7979 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
7980   hasTypeLoc(loc(asString("int")))))))
7981   matches `A&lt;int&gt; a`.
7982 </pre></td></tr>
7983
7984
7985 <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>
7986 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches templateSpecializationTypes, class template specializations,
7987 variable template specializations, and function template specializations
7988 that have at least one TemplateArgument matching the given InnerMatcher.
7989
7990 Given
7991   template&lt;typename T&gt; class A {};
7992   template&lt;&gt; class A&lt;double&gt; {};
7993   A&lt;int&gt; a;
7994
7995   template&lt;typename T&gt; f() {};
7996   void func() { f&lt;int&gt;(); };
7997
7998 classTemplateSpecializationDecl(hasAnyTemplateArgument(
7999     refersToType(asString("int"))))
8000   matches the specialization A&lt;int&gt;
8001
8002 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
8003   matches the specialization f&lt;int&gt;
8004 </pre></td></tr>
8005
8006
8007 <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>
8008 <tr><td colspan="4" class="doc" id="hasSpecializedTemplate0"><pre>Matches the specialized template of a specialization declaration.
8009
8010 Given
8011   template&lt;typename T&gt; class A {}; #1
8012   template&lt;&gt; class A&lt;int&gt; {}; #2
8013 classTemplateSpecializationDecl(hasSpecializedTemplate(classTemplateDecl()))
8014   matches '#2' with classTemplateDecl() matching the class template
8015   declaration of 'A' at #1.
8016 </pre></td></tr>
8017
8018
8019 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</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>
8020 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc0"><pre>Matches template specialization `TypeLoc`s, class template specializations,
8021 variable template specializations, and function template specializations
8022 where the n'th `TemplateArgumentLoc` matches the given `InnerMatcher`.
8023
8024 Given
8025   template&lt;typename T, typename U&gt; class A {};
8026   A&lt;double, int&gt; b;
8027   A&lt;int, double&gt; c;
8028 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
8029   hasTypeLoc(loc(asString("double")))))))
8030   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
8031 </pre></td></tr>
8032
8033
8034 <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>
8035 <tr><td colspan="4" class="doc" id="hasTemplateArgument0"><pre>Matches templateSpecializationType, class template specializations,
8036 variable template specializations, and function template specializations
8037 where the n'th TemplateArgument matches the given InnerMatcher.
8038
8039 Given
8040   template&lt;typename T, typename U&gt; class A {};
8041   A&lt;bool, int&gt; b;
8042   A&lt;int, bool&gt; c;
8043
8044   template&lt;typename T&gt; void f() {}
8045   void func() { f&lt;int&gt;(); };
8046 classTemplateSpecializationDecl(hasTemplateArgument(
8047     1, refersToType(asString("int"))))
8048   matches the specialization A&lt;bool, int&gt;
8049
8050 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
8051   matches the specialization f&lt;int&gt;
8052 </pre></td></tr>
8053
8054
8055 <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>
8056 <tr><td colspan="4" class="doc" id="hasElementType1"><pre>Matches arrays and C99 complex types that have a specific element
8057 type.
8058
8059 Given
8060   struct A {};
8061   A a[7];
8062   int b[7];
8063 arrayType(hasElementType(builtinType()))
8064   matches "int b[7]"
8065
8066 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;
8067 </pre></td></tr>
8068
8069
8070 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</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>
8071 <tr><td colspan="4" class="doc" id="hasTypeLoc7"><pre>Matches if the type location of a node matches the inner matcher.
8072
8073 Examples:
8074   int x;
8075 declaratorDecl(hasTypeLoc(loc(asString("int"))))
8076   matches int x
8077
8078 auto x = int(3);
8079 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
8080   matches int(3)
8081
8082 struct Foo { Foo(int, int); };
8083 auto x = Foo(1, 2);
8084 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
8085   matches Foo(1, 2)
8086
8087 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;,
8088   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;,
8089   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;,
8090   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
8091   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
8092   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;,
8093   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;,
8094   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
8095 </pre></td></tr>
8096
8097
8098 <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>
8099 <tr><td colspan="4" class="doc" id="hasAnySubstatement0"><pre>Matches compound statements where at least one substatement matches
8100 a given matcher. Also matches StmtExprs that have CompoundStmt as children.
8101
8102 Given
8103   { {}; 1+2; }
8104 hasAnySubstatement(compoundStmt())
8105   matches '{ {}; 1+2; }'
8106 with compoundStmt()
8107   matching '{}'
8108 </pre></td></tr>
8109
8110
8111 <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>
8112 <tr><td colspan="4" class="doc" id="hasBody5"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8113 definition that has a given body. Note that in case of functions or
8114 coroutines this matcher only matches the definition itself and not the
8115 other declarations of the same function or coroutine.
8116
8117 Given
8118   for (;;) {}
8119 forStmt(hasBody(compoundStmt()))
8120   matches 'for (;;) {}'
8121 with compoundStmt()
8122   matching '{}'
8123
8124 Given
8125   void f();
8126   void f() {}
8127 functionDecl(hasBody(compoundStmt()))
8128   matches 'void f() {}'
8129 with compoundStmt()
8130   matching '{}'
8131   but does not match 'void f();'
8132 </pre></td></tr>
8133
8134
8135 <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>
8136 <tr><td colspan="4" class="doc" id="hasDecayedType0"><pre>Matches the decayed type, whoes decayed type matches InnerMatcher
8137 </pre></td></tr>
8138
8139
8140 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgumentLoc3')"><a name="hasAnyTemplateArgumentLoc3Anchor">hasAnyTemplateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
8141 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgumentLoc3"><pre>Matches template specialization `TypeLoc`s, class template specializations,
8142 variable template specializations, and function template specializations
8143 that have at least one `TemplateArgumentLoc` matching the given
8144 `InnerMatcher`.
8145
8146 Given
8147   template&lt;typename T&gt; class A {};
8148   A&lt;int&gt; a;
8149 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
8150   hasTypeLoc(loc(asString("int")))))))
8151   matches `A&lt;int&gt; a`.
8152 </pre></td></tr>
8153
8154
8155 <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>
8156 <tr><td colspan="4" class="doc" id="hasDeclaration11"><pre>Matches a node if the declaration associated with that node
8157 matches the given matcher.
8158
8159 The associated declaration is:
8160 - for type nodes, the declaration of the underlying type
8161 - for CallExpr, the declaration of the callee
8162 - for MemberExpr, the declaration of the referenced member
8163 - for CXXConstructExpr, the declaration of the constructor
8164 - for CXXNewExpr, the declaration of the operator new
8165 - for ObjCIvarExpr, the declaration of the ivar
8166
8167 For type nodes, hasDeclaration will generally match the declaration of the
8168 sugared type. Given
8169   class X {};
8170   typedef X Y;
8171   Y y;
8172 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
8173 typedefDecl. A common use case is to match the underlying, desugared type.
8174 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
8175   varDecl(hasType(hasUnqualifiedDesugaredType(
8176       recordType(hasDeclaration(decl())))))
8177 In this matcher, the decl will match the CXXRecordDecl of class X.
8178
8179 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;,
8180   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;,
8181   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;,
8182   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;,
8183   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;,
8184   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;,
8185   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
8186 </pre></td></tr>
8187
8188
8189 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgumentLoc3')"><a name="hasTemplateArgumentLoc3Anchor">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>
8190 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc3"><pre>Matches template specialization `TypeLoc`s, class template specializations,
8191 variable template specializations, and function template specializations
8192 where the n'th `TemplateArgumentLoc` matches the given `InnerMatcher`.
8193
8194 Given
8195   template&lt;typename T, typename U&gt; class A {};
8196   A&lt;double, int&gt; b;
8197   A&lt;int, double&gt; c;
8198 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
8199   hasTypeLoc(loc(asString("double")))))))
8200   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
8201 </pre></td></tr>
8202
8203
8204 <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>
8205 <tr><td colspan="4" class="doc" id="throughUsingDecl0"><pre>Matches if a node refers to a declaration through a specific
8206 using shadow declaration.
8207
8208 Examples:
8209   namespace a { int f(); }
8210   using a::f;
8211   int x = f();
8212 declRefExpr(throughUsingDecl(anything()))
8213   matches f
8214
8215   namespace a { class X{}; }
8216   using a::X;
8217   X x;
8218 typeLoc(loc(usingType(throughUsingDecl(anything()))))
8219   matches X
8220
8221 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;
8222 </pre></td></tr>
8223
8224
8225 <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>
8226 <tr><td colspan="4" class="doc" id="to0"><pre>Matches a DeclRefExpr that refers to a declaration that matches the
8227 specified matcher.
8228
8229 Example matches x in if(x)
8230     (matcher = declRefExpr(to(varDecl(hasName("x")))))
8231   bool x;
8232   if (x) {}
8233 </pre></td></tr>
8234
8235
8236 <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>
8237 <tr><td colspan="4" class="doc" id="containsDeclaration0"><pre>Matches the n'th declaration of a declaration statement.
8238
8239 Note that this does not work for global declarations because the AST
8240 breaks up multiple-declaration DeclStmt's into multiple single-declaration
8241 DeclStmt's.
8242 Example: Given non-global declarations
8243   int a, b = 0;
8244   int c;
8245   int d = 2, e;
8246 declStmt(containsDeclaration(
8247       0, varDecl(hasInitializer(anything()))))
8248   matches only 'int d = 2, e;', and
8249 declStmt(containsDeclaration(1, varDecl()))
8250   matches 'int a, b = 0' as well as 'int d = 2, e;'
8251   but 'int c;' is not matched.
8252 </pre></td></tr>
8253
8254
8255 <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>
8256 <tr><td colspan="4" class="doc" id="hasSingleDecl0"><pre>Matches the Decl of a DeclStmt which has a single declaration.
8257
8258 Given
8259   int a, b;
8260   int c;
8261 declStmt(hasSingleDecl(anything()))
8262   matches 'int c;' but not 'int a, b;'.
8263 </pre></td></tr>
8264
8265
8266 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</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>
8267 <tr><td colspan="4" class="doc" id="hasTypeLoc8"><pre>Matches if the type location of a node matches the inner matcher.
8268
8269 Examples:
8270   int x;
8271 declaratorDecl(hasTypeLoc(loc(asString("int"))))
8272   matches int x
8273
8274 auto x = int(3);
8275 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
8276   matches int(3)
8277
8278 struct Foo { Foo(int, int); };
8279 auto x = Foo(1, 2);
8280 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
8281   matches Foo(1, 2)
8282
8283 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;,
8284   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;,
8285   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;,
8286   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
8287   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
8288   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;,
8289   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;,
8290   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
8291 </pre></td></tr>
8292
8293
8294 <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>
8295 <tr><td colspan="4" class="doc" id="hasDeclContext0"><pre>Matches declarations whose declaration context, interpreted as a
8296 Decl, matches InnerMatcher.
8297
8298 Given
8299   namespace N {
8300     namespace M {
8301       class D {};
8302     }
8303   }
8304
8305 cxxRcordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
8306 declaration of class D.
8307 </pre></td></tr>
8308
8309
8310 <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>
8311 <tr><td colspan="4" class="doc" id="hasUnderlyingType0"><pre>Matches DecltypeType or UsingType nodes to find the underlying type.
8312
8313 Given
8314   decltype(1) a = 1;
8315   decltype(2.0) b = 2.0;
8316 decltypeType(hasUnderlyingType(isInteger()))
8317   matches the type of "a"
8318
8319 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;
8320 </pre></td></tr>
8321
8322
8323 <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>
8324 <tr><td colspan="4" class="doc" id="hasAnyBinding0"><pre>Matches any binding of a DecompositionDecl.
8325
8326 For example, in:
8327 void foo()
8328 {
8329     int arr[3];
8330     auto &amp;[f, s, t] = arr;
8331
8332     f = 42;
8333 }
8334 The matcher:
8335   decompositionDecl(hasAnyBinding(bindingDecl(hasName("f").bind("fBinding"))))
8336 matches the decomposition decl with 'f' bound to "fBinding".
8337 </pre></td></tr>
8338
8339
8340 <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>
8341 <tr><td colspan="4" class="doc" id="hasBinding0"><pre>Matches the Nth binding of a DecompositionDecl.
8342
8343 For example, in:
8344 void foo()
8345 {
8346     int arr[3];
8347     auto &amp;[f, s, t] = arr;
8348
8349     f = 42;
8350 }
8351 The matcher:
8352   decompositionDecl(hasBinding(0,
8353   bindingDecl(hasName("f").bind("fBinding"))))
8354 matches the decomposition decl with 'f' bound to "fBinding".
8355 </pre></td></tr>
8356
8357
8358 <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>
8359 <tr><td colspan="4" class="doc" id="hasBody0"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8360 definition that has a given body. Note that in case of functions or
8361 coroutines this matcher only matches the definition itself and not the
8362 other declarations of the same function or coroutine.
8363
8364 Given
8365   for (;;) {}
8366 forStmt(hasBody(compoundStmt()))
8367   matches 'for (;;) {}'
8368 with compoundStmt()
8369   matching '{}'
8370
8371 Given
8372   void f();
8373   void f() {}
8374 functionDecl(hasBody(compoundStmt()))
8375   matches 'void f() {}'
8376 with compoundStmt()
8377   matching '{}'
8378   but does not match 'void f();'
8379 </pre></td></tr>
8380
8381
8382 <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>
8383 <tr><td colspan="4" class="doc" id="hasCondition3"><pre>Matches the condition expression of an if statement, for loop,
8384 switch statement or conditional operator.
8385
8386 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
8387   if (true) {}
8388 </pre></td></tr>
8389
8390
8391 <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>
8392 <tr><td colspan="4" class="doc" id="hasNamedTypeLoc0"><pre>Matches elaborated `TypeLoc`s that have a named `TypeLoc` matching
8393 `InnerMatcher`.
8394
8395 Given
8396   template &lt;typename T&gt;
8397   class C {};
8398   class C&lt;int&gt; c;
8399
8400   class D {};
8401   class D d;
8402 elaboratedTypeLoc(hasNamedTypeLoc(templateSpecializationTypeLoc()));
8403   matches the `TypeLoc` of the variable declaration of `c`, but not `d`.
8404 </pre></td></tr>
8405
8406
8407 <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>
8408 <tr><td colspan="4" class="doc" id="hasQualifier0"><pre>Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
8409 matches InnerMatcher if the qualifier exists.
8410
8411 Given
8412   namespace N {
8413     namespace M {
8414       class D {};
8415     }
8416   }
8417   N::M::D d;
8418
8419 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
8420 matches the type of the variable declaration of d.
8421 </pre></td></tr>
8422
8423
8424 <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>
8425 <tr><td colspan="4" class="doc" id="namesType0"><pre>Matches ElaboratedTypes whose named type matches InnerMatcher.
8426
8427 Given
8428   namespace N {
8429     namespace M {
8430       class D {};
8431     }
8432   }
8433   N::M::D d;
8434
8435 elaboratedType(namesType(recordType(
8436 hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
8437 declaration of d.
8438 </pre></td></tr>
8439
8440
8441 <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>
8442 <tr><td colspan="4" class="doc" id="hasDeclaration10"><pre>Matches a node if the declaration associated with that node
8443 matches the given matcher.
8444
8445 The associated declaration is:
8446 - for type nodes, the declaration of the underlying type
8447 - for CallExpr, the declaration of the callee
8448 - for MemberExpr, the declaration of the referenced member
8449 - for CXXConstructExpr, the declaration of the constructor
8450 - for CXXNewExpr, the declaration of the operator new
8451 - for ObjCIvarExpr, the declaration of the ivar
8452
8453 For type nodes, hasDeclaration will generally match the declaration of the
8454 sugared type. Given
8455   class X {};
8456   typedef X Y;
8457   Y y;
8458 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
8459 typedefDecl. A common use case is to match the underlying, desugared type.
8460 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
8461   varDecl(hasType(hasUnqualifiedDesugaredType(
8462       recordType(hasDeclaration(decl())))))
8463 In this matcher, the decl will match the CXXRecordDecl of class X.
8464
8465 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;,
8466   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;,
8467   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;,
8468   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;,
8469   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;,
8470   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;,
8471   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
8472 </pre></td></tr>
8473
8474
8475 <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>
8476 <tr><td colspan="4" class="doc" id="hasDestinationType0"><pre>Matches casts whose destination type matches a given matcher.
8477
8478 (Note: Clang's AST refers to other conversions as "casts" too, and calls
8479 actual casts "explicit" casts.)
8480 </pre></td></tr>
8481
8482
8483 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</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>
8484 <tr><td colspan="4" class="doc" id="hasTypeLoc9"><pre>Matches if the type location of a node matches the inner matcher.
8485
8486 Examples:
8487   int x;
8488 declaratorDecl(hasTypeLoc(loc(asString("int"))))
8489   matches int x
8490
8491 auto x = int(3);
8492 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
8493   matches int(3)
8494
8495 struct Foo { Foo(int, int); };
8496 auto x = Foo(1, 2);
8497 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
8498   matches Foo(1, 2)
8499
8500 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;,
8501   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;,
8502   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;,
8503   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
8504   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
8505   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;,
8506   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;,
8507   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
8508 </pre></td></tr>
8509
8510
8511 <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>
8512 <tr><td colspan="4" class="doc" id="hasType5"><pre>Overloaded to match the declaration of the expression's or value
8513 declaration's type.
8514
8515 In case of a value declaration (for example a variable declaration),
8516 this resolves one layer of indirection. For example, in the value
8517 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
8518 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
8519 declaration of x.
8520
8521 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8522             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8523             and friend class X (matcher = friendDecl(hasType("X"))
8524             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8525                                               cxxRecordDecl(hasName("X"))))
8526  class X {};
8527  void y(X &amp;x) { x; X z; }
8528  class Y { friend class X; };
8529  class Z : public virtual X {};
8530
8531 Example matches class Derived
8532 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
8533 class Base {};
8534 class Derived : Base {};
8535
8536 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;,
8537 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
8538 </pre></td></tr>
8539
8540
8541 <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>
8542 <tr><td colspan="4" class="doc" id="hasType0"><pre>Matches if the expression's or declaration's type matches a type
8543 matcher.
8544
8545 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8546             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8547             and U (matcher = typedefDecl(hasType(asString("int")))
8548             and friend class X (matcher = friendDecl(hasType("X"))
8549             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8550                                               asString("class X")))
8551  class X {};
8552  void y(X &amp;x) { x; X z; }
8553  typedef int U;
8554  class Y { friend class X; };
8555  class Z : public virtual X {};
8556 </pre></td></tr>
8557
8558
8559 <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>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
8560 <tr><td colspan="4" class="doc" id="ignoringElidableConstructorCall0"><pre>Matches expressions that match InnerMatcher that are possibly wrapped in an
8561 elidable constructor and other corresponding bookkeeping nodes.
8562
8563 In C++17, elidable copy constructors are no longer being generated in the
8564 AST as it is not permitted by the standard. They are, however, part of the
8565 AST in C++14 and earlier. So, a matcher must abstract over these differences
8566 to work in all language modes. This matcher skips elidable constructor-call
8567 AST nodes, `ExprWithCleanups` nodes wrapping elidable constructor-calls and
8568 various implicit nodes inside the constructor calls, all of which will not
8569 appear in the C++17 AST.
8570
8571 Given
8572
8573 struct H {};
8574 H G();
8575 void f() {
8576   H D = G();
8577 }
8578
8579 ``varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr())))``
8580 matches ``H D = G()`` in C++11 through C++17 (and beyond).
8581 </pre></td></tr>
8582
8583
8584 <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>
8585 <tr><td colspan="4" class="doc" id="ignoringImpCasts0"><pre>Matches expressions that match InnerMatcher after any implicit casts
8586 are stripped off.
8587
8588 Parentheses and explicit casts are not discarded.
8589 Given
8590   int arr[5];
8591   int a = 0;
8592   char b = 0;
8593   const int c = a;
8594   int *d = arr;
8595   long e = (long) 0l;
8596 The matchers
8597    varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
8598    varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
8599 would match the declarations for a, b, c, and d, but not e.
8600 While
8601    varDecl(hasInitializer(integerLiteral()))
8602    varDecl(hasInitializer(declRefExpr()))
8603 only match the declarations for a.
8604 </pre></td></tr>
8605
8606
8607 <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>
8608 <tr><td colspan="4" class="doc" id="ignoringImplicit0"><pre>Matches expressions that match InnerMatcher after any implicit AST
8609 nodes are stripped off.
8610
8611 Parentheses and explicit casts are not discarded.
8612 Given
8613   class C {};
8614   C a = C();
8615   C b;
8616   C c = b;
8617 The matchers
8618    varDecl(hasInitializer(ignoringImplicit(cxxConstructExpr())))
8619 would match the declarations for a, b, and c.
8620 While
8621    varDecl(hasInitializer(cxxConstructExpr()))
8622 only match the declarations for b and c.
8623 </pre></td></tr>
8624
8625
8626 <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>
8627 <tr><td colspan="4" class="doc" id="ignoringParenCasts0"><pre>Matches expressions that match InnerMatcher after parentheses and
8628 casts are stripped off.
8629
8630 Implicit and non-C Style casts are also discarded.
8631 Given
8632   int a = 0;
8633   char b = (0);
8634   void* c = reinterpret_cast&lt;char*&gt;(0);
8635   char d = char(0);
8636 The matcher
8637    varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
8638 would match the declarations for a, b, c, and d.
8639 while
8640    varDecl(hasInitializer(integerLiteral()))
8641 only match the declaration for a.
8642 </pre></td></tr>
8643
8644
8645 <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>
8646 <tr><td colspan="4" class="doc" id="ignoringParenImpCasts0"><pre>Matches expressions that match InnerMatcher after implicit casts and
8647 parentheses are stripped off.
8648
8649 Explicit casts are not discarded.
8650 Given
8651   int arr[5];
8652   int a = 0;
8653   char b = (0);
8654   const int c = a;
8655   int *d = (arr);
8656   long e = ((long) 0l);
8657 The matchers
8658    varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
8659    varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
8660 would match the declarations for a, b, c, and d, but not e.
8661 while
8662    varDecl(hasInitializer(integerLiteral()))
8663    varDecl(hasInitializer(declRefExpr()))
8664 would only match the declaration for a.
8665 </pre></td></tr>
8666
8667
8668 <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>
8669 <tr><td colspan="4" class="doc" id="ignoringParens1"><pre>Overload ignoringParens for Expr.
8670
8671 Given
8672   const char* str = ("my-string");
8673 The matcher
8674   implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))
8675 would match the implicit cast resulting from the assignment.
8676 </pre></td></tr>
8677
8678
8679 <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>
8680 <tr><td colspan="4" class="doc" id="hasInClassInitializer0"><pre>Matches non-static data members that have an in-class initializer.
8681
8682 Given
8683   class C {
8684     int a = 2;
8685     int b = 3;
8686     int c;
8687   };
8688 fieldDecl(hasInClassInitializer(integerLiteral(equals(2))))
8689   matches 'int a;' but not 'int b;'.
8690 fieldDecl(hasInClassInitializer(anything()))
8691   matches 'int a;' and 'int b;' but not 'int c;'.
8692 </pre></td></tr>
8693
8694
8695 <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>
8696 <tr><td colspan="4" class="doc" id="hasBody1"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8697 definition that has a given body. Note that in case of functions or
8698 coroutines this matcher only matches the definition itself and not the
8699 other declarations of the same function or coroutine.
8700
8701 Given
8702   for (;;) {}
8703 forStmt(hasBody(compoundStmt()))
8704   matches 'for (;;) {}'
8705 with compoundStmt()
8706   matching '{}'
8707
8708 Given
8709   void f();
8710   void f() {}
8711 functionDecl(hasBody(compoundStmt()))
8712   matches 'void f() {}'
8713 with compoundStmt()
8714   matching '{}'
8715   but does not match 'void f();'
8716 </pre></td></tr>
8717
8718
8719 <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>
8720 <tr><td colspan="4" class="doc" id="hasCondition1"><pre>Matches the condition expression of an if statement, for loop,
8721 switch statement or conditional operator.
8722
8723 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
8724   if (true) {}
8725 </pre></td></tr>
8726
8727
8728 <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>
8729 <tr><td colspan="4" class="doc" id="hasIncrement0"><pre>Matches the increment statement of a for loop.
8730
8731 Example:
8732     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
8733 matches '++x' in
8734     for (x; x &lt; N; ++x) { }
8735 </pre></td></tr>
8736
8737
8738 <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>
8739 <tr><td colspan="4" class="doc" id="hasLoopInit0"><pre>Matches the initialization statement of a for loop.
8740
8741 Example:
8742     forStmt(hasLoopInit(declStmt()))
8743 matches 'int x = 0' in
8744     for (int x = 0; x &lt; N; ++x) { }
8745 </pre></td></tr>
8746
8747
8748 <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>
8749 <tr><td colspan="4" class="doc" id="hasType6"><pre>Overloaded to match the declaration of the expression's or value
8750 declaration's type.
8751
8752 In case of a value declaration (for example a variable declaration),
8753 this resolves one layer of indirection. For example, in the value
8754 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
8755 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
8756 declaration of x.
8757
8758 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8759             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8760             and friend class X (matcher = friendDecl(hasType("X"))
8761             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8762                                               cxxRecordDecl(hasName("X"))))
8763  class X {};
8764  void y(X &amp;x) { x; X z; }
8765  class Y { friend class X; };
8766  class Z : public virtual X {};
8767
8768 Example matches class Derived
8769 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
8770 class Base {};
8771 class Derived : Base {};
8772
8773 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;,
8774 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
8775 </pre></td></tr>
8776
8777
8778 <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>
8779 <tr><td colspan="4" class="doc" id="hasType1"><pre>Matches if the expression's or declaration's type matches a type
8780 matcher.
8781
8782 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
8783             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
8784             and U (matcher = typedefDecl(hasType(asString("int")))
8785             and friend class X (matcher = friendDecl(hasType("X"))
8786             and public virtual X (matcher = cxxBaseSpecifier(hasType(
8787                                               asString("class X")))
8788  class X {};
8789  void y(X &amp;x) { x; X z; }
8790  typedef int U;
8791  class Y { friend class X; };
8792  class Z : public virtual X {};
8793 </pre></td></tr>
8794
8795
8796 <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>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
8797 <tr><td colspan="4" class="doc" id="forEachTemplateArgument2"><pre>Matches templateSpecializationType, class template specialization,
8798 variable template specialization, and function template specialization
8799 nodes where the template argument matches the inner matcher. This matcher
8800 may produce multiple matches.
8801
8802 Given
8803   template &lt;typename T, unsigned N, unsigned M&gt;
8804   struct Matrix {};
8805
8806   constexpr unsigned R = 2;
8807   Matrix&lt;int, R * 2, R * 4&gt; M;
8808
8809   template &lt;typename T, typename U&gt;
8810   void f(T&amp;&amp; t, U&amp;&amp; u) {}
8811
8812   bool B = false;
8813   f(R, B);
8814 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
8815   matches twice, with expr() matching 'R * 2' and 'R * 4'
8816 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
8817   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
8818   and 'bool'
8819 </pre></td></tr>
8820
8821
8822 <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>
8823 <tr><td colspan="4" class="doc" id="hasAnyBody0"><pre>Matches a function declaration that has a given body present in the AST.
8824 Note that this matcher matches all the declarations of a function whose
8825 body is present in the AST.
8826
8827 Given
8828   void f();
8829   void f() {}
8830   void g();
8831 functionDecl(hasAnyBody(compoundStmt()))
8832   matches both 'void f();'
8833   and 'void f() {}'
8834 with compoundStmt()
8835   matching '{}'
8836   but does not match 'void g();'
8837 </pre></td></tr>
8838
8839
8840 <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>
8841 <tr><td colspan="4" class="doc" id="hasAnyParameter0"><pre>Matches any parameter of a function or an ObjC method declaration or a
8842 block.
8843
8844 Does not match the 'this' parameter of a method.
8845
8846 Given
8847   class X { void f(int x, int y, int z) {} };
8848 cxxMethodDecl(hasAnyParameter(hasName("y")))
8849   matches f(int x, int y, int z) {}
8850 with hasAnyParameter(...)
8851   matching int y
8852
8853 For ObjectiveC, given
8854   @interface I - (void) f:(int) y; @end
8855
8856 the matcher objcMethodDecl(hasAnyParameter(hasName("y")))
8857 matches the declaration of method f with hasParameter
8858 matching y.
8859
8860 For blocks, given
8861   b = ^(int y) { printf("%d", y) };
8862
8863 the matcher blockDecl(hasAnyParameter(hasName("y")))
8864 matches the declaration of the block b with hasParameter
8865 matching y.
8866 </pre></td></tr>
8867
8868
8869 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgumentLoc2')"><a name="hasAnyTemplateArgumentLoc2Anchor">hasAnyTemplateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
8870 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgumentLoc2"><pre>Matches template specialization `TypeLoc`s, class template specializations,
8871 variable template specializations, and function template specializations
8872 that have at least one `TemplateArgumentLoc` matching the given
8873 `InnerMatcher`.
8874
8875 Given
8876   template&lt;typename T&gt; class A {};
8877   A&lt;int&gt; a;
8878 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
8879   hasTypeLoc(loc(asString("int")))))))
8880   matches `A&lt;int&gt; a`.
8881 </pre></td></tr>
8882
8883
8884 <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>
8885 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument2"><pre>Matches templateSpecializationTypes, class template specializations,
8886 variable template specializations, and function template specializations
8887 that have at least one TemplateArgument matching the given InnerMatcher.
8888
8889 Given
8890   template&lt;typename T&gt; class A {};
8891   template&lt;&gt; class A&lt;double&gt; {};
8892   A&lt;int&gt; a;
8893
8894   template&lt;typename T&gt; f() {};
8895   void func() { f&lt;int&gt;(); };
8896
8897 classTemplateSpecializationDecl(hasAnyTemplateArgument(
8898     refersToType(asString("int"))))
8899   matches the specialization A&lt;int&gt;
8900
8901 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
8902   matches the specialization f&lt;int&gt;
8903 </pre></td></tr>
8904
8905
8906 <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>
8907 <tr><td colspan="4" class="doc" id="hasBody4"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
8908 definition that has a given body. Note that in case of functions or
8909 coroutines this matcher only matches the definition itself and not the
8910 other declarations of the same function or coroutine.
8911
8912 Given
8913   for (;;) {}
8914 forStmt(hasBody(compoundStmt()))
8915   matches 'for (;;) {}'
8916 with compoundStmt()
8917   matching '{}'
8918
8919 Given
8920   void f();
8921   void f() {}
8922 functionDecl(hasBody(compoundStmt()))
8923   matches 'void f() {}'
8924 with compoundStmt()
8925   matching '{}'
8926   but does not match 'void f();'
8927 </pre></td></tr>
8928
8929
8930 <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>
8931 <tr><td colspan="4" class="doc" id="hasExplicitSpecifier0"><pre>Matches the expression in an explicit specifier if present in the given
8932 declaration.
8933
8934 Given
8935   template&lt;bool b&gt;
8936   struct S {
8937     S(int); // #1
8938     explicit S(double); // #2
8939     operator int(); // #3
8940     explicit operator bool(); // #4
8941     explicit(false) S(bool) // # 7
8942     explicit(true) S(char) // # 8
8943     explicit(b) S(S) // # 9
8944   };
8945   S(int) -&gt; S&lt;true&gt; // #5
8946   explicit S(double) -&gt; S&lt;false&gt; // #6
8947 cxxConstructorDecl(hasExplicitSpecifier(constantExpr())) will match #7, #8 and #9, but not #1 or #2.
8948 cxxConversionDecl(hasExplicitSpecifier(constantExpr())) will not match #3 or #4.
8949 cxxDeductionGuideDecl(hasExplicitSpecifier(constantExpr())) will not match #5 or #6.
8950 </pre></td></tr>
8951
8952
8953 <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>
8954 <tr><td colspan="4" class="doc" id="hasParameter0"><pre>Matches the n'th parameter of a function or an ObjC method
8955 declaration or a block.
8956
8957 Given
8958   class X { void f(int x) {} };
8959 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
8960   matches f(int x) {}
8961 with hasParameter(...)
8962   matching int x
8963
8964 For ObjectiveC, given
8965   @interface I - (void) f:(int) y; @end
8966
8967 the matcher objcMethodDecl(hasParameter(0, hasName("y")))
8968 matches the declaration of method f with hasParameter
8969 matching y.
8970 </pre></td></tr>
8971
8972
8973 <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>
8974 <tr><td colspan="4" class="doc" id="hasReturnTypeLoc0"><pre>Matches a function declared with the specified return `TypeLoc`.
8975
8976 Given
8977   int f() { return 5; }
8978   void g() {}
8979 functionDecl(hasReturnTypeLoc(loc(asString("int"))))
8980   matches the declaration of `f`, but not `g`.
8981 </pre></td></tr>
8982
8983
8984 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgumentLoc2')"><a name="hasTemplateArgumentLoc2Anchor">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>
8985 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc2"><pre>Matches template specialization `TypeLoc`s, class template specializations,
8986 variable template specializations, and function template specializations
8987 where the n'th `TemplateArgumentLoc` matches the given `InnerMatcher`.
8988
8989 Given
8990   template&lt;typename T, typename U&gt; class A {};
8991   A&lt;double, int&gt; b;
8992   A&lt;int, double&gt; c;
8993 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
8994   hasTypeLoc(loc(asString("double")))))))
8995   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
8996 </pre></td></tr>
8997
8998
8999 <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>
9000 <tr><td colspan="4" class="doc" id="hasTemplateArgument2"><pre>Matches templateSpecializationType, class template specializations,
9001 variable template specializations, and function template specializations
9002 where the n'th TemplateArgument matches the given InnerMatcher.
9003
9004 Given
9005   template&lt;typename T, typename U&gt; class A {};
9006   A&lt;bool, int&gt; b;
9007   A&lt;int, bool&gt; c;
9008
9009   template&lt;typename T&gt; void f() {}
9010   void func() { f&lt;int&gt;(); };
9011 classTemplateSpecializationDecl(hasTemplateArgument(
9012     1, refersToType(asString("int"))))
9013   matches the specialization A&lt;bool, int&gt;
9014
9015 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
9016   matches the specialization f&lt;int&gt;
9017 </pre></td></tr>
9018
9019
9020 <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>
9021 <tr><td colspan="4" class="doc" id="returns0"><pre>Matches the return type of a function declaration.
9022
9023 Given:
9024   class X { int f() { return 1; } };
9025 cxxMethodDecl(returns(asString("int")))
9026   matches int f() { return 1; }
9027 </pre></td></tr>
9028
9029
9030 <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>
9031 <tr><td colspan="4" class="doc" id="hasCondition0"><pre>Matches the condition expression of an if statement, for loop,
9032 switch statement or conditional operator.
9033
9034 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
9035   if (true) {}
9036 </pre></td></tr>
9037
9038
9039 <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>
9040 <tr><td colspan="4" class="doc" id="hasConditionVariableStatement0"><pre>Matches the condition variable statement in an if statement.
9041
9042 Given
9043   if (A* a = GetAPointer()) {}
9044 hasConditionVariableStatement(...)
9045   matches 'A* a = GetAPointer()'.
9046 </pre></td></tr>
9047
9048
9049 <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>
9050 <tr><td colspan="4" class="doc" id="hasElse0"><pre>Matches the else-statement of an if statement.
9051
9052 Examples matches the if statement
9053   (matcher = ifStmt(hasElse(cxxBoolLiteral(equals(true)))))
9054   if (false) false; else true;
9055 </pre></td></tr>
9056
9057
9058 <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>
9059 <tr><td colspan="4" class="doc" id="hasInitStatement0"><pre>Matches selection statements with initializer.
9060
9061 Given:
9062  void foo() {
9063    if (int i = foobar(); i &gt; 0) {}
9064    switch (int i = foobar(); i) {}
9065    for (auto&amp; a = get_range(); auto&amp; x : a) {}
9066  }
9067  void bar() {
9068    if (foobar() &gt; 0) {}
9069    switch (foobar()) {}
9070    for (auto&amp; x : get_range()) {}
9071  }
9072 ifStmt(hasInitStatement(anything()))
9073   matches the if statement in foo but not in bar.
9074 switchStmt(hasInitStatement(anything()))
9075   matches the switch statement in foo but not in bar.
9076 cxxForRangeStmt(hasInitStatement(anything()))
9077   matches the range for statement in foo but not in bar.
9078 </pre></td></tr>
9079
9080
9081 <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>
9082 <tr><td colspan="4" class="doc" id="hasThen0"><pre>Matches the then-statement of an if statement.
9083
9084 Examples matches the if statement
9085   (matcher = ifStmt(hasThen(cxxBoolLiteral(equals(true)))))
9086   if (false) true; else false;
9087 </pre></td></tr>
9088
9089
9090 <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>
9091 <tr><td colspan="4" class="doc" id="hasImplicitDestinationType0"><pre>Matches implicit casts whose destination type matches a given
9092 matcher.
9093 </pre></td></tr>
9094
9095
9096 <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, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
9097 <tr><td colspan="4" class="doc" id="hasInit0"><pre>Matches the n'th item of an initializer list expression.
9098
9099 Example matches y.
9100     (matcher = initListExpr(hasInit(0, expr())))
9101   int x{y}.
9102 </pre></td></tr>
9103
9104
9105 <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>
9106 <tr><td colspan="4" class="doc" id="hasSyntacticForm0"><pre>Matches the syntactic form of init list expressions
9107 (if expression have it).
9108 </pre></td></tr>
9109
9110
9111 <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>
9112 <tr><td colspan="4" class="doc" id="hasDeclaration9"><pre>Matches a node if the declaration associated with that node
9113 matches the given matcher.
9114
9115 The associated declaration is:
9116 - for type nodes, the declaration of the underlying type
9117 - for CallExpr, the declaration of the callee
9118 - for MemberExpr, the declaration of the referenced member
9119 - for CXXConstructExpr, the declaration of the constructor
9120 - for CXXNewExpr, the declaration of the operator new
9121 - for ObjCIvarExpr, the declaration of the ivar
9122
9123 For type nodes, hasDeclaration will generally match the declaration of the
9124 sugared type. Given
9125   class X {};
9126   typedef X Y;
9127   Y y;
9128 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9129 typedefDecl. A common use case is to match the underlying, desugared type.
9130 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9131   varDecl(hasType(hasUnqualifiedDesugaredType(
9132       recordType(hasDeclaration(decl())))))
9133 In this matcher, the decl will match the CXXRecordDecl of class X.
9134
9135 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;,
9136   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;,
9137   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;,
9138   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;,
9139   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;,
9140   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;,
9141   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9142 </pre></td></tr>
9143
9144
9145 <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>
9146 <tr><td colspan="4" class="doc" id="hasDeclaration8"><pre>Matches a node if the declaration associated with that node
9147 matches the given matcher.
9148
9149 The associated declaration is:
9150 - for type nodes, the declaration of the underlying type
9151 - for CallExpr, the declaration of the callee
9152 - for MemberExpr, the declaration of the referenced member
9153 - for CXXConstructExpr, the declaration of the constructor
9154 - for CXXNewExpr, the declaration of the operator new
9155 - for ObjCIvarExpr, the declaration of the ivar
9156
9157 For type nodes, hasDeclaration will generally match the declaration of the
9158 sugared type. Given
9159   class X {};
9160   typedef X Y;
9161   Y y;
9162 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9163 typedefDecl. A common use case is to match the underlying, desugared type.
9164 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9165   varDecl(hasType(hasUnqualifiedDesugaredType(
9166       recordType(hasDeclaration(decl())))))
9167 In this matcher, the decl will match the CXXRecordDecl of class X.
9168
9169 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;,
9170   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;,
9171   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;,
9172   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;,
9173   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;,
9174   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;,
9175   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9176 </pre></td></tr>
9177
9178
9179 <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>
9180 <tr><td colspan="4" class="doc" id="capturesVar0"><pre>Matches a `LambdaCapture` that refers to the specified `VarDecl`. The
9181 `VarDecl` can be a separate variable that is captured by value or
9182 reference, or a synthesized variable if the capture has an initializer.
9183
9184 Given
9185   void foo() {
9186     int x;
9187     auto f = [x](){};
9188     auto g = [x = 1](){};
9189   }
9190 In the matcher
9191 lambdaExpr(hasAnyCapture(lambdaCapture(capturesVar(hasName("x")))),
9192 capturesVar(hasName("x")) matches `x` and `x = 1`.
9193 </pre></td></tr>
9194
9195
9196 <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>
9197 <tr><td colspan="4" class="doc" id="forEachLambdaCapture0"><pre>Matches each lambda capture in a lambda expression.
9198
9199 Given
9200   int main() {
9201     int x, y;
9202     float z;
9203     auto f = [=]() { return x + y + z; };
9204   }
9205 lambdaExpr(forEachLambdaCapture(
9206     lambdaCapture(capturesVar(varDecl(hasType(isInteger()))))))
9207 will trigger two matches, binding for 'x' and 'y' respectively.
9208 </pre></td></tr>
9209
9210
9211 <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>
9212 <tr><td colspan="4" class="doc" id="hasAnyCapture0"><pre>Matches any capture in a lambda expression.
9213
9214 Given
9215   void foo() {
9216     int t = 5;
9217     auto f = [=](){ return t; };
9218   }
9219 lambdaExpr(hasAnyCapture(lambdaCapture())) and
9220 lambdaExpr(hasAnyCapture(lambdaCapture(refersToVarDecl(hasName("t")))))
9221   both match `[=](){ return t; }`.
9222 </pre></td></tr>
9223
9224
9225 <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>
9226 <tr><td colspan="4" class="doc" id="hasDeclaration7"><pre>Matches a node if the declaration associated with that node
9227 matches the given matcher.
9228
9229 The associated declaration is:
9230 - for type nodes, the declaration of the underlying type
9231 - for CallExpr, the declaration of the callee
9232 - for MemberExpr, the declaration of the referenced member
9233 - for CXXConstructExpr, the declaration of the constructor
9234 - for CXXNewExpr, the declaration of the operator new
9235 - for ObjCIvarExpr, the declaration of the ivar
9236
9237 For type nodes, hasDeclaration will generally match the declaration of the
9238 sugared type. Given
9239   class X {};
9240   typedef X Y;
9241   Y y;
9242 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9243 typedefDecl. A common use case is to match the underlying, desugared type.
9244 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9245   varDecl(hasType(hasUnqualifiedDesugaredType(
9246       recordType(hasDeclaration(decl())))))
9247 In this matcher, the decl will match the CXXRecordDecl of class X.
9248
9249 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;,
9250   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;,
9251   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;,
9252   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;,
9253   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;,
9254   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;,
9255   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9256 </pre></td></tr>
9257
9258
9259 <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>
9260 <tr><td colspan="4" class="doc" id="hasObjectExpression0"><pre>Matches a member expression where the object expression is matched by a
9261 given matcher. Implicit object expressions are included; that is, it matches
9262 use of implicit `this`.
9263
9264 Given
9265   struct X {
9266     int m;
9267     int f(X x) { x.m; return m; }
9268   };
9269 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))
9270   matches `x.m`, but not `m`; however,
9271 memberExpr(hasObjectExpression(hasType(pointsTo(
9272      cxxRecordDecl(hasName("X"))))))
9273   matches `m` (aka. `this-&gt;m`), but not `x.m`.
9274 </pre></td></tr>
9275
9276
9277 <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>
9278 <tr><td colspan="4" class="doc" id="member0"><pre>Matches a member expression where the member is matched by a
9279 given matcher.
9280
9281 Given
9282   struct { int first, second; } first, second;
9283   int i(second.first);
9284   int j(first.second);
9285 memberExpr(member(hasName("first")))
9286   matches second.first
9287   but not first.second (because the member name there is "second").
9288 </pre></td></tr>
9289
9290
9291 <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>
9292 <tr><td colspan="4" class="doc" id="pointee1"><pre>Narrows PointerType (and similar) matchers to those where the
9293 pointee matches a given matcher.
9294
9295 Given
9296   int *a;
9297   int const *b;
9298   float const *f;
9299 pointerType(pointee(isConstQualified(), isInteger()))
9300   matches "int const *b"
9301
9302 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;,
9303   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;
9304 </pre></td></tr>
9305
9306
9307 <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>
9308 <tr><td colspan="4" class="doc" id="hasUnderlyingDecl0"><pre>Matches a NamedDecl whose underlying declaration matches the given
9309 matcher.
9310
9311 Given
9312   namespace N { template&lt;class T&gt; void f(T t); }
9313   template &lt;class T&gt; void g() { using N::f; f(T()); }
9314 unresolvedLookupExpr(hasAnyDeclaration(
9315     namedDecl(hasUnderlyingDecl(hasName("::N::f")))))
9316   matches the use of f in g() .
9317 </pre></td></tr>
9318
9319
9320 <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>
9321 <tr><td colspan="4" class="doc" id="hasPrefix1"><pre>Matches on the prefix of a NestedNameSpecifierLoc.
9322
9323 Given
9324   struct A { struct B { struct C {}; }; };
9325   A::B::C c;
9326 nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
9327   matches "A::"
9328 </pre></td></tr>
9329
9330
9331 <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>
9332 <tr><td colspan="4" class="doc" id="loc1"><pre>Matches NestedNameSpecifierLocs for which the given inner
9333 NestedNameSpecifier-matcher matches.
9334 </pre></td></tr>
9335
9336
9337 <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>
9338 <tr><td colspan="4" class="doc" id="specifiesTypeLoc0"><pre>Matches nested name specifier locs that specify a type matching the
9339 given TypeLoc.
9340
9341 Given
9342   struct A { struct B { struct C {}; }; };
9343   A::B::C c;
9344 nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
9345   hasDeclaration(cxxRecordDecl(hasName("A")))))))
9346   matches "A::"
9347 </pre></td></tr>
9348
9349
9350 <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>
9351 <tr><td colspan="4" class="doc" id="hasPrefix0"><pre>Matches on the prefix of a NestedNameSpecifier.
9352
9353 Given
9354   struct A { struct B { struct C {}; }; };
9355   A::B::C c;
9356 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
9357   matches "A::"
9358 </pre></td></tr>
9359
9360
9361 <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>
9362 <tr><td colspan="4" class="doc" id="specifiesNamespace0"><pre>Matches nested name specifiers that specify a namespace matching the
9363 given namespace matcher.
9364
9365 Given
9366   namespace ns { struct A {}; }
9367   ns::A a;
9368 nestedNameSpecifier(specifiesNamespace(hasName("ns")))
9369   matches "ns::"
9370 </pre></td></tr>
9371
9372
9373 <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>
9374 <tr><td colspan="4" class="doc" id="specifiesType0"><pre>Matches nested name specifiers that specify a type matching the
9375 given QualType matcher without qualifiers.
9376
9377 Given
9378   struct A { struct B { struct C {}; }; };
9379   A::B::C c;
9380 nestedNameSpecifier(specifiesType(
9381   hasDeclaration(cxxRecordDecl(hasName("A")))
9382 ))
9383   matches "A::"
9384 </pre></td></tr>
9385
9386
9387 <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>
9388 <tr><td colspan="4" class="doc" id="hasAnyClause0"><pre>Matches any clause in an OpenMP directive.
9389
9390 Given
9391
9392   #pragma omp parallel
9393   #pragma omp parallel default(none)
9394
9395 ``ompExecutableDirective(hasAnyClause(anything()))`` matches
9396 ``omp parallel default(none)``.
9397 </pre></td></tr>
9398
9399
9400 <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>
9401 <tr><td colspan="4" class="doc" id="hasStructuredBlock0"><pre>Matches the structured-block of the OpenMP executable directive
9402
9403 Prerequisite: the executable directive must not be standalone directive.
9404 If it is, it will never match.
9405
9406 Given
9407
9408    #pragma omp parallel
9409    ;
9410    #pragma omp parallel
9411    {}
9412
9413 ``ompExecutableDirective(hasStructuredBlock(nullStmt()))`` will match ``;``
9414 </pre></td></tr>
9415
9416
9417 <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>
9418 <tr><td colspan="4" class="doc" id="isDerivedFrom1"><pre>Matches C++ classes that are directly or indirectly derived from a class
9419 matching Base, or Objective-C classes that directly or indirectly
9420 subclass a class matching Base.
9421
9422 Note that a class is not considered to be derived from itself.
9423
9424 Example matches Y, Z, C (Base == hasName("X"))
9425   class X;
9426   class Y : public X {};  // directly derived
9427   class Z : public Y {};  // indirectly derived
9428   typedef X A;
9429   typedef A B;
9430   class C : public B {};  // derived from a typedef of X
9431
9432 In the following example, Bar matches isDerivedFrom(hasName("X")):
9433   class Foo;
9434   typedef Foo X;
9435   class Bar : public Foo {};  // derived from a type that X is a typedef of
9436
9437 In the following example, Bar matches isDerivedFrom(hasName("NSObject"))
9438   @interface NSObject @end
9439   @interface Bar : NSObject @end
9440
9441 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;
9442 </pre></td></tr>
9443
9444
9445 <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>
9446 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom1"><pre>Matches C++ or Objective-C classes that are directly derived from a class
9447 matching Base.
9448
9449 Note that a class is not considered to be derived from itself.
9450
9451 Example matches Y, C (Base == hasName("X"))
9452   class X;
9453   class Y : public X {};  // directly derived
9454   class Z : public Y {};  // indirectly derived
9455   typedef X A;
9456   typedef A B;
9457   class C : public B {};  // derived from a typedef of X
9458
9459 In the following example, Bar matches isDerivedFrom(hasName("X")):
9460   class Foo;
9461   typedef Foo X;
9462   class Bar : public Foo {};  // derived from a type that X is a typedef of
9463 </pre></td></tr>
9464
9465
9466 <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>
9467 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom1"><pre>Similar to isDerivedFrom(), but also matches classes that directly
9468 match Base.
9469 </pre></td></tr>
9470
9471
9472 <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>
9473 <tr><td colspan="4" class="doc" id="callee2"><pre>Matches 1) if the call expression's callee's declaration matches the
9474 given matcher; or 2) if the Obj-C message expression's callee's method
9475 declaration matches the given matcher.
9476
9477 Example matches y.x() (matcher = callExpr(callee(
9478                                    cxxMethodDecl(hasName("x")))))
9479   class Y { public: void x(); };
9480   void z() { Y y; y.x(); }
9481
9482 Example 2. Matches [I foo] with
9483 objcMessageExpr(callee(objcMethodDecl(hasName("foo"))))
9484
9485   @interface I: NSObject
9486   +(void)foo;
9487   @end
9488   ...
9489   [I foo]
9490 </pre></td></tr>
9491
9492
9493 <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>
9494 <tr><td colspan="4" class="doc" id="hasAnyArgument3"><pre>Matches any argument of a call expression or a constructor call
9495 expression, or an ObjC-message-send expression.
9496
9497 Given
9498   void x(int, int, int) { int y; x(1, y, 42); }
9499 callExpr(hasAnyArgument(declRefExpr()))
9500   matches x(1, y, 42)
9501 with hasAnyArgument(...)
9502   matching y
9503
9504 For ObjectiveC, given
9505   @interface I - (void) f:(int) y; @end
9506   void foo(I *i) { [i f:12]; }
9507 objcMessageExpr(hasAnyArgument(integerLiteral(equals(12))))
9508   matches [i f:12]
9509 </pre></td></tr>
9510
9511
9512 <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>
9513 <tr><td colspan="4" class="doc" id="hasArgument3"><pre>Matches the n'th argument of a call expression or a constructor
9514 call expression.
9515
9516 Example matches y in x(y)
9517     (matcher = callExpr(hasArgument(0, declRefExpr())))
9518   void x(int) { int y; x(y); }
9519 </pre></td></tr>
9520
9521
9522 <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>
9523 <tr><td colspan="4" class="doc" id="hasReceiver0"><pre>Matches if the Objective-C message is sent to an instance,
9524 and the inner matcher matches on that instance.
9525
9526 For example the method call in
9527   NSString *x = @"hello";
9528   [x containsString:@"h"];
9529 is matched by
9530 objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x"))))))
9531 </pre></td></tr>
9532
9533
9534 <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>
9535 <tr><td colspan="4" class="doc" id="hasReceiverType0"><pre>Matches on the receiver of an ObjectiveC Message expression.
9536
9537 Example
9538 matcher = objCMessageExpr(hasReceiverType(asString("UIWebView *")));
9539 matches the [webView ...] message invocation.
9540   NSString *webViewJavaScript = ...
9541   UIWebView *webView = ...
9542   [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
9543 </pre></td></tr>
9544
9545
9546 <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>
9547 <tr><td colspan="4" class="doc" id="hasAnyParameter1"><pre>Matches any parameter of a function or an ObjC method declaration or a
9548 block.
9549
9550 Does not match the 'this' parameter of a method.
9551
9552 Given
9553   class X { void f(int x, int y, int z) {} };
9554 cxxMethodDecl(hasAnyParameter(hasName("y")))
9555   matches f(int x, int y, int z) {}
9556 with hasAnyParameter(...)
9557   matching int y
9558
9559 For ObjectiveC, given
9560   @interface I - (void) f:(int) y; @end
9561
9562 the matcher objcMethodDecl(hasAnyParameter(hasName("y")))
9563 matches the declaration of method f with hasParameter
9564 matching y.
9565
9566 For blocks, given
9567   b = ^(int y) { printf("%d", y) };
9568
9569 the matcher blockDecl(hasAnyParameter(hasName("y")))
9570 matches the declaration of the block b with hasParameter
9571 matching y.
9572 </pre></td></tr>
9573
9574
9575 <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>
9576 <tr><td colspan="4" class="doc" id="hasParameter1"><pre>Matches the n'th parameter of a function or an ObjC method
9577 declaration or a block.
9578
9579 Given
9580   class X { void f(int x) {} };
9581 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
9582   matches f(int x) {}
9583 with hasParameter(...)
9584   matching int x
9585
9586 For ObjectiveC, given
9587   @interface I - (void) f:(int) y; @end
9588
9589 the matcher objcMethodDecl(hasParameter(0, hasName("y")))
9590 matches the declaration of method f with hasParameter
9591 matching y.
9592 </pre></td></tr>
9593
9594
9595 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</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>
9596 <tr><td colspan="4" class="doc" id="hasTypeLoc10"><pre>Matches if the type location of a node matches the inner matcher.
9597
9598 Examples:
9599   int x;
9600 declaratorDecl(hasTypeLoc(loc(asString("int"))))
9601   matches int x
9602
9603 auto x = int(3);
9604 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
9605   matches int(3)
9606
9607 struct Foo { Foo(int, int); };
9608 auto x = Foo(1, 2);
9609 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
9610   matches Foo(1, 2)
9611
9612 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;,
9613   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;,
9614   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;,
9615   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
9616   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
9617   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;,
9618   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;,
9619   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
9620 </pre></td></tr>
9621
9622
9623 <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>
9624 <tr><td colspan="4" class="doc" id="hasSourceExpression1"><pre>Matches if the cast's source expression
9625 or opaque value's source expression matches the given matcher.
9626
9627 Example 1: matches "a string"
9628 (matcher = castExpr(hasSourceExpression(cxxConstructExpr())))
9629 class URL { URL(string); };
9630 URL url = "a string";
9631
9632 Example 2: matches 'b' (matcher =
9633 opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr())))
9634 int a = b ?: 1;
9635 </pre></td></tr>
9636
9637
9638 <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>
9639 <tr><td colspan="4" class="doc" id="hasAnyDeclaration0"><pre>Matches an OverloadExpr if any of the declarations in the set of
9640 overloads matches the given matcher.
9641
9642 Given
9643   template &lt;typename T&gt; void foo(T);
9644   template &lt;typename T&gt; void bar(T);
9645   template &lt;typename T&gt; void baz(T t) {
9646     foo(t);
9647     bar(t);
9648   }
9649 unresolvedLookupExpr(hasAnyDeclaration(
9650     functionTemplateDecl(hasName("foo"))))
9651   matches foo in foo(t); but not bar in bar(t);
9652 </pre></td></tr>
9653
9654
9655 <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>
9656 <tr><td colspan="4" class="doc" id="innerType0"><pre>Matches ParenType nodes where the inner type is a specific type.
9657
9658 Given
9659   int (*ptr_to_array)[4];
9660   int (*ptr_to_func)(int);
9661
9662 varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
9663 ptr_to_func but not ptr_to_array.
9664
9665 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;
9666 </pre></td></tr>
9667
9668
9669 <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>
9670 <tr><td colspan="4" class="doc" id="hasPointeeLoc0"><pre>Matches pointer `TypeLoc`s that have a pointee `TypeLoc` matching
9671 `PointeeMatcher`.
9672
9673 Given
9674   int* x;
9675 pointerTypeLoc(hasPointeeLoc(loc(asString("int"))))
9676   matches `int*`.
9677 </pre></td></tr>
9678
9679
9680 <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>
9681 <tr><td colspan="4" class="doc" id="pointee2"><pre>Narrows PointerType (and similar) matchers to those where the
9682 pointee matches a given matcher.
9683
9684 Given
9685   int *a;
9686   int const *b;
9687   float const *f;
9688 pointerType(pointee(isConstQualified(), isInteger()))
9689   matches "int const *b"
9690
9691 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;,
9692   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;
9693 </pre></td></tr>
9694
9695
9696 <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>
9697 <tr><td colspan="4" class="doc" id="hasCanonicalType0"><pre>Matches QualTypes whose canonical type matches InnerMatcher.
9698
9699 Given:
9700   typedef int &amp;int_ref;
9701   int a;
9702   int_ref b = a;
9703
9704 varDecl(hasType(qualType(referenceType()))))) will not match the
9705 declaration of b but varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
9706 </pre></td></tr>
9707
9708
9709 <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>
9710 <tr><td colspan="4" class="doc" id="hasDeclaration6"><pre>Matches a node if the declaration associated with that node
9711 matches the given matcher.
9712
9713 The associated declaration is:
9714 - for type nodes, the declaration of the underlying type
9715 - for CallExpr, the declaration of the callee
9716 - for MemberExpr, the declaration of the referenced member
9717 - for CXXConstructExpr, the declaration of the constructor
9718 - for CXXNewExpr, the declaration of the operator new
9719 - for ObjCIvarExpr, the declaration of the ivar
9720
9721 For type nodes, hasDeclaration will generally match the declaration of the
9722 sugared type. Given
9723   class X {};
9724   typedef X Y;
9725   Y y;
9726 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9727 typedefDecl. A common use case is to match the underlying, desugared type.
9728 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9729   varDecl(hasType(hasUnqualifiedDesugaredType(
9730       recordType(hasDeclaration(decl())))))
9731 In this matcher, the decl will match the CXXRecordDecl of class X.
9732
9733 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;,
9734   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;,
9735   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;,
9736   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;,
9737   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;,
9738   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;,
9739   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9740 </pre></td></tr>
9741
9742
9743 <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>
9744 <tr><td colspan="4" class="doc" id="ignoringParens0"><pre>Matches types that match InnerMatcher after any parens are stripped.
9745
9746 Given
9747   void (*fp)(void);
9748 The matcher
9749   varDecl(hasType(pointerType(pointee(ignoringParens(functionType())))))
9750 would match the declaration for fp.
9751 </pre></td></tr>
9752
9753
9754 <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>
9755 <tr><td colspan="4" class="doc" id="pointsTo1"><pre>Overloaded to match the pointee type's declaration.
9756 </pre></td></tr>
9757
9758
9759 <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>
9760 <tr><td colspan="4" class="doc" id="pointsTo0"><pre>Matches if the matched type is a pointer type and the pointee type
9761 matches the specified matcher.
9762
9763 Example matches y-&gt;x()
9764   (matcher = cxxMemberCallExpr(on(hasType(pointsTo
9765      cxxRecordDecl(hasName("Y")))))))
9766   class Y { public: void x(); };
9767   void z() { Y *y; y-&gt;x(); }
9768 </pre></td></tr>
9769
9770
9771 <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>
9772 <tr><td colspan="4" class="doc" id="references1"><pre>Overloaded to match the referenced type's declaration.
9773 </pre></td></tr>
9774
9775
9776 <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>
9777 <tr><td colspan="4" class="doc" id="references0"><pre>Matches if the matched type is a reference type and the referenced
9778 type matches the specified matcher.
9779
9780 Example matches X &amp;x and const X &amp;y
9781     (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X"))))))
9782   class X {
9783     void a(X b) {
9784       X &amp;x = b;
9785       const X &amp;y = b;
9786     }
9787   };
9788 </pre></td></tr>
9789
9790
9791 <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>
9792 <tr><td colspan="4" class="doc" id="hasUnqualifiedLoc0"><pre>Matches `QualifiedTypeLoc`s that have an unqualified `TypeLoc` matching
9793 `InnerMatcher`.
9794
9795 Given
9796   int* const x;
9797   const int y;
9798 qualifiedTypeLoc(hasUnqualifiedLoc(pointerTypeLoc()))
9799   matches the `TypeLoc` of the variable declaration of `x`, but not `y`.
9800 </pre></td></tr>
9801
9802
9803 <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>
9804 <tr><td colspan="4" class="doc" id="hasDeclaration5"><pre>Matches a node if the declaration associated with that node
9805 matches the given matcher.
9806
9807 The associated declaration is:
9808 - for type nodes, the declaration of the underlying type
9809 - for CallExpr, the declaration of the callee
9810 - for MemberExpr, the declaration of the referenced member
9811 - for CXXConstructExpr, the declaration of the constructor
9812 - for CXXNewExpr, the declaration of the operator new
9813 - for ObjCIvarExpr, the declaration of the ivar
9814
9815 For type nodes, hasDeclaration will generally match the declaration of the
9816 sugared type. Given
9817   class X {};
9818   typedef X Y;
9819   Y y;
9820 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
9821 typedefDecl. A common use case is to match the underlying, desugared type.
9822 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
9823   varDecl(hasType(hasUnqualifiedDesugaredType(
9824       recordType(hasDeclaration(decl())))))
9825 In this matcher, the decl will match the CXXRecordDecl of class X.
9826
9827 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;,
9828   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;,
9829   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;,
9830   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;,
9831   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;,
9832   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;,
9833   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
9834 </pre></td></tr>
9835
9836
9837 <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>
9838 <tr><td colspan="4" class="doc" id="hasReferentLoc0"><pre>Matches reference `TypeLoc`s that have a referent `TypeLoc` matching
9839 `ReferentMatcher`.
9840
9841 Given
9842   int x = 3;
9843   int&amp; xx = x;
9844 referenceTypeLoc(hasReferentLoc(loc(asString("int"))))
9845   matches `int&amp;`.
9846 </pre></td></tr>
9847
9848
9849 <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>
9850 <tr><td colspan="4" class="doc" id="pointee3"><pre>Narrows PointerType (and similar) matchers to those where the
9851 pointee matches a given matcher.
9852
9853 Given
9854   int *a;
9855   int const *b;
9856   float const *f;
9857 pointerType(pointee(isConstQualified(), isInteger()))
9858   matches "int const *b"
9859
9860 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;,
9861   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;
9862 </pre></td></tr>
9863
9864
9865 <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>
9866 <tr><td colspan="4" class="doc" id="hasReturnValue0"><pre>Matches the return value expression of a return statement
9867
9868 Given
9869   return a + b;
9870 hasReturnValue(binaryOperator())
9871   matches 'return a + b'
9872 with binaryOperator()
9873   matching 'a + b'
9874 </pre></td></tr>
9875
9876
9877 <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>
9878 <tr><td colspan="4" class="doc" id="hasAnySubstatement1"><pre>Matches compound statements where at least one substatement matches
9879 a given matcher. Also matches StmtExprs that have CompoundStmt as children.
9880
9881 Given
9882   { {}; 1+2; }
9883 hasAnySubstatement(compoundStmt())
9884   matches '{ {}; 1+2; }'
9885 with compoundStmt()
9886   matching '{}'
9887 </pre></td></tr>
9888
9889
9890 <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>
9891 <tr><td colspan="4" class="doc" id="alignOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
9892 alignof.
9893 </pre></td></tr>
9894
9895
9896 <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>
9897 <tr><td colspan="4" class="doc" id="forCallable0"><pre>Matches declaration of the function, method, or block the statement
9898 belongs to.
9899
9900 Given:
9901 F&amp; operator=(const F&amp; o) {
9902   std::copy_if(o.begin(), o.end(), begin(), [](V v) { return v &gt; 0; });
9903   return *this;
9904 }
9905 returnStmt(forCallable(functionDecl(hasName("operator="))))
9906   matches 'return *this'
9907   but does not match 'return v &gt; 0'
9908
9909 Given:
9910 -(void) foo {
9911   int x = 1;
9912   dispatch_sync(queue, ^{ int y = 2; });
9913 }
9914 declStmt(forCallable(objcMethodDecl()))
9915   matches 'int x = 1'
9916   but does not match 'int y = 2'.
9917 whereas declStmt(forCallable(blockDecl()))
9918   matches 'int y = 2'
9919   but does not match 'int x = 1'.
9920 </pre></td></tr>
9921
9922
9923 <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>
9924 <tr><td colspan="4" class="doc" id="forFunction0"><pre>Matches declaration of the function the statement belongs to.
9925
9926 Deprecated. Use forCallable() to correctly handle the situation when
9927 the declaration is not a function (but a block or an Objective-C method).
9928 forFunction() not only fails to take non-functions into account but also
9929 may match the wrong declaration in their presence.
9930
9931 Given:
9932 F&amp; operator=(const F&amp; o) {
9933   std::copy_if(o.begin(), o.end(), begin(), [](V v) { return v &gt; 0; });
9934   return *this;
9935 }
9936 returnStmt(forFunction(hasName("operator=")))
9937   matches 'return *this'
9938   but does not match 'return v &gt; 0'
9939 </pre></td></tr>
9940
9941
9942 <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>
9943 <tr><td colspan="4" class="doc" id="sizeOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
9944 sizeof.
9945 </pre></td></tr>
9946
9947
9948 <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>
9949 <tr><td colspan="4" class="doc" id="hasReplacementType0"><pre>Matches template type parameter substitutions that have a replacement
9950 type that matches the provided matcher.
9951
9952 Given
9953   template &lt;typename T&gt;
9954   double F(T t);
9955   int i;
9956   double j = F(i);
9957
9958 substTemplateTypeParmType(hasReplacementType(type())) matches int
9959 </pre></td></tr>
9960
9961
9962 <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>
9963 <tr><td colspan="4" class="doc" id="forEachSwitchCase0"><pre>Matches each case or default statement belonging to the given switch
9964 statement. This matcher may produce multiple matches.
9965
9966 Given
9967   switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
9968 switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
9969   matches four times, with "c" binding each of "case 1:", "case 2:",
9970 "case 3:" and "case 4:", and "s" respectively binding "switch (1)",
9971 "switch (1)", "switch (2)" and "switch (2)".
9972 </pre></td></tr>
9973
9974
9975 <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>
9976 <tr><td colspan="4" class="doc" id="hasCondition4"><pre>Matches the condition expression of an if statement, for loop,
9977 switch statement or conditional operator.
9978
9979 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
9980   if (true) {}
9981 </pre></td></tr>
9982
9983
9984 <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>
9985 <tr><td colspan="4" class="doc" id="hasInitStatement1"><pre>Matches selection statements with initializer.
9986
9987 Given:
9988  void foo() {
9989    if (int i = foobar(); i &gt; 0) {}
9990    switch (int i = foobar(); i) {}
9991    for (auto&amp; a = get_range(); auto&amp; x : a) {}
9992  }
9993  void bar() {
9994    if (foobar() &gt; 0) {}
9995    switch (foobar()) {}
9996    for (auto&amp; x : get_range()) {}
9997  }
9998 ifStmt(hasInitStatement(anything()))
9999   matches the if statement in foo but not in bar.
10000 switchStmt(hasInitStatement(anything()))
10001   matches the switch statement in foo but not in bar.
10002 cxxForRangeStmt(hasInitStatement(anything()))
10003   matches the range for statement in foo but not in bar.
10004 </pre></td></tr>
10005
10006
10007 <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>
10008 <tr><td colspan="4" class="doc" id="hasDeclaration4"><pre>Matches a node if the declaration associated with that node
10009 matches the given matcher.
10010
10011 The associated declaration is:
10012 - for type nodes, the declaration of the underlying type
10013 - for CallExpr, the declaration of the callee
10014 - for MemberExpr, the declaration of the referenced member
10015 - for CXXConstructExpr, the declaration of the constructor
10016 - for CXXNewExpr, the declaration of the operator new
10017 - for ObjCIvarExpr, the declaration of the ivar
10018
10019 For type nodes, hasDeclaration will generally match the declaration of the
10020 sugared type. Given
10021   class X {};
10022   typedef X Y;
10023   Y y;
10024 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10025 typedefDecl. A common use case is to match the underlying, desugared type.
10026 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10027   varDecl(hasType(hasUnqualifiedDesugaredType(
10028       recordType(hasDeclaration(decl())))))
10029 In this matcher, the decl will match the CXXRecordDecl of class X.
10030
10031 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;,
10032   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;,
10033   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;,
10034   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;,
10035   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;,
10036   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;,
10037   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10038 </pre></td></tr>
10039
10040
10041 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</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>
10042 <tr><td colspan="4" class="doc" id="hasTypeLoc11"><pre>Matches if the type location of a node matches the inner matcher.
10043
10044 Examples:
10045   int x;
10046 declaratorDecl(hasTypeLoc(loc(asString("int"))))
10047   matches int x
10048
10049 auto x = int(3);
10050 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
10051   matches int(3)
10052
10053 struct Foo { Foo(int, int); };
10054 auto x = Foo(1, 2);
10055 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
10056   matches Foo(1, 2)
10057
10058 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;,
10059   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;,
10060   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;,
10061   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
10062   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
10063   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;,
10064   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;,
10065   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
10066 </pre></td></tr>
10067
10068
10069 <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>
10070 <tr><td colspan="4" class="doc" id="isExpr0"><pre>Matches a sugar TemplateArgument that refers to a certain expression.
10071
10072 Given
10073   struct B { int next; };
10074   template&lt;int(B::*next_ptr)&gt; struct A {};
10075   A&lt;&amp;B::next&gt; a;
10076 templateSpecializationType(hasAnyTemplateArgument(
10077   isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
10078   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
10079     B::next
10080 </pre></td></tr>
10081
10082
10083 <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>
10084 <tr><td colspan="4" class="doc" id="refersToDeclaration0"><pre>Matches a canonical TemplateArgument that refers to a certain
10085 declaration.
10086
10087 Given
10088   struct B { int next; };
10089   template&lt;int(B::*next_ptr)&gt; struct A {};
10090   A&lt;&amp;B::next&gt; a;
10091 classTemplateSpecializationDecl(hasAnyTemplateArgument(
10092     refersToDeclaration(fieldDecl(hasName("next")))))
10093   matches the specialization A&lt;&amp;B::next&gt; with fieldDecl(...) matching
10094     B::next
10095 </pre></td></tr>
10096
10097
10098 <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>
10099 <tr><td colspan="4" class="doc" id="refersToIntegralType0"><pre>Matches a TemplateArgument that refers to an integral type.
10100
10101 Given
10102   template&lt;int T&gt; struct C {};
10103   C&lt;42&gt; c;
10104 classTemplateSpecializationDecl(
10105   hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
10106   matches the implicit instantiation of C in C&lt;42&gt;.
10107 </pre></td></tr>
10108
10109
10110 <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>
10111 <tr><td colspan="4" class="doc" id="refersToTemplate0"><pre>Matches a TemplateArgument that refers to a certain template.
10112
10113 Given
10114   template&lt;template &lt;typename&gt; class S&gt; class X {};
10115   template&lt;typename T&gt; class Y {};
10116   X&lt;Y&gt; xi;
10117 classTemplateSpecializationDecl(hasAnyTemplateArgument(
10118     refersToTemplate(templateName())))
10119   matches the specialization X&lt;Y&gt;
10120 </pre></td></tr>
10121
10122
10123 <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>
10124 <tr><td colspan="4" class="doc" id="refersToType0"><pre>Matches a TemplateArgument that refers to a certain type.
10125
10126 Given
10127   struct X {};
10128   template&lt;typename T&gt; struct A {};
10129   A&lt;X&gt; a;
10130 classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
10131   recordType(hasDeclaration(recordDecl(hasName("X")))))))
10132 matches the specialization of struct A generated by A&lt;X&gt;.
10133 </pre></td></tr>
10134
10135
10136 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationTypeLoc.html">TemplateSpecializationTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgumentLoc4')"><a name="hasAnyTemplateArgumentLoc4Anchor">hasAnyTemplateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
10137 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgumentLoc4"><pre>Matches template specialization `TypeLoc`s, class template specializations,
10138 variable template specializations, and function template specializations
10139 that have at least one `TemplateArgumentLoc` matching the given
10140 `InnerMatcher`.
10141
10142 Given
10143   template&lt;typename T&gt; class A {};
10144   A&lt;int&gt; a;
10145 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
10146   hasTypeLoc(loc(asString("int")))))))
10147   matches `A&lt;int&gt; a`.
10148 </pre></td></tr>
10149
10150
10151 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationTypeLoc.html">TemplateSpecializationTypeLoc</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgumentLoc4')"><a name="hasTemplateArgumentLoc4Anchor">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>
10152 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc4"><pre>Matches template specialization `TypeLoc`s, class template specializations,
10153 variable template specializations, and function template specializations
10154 where the n'th `TemplateArgumentLoc` matches the given `InnerMatcher`.
10155
10156 Given
10157   template&lt;typename T, typename U&gt; class A {};
10158   A&lt;double, int&gt; b;
10159   A&lt;int, double&gt; c;
10160 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
10161   hasTypeLoc(loc(asString("double")))))))
10162   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
10163 </pre></td></tr>
10164
10165
10166 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument3')"><a name="forEachTemplateArgument3Anchor">forEachTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
10167 <tr><td colspan="4" class="doc" id="forEachTemplateArgument3"><pre>Matches templateSpecializationType, class template specialization,
10168 variable template specialization, and function template specialization
10169 nodes where the template argument matches the inner matcher. This matcher
10170 may produce multiple matches.
10171
10172 Given
10173   template &lt;typename T, unsigned N, unsigned M&gt;
10174   struct Matrix {};
10175
10176   constexpr unsigned R = 2;
10177   Matrix&lt;int, R * 2, R * 4&gt; M;
10178
10179   template &lt;typename T, typename U&gt;
10180   void f(T&amp;&amp; t, U&amp;&amp; u) {}
10181
10182   bool B = false;
10183   f(R, B);
10184 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
10185   matches twice, with expr() matching 'R * 2' and 'R * 4'
10186 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
10187   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
10188   and 'bool'
10189 </pre></td></tr>
10190
10191
10192 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument3')"><a name="hasAnyTemplateArgument3Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
10193 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument3"><pre>Matches templateSpecializationTypes, class template specializations,
10194 variable template specializations, and function template specializations
10195 that have at least one TemplateArgument matching the given InnerMatcher.
10196
10197 Given
10198   template&lt;typename T&gt; class A {};
10199   template&lt;&gt; class A&lt;double&gt; {};
10200   A&lt;int&gt; a;
10201
10202   template&lt;typename T&gt; f() {};
10203   void func() { f&lt;int&gt;(); };
10204
10205 classTemplateSpecializationDecl(hasAnyTemplateArgument(
10206     refersToType(asString("int"))))
10207   matches the specialization A&lt;int&gt;
10208
10209 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
10210   matches the specialization f&lt;int&gt;
10211 </pre></td></tr>
10212
10213
10214 <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>
10215 <tr><td colspan="4" class="doc" id="hasDeclaration3"><pre>Matches a node if the declaration associated with that node
10216 matches the given matcher.
10217
10218 The associated declaration is:
10219 - for type nodes, the declaration of the underlying type
10220 - for CallExpr, the declaration of the callee
10221 - for MemberExpr, the declaration of the referenced member
10222 - for CXXConstructExpr, the declaration of the constructor
10223 - for CXXNewExpr, the declaration of the operator new
10224 - for ObjCIvarExpr, the declaration of the ivar
10225
10226 For type nodes, hasDeclaration will generally match the declaration of the
10227 sugared type. Given
10228   class X {};
10229   typedef X Y;
10230   Y y;
10231 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10232 typedefDecl. A common use case is to match the underlying, desugared type.
10233 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10234   varDecl(hasType(hasUnqualifiedDesugaredType(
10235       recordType(hasDeclaration(decl())))))
10236 In this matcher, the decl will match the CXXRecordDecl of class X.
10237
10238 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;,
10239   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;,
10240   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;,
10241   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;,
10242   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;,
10243   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;,
10244   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10245 </pre></td></tr>
10246
10247
10248 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasTemplateArgument3')"><a name="hasTemplateArgument3Anchor">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>
10249 <tr><td colspan="4" class="doc" id="hasTemplateArgument3"><pre>Matches templateSpecializationType, class template specializations,
10250 variable template specializations, and function template specializations
10251 where the n'th TemplateArgument matches the given InnerMatcher.
10252
10253 Given
10254   template&lt;typename T, typename U&gt; class A {};
10255   A&lt;bool, int&gt; b;
10256   A&lt;int, bool&gt; c;
10257
10258   template&lt;typename T&gt; void f() {}
10259   void func() { f&lt;int&gt;(); };
10260 classTemplateSpecializationDecl(hasTemplateArgument(
10261     1, refersToType(asString("int"))))
10262   matches the specialization A&lt;bool, int&gt;
10263
10264 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
10265   matches the specialization f&lt;int&gt;
10266 </pre></td></tr>
10267
10268
10269 <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>
10270 <tr><td colspan="4" class="doc" id="hasDeclaration2"><pre>Matches a node if the declaration associated with that node
10271 matches the given matcher.
10272
10273 The associated declaration is:
10274 - for type nodes, the declaration of the underlying type
10275 - for CallExpr, the declaration of the callee
10276 - for MemberExpr, the declaration of the referenced member
10277 - for CXXConstructExpr, the declaration of the constructor
10278 - for CXXNewExpr, the declaration of the operator new
10279 - for ObjCIvarExpr, the declaration of the ivar
10280
10281 For type nodes, hasDeclaration will generally match the declaration of the
10282 sugared type. Given
10283   class X {};
10284   typedef X Y;
10285   Y y;
10286 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10287 typedefDecl. A common use case is to match the underlying, desugared type.
10288 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10289   varDecl(hasType(hasUnqualifiedDesugaredType(
10290       recordType(hasDeclaration(decl())))))
10291 In this matcher, the decl will match the CXXRecordDecl of class X.
10292
10293 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;,
10294   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;,
10295   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;,
10296   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;,
10297   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;,
10298   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;,
10299   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10300 </pre></td></tr>
10301
10302
10303 <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>
10304 <tr><td colspan="4" class="doc" id="loc0"><pre>Matches TypeLocs for which the given inner
10305 QualType-matcher matches.
10306 </pre></td></tr>
10307
10308
10309 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</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>
10310 <tr><td colspan="4" class="doc" id="hasTypeLoc12"><pre>Matches if the type location of a node matches the inner matcher.
10311
10312 Examples:
10313   int x;
10314 declaratorDecl(hasTypeLoc(loc(asString("int"))))
10315   matches int x
10316
10317 auto x = int(3);
10318 cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int"))))
10319   matches int(3)
10320
10321 struct Foo { Foo(int, int); };
10322 auto x = Foo(1, 2);
10323 cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo"))))
10324   matches Foo(1, 2)
10325
10326 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;,
10327   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;,
10328   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;,
10329   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;,
10330   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;,
10331   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;,
10332   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;,
10333   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;
10334 </pre></td></tr>
10335
10336
10337 <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>
10338 <tr><td colspan="4" class="doc" id="hasType2"><pre>Matches if the expression's or declaration's type matches a type
10339 matcher.
10340
10341 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
10342             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
10343             and U (matcher = typedefDecl(hasType(asString("int")))
10344             and friend class X (matcher = friendDecl(hasType("X"))
10345             and public virtual X (matcher = cxxBaseSpecifier(hasType(
10346                                               asString("class X")))
10347  class X {};
10348  void y(X &amp;x) { x; X z; }
10349  typedef int U;
10350  class Y { friend class X; };
10351  class Z : public virtual X {};
10352 </pre></td></tr>
10353
10354
10355 <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>
10356 <tr><td colspan="4" class="doc" id="hasDeclaration1"><pre>Matches a node if the declaration associated with that node
10357 matches the given matcher.
10358
10359 The associated declaration is:
10360 - for type nodes, the declaration of the underlying type
10361 - for CallExpr, the declaration of the callee
10362 - for MemberExpr, the declaration of the referenced member
10363 - for CXXConstructExpr, the declaration of the constructor
10364 - for CXXNewExpr, the declaration of the operator new
10365 - for ObjCIvarExpr, the declaration of the ivar
10366
10367 For type nodes, hasDeclaration will generally match the declaration of the
10368 sugared type. Given
10369   class X {};
10370   typedef X Y;
10371   Y y;
10372 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10373 typedefDecl. A common use case is to match the underlying, desugared type.
10374 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10375   varDecl(hasType(hasUnqualifiedDesugaredType(
10376       recordType(hasDeclaration(decl())))))
10377 In this matcher, the decl will match the CXXRecordDecl of class X.
10378
10379 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;,
10380   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;,
10381   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;,
10382   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;,
10383   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;,
10384   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;,
10385   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10386 </pre></td></tr>
10387
10388
10389 <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>
10390 <tr><td colspan="4" class="doc" id="hasUnqualifiedDesugaredType0"><pre>Matches if the matched type matches the unqualified desugared
10391 type of the matched node.
10392
10393 For example, in:
10394   class A {};
10395   using B = A;
10396 The matcher type(hasUnqualifiedDesugaredType(recordType())) matches
10397 both B and A.
10398 </pre></td></tr>
10399
10400
10401 <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>
10402 <tr><td colspan="4" class="doc" id="hasArgumentOfType0"><pre>Matches unary expressions that have a specific type of argument.
10403
10404 Given
10405   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
10406 unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
10407   matches sizeof(a) and alignof(c)
10408 </pre></td></tr>
10409
10410
10411 <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>
10412 <tr><td colspan="4" class="doc" id="hasUnaryOperand0"><pre>Matches if the operand of a unary operator matches.
10413
10414 Example matches true (matcher = hasUnaryOperand(
10415                                   cxxBoolLiteral(equals(true))))
10416   !true
10417 </pre></td></tr>
10418
10419
10420 <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>
10421 <tr><td colspan="4" class="doc" id="hasObjectExpression1"><pre>Matches a member expression where the object expression is matched by a
10422 given matcher. Implicit object expressions are included; that is, it matches
10423 use of implicit `this`.
10424
10425 Given
10426   struct X {
10427     int m;
10428     int f(X x) { x.m; return m; }
10429   };
10430 memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))))
10431   matches `x.m`, but not `m`; however,
10432 memberExpr(hasObjectExpression(hasType(pointsTo(
10433      cxxRecordDecl(hasName("X"))))))
10434   matches `m` (aka. `this-&gt;m`), but not `x.m`.
10435 </pre></td></tr>
10436
10437
10438 <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>
10439 <tr><td colspan="4" class="doc" id="hasDeclaration0"><pre>Matches a node if the declaration associated with that node
10440 matches the given matcher.
10441
10442 The associated declaration is:
10443 - for type nodes, the declaration of the underlying type
10444 - for CallExpr, the declaration of the callee
10445 - for MemberExpr, the declaration of the referenced member
10446 - for CXXConstructExpr, the declaration of the constructor
10447 - for CXXNewExpr, the declaration of the operator new
10448 - for ObjCIvarExpr, the declaration of the ivar
10449
10450 For type nodes, hasDeclaration will generally match the declaration of the
10451 sugared type. Given
10452   class X {};
10453   typedef X Y;
10454   Y y;
10455 in varDecl(hasType(hasDeclaration(decl()))) the decl will match the
10456 typedefDecl. A common use case is to match the underlying, desugared type.
10457 This can be achieved by using the hasUnqualifiedDesugaredType matcher:
10458   varDecl(hasType(hasUnqualifiedDesugaredType(
10459       recordType(hasDeclaration(decl())))))
10460 In this matcher, the decl will match the CXXRecordDecl of class X.
10461
10462 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;,
10463   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;,
10464   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;,
10465   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;,
10466   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;,
10467   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;,
10468   Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingType.html">UnresolvedUsingType</a>&gt;
10469 </pre></td></tr>
10470
10471
10472 <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>
10473 <tr><td colspan="4" class="doc" id="hasTargetDecl0"><pre>Matches a using shadow declaration where the target declaration is
10474 matched by the given matcher.
10475
10476 Given
10477   namespace X { int a; void b(); }
10478   using X::a;
10479   using X::b;
10480 usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
10481   matches using X::b but not using X::a </pre></td></tr>
10482
10483
10484 <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>
10485 <tr><td colspan="4" class="doc" id="hasUnderlyingType1"><pre>Matches DecltypeType or UsingType nodes to find the underlying type.
10486
10487 Given
10488   decltype(1) a = 1;
10489   decltype(2.0) b = 2.0;
10490 decltypeType(hasUnderlyingType(isInteger()))
10491   matches the type of "a"
10492
10493 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;
10494 </pre></td></tr>
10495
10496
10497 <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>
10498 <tr><td colspan="4" class="doc" id="throughUsingDecl1"><pre>Matches if a node refers to a declaration through a specific
10499 using shadow declaration.
10500
10501 Examples:
10502   namespace a { int f(); }
10503   using a::f;
10504   int x = f();
10505 declRefExpr(throughUsingDecl(anything()))
10506   matches f
10507
10508   namespace a { class X{}; }
10509   using a::X;
10510   X x;
10511 typeLoc(loc(usingType(throughUsingDecl(anything()))))
10512   matches X
10513
10514 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;
10515 </pre></td></tr>
10516
10517
10518 <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>
10519 <tr><td colspan="4" class="doc" id="hasType7"><pre>Overloaded to match the declaration of the expression's or value
10520 declaration's type.
10521
10522 In case of a value declaration (for example a variable declaration),
10523 this resolves one layer of indirection. For example, in the value
10524 declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
10525 X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
10526 declaration of x.
10527
10528 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
10529             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
10530             and friend class X (matcher = friendDecl(hasType("X"))
10531             and public virtual X (matcher = cxxBaseSpecifier(hasType(
10532                                               cxxRecordDecl(hasName("X"))))
10533  class X {};
10534  void y(X &amp;x) { x; X z; }
10535  class Y { friend class X; };
10536  class Z : public virtual X {};
10537
10538 Example matches class Derived
10539 (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base"))))))
10540 class Base {};
10541 class Derived : Base {};
10542
10543 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;,
10544 Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
10545 </pre></td></tr>
10546
10547
10548 <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>
10549 <tr><td colspan="4" class="doc" id="hasType3"><pre>Matches if the expression's or declaration's type matches a type
10550 matcher.
10551
10552 Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
10553             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
10554             and U (matcher = typedefDecl(hasType(asString("int")))
10555             and friend class X (matcher = friendDecl(hasType("X"))
10556             and public virtual X (matcher = cxxBaseSpecifier(hasType(
10557                                               asString("class X")))
10558  class X {};
10559  void y(X &amp;x) { x; X z; }
10560  typedef int U;
10561  class Y { friend class X; };
10562  class Z : public virtual X {};
10563 </pre></td></tr>
10564
10565
10566 <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>
10567 <tr><td colspan="4" class="doc" id="hasInitializer0"><pre>Matches a variable declaration that has an initializer expression
10568 that matches the given matcher.
10569
10570 Example matches x (matcher = varDecl(hasInitializer(callExpr())))
10571   bool y() { return true; }
10572   bool x = y();
10573 </pre></td></tr>
10574
10575
10576 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarTemplateSpecializationDecl.html">VarTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument1')"><a name="forEachTemplateArgument1Anchor">forEachTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
10577 <tr><td colspan="4" class="doc" id="forEachTemplateArgument1"><pre>Matches templateSpecializationType, class template specialization,
10578 variable template specialization, and function template specialization
10579 nodes where the template argument matches the inner matcher. This matcher
10580 may produce multiple matches.
10581
10582 Given
10583   template &lt;typename T, unsigned N, unsigned M&gt;
10584   struct Matrix {};
10585
10586   constexpr unsigned R = 2;
10587   Matrix&lt;int, R * 2, R * 4&gt; M;
10588
10589   template &lt;typename T, typename U&gt;
10590   void f(T&amp;&amp; t, U&amp;&amp; u) {}
10591
10592   bool B = false;
10593   f(R, B);
10594 templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
10595   matches twice, with expr() matching 'R * 2' and 'R * 4'
10596 functionDecl(forEachTemplateArgument(refersToType(builtinType())))
10597   matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
10598   and 'bool'
10599 </pre></td></tr>
10600
10601
10602 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarTemplateSpecializationDecl.html">VarTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgumentLoc1')"><a name="hasAnyTemplateArgumentLoc1Anchor">hasAnyTemplateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt; InnerMatcher</td></tr>
10603 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgumentLoc1"><pre>Matches template specialization `TypeLoc`s, class template specializations,
10604 variable template specializations, and function template specializations
10605 that have at least one `TemplateArgumentLoc` matching the given
10606 `InnerMatcher`.
10607
10608 Given
10609   template&lt;typename T&gt; class A {};
10610   A&lt;int&gt; a;
10611 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
10612   hasTypeLoc(loc(asString("int")))))))
10613   matches `A&lt;int&gt; a`.
10614 </pre></td></tr>
10615
10616
10617 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarTemplateSpecializationDecl.html">VarTemplateSpecializationDecl</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>
10618 <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument1"><pre>Matches templateSpecializationTypes, class template specializations,
10619 variable template specializations, and function template specializations
10620 that have at least one TemplateArgument matching the given InnerMatcher.
10621
10622 Given
10623   template&lt;typename T&gt; class A {};
10624   template&lt;&gt; class A&lt;double&gt; {};
10625   A&lt;int&gt; a;
10626
10627   template&lt;typename T&gt; f() {};
10628   void func() { f&lt;int&gt;(); };
10629
10630 classTemplateSpecializationDecl(hasAnyTemplateArgument(
10631     refersToType(asString("int"))))
10632   matches the specialization A&lt;int&gt;
10633
10634 functionDecl(hasAnyTemplateArgument(refersToType(asString("int"))))
10635   matches the specialization f&lt;int&gt;
10636 </pre></td></tr>
10637
10638
10639 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarTemplateSpecializationDecl.html">VarTemplateSpecializationDecl</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>
10640 <tr><td colspan="4" class="doc" id="hasTemplateArgumentLoc1"><pre>Matches template specialization `TypeLoc`s, class template specializations,
10641 variable template specializations, and function template specializations
10642 where the n'th `TemplateArgumentLoc` matches the given `InnerMatcher`.
10643
10644 Given
10645   template&lt;typename T, typename U&gt; class A {};
10646   A&lt;double, int&gt; b;
10647   A&lt;int, double&gt; c;
10648 varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
10649   hasTypeLoc(loc(asString("double")))))))
10650   matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
10651 </pre></td></tr>
10652
10653
10654 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarTemplateSpecializationDecl.html">VarTemplateSpecializationDecl</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>
10655 <tr><td colspan="4" class="doc" id="hasTemplateArgument1"><pre>Matches templateSpecializationType, class template specializations,
10656 variable template specializations, and function template specializations
10657 where the n'th TemplateArgument matches the given InnerMatcher.
10658
10659 Given
10660   template&lt;typename T, typename U&gt; class A {};
10661   A&lt;bool, int&gt; b;
10662   A&lt;int, bool&gt; c;
10663
10664   template&lt;typename T&gt; void f() {}
10665   void func() { f&lt;int&gt;(); };
10666 classTemplateSpecializationDecl(hasTemplateArgument(
10667     1, refersToType(asString("int"))))
10668   matches the specialization A&lt;bool, int&gt;
10669
10670 functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))
10671   matches the specialization f&lt;int&gt;
10672 </pre></td></tr>
10673
10674
10675 <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>
10676 <tr><td colspan="4" class="doc" id="hasSizeExpr0"><pre>Matches VariableArrayType nodes that have a specific size
10677 expression.
10678
10679 Given
10680   void f(int b) {
10681     int a[b];
10682   }
10683 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
10684   varDecl(hasName("b")))))))
10685   matches "int a[b]"
10686 </pre></td></tr>
10687
10688
10689 <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>
10690 <tr><td colspan="4" class="doc" id="hasBody2"><pre>Matches a 'for', 'while', 'while' statement or a function or coroutine
10691 definition that has a given body. Note that in case of functions or
10692 coroutines this matcher only matches the definition itself and not the
10693 other declarations of the same function or coroutine.
10694
10695 Given
10696   for (;;) {}
10697 forStmt(hasBody(compoundStmt()))
10698   matches 'for (;;) {}'
10699 with compoundStmt()
10700   matching '{}'
10701
10702 Given
10703   void f();
10704   void f() {}
10705 functionDecl(hasBody(compoundStmt()))
10706   matches 'void f() {}'
10707 with compoundStmt()
10708   matching '{}'
10709   but does not match 'void f();'
10710 </pre></td></tr>
10711
10712
10713 <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>
10714 <tr><td colspan="4" class="doc" id="hasCondition2"><pre>Matches the condition expression of an if statement, for loop,
10715 switch statement or conditional operator.
10716
10717 Example matches true (matcher = hasCondition(cxxBoolLiteral(equals(true))))
10718   if (true) {}
10719 </pre></td></tr>
10720
10721 <!--END_TRAVERSAL_MATCHERS -->
10722 </table>
10723
10724 </div>
10725 </body>
10726 </html>
10727
10728