contrib/llvm/tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp

   1 //===- ASTMatchersInternal.cpp - Structural query framework ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  Implements the base layer of the matcher framework.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/ASTMatchers/ASTMatchersInternal.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/ASTTypeTraits.h"
  17 #include "clang/AST/Decl.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/PrettyPrinter.h"
  20 #include "clang/ASTMatchers/ASTMatchers.h"
  21 #include "clang/Basic/LLVM.h"
  22 #include "llvm/ADT/ArrayRef.h"
  23 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  24 #include "llvm/ADT/None.h"
  25 #include "llvm/ADT/SmallString.h"
  26 #include "llvm/ADT/SmallVector.h"
  27 #include "llvm/ADT/StringRef.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30 #include "llvm/Support/ManagedStatic.h"
  31 #include "llvm/Support/raw_ostream.h"
  32 #include <algorithm>
  33 #include <cassert>
  34 #include <cstddef>
  35 #include <string>
  36 #include <utility>
  37 #include <vector>
  38
  39 namespace clang {
  40 namespace ast_matchers {
  41
  42 AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector<std::string>,
  43               Matches) {
  44   std::string SelString = Node.getSelector().getAsString();
  45   for (const std::string &S : Matches)
  46     if (S == SelString)
  47       return true;
  48   return false;
  49 }
  50
  51 namespace internal {
  52
  53 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
  54                       ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
  55                       ArrayRef<DynTypedMatcher> InnerMatchers);
  56
  57 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
  58                            ASTMatchFinder *Finder,
  59                            BoundNodesTreeBuilder *Builder,
  60                            ArrayRef<DynTypedMatcher> InnerMatchers);
  61
  62 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
  63                             ASTMatchFinder *Finder,
  64                             BoundNodesTreeBuilder *Builder,
  65                             ArrayRef<DynTypedMatcher> InnerMatchers);
  66
  67 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
  68                            ASTMatchFinder *Finder,
  69                            BoundNodesTreeBuilder *Builder,
  70                            ArrayRef<DynTypedMatcher> InnerMatchers);
  71
  72 void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) {
  73   if (Bindings.empty())
  74     Bindings.push_back(BoundNodesMap());
  75   for (BoundNodesMap &Binding : Bindings) {
  76     ResultVisitor->visitMatch(BoundNodes(Binding));
  77   }
  78 }
  79
  80 namespace {
  81
  82 using VariadicOperatorFunction = bool (*)(
  83     const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder,
  84     BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
  85
  86 template <VariadicOperatorFunction Func>
  87 class VariadicMatcher : public DynMatcherInterface {
  88 public:
  89   VariadicMatcher(std::vector<DynTypedMatcher> InnerMatchers)
  90       : InnerMatchers(std::move(InnerMatchers)) {}
  91
  92   bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
  93                   ASTMatchFinder *Finder,
  94                   BoundNodesTreeBuilder *Builder) const override {
  95     return Func(DynNode, Finder, Builder, InnerMatchers);
  96   }
  97
  98 private:
  99   std::vector<DynTypedMatcher> InnerMatchers;
 100 };
 101
 102 class IdDynMatcher : public DynMatcherInterface {
 103 public:
 104   IdDynMatcher(StringRef ID,
 105                IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
 106       : ID(ID), InnerMatcher(std::move(InnerMatcher)) {}
 107
 108   bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
 109                   ASTMatchFinder *Finder,
 110                   BoundNodesTreeBuilder *Builder) const override {
 111     bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder);
 112     if (Result) Builder->setBinding(ID, DynNode);
 113     return Result;
 114   }
 115
 116 private:
 117   const std::string ID;
 118   const IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
 119 };
 120
 121 /// A matcher that always returns true.
 122 ///
 123 /// We only ever need one instance of this matcher, so we create a global one
 124 /// and reuse it to reduce the overhead of the matcher and increase the chance
 125 /// of cache hits.
 126 class TrueMatcherImpl : public DynMatcherInterface {
 127 public:
 128   TrueMatcherImpl() {
 129     Retain(); // Reference count will never become zero.
 130   }
 131
 132   bool dynMatches(const ast_type_traits::DynTypedNode &, ASTMatchFinder *,
 133                   BoundNodesTreeBuilder *) const override {
 134     return true;
 135   }
 136 };
 137
 138 } // namespace
 139
 140 static llvm::ManagedStatic<TrueMatcherImpl> TrueMatcherInstance;
 141
 142 DynTypedMatcher DynTypedMatcher::constructVariadic(
 143     DynTypedMatcher::VariadicOperator Op,
 144     ast_type_traits::ASTNodeKind SupportedKind,
 145     std::vector<DynTypedMatcher> InnerMatchers) {
 146   assert(!InnerMatchers.empty() && "Array must not be empty.");
 147   assert(llvm::all_of(InnerMatchers,
 148                       [SupportedKind](const DynTypedMatcher &M) {
 149                         return M.canConvertTo(SupportedKind);
 150                       }) &&
 151          "InnerMatchers must be convertible to SupportedKind!");
 152
 153   // We must relax the restrict kind here.
 154   // The different operators might deal differently with a mismatch.
 155   // Make it the same as SupportedKind, since that is the broadest type we are
 156   // allowed to accept.
 157   auto RestrictKind = SupportedKind;
 158
 159   switch (Op) {
 160   case VO_AllOf:
 161     // In the case of allOf() we must pass all the checks, so making
 162     // RestrictKind the most restrictive can save us time. This way we reject
 163     // invalid types earlier and we can elide the kind checks inside the
 164     // matcher.
 165     for (auto &IM : InnerMatchers) {
 166       RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType(
 167           RestrictKind, IM.RestrictKind);
 168     }
 169     return DynTypedMatcher(
 170         SupportedKind, RestrictKind,
 171         new VariadicMatcher<AllOfVariadicOperator>(std::move(InnerMatchers)));
 172
 173   case VO_AnyOf:
 174     return DynTypedMatcher(
 175         SupportedKind, RestrictKind,
 176         new VariadicMatcher<AnyOfVariadicOperator>(std::move(InnerMatchers)));
 177
 178   case VO_EachOf:
 179     return DynTypedMatcher(
 180         SupportedKind, RestrictKind,
 181         new VariadicMatcher<EachOfVariadicOperator>(std::move(InnerMatchers)));
 182
 183   case VO_UnaryNot:
 184     // FIXME: Implement the Not operator to take a single matcher instead of a
 185     // vector.
 186     return DynTypedMatcher(
 187         SupportedKind, RestrictKind,
 188         new VariadicMatcher<NotUnaryOperator>(std::move(InnerMatchers)));
 189   }
 190   llvm_unreachable("Invalid Op value.");
 191 }
 192
 193 DynTypedMatcher DynTypedMatcher::trueMatcher(
 194     ast_type_traits::ASTNodeKind NodeKind) {
 195   return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance);
 196 }
 197
 198 bool DynTypedMatcher::canMatchNodesOfKind(
 199     ast_type_traits::ASTNodeKind Kind) const {
 200   return RestrictKind.isBaseOf(Kind);
 201 }
 202
 203 DynTypedMatcher DynTypedMatcher::dynCastTo(
 204     const ast_type_traits::ASTNodeKind Kind) const {
 205   auto Copy = *this;
 206   Copy.SupportedKind = Kind;
 207   Copy.RestrictKind =
 208       ast_type_traits::ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
 209   return Copy;
 210 }
 211
 212 bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode,
 213                               ASTMatchFinder *Finder,
 214                               BoundNodesTreeBuilder *Builder) const {
 215   if (RestrictKind.isBaseOf(DynNode.getNodeKind()) &&
 216       Implementation->dynMatches(DynNode, Finder, Builder)) {
 217     return true;
 218   }
 219   // Delete all bindings when a matcher does not match.
 220   // This prevents unexpected exposure of bound nodes in unmatches
 221   // branches of the match tree.
 222   Builder->removeBindings([](const BoundNodesMap &) { return true; });
 223   return false;
 224 }
 225
 226 bool DynTypedMatcher::matchesNoKindCheck(
 227     const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder,
 228     BoundNodesTreeBuilder *Builder) const {
 229   assert(RestrictKind.isBaseOf(DynNode.getNodeKind()));
 230   if (Implementation->dynMatches(DynNode, Finder, Builder)) {
 231     return true;
 232   }
 233   // Delete all bindings when a matcher does not match.
 234   // This prevents unexpected exposure of bound nodes in unmatches
 235   // branches of the match tree.
 236   Builder->removeBindings([](const BoundNodesMap &) { return true; });
 237   return false;
 238 }
 239
 240 llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
 241   if (!AllowBind) return llvm::None;
 242   auto Result = *this;
 243   Result.Implementation =
 244       new IdDynMatcher(ID, std::move(Result.Implementation));
 245   return std::move(Result);
 246 }
 247
 248 bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const {
 249   const auto From = getSupportedKind();
 250   auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>();
 251   auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind<Type>();
 252   /// Mimic the implicit conversions of Matcher<>.
 253   /// - From Matcher<Type> to Matcher<QualType>
 254   if (From.isSame(TypeKind) && To.isSame(QualKind)) return true;
 255   /// - From Matcher<Base> to Matcher<Derived>
 256   return From.isBaseOf(To);
 257 }
 258
 259 void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) {
 260   Bindings.append(Other.Bindings.begin(), Other.Bindings.end());
 261 }
 262
 263 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
 264                       ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
 265                       ArrayRef<DynTypedMatcher> InnerMatchers) {
 266   if (InnerMatchers.size() != 1)
 267     return false;
 268
 269   // The 'unless' matcher will always discard the result:
 270   // If the inner matcher doesn't match, unless returns true,
 271   // but the inner matcher cannot have bound anything.
 272   // If the inner matcher matches, the result is false, and
 273   // any possible binding will be discarded.
 274   // We still need to hand in all the bound nodes up to this
 275   // point so the inner matcher can depend on bound nodes,
 276   // and we need to actively discard the bound nodes, otherwise
 277   // the inner matcher will reset the bound nodes if it doesn't
 278   // match, but this would be inversed by 'unless'.
 279   BoundNodesTreeBuilder Discard(*Builder);
 280   return !InnerMatchers[0].matches(DynNode, Finder, &Discard);
 281 }
 282
 283 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
 284                            ASTMatchFinder *Finder,
 285                            BoundNodesTreeBuilder *Builder,
 286                            ArrayRef<DynTypedMatcher> InnerMatchers) {
 287   // allOf leads to one matcher for each alternative in the first
 288   // matcher combined with each alternative in the second matcher.
 289   // Thus, we can reuse the same Builder.
 290   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
 291     if (!InnerMatcher.matchesNoKindCheck(DynNode, Finder, Builder))
 292       return false;
 293   }
 294   return true;
 295 }
 296
 297 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
 298                             ASTMatchFinder *Finder,
 299                             BoundNodesTreeBuilder *Builder,
 300                             ArrayRef<DynTypedMatcher> InnerMatchers) {
 301   BoundNodesTreeBuilder Result;
 302   bool Matched = false;
 303   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
 304     BoundNodesTreeBuilder BuilderInner(*Builder);
 305     if (InnerMatcher.matches(DynNode, Finder, &BuilderInner)) {
 306       Matched = true;
 307       Result.addMatch(BuilderInner);
 308     }
 309   }
 310   *Builder = std::move(Result);
 311   return Matched;
 312 }
 313
 314 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
 315                            ASTMatchFinder *Finder,
 316                            BoundNodesTreeBuilder *Builder,
 317                            ArrayRef<DynTypedMatcher> InnerMatchers) {
 318   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
 319     BoundNodesTreeBuilder Result = *Builder;
 320     if (InnerMatcher.matches(DynNode, Finder, &Result)) {
 321       *Builder = std::move(Result);
 322       return true;
 323     }
 324   }
 325   return false;
 326 }
 327
 328 inline static
 329 std::vector<std::string> vectorFromRefs(ArrayRef<const StringRef *> NameRefs) {
 330   std::vector<std::string> Names;
 331   for (auto *Name : NameRefs)
 332     Names.emplace_back(*Name);
 333   return Names;
 334 }
 335
 336 Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs) {
 337   std::vector<std::string> Names = vectorFromRefs(NameRefs);
 338   return internal::Matcher<NamedDecl>(new internal::HasNameMatcher(Names));
 339 }
 340
 341 Matcher<ObjCMessageExpr> hasAnySelectorFunc(
 342     ArrayRef<const StringRef *> NameRefs) {
 343   return hasAnySelectorMatcher(vectorFromRefs(NameRefs));
 344 }
 345
 346 HasNameMatcher::HasNameMatcher(std::vector<std::string> N)
 347     : UseUnqualifiedMatch(std::all_of(
 348           N.begin(), N.end(),
 349           [](StringRef Name) { return Name.find("::") == Name.npos; })),
 350       Names(std::move(N)) {
 351 #ifndef NDEBUG
 352   for (StringRef Name : Names)
 353     assert(!Name.empty());
 354 #endif
 355 }
 356
 357 static bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) {
 358   StringRef Name = FullName;
 359   if (!Name.endswith(Suffix))
 360     return false;
 361   Name = Name.drop_back(Suffix.size());
 362   if (!Name.empty()) {
 363     if (!Name.endswith("::"))
 364       return false;
 365     Name = Name.drop_back(2);
 366   }
 367   FullName = Name;
 368   return true;
 369 }
 370
 371 static StringRef getNodeName(const NamedDecl &Node,
 372                              llvm::SmallString<128> &Scratch) {
 373   // Simple name.
 374   if (Node.getIdentifier())
 375     return Node.getName();
 376
 377   if (Node.getDeclName()) {
 378     // Name needs to be constructed.
 379     Scratch.clear();
 380     llvm::raw_svector_ostream OS(Scratch);
 381     Node.printName(OS);
 382     return OS.str();
 383   }
 384
 385   return "(anonymous)";
 386 }
 387
 388 static StringRef getNodeName(const RecordDecl &Node,
 389                              llvm::SmallString<128> &Scratch) {
 390   if (Node.getIdentifier()) {
 391     return Node.getName();
 392   }
 393   Scratch.clear();
 394   return ("(anonymous " + Node.getKindName() + ")").toStringRef(Scratch);
 395 }
 396
 397 static StringRef getNodeName(const NamespaceDecl &Node,
 398                              llvm::SmallString<128> &Scratch) {
 399   return Node.isAnonymousNamespace() ? "(anonymous namespace)" : Node.getName();
 400 }
 401
 402 namespace {
 403
 404 class PatternSet {
 405 public:
 406   PatternSet(ArrayRef<std::string> Names) {
 407     for (StringRef Name : Names)
 408       Patterns.push_back({Name, Name.startswith("::")});
 409   }
 410
 411   /// Consumes the name suffix from each pattern in the set and removes the ones
 412   /// that didn't match.
 413   /// Return true if there are still any patterns left.
 414   bool consumeNameSuffix(StringRef NodeName, bool CanSkip) {
 415     for (size_t I = 0; I < Patterns.size();) {
 416       if (::clang::ast_matchers::internal::consumeNameSuffix(Patterns[I].P,
 417                                                              NodeName) ||
 418           CanSkip) {
 419         ++I;
 420       } else {
 421         Patterns.erase(Patterns.begin() + I);
 422       }
 423     }
 424     return !Patterns.empty();
 425   }
 426
 427   /// Check if any of the patterns are a match.
 428   /// A match will be a pattern that was fully consumed, that also matches the
 429   /// 'fully qualified' requirement.
 430   bool foundMatch(bool AllowFullyQualified) const {
 431     for (auto& P: Patterns)
 432       if (P.P.empty() && (AllowFullyQualified || !P.IsFullyQualified))
 433         return true;
 434     return false;
 435   }
 436
 437 private:
 438   struct Pattern {
 439     StringRef P;
 440     bool IsFullyQualified;
 441   };
 442
 443   llvm::SmallVector<Pattern, 8> Patterns;
 444 };
 445
 446 } // namespace
 447
 448 bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const {
 449   assert(UseUnqualifiedMatch);
 450   llvm::SmallString<128> Scratch;
 451   StringRef NodeName = getNodeName(Node, Scratch);
 452   return llvm::any_of(Names, [&](StringRef Name) {
 453     return consumeNameSuffix(Name, NodeName) && Name.empty();
 454   });
 455 }
 456
 457 bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const {
 458   PatternSet Patterns(Names);
 459   llvm::SmallString<128> Scratch;
 460
 461   // This function is copied and adapted from NamedDecl::printQualifiedName()
 462   // By matching each part individually we optimize in a couple of ways:
 463   //  - We can exit early on the first failure.
 464   //  - We can skip inline/anonymous namespaces without another pass.
 465   //  - We print one name at a time, reducing the chance of overflowing the
 466   //    inlined space of the SmallString.
 467
 468   // First, match the name.
 469   if (!Patterns.consumeNameSuffix(getNodeName(Node, Scratch),
 470                                   /*CanSkip=*/false))
 471     return false;
 472
 473   // Try to match each declaration context.
 474   // We are allowed to skip anonymous and inline namespaces if they don't match.
 475   const DeclContext *Ctx = Node.getDeclContext();
 476
 477   if (Ctx->isFunctionOrMethod())
 478     return Patterns.foundMatch(/*AllowFullyQualified=*/false);
 479
 480   for (; Ctx && isa<NamedDecl>(Ctx); Ctx = Ctx->getParent()) {
 481     if (Patterns.foundMatch(/*AllowFullyQualified=*/false))
 482       return true;
 483
 484     if (const auto *ND = dyn_cast<NamespaceDecl>(Ctx)) {
 485       // If it matches (or we can skip it), continue.
 486       if (Patterns.consumeNameSuffix(getNodeName(*ND, Scratch),
 487                                      /*CanSkip=*/ND->isAnonymousNamespace() ||
 488                                          ND->isInline()))
 489         continue;
 490       return false;
 491     }
 492     if (const auto *RD = dyn_cast<RecordDecl>(Ctx)) {
 493       if (!isa<ClassTemplateSpecializationDecl>(Ctx)) {
 494         if (Patterns.consumeNameSuffix(getNodeName(*RD, Scratch),
 495                                        /*CanSkip=*/false))
 496           continue;
 497
 498         return false;
 499       }
 500     }
 501
 502     // We don't know how to deal with this DeclContext.
 503     // Fallback to the slow version of the code.
 504     return matchesNodeFullSlow(Node);
 505   }
 506
 507   return Patterns.foundMatch(/*AllowFullyQualified=*/true);
 508 }
 509
 510 bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
 511   const bool SkipUnwrittenCases[] = {false, true};
 512   for (bool SkipUnwritten : SkipUnwrittenCases) {
 513     llvm::SmallString<128> NodeName = StringRef("::");
 514     llvm::raw_svector_ostream OS(NodeName);
 515
 516     if (SkipUnwritten) {
 517       PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy();
 518       Policy.SuppressUnwrittenScope = true;
 519       Node.printQualifiedName(OS, Policy);
 520     } else {
 521       Node.printQualifiedName(OS);
 522     }
 523
 524     const StringRef FullName = OS.str();
 525
 526     for (const StringRef Pattern : Names) {
 527       if (Pattern.startswith("::")) {
 528         if (FullName == Pattern)
 529           return true;
 530       } else if (FullName.endswith(Pattern) &&
 531                  FullName.drop_back(Pattern.size()).endswith("::")) {
 532         return true;
 533       }
 534     }
 535   }
 536
 537   return false;
 538 }
 539
 540 bool HasNameMatcher::matchesNode(const NamedDecl &Node) const {
 541   assert(matchesNodeFullFast(Node) == matchesNodeFullSlow(Node));
 542   if (UseUnqualifiedMatch) {
 543     assert(matchesNodeUnqualified(Node) == matchesNodeFullFast(Node));
 544     return matchesNodeUnqualified(Node);
 545   }
 546   return matchesNodeFullFast(Node);
 547 }
 548
 549 } // end namespace internal
 550
 551 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAutoreleasePoolStmt>
 552     autoreleasePoolStmt;
 553 const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
 554     translationUnitDecl;
 555 const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> typedefDecl;
 556 const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
 557     typedefNameDecl;
 558 const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> typeAliasDecl;
 559 const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
 560     typeAliasTemplateDecl;
 561 const internal::VariadicAllOfMatcher<Decl> decl;
 562 const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
 563     linkageSpecDecl;
 564 const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl;
 565 const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl;
 566 const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> namespaceDecl;
 567 const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
 568     namespaceAliasDecl;
 569 const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl;
 570 const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> cxxRecordDecl;
 571 const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
 572     classTemplateDecl;
 573 const internal::VariadicDynCastAllOfMatcher<Decl,
 574                                             ClassTemplateSpecializationDecl>
 575     classTemplateSpecializationDecl;
 576 const internal::VariadicDynCastAllOfMatcher<
 577     Decl, ClassTemplatePartialSpecializationDecl>
 578     classTemplatePartialSpecializationDecl;
 579 const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
 580     declaratorDecl;
 581 const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> parmVarDecl;
 582 const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
 583     accessSpecDecl;
 584 const internal::VariadicAllOfMatcher<CXXCtorInitializer> cxxCtorInitializer;
 585 const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
 586 const internal::VariadicAllOfMatcher<TemplateName> templateName;
 587 const internal::VariadicDynCastAllOfMatcher<Decl, NonTypeTemplateParmDecl>
 588     nonTypeTemplateParmDecl;
 589 const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
 590     templateTypeParmDecl;
 591 const internal::VariadicAllOfMatcher<QualType> qualType;
 592 const internal::VariadicAllOfMatcher<Type> type;
 593 const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
 594 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryExprOrTypeTraitExpr>
 595     unaryExprOrTypeTraitExpr;
 596 const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
 597 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
 598     cxxConstructorDecl;
 599 const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
 600     cxxDestructorDecl;
 601 const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
 602 const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
 603     enumConstantDecl;
 604 const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> cxxMethodDecl;
 605 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
 606     cxxConversionDecl;
 607 const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
 608 const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
 609 const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
 610     indirectFieldDecl;
 611 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl;
 612 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
 613     functionTemplateDecl;
 614 const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
 615 const internal::VariadicAllOfMatcher<Stmt> stmt;
 616 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
 617 const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
 618 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
 619     unresolvedMemberExpr;
 620 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDependentScopeMemberExpr>
 621     cxxDependentScopeMemberExpr;
 622 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
 623 const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
 624 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
 625     cxxMemberCallExpr;
 626 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
 627     objcMessageExpr;
 628 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
 629     objcInterfaceDecl;
 630 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
 631     objcImplementationDecl;
 632 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
 633     objcProtocolDecl;
 634 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
 635     objcCategoryDecl;
 636 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
 637     objcCategoryImplDecl;
 638 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
 639     objcMethodDecl;
 640 const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
 641     blockDecl;
 642 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> objcIvarDecl;
 643 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
 644     objcPropertyDecl;
 645 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
 646     objcThrowStmt;
 647 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> objcTryStmt;
 648 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
 649     objcCatchStmt;
 650 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
 651     objcFinallyStmt;
 652 const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
 653     exprWithCleanups;
 654 const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
 655 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStdInitializerListExpr>
 656     cxxStdInitializerListExpr;
 657 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
 658     implicitValueInitExpr;
 659 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> parenListExpr;
 660 const internal::VariadicDynCastAllOfMatcher<Stmt, SubstNonTypeTemplateParmExpr>
 661     substNonTypeTemplateParmExpr;
 662 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
 663 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
 664     usingDirectiveDecl;
 665 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
 666     unresolvedLookupExpr;
 667 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingValueDecl>
 668     unresolvedUsingValueDecl;
 669 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingTypenameDecl>
 670     unresolvedUsingTypenameDecl;
 671 const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr;
 672 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
 673 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
 674     cxxConstructExpr;
 675 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXUnresolvedConstructExpr>
 676     cxxUnresolvedConstructExpr;
 677 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> cxxThisExpr;
 678 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
 679     cxxBindTemporaryExpr;
 680 const internal::VariadicDynCastAllOfMatcher<Stmt, MaterializeTemporaryExpr>
 681     materializeTemporaryExpr;
 682 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
 683 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> cxxDeleteExpr;
 684 const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
 685     arraySubscriptExpr;
 686 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
 687     cxxDefaultArgExpr;
 688 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
 689     cxxOperatorCallExpr;
 690 const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
 691 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr;
 692 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> objcIvarRefExpr;
 693 const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
 694 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
 695 const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
 696 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
 697     cxxForRangeStmt;
 698 const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
 699 const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
 700 const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
 701 const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt;
 702 const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
 703 const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
 704 const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
 705 const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> addrLabelExpr;
 706 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
 707 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
 708 const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
 709 const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt;
 710 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt;
 711 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt;
 712 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
 713 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr;
 714 const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
 715 const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
 716 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
 717     cxxBoolLiteral;
 718 const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> stringLiteral;
 719 const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
 720     characterLiteral;
 721 const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
 722     integerLiteral;
 723 const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral;
 724 const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral;
 725 const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
 726     userDefinedLiteral;
 727 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
 728     compoundLiteralExpr;
 729 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
 730     cxxNullPtrLiteralExpr;
 731 const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr;
 732 const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
 733 const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
 734 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
 735     binaryOperator;
 736 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> unaryOperator;
 737 const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
 738     conditionalOperator;
 739 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryConditionalOperator>
 740     binaryConditionalOperator;
 741 const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
 742     opaqueValueExpr;
 743 const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
 744     staticAssertDecl;
 745 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
 746     cxxReinterpretCastExpr;
 747 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
 748     cxxStaticCastExpr;
 749 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
 750     cxxDynamicCastExpr;
 751 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
 752     cxxConstCastExpr;
 753 const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
 754     cStyleCastExpr;
 755 const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
 756     explicitCastExpr;
 757 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
 758     implicitCastExpr;
 759 const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
 760 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
 761     cxxFunctionalCastExpr;
 762 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
 763     cxxTemporaryObjectExpr;
 764 const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
 765     predefinedExpr;
 766 const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
 767     designatedInitExpr;
 768 const internal::VariadicOperatorMatcherFunc<
 769     2, std::numeric_limits<unsigned>::max()>
 770     eachOf = {internal::DynTypedMatcher::VO_EachOf};
 771 const internal::VariadicOperatorMatcherFunc<
 772     2, std::numeric_limits<unsigned>::max()>
 773     anyOf = {internal::DynTypedMatcher::VO_AnyOf};
 774 const internal::VariadicOperatorMatcherFunc<
 775     2, std::numeric_limits<unsigned>::max()>
 776     allOf = {internal::DynTypedMatcher::VO_AllOf};
 777 const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
 778                                  internal::hasAnyNameFunc>
 779     hasAnyName = {};
 780 const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>, StringRef,
 781                                  internal::hasAnySelectorFunc>
 782     hasAnySelector = {};
 783 const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has = {};
 784 const internal::ArgumentAdaptingMatcherFunc<internal::HasDescendantMatcher>
 785     hasDescendant = {};
 786 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> forEach =
 787     {};
 788 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachDescendantMatcher>
 789     forEachDescendant = {};
 790 const internal::ArgumentAdaptingMatcherFunc<
 791     internal::HasParentMatcher,
 792     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>,
 793     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>>
 794     hasParent = {};
 795 const internal::ArgumentAdaptingMatcherFunc<
 796     internal::HasAncestorMatcher,
 797     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>,
 798     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>>
 799     hasAncestor = {};
 800 const internal::VariadicOperatorMatcherFunc<1, 1> unless = {
 801     internal::DynTypedMatcher::VO_UnaryNot};
 802 const internal::VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
 803 const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
 804     nestedNameSpecifierLoc;
 805 const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
 806     cudaKernelCallExpr;
 807 const AstTypeMatcher<BuiltinType> builtinType;
 808 const AstTypeMatcher<ArrayType> arrayType;
 809 const AstTypeMatcher<ComplexType> complexType;
 810 const AstTypeMatcher<ConstantArrayType> constantArrayType;
 811 const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
 812 const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
 813 const AstTypeMatcher<VariableArrayType> variableArrayType;
 814 const AstTypeMatcher<AtomicType> atomicType;
 815 const AstTypeMatcher<AutoType> autoType;
 816 const AstTypeMatcher<DecltypeType> decltypeType;
 817 const AstTypeMatcher<FunctionType> functionType;
 818 const AstTypeMatcher<FunctionProtoType> functionProtoType;
 819 const AstTypeMatcher<ParenType> parenType;
 820 const AstTypeMatcher<BlockPointerType> blockPointerType;
 821 const AstTypeMatcher<MemberPointerType> memberPointerType;
 822 const AstTypeMatcher<PointerType> pointerType;
 823 const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
 824 const AstTypeMatcher<ReferenceType> referenceType;
 825 const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
 826 const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
 827 const AstTypeMatcher<TypedefType> typedefType;
 828 const AstTypeMatcher<EnumType> enumType;
 829 const AstTypeMatcher<TemplateSpecializationType> templateSpecializationType;
 830 const AstTypeMatcher<UnaryTransformType> unaryTransformType;
 831 const AstTypeMatcher<RecordType> recordType;
 832 const AstTypeMatcher<TagType> tagType;
 833 const AstTypeMatcher<ElaboratedType> elaboratedType;
 834 const AstTypeMatcher<SubstTemplateTypeParmType> substTemplateTypeParmType;
 835 const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
 836 const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
 837 const AstTypeMatcher<DecayedType> decayedType;
 838 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType,
 839                                  AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType,
 840                                                                  ComplexType));
 841 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType,
 842                                  AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType));
 843 AST_TYPELOC_TRAVERSE_MATCHER_DEF(
 844     pointee,
 845     AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType,
 846                                     PointerType, ReferenceType));
 847
 848 } // end namespace ast_matchers
 849 } // end namespace clang