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