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