clang/lib/ASTMatchers/ASTMatchersInternal.cpp

   1 //===- ASTMatchersInternal.cpp - Structural query framework ---------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  Implements the base layer of the matcher framework.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/ASTMatchers/ASTMatchersInternal.h"
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/ASTTypeTraits.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/AST/DeclTemplate.h"
  18 #include "clang/AST/ParentMapContext.h"
  19 #include "clang/AST/PrettyPrinter.h"
  20 #include "clang/ASTMatchers/ASTMatchers.h"
  21 #include "clang/Basic/LLVM.h"
  22 #include "clang/Lex/Lexer.h"
  23 #include "llvm/ADT/ArrayRef.h"
  24 #include "llvm/ADT/DenseSet.h"
  25 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  26 #include "llvm/ADT/SmallString.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/ADT/StringRef.h"
  29 #include "llvm/Support/Casting.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/ManagedStatic.h"
  32 #include "llvm/Support/Regex.h"
  33 #include "llvm/Support/WithColor.h"
  34 #include "llvm/Support/raw_ostream.h"
  35 #include <algorithm>
  36 #include <cassert>
  37 #include <cstddef>
  38 #include <optional>
  39 #include <string>
  40 #include <utility>
  41 #include <vector>
  42
  43 namespace clang {
  44 namespace ast_matchers {
  45
  46 AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector<std::string>,
  47               Matches) {
  48   return llvm::is_contained(Matches, Node.getSelector().getAsString());
  49 }
  50
  51 namespace internal {
  52
  53 static bool notUnaryOperator(const DynTypedNode &DynNode,
  54                              ASTMatchFinder *Finder,
  55                              BoundNodesTreeBuilder *Builder,
  56                              ArrayRef<DynTypedMatcher> InnerMatchers);
  57
  58 static bool allOfVariadicOperator(const DynTypedNode &DynNode,
  59                                   ASTMatchFinder *Finder,
  60                                   BoundNodesTreeBuilder *Builder,
  61                                   ArrayRef<DynTypedMatcher> InnerMatchers);
  62
  63 static bool eachOfVariadicOperator(const DynTypedNode &DynNode,
  64                                    ASTMatchFinder *Finder,
  65                                    BoundNodesTreeBuilder *Builder,
  66                                    ArrayRef<DynTypedMatcher> InnerMatchers);
  67
  68 static bool anyOfVariadicOperator(const DynTypedNode &DynNode,
  69                                   ASTMatchFinder *Finder,
  70                                   BoundNodesTreeBuilder *Builder,
  71                                   ArrayRef<DynTypedMatcher> InnerMatchers);
  72
  73 static bool optionallyVariadicOperator(const DynTypedNode &DynNode,
  74                                        ASTMatchFinder *Finder,
  75                                        BoundNodesTreeBuilder *Builder,
  76                                        ArrayRef<DynTypedMatcher> InnerMatchers);
  77
  78 bool matchesAnyBase(const CXXRecordDecl &Node,
  79                     const Matcher<CXXBaseSpecifier> &BaseSpecMatcher,
  80                     ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) {
  81   if (!Node.hasDefinition())
  82     return false;
  83
  84   CXXBasePaths Paths;
  85   Paths.setOrigin(&Node);
  86
  87   const auto basePredicate =
  88       [Finder, Builder, &BaseSpecMatcher](const CXXBaseSpecifier *BaseSpec,
  89                                           CXXBasePath &IgnoredParam) {
  90         BoundNodesTreeBuilder Result(*Builder);
  91         if (BaseSpecMatcher.matches(*BaseSpec, Finder, &Result)) {
  92           *Builder = std::move(Result);
  93           return true;
  94         }
  95         return false;
  96       };
  97
  98   return Node.lookupInBases(basePredicate, Paths,
  99                             /*LookupInDependent =*/true);
 100 }
 101
 102 void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) {
 103   if (Bindings.empty())
 104     Bindings.push_back(BoundNodesMap());
 105   for (BoundNodesMap &Binding : Bindings) {
 106     ResultVisitor->visitMatch(BoundNodes(Binding));
 107   }
 108 }
 109
 110 namespace {
 111
 112 using VariadicOperatorFunction = bool (*)(
 113     const DynTypedNode &DynNode, ASTMatchFinder *Finder,
 114     BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
 115
 116 template <VariadicOperatorFunction Func>
 117 class VariadicMatcher : public DynMatcherInterface {
 118 public:
 119   VariadicMatcher(std::vector<DynTypedMatcher> InnerMatchers)
 120       : InnerMatchers(std::move(InnerMatchers)) {}
 121
 122   bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
 123                   BoundNodesTreeBuilder *Builder) const override {
 124     return Func(DynNode, Finder, Builder, InnerMatchers);
 125   }
 126
 127 private:
 128   std::vector<DynTypedMatcher> InnerMatchers;
 129 };
 130
 131 class IdDynMatcher : public DynMatcherInterface {
 132 public:
 133   IdDynMatcher(StringRef ID,
 134                IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
 135       : ID(ID), InnerMatcher(std::move(InnerMatcher)) {}
 136
 137   bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
 138                   BoundNodesTreeBuilder *Builder) const override {
 139     bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder);
 140     if (Result) Builder->setBinding(ID, DynNode);
 141     return Result;
 142   }
 143
 144   std::optional<clang::TraversalKind> TraversalKind() const override {
 145     return InnerMatcher->TraversalKind();
 146   }
 147
 148 private:
 149   const std::string ID;
 150   const IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
 151 };
 152
 153 /// A matcher that always returns true.
 154 class TrueMatcherImpl : public DynMatcherInterface {
 155 public:
 156   TrueMatcherImpl() = default;
 157
 158   bool dynMatches(const DynTypedNode &, ASTMatchFinder *,
 159                   BoundNodesTreeBuilder *) const override {
 160     return true;
 161   }
 162 };
 163
 164 /// A matcher that specifies a particular \c TraversalKind.
 165 ///
 166 /// The kind provided to the constructor overrides any kind that may be
 167 /// specified by the `InnerMatcher`.
 168 class DynTraversalMatcherImpl : public DynMatcherInterface {
 169 public:
 170   explicit DynTraversalMatcherImpl(
 171       clang::TraversalKind TK,
 172       IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
 173       : TK(TK), InnerMatcher(std::move(InnerMatcher)) {}
 174
 175   bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
 176                   BoundNodesTreeBuilder *Builder) const override {
 177     return this->InnerMatcher->dynMatches(DynNode, Finder, Builder);
 178   }
 179
 180   std::optional<clang::TraversalKind> TraversalKind() const override {
 181     return TK;
 182   }
 183
 184 private:
 185   clang::TraversalKind TK;
 186   IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
 187 };
 188
 189 } // namespace
 190
 191 bool ASTMatchFinder::isTraversalIgnoringImplicitNodes() const {
 192   return getASTContext().getParentMapContext().getTraversalKind() ==
 193          TK_IgnoreUnlessSpelledInSource;
 194 }
 195
 196 DynTypedMatcher
 197 DynTypedMatcher::constructVariadic(DynTypedMatcher::VariadicOperator Op,
 198                                    ASTNodeKind SupportedKind,
 199                                    std::vector<DynTypedMatcher> InnerMatchers) {
 200   assert(!InnerMatchers.empty() && "Array must not be empty.");
 201   assert(llvm::all_of(InnerMatchers,
 202                       [SupportedKind](const DynTypedMatcher &M) {
 203                         return M.canConvertTo(SupportedKind);
 204                       }) &&
 205          "InnerMatchers must be convertible to SupportedKind!");
 206
 207   // We must relax the restrict kind here.
 208   // The different operators might deal differently with a mismatch.
 209   // Make it the same as SupportedKind, since that is the broadest type we are
 210   // allowed to accept.
 211   auto RestrictKind = SupportedKind;
 212
 213   switch (Op) {
 214   case VO_AllOf:
 215     // In the case of allOf() we must pass all the checks, so making
 216     // RestrictKind the most restrictive can save us time. This way we reject
 217     // invalid types earlier and we can elide the kind checks inside the
 218     // matcher.
 219     for (auto &IM : InnerMatchers) {
 220       RestrictKind =
 221           ASTNodeKind::getMostDerivedType(RestrictKind, IM.RestrictKind);
 222     }
 223     return DynTypedMatcher(
 224         SupportedKind, RestrictKind,
 225         new VariadicMatcher<allOfVariadicOperator>(std::move(InnerMatchers)));
 226
 227   case VO_AnyOf:
 228     return DynTypedMatcher(
 229         SupportedKind, RestrictKind,
 230         new VariadicMatcher<anyOfVariadicOperator>(std::move(InnerMatchers)));
 231
 232   case VO_EachOf:
 233     return DynTypedMatcher(
 234         SupportedKind, RestrictKind,
 235         new VariadicMatcher<eachOfVariadicOperator>(std::move(InnerMatchers)));
 236
 237   case VO_Optionally:
 238     return DynTypedMatcher(SupportedKind, RestrictKind,
 239                            new VariadicMatcher<optionallyVariadicOperator>(
 240                                std::move(InnerMatchers)));
 241
 242   case VO_UnaryNot:
 243     // FIXME: Implement the Not operator to take a single matcher instead of a
 244     // vector.
 245     return DynTypedMatcher(
 246         SupportedKind, RestrictKind,
 247         new VariadicMatcher<notUnaryOperator>(std::move(InnerMatchers)));
 248   }
 249   llvm_unreachable("Invalid Op value.");
 250 }
 251
 252 DynTypedMatcher
 253 DynTypedMatcher::constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
 254                                             ASTNodeKind RestrictKind) {
 255   DynTypedMatcher Copy = InnerMatcher;
 256   Copy.RestrictKind = RestrictKind;
 257   return Copy;
 258 }
 259
 260 DynTypedMatcher DynTypedMatcher::withTraversalKind(TraversalKind TK) {
 261   auto Copy = *this;
 262   Copy.Implementation =
 263       new DynTraversalMatcherImpl(TK, std::move(Copy.Implementation));
 264   return Copy;
 265 }
 266
 267 DynTypedMatcher DynTypedMatcher::trueMatcher(ASTNodeKind NodeKind) {
 268   // We only ever need one instance of TrueMatcherImpl, so we create a static
 269   // instance and reuse it to reduce the overhead of the matcher and increase
 270   // the chance of cache hits.
 271   static const llvm::IntrusiveRefCntPtr<TrueMatcherImpl> Instance =
 272       new TrueMatcherImpl();
 273   return DynTypedMatcher(NodeKind, NodeKind, Instance);
 274 }
 275
 276 bool DynTypedMatcher::canMatchNodesOfKind(ASTNodeKind Kind) const {
 277   return RestrictKind.isBaseOf(Kind);
 278 }
 279
 280 DynTypedMatcher DynTypedMatcher::dynCastTo(const ASTNodeKind Kind) const {
 281   auto Copy = *this;
 282   Copy.SupportedKind = Kind;
 283   Copy.RestrictKind = ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
 284   return Copy;
 285 }
 286
 287 bool DynTypedMatcher::matches(const DynTypedNode &DynNode,
 288                               ASTMatchFinder *Finder,
 289                               BoundNodesTreeBuilder *Builder) const {
 290   TraversalKindScope RAII(Finder->getASTContext(),
 291                           Implementation->TraversalKind());
 292
 293   if (Finder->isTraversalIgnoringImplicitNodes() &&
 294       Finder->IsMatchingInASTNodeNotSpelledInSource())
 295     return false;
 296
 297   if (!Finder->isTraversalIgnoringImplicitNodes() &&
 298       Finder->IsMatchingInASTNodeNotAsIs())
 299     return false;
 300
 301   auto N =
 302       Finder->getASTContext().getParentMapContext().traverseIgnored(DynNode);
 303
 304   if (RestrictKind.isBaseOf(N.getNodeKind()) &&
 305       Implementation->dynMatches(N, Finder, Builder)) {
 306     return true;
 307   }
 308   // Delete all bindings when a matcher does not match.
 309   // This prevents unexpected exposure of bound nodes in unmatches
 310   // branches of the match tree.
 311   Builder->removeBindings([](const BoundNodesMap &) { return true; });
 312   return false;
 313 }
 314
 315 bool DynTypedMatcher::matchesNoKindCheck(const DynTypedNode &DynNode,
 316                                          ASTMatchFinder *Finder,
 317                                          BoundNodesTreeBuilder *Builder) const {
 318   TraversalKindScope raii(Finder->getASTContext(),
 319                           Implementation->TraversalKind());
 320
 321   if (Finder->isTraversalIgnoringImplicitNodes() &&
 322       Finder->IsMatchingInASTNodeNotSpelledInSource())
 323     return false;
 324
 325   if (!Finder->isTraversalIgnoringImplicitNodes() &&
 326       Finder->IsMatchingInASTNodeNotAsIs())
 327     return false;
 328
 329   auto N =
 330       Finder->getASTContext().getParentMapContext().traverseIgnored(DynNode);
 331
 332   assert(RestrictKind.isBaseOf(N.getNodeKind()));
 333   if (Implementation->dynMatches(N, Finder, Builder)) {
 334     return true;
 335   }
 336   // Delete all bindings when a matcher does not match.
 337   // This prevents unexpected exposure of bound nodes in unmatches
 338   // branches of the match tree.
 339   Builder->removeBindings([](const BoundNodesMap &) { return true; });
 340   return false;
 341 }
 342
 343 std::optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
 344   if (!AllowBind)
 345     return std::nullopt;
 346   auto Result = *this;
 347   Result.Implementation =
 348       new IdDynMatcher(ID, std::move(Result.Implementation));
 349   return std::move(Result);
 350 }
 351
 352 bool DynTypedMatcher::canConvertTo(ASTNodeKind To) const {
 353   const auto From = getSupportedKind();
 354   auto QualKind = ASTNodeKind::getFromNodeKind<QualType>();
 355   auto TypeKind = ASTNodeKind::getFromNodeKind<Type>();
 356   /// Mimic the implicit conversions of Matcher<>.
 357   /// - From Matcher<Type> to Matcher<QualType>
 358   if (From.isSame(TypeKind) && To.isSame(QualKind)) return true;
 359   /// - From Matcher<Base> to Matcher<Derived>
 360   return From.isBaseOf(To);
 361 }
 362
 363 void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) {
 364   Bindings.append(Other.Bindings.begin(), Other.Bindings.end());
 365 }
 366
 367 static bool notUnaryOperator(const DynTypedNode &DynNode,
 368                              ASTMatchFinder *Finder,
 369                              BoundNodesTreeBuilder *Builder,
 370                              ArrayRef<DynTypedMatcher> InnerMatchers) {
 371   if (InnerMatchers.size() != 1)
 372     return false;
 373
 374   // The 'unless' matcher will always discard the result:
 375   // If the inner matcher doesn't match, unless returns true,
 376   // but the inner matcher cannot have bound anything.
 377   // If the inner matcher matches, the result is false, and
 378   // any possible binding will be discarded.
 379   // We still need to hand in all the bound nodes up to this
 380   // point so the inner matcher can depend on bound nodes,
 381   // and we need to actively discard the bound nodes, otherwise
 382   // the inner matcher will reset the bound nodes if it doesn't
 383   // match, but this would be inversed by 'unless'.
 384   BoundNodesTreeBuilder Discard(*Builder);
 385   return !InnerMatchers[0].matches(DynNode, Finder, &Discard);
 386 }
 387
 388 static bool allOfVariadicOperator(const DynTypedNode &DynNode,
 389                                   ASTMatchFinder *Finder,
 390                                   BoundNodesTreeBuilder *Builder,
 391                                   ArrayRef<DynTypedMatcher> InnerMatchers) {
 392   // allOf leads to one matcher for each alternative in the first
 393   // matcher combined with each alternative in the second matcher.
 394   // Thus, we can reuse the same Builder.
 395   return llvm::all_of(InnerMatchers, [&](const DynTypedMatcher &InnerMatcher) {
 396     return InnerMatcher.matchesNoKindCheck(DynNode, Finder, Builder);
 397   });
 398 }
 399
 400 static bool eachOfVariadicOperator(const DynTypedNode &DynNode,
 401                                    ASTMatchFinder *Finder,
 402                                    BoundNodesTreeBuilder *Builder,
 403                                    ArrayRef<DynTypedMatcher> InnerMatchers) {
 404   BoundNodesTreeBuilder Result;
 405   bool Matched = false;
 406   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
 407     BoundNodesTreeBuilder BuilderInner(*Builder);
 408     if (InnerMatcher.matches(DynNode, Finder, &BuilderInner)) {
 409       Matched = true;
 410       Result.addMatch(BuilderInner);
 411     }
 412   }
 413   *Builder = std::move(Result);
 414   return Matched;
 415 }
 416
 417 static bool anyOfVariadicOperator(const DynTypedNode &DynNode,
 418                                   ASTMatchFinder *Finder,
 419                                   BoundNodesTreeBuilder *Builder,
 420                                   ArrayRef<DynTypedMatcher> InnerMatchers) {
 421   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
 422     BoundNodesTreeBuilder Result = *Builder;
 423     if (InnerMatcher.matches(DynNode, Finder, &Result)) {
 424       *Builder = std::move(Result);
 425       return true;
 426     }
 427   }
 428   return false;
 429 }
 430
 431 static bool
 432 optionallyVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
 433                            BoundNodesTreeBuilder *Builder,
 434                            ArrayRef<DynTypedMatcher> InnerMatchers) {
 435   if (InnerMatchers.size() != 1)
 436     return false;
 437
 438   BoundNodesTreeBuilder Result(*Builder);
 439   if (InnerMatchers[0].matches(DynNode, Finder, &Result))
 440     *Builder = std::move(Result);
 441   return true;
 442 }
 443
 444 inline static
 445 std::vector<std::string> vectorFromRefs(ArrayRef<const StringRef *> NameRefs) {
 446   std::vector<std::string> Names;
 447   Names.reserve(NameRefs.size());
 448   for (auto *Name : NameRefs)
 449     Names.emplace_back(*Name);
 450   return Names;
 451 }
 452
 453 Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs) {
 454   return internal::Matcher<NamedDecl>(
 455       new internal::HasNameMatcher(vectorFromRefs(NameRefs)));
 456 }
 457
 458 Matcher<ObjCMessageExpr> hasAnySelectorFunc(
 459     ArrayRef<const StringRef *> NameRefs) {
 460   return hasAnySelectorMatcher(vectorFromRefs(NameRefs));
 461 }
 462
 463 HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef<const StringRef *> NameRefs) {
 464   return HasOpNameMatcher(vectorFromRefs(NameRefs));
 465 }
 466
 467 HasOverloadOpNameMatcher
 468 hasAnyOverloadedOperatorNameFunc(ArrayRef<const StringRef *> NameRefs) {
 469   return HasOverloadOpNameMatcher(vectorFromRefs(NameRefs));
 470 }
 471
 472 HasNameMatcher::HasNameMatcher(std::vector<std::string> N)
 473     : UseUnqualifiedMatch(
 474           llvm::all_of(N, [](StringRef Name) { return !Name.contains("::"); })),
 475       Names(std::move(N)) {
 476 #ifndef NDEBUG
 477   for (StringRef Name : Names)
 478     assert(!Name.empty());
 479 #endif
 480 }
 481
 482 static bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) {
 483   StringRef Name = FullName;
 484   if (!Name.ends_with(Suffix))
 485     return false;
 486   Name = Name.drop_back(Suffix.size());
 487   if (!Name.empty()) {
 488     if (!Name.ends_with("::"))
 489       return false;
 490     Name = Name.drop_back(2);
 491   }
 492   FullName = Name;
 493   return true;
 494 }
 495
 496 static StringRef getNodeName(const NamedDecl &Node,
 497                              llvm::SmallString<128> &Scratch) {
 498   // Simple name.
 499   if (Node.getIdentifier())
 500     return Node.getName();
 501
 502   if (Node.getDeclName()) {
 503     // Name needs to be constructed.
 504     Scratch.clear();
 505     llvm::raw_svector_ostream OS(Scratch);
 506     Node.printName(OS);
 507     return OS.str();
 508   }
 509
 510   return "(anonymous)";
 511 }
 512
 513 static StringRef getNodeName(const RecordDecl &Node,
 514                              llvm::SmallString<128> &Scratch) {
 515   if (Node.getIdentifier()) {
 516     return Node.getName();
 517   }
 518   Scratch.clear();
 519   return ("(anonymous " + Node.getKindName() + ")").toStringRef(Scratch);
 520 }
 521
 522 static StringRef getNodeName(const NamespaceDecl &Node,
 523                              llvm::SmallString<128> &Scratch) {
 524   return Node.isAnonymousNamespace() ? "(anonymous namespace)" : Node.getName();
 525 }
 526
 527 namespace {
 528
 529 class PatternSet {
 530 public:
 531   PatternSet(ArrayRef<std::string> Names) {
 532     Patterns.reserve(Names.size());
 533     for (StringRef Name : Names)
 534       Patterns.push_back({Name, Name.starts_with("::")});
 535   }
 536
 537   /// Consumes the name suffix from each pattern in the set and removes the ones
 538   /// that didn't match.
 539   /// Return true if there are still any patterns left.
 540   bool consumeNameSuffix(StringRef NodeName, bool CanSkip) {
 541     if (CanSkip) {
 542       // If we can skip the node, then we need to handle the case where a
 543       // skipped node has the same name as its parent.
 544       // namespace a { inline namespace a { class A; } }
 545       // cxxRecordDecl(hasName("::a::A"))
 546       // To do this, any patterns that match should be duplicated in our set,
 547       // one of them with the tail removed.
 548       for (size_t I = 0, E = Patterns.size(); I != E; ++I) {
 549         StringRef Pattern = Patterns[I].P;
 550         if (ast_matchers::internal::consumeNameSuffix(Patterns[I].P, NodeName))
 551           Patterns.push_back({Pattern, Patterns[I].IsFullyQualified});
 552       }
 553     } else {
 554       llvm::erase_if(Patterns, [&NodeName](auto &Pattern) {
 555         return !::clang::ast_matchers::internal::consumeNameSuffix(Pattern.P,
 556                                                                    NodeName);
 557       });
 558     }
 559     return !Patterns.empty();
 560   }
 561
 562   /// Check if any of the patterns are a match.
 563   /// A match will be a pattern that was fully consumed, that also matches the
 564   /// 'fully qualified' requirement.
 565   bool foundMatch(bool AllowFullyQualified) const {
 566     return llvm::any_of(Patterns, [&](const Pattern &Pattern) {
 567       return Pattern.P.empty() &&
 568              (AllowFullyQualified || !Pattern.IsFullyQualified);
 569     });
 570   }
 571
 572 private:
 573   struct Pattern {
 574     StringRef P;
 575     bool IsFullyQualified;
 576   };
 577
 578   llvm::SmallVector<Pattern, 8> Patterns;
 579 };
 580
 581 } // namespace
 582
 583 bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const {
 584   assert(UseUnqualifiedMatch);
 585   llvm::SmallString<128> Scratch;
 586   StringRef NodeName = getNodeName(Node, Scratch);
 587   return llvm::any_of(Names, [&](StringRef Name) {
 588     return consumeNameSuffix(Name, NodeName) && Name.empty();
 589   });
 590 }
 591
 592 bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const {
 593   PatternSet Patterns(Names);
 594   llvm::SmallString<128> Scratch;
 595
 596   // This function is copied and adapted from NamedDecl::printQualifiedName()
 597   // By matching each part individually we optimize in a couple of ways:
 598   //  - We can exit early on the first failure.
 599   //  - We can skip inline/anonymous namespaces without another pass.
 600   //  - We print one name at a time, reducing the chance of overflowing the
 601   //    inlined space of the SmallString.
 602
 603   // First, match the name.
 604   if (!Patterns.consumeNameSuffix(getNodeName(Node, Scratch),
 605                                   /*CanSkip=*/false))
 606     return false;
 607
 608   // Try to match each declaration context.
 609   // We are allowed to skip anonymous and inline namespaces if they don't match.
 610   const DeclContext *Ctx = Node.getDeclContext();
 611
 612   if (Ctx->isFunctionOrMethod())
 613     return Patterns.foundMatch(/*AllowFullyQualified=*/false);
 614
 615   for (; Ctx; Ctx = Ctx->getParent()) {
 616     // Linkage Spec can just be ignored
 617     // FIXME: Any other DeclContext kinds that can be safely disregarded
 618     if (isa<LinkageSpecDecl>(Ctx))
 619       continue;
 620     if (!isa<NamedDecl>(Ctx))
 621       break;
 622     if (Patterns.foundMatch(/*AllowFullyQualified=*/false))
 623       return true;
 624
 625     if (const auto *ND = dyn_cast<NamespaceDecl>(Ctx)) {
 626       // If it matches (or we can skip it), continue.
 627       if (Patterns.consumeNameSuffix(getNodeName(*ND, Scratch),
 628                                      /*CanSkip=*/ND->isAnonymousNamespace() ||
 629                                          ND->isInline()))
 630         continue;
 631       return false;
 632     }
 633     if (const auto *RD = dyn_cast<RecordDecl>(Ctx)) {
 634       if (!isa<ClassTemplateSpecializationDecl>(Ctx)) {
 635         if (Patterns.consumeNameSuffix(getNodeName(*RD, Scratch),
 636                                        /*CanSkip=*/false))
 637           continue;
 638
 639         return false;
 640       }
 641     }
 642
 643     // We don't know how to deal with this DeclContext.
 644     // Fallback to the slow version of the code.
 645     return matchesNodeFullSlow(Node);
 646   }
 647
 648   return Patterns.foundMatch(/*AllowFullyQualified=*/true);
 649 }
 650
 651 bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
 652   const bool SkipUnwrittenCases[] = {false, true};
 653   for (bool SkipUnwritten : SkipUnwrittenCases) {
 654     llvm::SmallString<128> NodeName = StringRef("::");
 655     llvm::raw_svector_ostream OS(NodeName);
 656
 657     PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy();
 658     Policy.SuppressUnwrittenScope = SkipUnwritten;
 659     Policy.SuppressInlineNamespace =
 660         SkipUnwritten ? PrintingPolicy::SuppressInlineNamespaceMode::All
 661                       : PrintingPolicy::SuppressInlineNamespaceMode::None;
 662     Node.printQualifiedName(OS, Policy);
 663
 664     const StringRef FullName = OS.str();
 665
 666     for (const StringRef Pattern : Names) {
 667       if (Pattern.starts_with("::")) {
 668         if (FullName == Pattern)
 669           return true;
 670       } else if (FullName.ends_with(Pattern) &&
 671                  FullName.drop_back(Pattern.size()).ends_with("::")) {
 672         return true;
 673       }
 674     }
 675   }
 676
 677   return false;
 678 }
 679
 680 bool HasNameMatcher::matchesNode(const NamedDecl &Node) const {
 681   assert(matchesNodeFullFast(Node) == matchesNodeFullSlow(Node));
 682   if (UseUnqualifiedMatch) {
 683     assert(matchesNodeUnqualified(Node) == matchesNodeFullFast(Node));
 684     return matchesNodeUnqualified(Node);
 685   }
 686   return matchesNodeFullFast(Node);
 687 }
 688
 689 // Checks whether \p Loc points to a token with source text of \p TokenText.
 690 static bool isTokenAtLoc(const SourceManager &SM, const LangOptions &LangOpts,
 691                          StringRef Text, SourceLocation Loc) {
 692   llvm::SmallString<16> Buffer;
 693   bool Invalid = false;
 694   // Since `Loc` may point into an expansion buffer, which has no corresponding
 695   // source, we need to look at the spelling location to read the actual source.
 696   StringRef TokenText = Lexer::getSpelling(SM.getSpellingLoc(Loc), Buffer, SM,
 697                                            LangOpts, &Invalid);
 698   return !Invalid && Text == TokenText;
 699 }
 700
 701 static std::optional<SourceLocation> getExpansionLocOfMacroRecursive(
 702     StringRef MacroName, SourceLocation Loc, const ASTContext &Context,
 703     llvm::DenseSet<SourceLocation> &CheckedLocations) {
 704   auto &SM = Context.getSourceManager();
 705   const LangOptions &LangOpts = Context.getLangOpts();
 706   while (Loc.isMacroID()) {
 707     if (CheckedLocations.count(Loc))
 708       return std::nullopt;
 709     CheckedLocations.insert(Loc);
 710     SrcMgr::ExpansionInfo Expansion =
 711         SM.getSLocEntry(SM.getFileID(Loc)).getExpansion();
 712     if (Expansion.isMacroArgExpansion()) {
 713       // Check macro argument for an expansion of the given macro. For example,
 714       // `F(G(3))`, where `MacroName` is `G`.
 715       if (std::optional<SourceLocation> ArgLoc =
 716               getExpansionLocOfMacroRecursive(MacroName,
 717                                               Expansion.getSpellingLoc(),
 718                                               Context, CheckedLocations)) {
 719         return ArgLoc;
 720       }
 721     }
 722     Loc = Expansion.getExpansionLocStart();
 723     if (isTokenAtLoc(SM, LangOpts, MacroName, Loc))
 724       return Loc;
 725   }
 726   return std::nullopt;
 727 }
 728
 729 std::optional<SourceLocation>
 730 getExpansionLocOfMacro(StringRef MacroName, SourceLocation Loc,
 731                        const ASTContext &Context) {
 732   llvm::DenseSet<SourceLocation> CheckedLocations;
 733   return getExpansionLocOfMacroRecursive(MacroName, Loc, Context,
 734                                          CheckedLocations);
 735 }
 736
 737 std::shared_ptr<llvm::Regex> createAndVerifyRegex(StringRef Regex,
 738                                                   llvm::Regex::RegexFlags Flags,
 739                                                   StringRef MatcherID) {
 740   assert(!Regex.empty() && "Empty regex string");
 741   auto SharedRegex = std::make_shared<llvm::Regex>(Regex, Flags);
 742   std::string Error;
 743   if (!SharedRegex->isValid(Error)) {
 744     llvm::WithColor::error()
 745         << "building matcher '" << MatcherID << "': " << Error << "\n";
 746     llvm::WithColor::note() << " input was '" << Regex << "'\n";
 747   }
 748   return SharedRegex;
 749 }
 750 } // end namespace internal
 751
 752 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAutoreleasePoolStmt>
 753     autoreleasePoolStmt;
 754 const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
 755     translationUnitDecl;
 756 const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> typedefDecl;
 757 const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
 758     typedefNameDecl;
 759 const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> typeAliasDecl;
 760 const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
 761     typeAliasTemplateDecl;
 762 const internal::VariadicAllOfMatcher<Decl> decl;
 763 const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl> decompositionDecl;
 764 const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl> bindingDecl;
 765 const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
 766     linkageSpecDecl;
 767 const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl;
 768 const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl;
 769 const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> namespaceDecl;
 770 const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
 771     namespaceAliasDecl;
 772 const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl;
 773 const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> cxxRecordDecl;
 774 const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
 775     classTemplateDecl;
 776 const internal::VariadicDynCastAllOfMatcher<Decl,
 777                                             ClassTemplateSpecializationDecl>
 778     classTemplateSpecializationDecl;
 779 const internal::VariadicDynCastAllOfMatcher<
 780     Decl, ClassTemplatePartialSpecializationDecl>
 781     classTemplatePartialSpecializationDecl;
 782 const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
 783     declaratorDecl;
 784 const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> parmVarDecl;
 785 const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
 786     accessSpecDecl;
 787 const internal::VariadicAllOfMatcher<CXXBaseSpecifier> cxxBaseSpecifier;
 788 const internal::VariadicAllOfMatcher<CXXCtorInitializer> cxxCtorInitializer;
 789 const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
 790 const internal::VariadicAllOfMatcher<TemplateArgumentLoc> templateArgumentLoc;
 791 const internal::VariadicAllOfMatcher<TemplateName> templateName;
 792 const internal::VariadicDynCastAllOfMatcher<Decl, NonTypeTemplateParmDecl>
 793     nonTypeTemplateParmDecl;
 794 const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
 795     templateTypeParmDecl;
 796 const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTemplateParmDecl>
 797     templateTemplateParmDecl;
 798
 799 const internal::VariadicAllOfMatcher<LambdaCapture> lambdaCapture;
 800 const internal::VariadicAllOfMatcher<QualType> qualType;
 801 const internal::VariadicAllOfMatcher<Type> type;
 802 const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
 803
 804 const internal::VariadicDynCastAllOfMatcher<TypeLoc, QualifiedTypeLoc>
 805     qualifiedTypeLoc;
 806 const internal::VariadicDynCastAllOfMatcher<TypeLoc, PointerTypeLoc>
 807     pointerTypeLoc;
 808 const internal::VariadicDynCastAllOfMatcher<TypeLoc, ReferenceTypeLoc>
 809     referenceTypeLoc;
 810 const internal::VariadicDynCastAllOfMatcher<TypeLoc,
 811                                             TemplateSpecializationTypeLoc>
 812     templateSpecializationTypeLoc;
 813 const internal::VariadicDynCastAllOfMatcher<TypeLoc, ElaboratedTypeLoc>
 814     elaboratedTypeLoc;
 815
 816 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryExprOrTypeTraitExpr>
 817     unaryExprOrTypeTraitExpr;
 818 const internal::VariadicDynCastAllOfMatcher<Decl, ExportDecl> exportDecl;
 819 const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
 820 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
 821     cxxConstructorDecl;
 822 const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
 823     cxxDestructorDecl;
 824 const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
 825 const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
 826     enumConstantDecl;
 827 const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl;
 828 const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> cxxMethodDecl;
 829 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
 830     cxxConversionDecl;
 831 const internal::VariadicDynCastAllOfMatcher<Decl, ConceptDecl> conceptDecl;
 832 const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
 833 const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
 834 const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
 835     indirectFieldDecl;
 836 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl;
 837 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
 838     functionTemplateDecl;
 839 const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
 840 const internal::VariadicAllOfMatcher<Stmt> stmt;
 841 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
 842 const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
 843 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
 844     unresolvedMemberExpr;
 845 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDependentScopeMemberExpr>
 846     cxxDependentScopeMemberExpr;
 847 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
 848 const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
 849 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
 850     cxxMemberCallExpr;
 851 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
 852     objcMessageExpr;
 853 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
 854     objcInterfaceDecl;
 855 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
 856     objcImplementationDecl;
 857 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
 858     objcProtocolDecl;
 859 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
 860     objcCategoryDecl;
 861 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
 862     objcCategoryImplDecl;
 863 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
 864     objcMethodDecl;
 865 const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
 866     blockDecl;
 867 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> objcIvarDecl;
 868 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
 869     objcPropertyDecl;
 870 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
 871     objcThrowStmt;
 872 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> objcTryStmt;
 873 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
 874     objcCatchStmt;
 875 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
 876     objcFinallyStmt;
 877 const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
 878     exprWithCleanups;
 879 const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
 880 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStdInitializerListExpr>
 881     cxxStdInitializerListExpr;
 882 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
 883     implicitValueInitExpr;
 884 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> parenListExpr;
 885 const internal::VariadicDynCastAllOfMatcher<Stmt, SubstNonTypeTemplateParmExpr>
 886     substNonTypeTemplateParmExpr;
 887 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
 888 const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl> usingEnumDecl;
 889 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
 890     usingDirectiveDecl;
 891 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
 892     unresolvedLookupExpr;
 893 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingValueDecl>
 894     unresolvedUsingValueDecl;
 895 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingTypenameDecl>
 896     unresolvedUsingTypenameDecl;
 897 const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr;
 898 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
 899 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
 900     cxxConstructExpr;
 901 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXUnresolvedConstructExpr>
 902     cxxUnresolvedConstructExpr;
 903 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> cxxThisExpr;
 904 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
 905     cxxBindTemporaryExpr;
 906 const internal::VariadicDynCastAllOfMatcher<Stmt, MaterializeTemporaryExpr>
 907     materializeTemporaryExpr;
 908 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
 909 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> cxxDeleteExpr;
 910 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
 911     cxxNoexceptExpr;
 912 const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
 913     arraySubscriptExpr;
 914 const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitIndexExpr>
 915     arrayInitIndexExpr;
 916 const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitLoopExpr>
 917     arrayInitLoopExpr;
 918 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
 919     cxxDefaultArgExpr;
 920 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
 921     cxxOperatorCallExpr;
 922 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXRewrittenBinaryOperator>
 923     cxxRewrittenBinaryOperator;
 924 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFoldExpr> cxxFoldExpr;
 925 const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
 926 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr;
 927 const internal::VariadicDynCastAllOfMatcher<Stmt, DependentScopeDeclRefExpr>
 928     dependentScopeDeclRefExpr;
 929 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> objcIvarRefExpr;
 930 const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
 931 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
 932 const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
 933 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
 934     cxxForRangeStmt;
 935 const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
 936 const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
 937 const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
 938 const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt;
 939 const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt> coreturnStmt;
 940 const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
 941 const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
 942 const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
 943 const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> addrLabelExpr;
 944 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
 945 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
 946 const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
 947 const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt;
 948 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt;
 949 const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
 950     coroutineBodyStmt;
 951 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt;
 952 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
 953 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr;
 954 const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
 955 const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
 956 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
 957     cxxBoolLiteral;
 958 const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> stringLiteral;
 959 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral> objcStringLiteral;
 960 const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
 961     characterLiteral;
 962 const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
 963     integerLiteral;
 964 const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral;
 965 const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral;
 966 const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
 967     fixedPointLiteral;
 968 const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
 969     userDefinedLiteral;
 970 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
 971     compoundLiteralExpr;
 972 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
 973     cxxNullPtrLiteralExpr;
 974 const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> chooseExpr;
 975 const internal::VariadicDynCastAllOfMatcher<Stmt, ConvertVectorExpr>
 976     convertVectorExpr;
 977 const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
 978     coawaitExpr;
 979 const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
 980     dependentCoawaitExpr;
 981 const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
 982     coyieldExpr;
 983 const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr;
 984 const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
 985     genericSelectionExpr;
 986 const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
 987 const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
 988 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
 989     binaryOperator;
 990 const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr,
 991                                 CXXRewrittenBinaryOperator>
 992     binaryOperation;
 993 const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation;
 994 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> unaryOperator;
 995 const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
 996     conditionalOperator;
 997 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryConditionalOperator>
 998     binaryConditionalOperator;
 999 const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
1000     opaqueValueExpr;
1001 const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
1002     staticAssertDecl;
1003 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
1004     cxxReinterpretCastExpr;
1005 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
1006     cxxStaticCastExpr;
1007 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
1008     cxxDynamicCastExpr;
1009 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
1010     cxxConstCastExpr;
1011 const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
1012     cStyleCastExpr;
1013 const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
1014     explicitCastExpr;
1015 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
1016     implicitCastExpr;
1017 const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
1018 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
1019     cxxFunctionalCastExpr;
1020 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
1021     cxxTemporaryObjectExpr;
1022 const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
1023     predefinedExpr;
1024 const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
1025     designatedInitExpr;
1026 const internal::VariadicOperatorMatcherFunc<
1027     2, std::numeric_limits<unsigned>::max()>
1028     eachOf = {internal::DynTypedMatcher::VO_EachOf};
1029 const internal::VariadicOperatorMatcherFunc<
1030     2, std::numeric_limits<unsigned>::max()>
1031     anyOf = {internal::DynTypedMatcher::VO_AnyOf};
1032 const internal::VariadicOperatorMatcherFunc<
1033     2, std::numeric_limits<unsigned>::max()>
1034     allOf = {internal::DynTypedMatcher::VO_AllOf};
1035 const internal::VariadicOperatorMatcherFunc<1, 1> optionally = {
1036     internal::DynTypedMatcher::VO_Optionally};
1037 const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
1038                                  internal::hasAnyNameFunc>
1039     hasAnyName = {};
1040
1041 const internal::VariadicFunction<internal::HasOpNameMatcher, StringRef,
1042                                  internal::hasAnyOperatorNameFunc>
1043     hasAnyOperatorName = {};
1044 const internal::VariadicFunction<internal::HasOverloadOpNameMatcher, StringRef,
1045                                  internal::hasAnyOverloadedOperatorNameFunc>
1046     hasAnyOverloadedOperatorName = {};
1047 const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>, StringRef,
1048                                  internal::hasAnySelectorFunc>
1049     hasAnySelector = {};
1050 const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has = {};
1051 const internal::ArgumentAdaptingMatcherFunc<internal::HasDescendantMatcher>
1052     hasDescendant = {};
1053 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> forEach =
1054     {};
1055 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachDescendantMatcher>
1056     forEachDescendant = {};
1057 const internal::ArgumentAdaptingMatcherFunc<
1058     internal::HasParentMatcher,
1059     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
1060     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
1061     hasParent = {};
1062 const internal::ArgumentAdaptingMatcherFunc<
1063     internal::HasAncestorMatcher,
1064     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
1065     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
1066     hasAncestor = {};
1067 const internal::VariadicOperatorMatcherFunc<1, 1> unless = {
1068     internal::DynTypedMatcher::VO_UnaryNot};
1069 const internal::VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
1070 const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
1071     nestedNameSpecifierLoc;
1072 const internal::VariadicAllOfMatcher<Attr> attr;
1073 const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
1074     cudaKernelCallExpr;
1075 const AstTypeMatcher<BuiltinType> builtinType;
1076 const AstTypeMatcher<ArrayType> arrayType;
1077 const AstTypeMatcher<ComplexType> complexType;
1078 const AstTypeMatcher<ConstantArrayType> constantArrayType;
1079 const AstTypeMatcher<DeducedTemplateSpecializationType>
1080     deducedTemplateSpecializationType;
1081 const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
1082 const AstTypeMatcher<DependentSizedExtVectorType> dependentSizedExtVectorType;
1083 const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
1084 const AstTypeMatcher<VariableArrayType> variableArrayType;
1085 const AstTypeMatcher<AtomicType> atomicType;
1086 const AstTypeMatcher<AutoType> autoType;
1087 const AstTypeMatcher<DecltypeType> decltypeType;
1088 const AstTypeMatcher<FunctionType> functionType;
1089 const AstTypeMatcher<FunctionProtoType> functionProtoType;
1090 const AstTypeMatcher<ParenType> parenType;
1091 const AstTypeMatcher<BlockPointerType> blockPointerType;
1092 const AstTypeMatcher<MacroQualifiedType> macroQualifiedType;
1093 const AstTypeMatcher<MemberPointerType> memberPointerType;
1094 const AstTypeMatcher<PointerType> pointerType;
1095 const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
1096 const AstTypeMatcher<ReferenceType> referenceType;
1097 const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
1098 const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
1099 const AstTypeMatcher<TypedefType> typedefType;
1100 const AstTypeMatcher<EnumType> enumType;
1101 const AstTypeMatcher<TemplateSpecializationType> templateSpecializationType;
1102 const AstTypeMatcher<UnaryTransformType> unaryTransformType;
1103 const AstTypeMatcher<RecordType> recordType;
1104 const AstTypeMatcher<TagType> tagType;
1105 const AstTypeMatcher<ElaboratedType> elaboratedType;
1106 const AstTypeMatcher<UsingType> usingType;
1107 const AstTypeMatcher<SubstTemplateTypeParmType> substTemplateTypeParmType;
1108 const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
1109 const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
1110 const AstTypeMatcher<DecayedType> decayedType;
1111 const AstTypeMatcher<DependentNameType> dependentNameType;
1112 const AstTypeMatcher<DependentTemplateSpecializationType>
1113     dependentTemplateSpecializationType;
1114 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType,
1115                                  AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType,
1116                                                                  ComplexType));
1117 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType,
1118                                  AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType));
1119 AST_TYPELOC_TRAVERSE_MATCHER_DEF(
1120     pointee,
1121     AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType,
1122                                     PointerType, ReferenceType,
1123                                     ObjCObjectPointerType));
1124
1125 const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
1126     ompExecutableDirective;
1127 const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause>
1128     ompDefaultClause;
1129 const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
1130     cxxDeductionGuideDecl;
1131
1132 } // end namespace ast_matchers
1133 } // end namespace clang