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