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