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