Home | History | Annotate | Line # | Download | only in ASTMatchers 
      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(llvm::all_of(
    472           N, [](StringRef Name) { return Name.find("::") == Name.npos; })),
    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<QualType> qualType;
    772 const internal::VariadicAllOfMatcher<Type> type;
    773 const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
    774 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryExprOrTypeTraitExpr>
    775     unaryExprOrTypeTraitExpr;
    776 const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
    777 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
    778     cxxConstructorDecl;
    779 const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
    780     cxxDestructorDecl;
    781 const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
    782 const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
    783     enumConstantDecl;
    784 const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl;
    785 const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> cxxMethodDecl;
    786 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
    787     cxxConversionDecl;
    788 const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
    789 const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
    790 const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
    791     indirectFieldDecl;
    792 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl;
    793 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
    794     functionTemplateDecl;
    795 const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
    796 const internal::VariadicAllOfMatcher<Stmt> stmt;
    797 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
    798 const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
    799 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
    800     unresolvedMemberExpr;
    801 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDependentScopeMemberExpr>
    802     cxxDependentScopeMemberExpr;
    803 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
    804 const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
    805 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
    806     cxxMemberCallExpr;
    807 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
    808     objcMessageExpr;
    809 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
    810     objcInterfaceDecl;
    811 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
    812     objcImplementationDecl;
    813 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
    814     objcProtocolDecl;
    815 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
    816     objcCategoryDecl;
    817 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
    818     objcCategoryImplDecl;
    819 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
    820     objcMethodDecl;
    821 const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
    822     blockDecl;
    823 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> objcIvarDecl;
    824 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
    825     objcPropertyDecl;
    826 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
    827     objcThrowStmt;
    828 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> objcTryStmt;
    829 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
    830     objcCatchStmt;
    831 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
    832     objcFinallyStmt;
    833 const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
    834     exprWithCleanups;
    835 const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
    836 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStdInitializerListExpr>
    837     cxxStdInitializerListExpr;
    838 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
    839     implicitValueInitExpr;
    840 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> parenListExpr;
    841 const internal::VariadicDynCastAllOfMatcher<Stmt, SubstNonTypeTemplateParmExpr>
    842     substNonTypeTemplateParmExpr;
    843 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
    844 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
    845     usingDirectiveDecl;
    846 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
    847     unresolvedLookupExpr;
    848 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingValueDecl>
    849     unresolvedUsingValueDecl;
    850 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingTypenameDecl>
    851     unresolvedUsingTypenameDecl;
    852 const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr;
    853 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
    854 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
    855     cxxConstructExpr;
    856 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXUnresolvedConstructExpr>
    857     cxxUnresolvedConstructExpr;
    858 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> cxxThisExpr;
    859 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
    860     cxxBindTemporaryExpr;
    861 const internal::VariadicDynCastAllOfMatcher<Stmt, MaterializeTemporaryExpr>
    862     materializeTemporaryExpr;
    863 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
    864 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> cxxDeleteExpr;
    865 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
    866     cxxNoexceptExpr;
    867 const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
    868     arraySubscriptExpr;
    869 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
    870     cxxDefaultArgExpr;
    871 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
    872     cxxOperatorCallExpr;
    873 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXRewrittenBinaryOperator>
    874     cxxRewrittenBinaryOperator;
    875 const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
    876 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr;
    877 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> objcIvarRefExpr;
    878 const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
    879 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
    880 const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
    881 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
    882     cxxForRangeStmt;
    883 const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
    884 const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
    885 const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
    886 const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt;
    887 const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt> coreturnStmt;
    888 const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
    889 const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
    890 const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
    891 const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> addrLabelExpr;
    892 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
    893 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
    894 const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
    895 const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt;
    896 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt;
    897 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt;
    898 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
    899 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr;
    900 const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
    901 const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
    902 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
    903     cxxBoolLiteral;
    904 const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> stringLiteral;
    905 const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
    906     characterLiteral;
    907 const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
    908     integerLiteral;
    909 const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral;
    910 const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral;
    911 const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
    912     fixedPointLiteral;
    913 const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
    914     userDefinedLiteral;
    915 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
    916     compoundLiteralExpr;
    917 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
    918     cxxNullPtrLiteralExpr;
    919 const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> chooseExpr;
    920 const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
    921     coawaitExpr;
    922 const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
    923     dependentCoawaitExpr;
    924 const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
    925     coyieldExpr;
    926 const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr;
    927 const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
    928     genericSelectionExpr;
    929 const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
    930 const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
    931 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
    932     binaryOperator;
    933 const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr,
    934                                 CXXRewrittenBinaryOperator>
    935     binaryOperation;
    936 const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation;
    937 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> unaryOperator;
    938 const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
    939     conditionalOperator;
    940 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryConditionalOperator>
    941     binaryConditionalOperator;
    942 const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
    943     opaqueValueExpr;
    944 const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
    945     staticAssertDecl;
    946 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
    947     cxxReinterpretCastExpr;
    948 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
    949     cxxStaticCastExpr;
    950 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
    951     cxxDynamicCastExpr;
    952 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
    953     cxxConstCastExpr;
    954 const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
    955     cStyleCastExpr;
    956 const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
    957     explicitCastExpr;
    958 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
    959     implicitCastExpr;
    960 const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
    961 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
    962     cxxFunctionalCastExpr;
    963 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
    964     cxxTemporaryObjectExpr;
    965 const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
    966     predefinedExpr;
    967 const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
    968     designatedInitExpr;
    969 const internal::VariadicOperatorMatcherFunc<
    970     2, std::numeric_limits<unsigned>::max()>
    971     eachOf = {internal::DynTypedMatcher::VO_EachOf};
    972 const internal::VariadicOperatorMatcherFunc<
    973     2, std::numeric_limits<unsigned>::max()>
    974     anyOf = {internal::DynTypedMatcher::VO_AnyOf};
    975 const internal::VariadicOperatorMatcherFunc<
    976     2, std::numeric_limits<unsigned>::max()>
    977     allOf = {internal::DynTypedMatcher::VO_AllOf};
    978 const internal::VariadicOperatorMatcherFunc<1, 1> optionally = {
    979     internal::DynTypedMatcher::VO_Optionally};
    980 const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
    981                                  internal::hasAnyNameFunc>
    982     hasAnyName = {};
    983 
    984 const internal::VariadicFunction<internal::HasOpNameMatcher, StringRef,
    985                                  internal::hasAnyOperatorNameFunc>
    986     hasAnyOperatorName = {};
    987 const internal::VariadicFunction<internal::HasOverloadOpNameMatcher, StringRef,
    988                                  internal::hasAnyOverloadedOperatorNameFunc>
    989     hasAnyOverloadedOperatorName = {};
    990 const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>, StringRef,
    991                                  internal::hasAnySelectorFunc>
    992     hasAnySelector = {};
    993 const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has = {};
    994 const internal::ArgumentAdaptingMatcherFunc<internal::HasDescendantMatcher>
    995     hasDescendant = {};
    996 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> forEach =
    997     {};
    998 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachDescendantMatcher>
    999     forEachDescendant = {};
   1000 const internal::ArgumentAdaptingMatcherFunc<
   1001     internal::HasParentMatcher,
   1002     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>,
   1003     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>>
   1004     hasParent = {};
   1005 const internal::ArgumentAdaptingMatcherFunc<
   1006     internal::HasAncestorMatcher,
   1007     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>,
   1008     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>>
   1009     hasAncestor = {};
   1010 const internal::VariadicOperatorMatcherFunc<1, 1> unless = {
   1011     internal::DynTypedMatcher::VO_UnaryNot};
   1012 const internal::VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
   1013 const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
   1014     nestedNameSpecifierLoc;
   1015 const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
   1016     cudaKernelCallExpr;
   1017 const AstTypeMatcher<BuiltinType> builtinType;
   1018 const AstTypeMatcher<ArrayType> arrayType;
   1019 const AstTypeMatcher<ComplexType> complexType;
   1020 const AstTypeMatcher<ConstantArrayType> constantArrayType;
   1021 const AstTypeMatcher<DeducedTemplateSpecializationType>
   1022     deducedTemplateSpecializationType;
   1023 const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
   1024 const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
   1025 const AstTypeMatcher<VariableArrayType> variableArrayType;
   1026 const AstTypeMatcher<AtomicType> atomicType;
   1027 const AstTypeMatcher<AutoType> autoType;
   1028 const AstTypeMatcher<DecltypeType> decltypeType;
   1029 const AstTypeMatcher<FunctionType> functionType;
   1030 const AstTypeMatcher<FunctionProtoType> functionProtoType;
   1031 const AstTypeMatcher<ParenType> parenType;
   1032 const AstTypeMatcher<BlockPointerType> blockPointerType;
   1033 const AstTypeMatcher<MemberPointerType> memberPointerType;
   1034 const AstTypeMatcher<PointerType> pointerType;
   1035 const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
   1036 const AstTypeMatcher<ReferenceType> referenceType;
   1037 const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
   1038 const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
   1039 const AstTypeMatcher<TypedefType> typedefType;
   1040 const AstTypeMatcher<EnumType> enumType;
   1041 const AstTypeMatcher<TemplateSpecializationType> templateSpecializationType;
   1042 const AstTypeMatcher<UnaryTransformType> unaryTransformType;
   1043 const AstTypeMatcher<RecordType> recordType;
   1044 const AstTypeMatcher<TagType> tagType;
   1045 const AstTypeMatcher<ElaboratedType> elaboratedType;
   1046 const AstTypeMatcher<SubstTemplateTypeParmType> substTemplateTypeParmType;
   1047 const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
   1048 const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
   1049 const AstTypeMatcher<DecayedType> decayedType;
   1050 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType,
   1051                                  AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType,
   1052                                                                  ComplexType));
   1053 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType,
   1054                                  AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType));
   1055 AST_TYPELOC_TRAVERSE_MATCHER_DEF(
   1056     pointee,
   1057     AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType,
   1058                                     PointerType, ReferenceType));
   1059 
   1060 const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
   1061     ompExecutableDirective;
   1062 const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause>
   1063     ompDefaultClause;
   1064 const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
   1065     cxxDeductionGuideDecl;
   1066 
   1067 } // end namespace ast_matchers
   1068 } // end namespace clang
   1069