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