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
41namespace clang {
42namespace ast_matchers {
43
44AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector<std::string>,
45 Matches) {
46 return llvm::is_contained(Range: Matches, Element: Node.getSelector().getAsString());
47}
48
49namespace internal {
50
51static bool notUnaryOperator(const DynTypedNode &DynNode,
52 ASTMatchFinder *Finder,
53 BoundNodesTreeBuilder *Builder,
54 ArrayRef<DynTypedMatcher> InnerMatchers);
55
56static bool allOfVariadicOperator(const DynTypedNode &DynNode,
57 ASTMatchFinder *Finder,
58 BoundNodesTreeBuilder *Builder,
59 ArrayRef<DynTypedMatcher> InnerMatchers);
60
61static bool eachOfVariadicOperator(const DynTypedNode &DynNode,
62 ASTMatchFinder *Finder,
63 BoundNodesTreeBuilder *Builder,
64 ArrayRef<DynTypedMatcher> InnerMatchers);
65
66static bool anyOfVariadicOperator(const DynTypedNode &DynNode,
67 ASTMatchFinder *Finder,
68 BoundNodesTreeBuilder *Builder,
69 ArrayRef<DynTypedMatcher> InnerMatchers);
70
71static bool optionallyVariadicOperator(const DynTypedNode &DynNode,
72 ASTMatchFinder *Finder,
73 BoundNodesTreeBuilder *Builder,
74 ArrayRef<DynTypedMatcher> InnerMatchers);
75
76bool 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(Node: *BaseSpec, Finder, Builder: &Result)) {
90 *Builder = std::move(Result);
91 return true;
92 }
93 return false;
94 };
95
96 return Node.lookupInBases(BaseMatches: basePredicate, Paths,
97 /*LookupInDependent =*/true);
98}
99
100void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) {
101 if (Bindings.empty())
102 Bindings.push_back(Elt: BoundNodesMap());
103 for (BoundNodesMap &Binding : Bindings) {
104 ResultVisitor->visitMatch(BoundNodesView: BoundNodes(Binding));
105 }
106}
107
108namespace {
109
110using VariadicOperatorFunction = bool (*)(
111 const DynTypedNode &DynNode, ASTMatchFinder *Finder,
112 BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
113
114template <VariadicOperatorFunction Func>
115class VariadicMatcher : public DynMatcherInterface {
116public:
117 VariadicMatcher(std::vector<DynTypedMatcher> InnerMatchers)
118 : InnerMatchers(std::move(InnerMatchers)) {}
119
120 bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
121 BoundNodesTreeBuilder *Builder) const override {
122 return Func(DynNode, Finder, Builder, InnerMatchers);
123 }
124
125private:
126 std::vector<DynTypedMatcher> InnerMatchers;
127};
128
129class IdDynMatcher : public DynMatcherInterface {
130public:
131 IdDynMatcher(StringRef ID,
132 IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
133 : ID(ID), InnerMatcher(std::move(InnerMatcher)) {}
134
135 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: ID, DynNode);
139 return Result;
140 }
141
142 std::optional<clang::TraversalKind> TraversalKind() const override {
143 return InnerMatcher->TraversalKind();
144 }
145
146private:
147 const std::string ID;
148 const IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
149};
150
151/// A matcher that always returns true.
152class TrueMatcherImpl : public DynMatcherInterface {
153public:
154 TrueMatcherImpl() = default;
155
156 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`.
166class DynTraversalMatcherImpl : public DynMatcherInterface {
167public:
168 explicit DynTraversalMatcherImpl(
169 clang::TraversalKind TK,
170 IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
171 : TK(TK), InnerMatcher(std::move(InnerMatcher)) {}
172
173 bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
174 BoundNodesTreeBuilder *Builder) const override {
175 return this->InnerMatcher->dynMatches(DynNode, Finder, Builder);
176 }
177
178 std::optional<clang::TraversalKind> TraversalKind() const override {
179 return TK;
180 }
181
182private:
183 clang::TraversalKind TK;
184 IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
185};
186
187} // namespace
188
189bool ASTMatchFinder::isTraversalIgnoringImplicitNodes() const {
190 return getASTContext().getParentMapContext().getTraversalKind() ==
191 TK_IgnoreUnlessSpelledInSource;
192}
193
194DynTypedMatcher
195DynTypedMatcher::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(Kind1: RestrictKind, Kind2: 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
250DynTypedMatcher
251DynTypedMatcher::constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
252 ASTNodeKind RestrictKind) {
253 DynTypedMatcher Copy = InnerMatcher;
254 Copy.RestrictKind = RestrictKind;
255 return Copy;
256}
257
258DynTypedMatcher DynTypedMatcher::withTraversalKind(TraversalKind TK) {
259 auto Copy = *this;
260 Copy.Implementation =
261 new DynTraversalMatcherImpl(TK, std::move(Copy.Implementation));
262 return Copy;
263}
264
265DynTypedMatcher 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
274bool DynTypedMatcher::canMatchNodesOfKind(ASTNodeKind Kind) const {
275 return RestrictKind.isBaseOf(Other: Kind);
276}
277
278DynTypedMatcher DynTypedMatcher::dynCastTo(const ASTNodeKind Kind) const {
279 auto Copy = *this;
280 Copy.SupportedKind = Kind;
281 Copy.RestrictKind = ASTNodeKind::getMostDerivedType(Kind1: Kind, Kind2: RestrictKind);
282 return Copy;
283}
284
285bool 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(N: DynNode);
301
302 if (RestrictKind.isBaseOf(Other: N.getNodeKind()) &&
303 Implementation->dynMatches(DynNode: 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(Predicate: [](const BoundNodesMap &) { return true; });
310 return false;
311}
312
313bool 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(N: DynNode);
329
330 assert(RestrictKind.isBaseOf(N.getNodeKind()));
331 if (Implementation->dynMatches(DynNode: 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(Predicate: [](const BoundNodesMap &) { return true; });
338 return false;
339}
340
341std::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
350bool 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(Other: TypeKind) && To.isSame(Other: QualKind)) return true;
357 /// - From Matcher<Base> to Matcher<Derived>
358 return From.isBaseOf(Other: To);
359}
360
361void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) {
362 Bindings.append(in_start: Other.Bindings.begin(), in_end: Other.Bindings.end());
363}
364
365static 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, Builder: &Discard);
384}
385
386static 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(Range&: InnerMatchers, P: [&](const DynTypedMatcher &InnerMatcher) {
394 return InnerMatcher.matchesNoKindCheck(DynNode, Finder, Builder);
395 });
396}
397
398static 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, Builder: &BuilderInner)) {
407 Matched = true;
408 Result.addMatch(Other: BuilderInner);
409 }
410 }
411 *Builder = std::move(Result);
412 return Matched;
413}
414
415static 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, Builder: &Result)) {
422 *Builder = std::move(Result);
423 return true;
424 }
425 }
426 return false;
427}
428
429static bool
430optionallyVariadicOperator(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, Builder: &Result))
438 *Builder = std::move(Result);
439 return true;
440}
441
442inline static
443std::vector<std::string> vectorFromRefs(ArrayRef<const StringRef *> NameRefs) {
444 std::vector<std::string> Names;
445 Names.reserve(n: NameRefs.size());
446 for (auto *Name : NameRefs)
447 Names.emplace_back(args: *Name);
448 return Names;
449}
450
451Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs) {
452 return internal::Matcher<NamedDecl>(
453 new internal::HasNameMatcher(vectorFromRefs(NameRefs)));
454}
455
456Matcher<ObjCMessageExpr> hasAnySelectorFunc(
457 ArrayRef<const StringRef *> NameRefs) {
458 return hasAnySelectorMatcher(Matches: vectorFromRefs(NameRefs));
459}
460
461HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef<const StringRef *> NameRefs) {
462 return HasOpNameMatcher(vectorFromRefs(NameRefs));
463}
464
465HasOverloadOpNameMatcher
466hasAnyOverloadedOperatorNameFunc(ArrayRef<const StringRef *> NameRefs) {
467 return HasOverloadOpNameMatcher(vectorFromRefs(NameRefs));
468}
469
470HasNameMatcher::HasNameMatcher(std::vector<std::string> N)
471 : UseUnqualifiedMatch(
472 llvm::all_of(Range&: N, P: [](StringRef Name) { return !Name.contains(Other: "::"); })),
473 Names(std::move(N)) {
474#ifndef NDEBUG
475 for (StringRef Name : Names)
476 assert(!Name.empty());
477#endif
478}
479
480static bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) {
481 StringRef Name = FullName;
482 if (!Name.ends_with(Suffix))
483 return false;
484 Name = Name.drop_back(N: Suffix.size());
485 if (!Name.empty()) {
486 if (!Name.ends_with(Suffix: "::"))
487 return false;
488 Name = Name.drop_back(N: 2);
489 }
490 FullName = Name;
491 return true;
492}
493
494static 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
511static StringRef getNodeName(const RecordDecl &Node,
512 llvm::SmallString<128> &Scratch) {
513 if (Node.getIdentifier()) {
514 return Node.getName();
515 }
516 Scratch.clear();
517
518 llvm::raw_svector_ostream OS(Scratch);
519
520 PrintingPolicy Copy(Node.getASTContext().getPrintingPolicy());
521 Copy.AnonymousTagLocations = false;
522 Node.printName(OS, Policy: Copy);
523
524 return OS.str();
525}
526
527static StringRef getNodeName(const NamespaceDecl &Node,
528 llvm::SmallString<128> &Scratch) {
529 return Node.isAnonymousNamespace() ? "(anonymous namespace)" : Node.getName();
530}
531
532namespace {
533
534class PatternSet {
535public:
536 PatternSet(ArrayRef<std::string> Names) {
537 Patterns.reserve(N: Names.size());
538 for (StringRef Name : Names)
539 Patterns.push_back(Elt: {.P: Name, .IsFullyQualified: Name.starts_with(Prefix: "::")});
540 }
541
542 /// Consumes the name suffix from each pattern in the set and removes the ones
543 /// that didn't match.
544 /// Return true if there are still any patterns left.
545 bool consumeNameSuffix(StringRef NodeName, bool CanSkip) {
546 if (CanSkip) {
547 // If we can skip the node, then we need to handle the case where a
548 // skipped node has the same name as its parent.
549 // namespace a { inline namespace a { class A; } }
550 // cxxRecordDecl(hasName("::a::A"))
551 // To do this, any patterns that match should be duplicated in our set,
552 // one of them with the tail removed.
553 for (size_t I = 0, E = Patterns.size(); I != E; ++I) {
554 StringRef Pattern = Patterns[I].P;
555 if (ast_matchers::internal::consumeNameSuffix(FullName&: Patterns[I].P, Suffix: NodeName))
556 Patterns.push_back(Elt: {.P: Pattern, .IsFullyQualified: Patterns[I].IsFullyQualified});
557 }
558 } else {
559 llvm::erase_if(C&: Patterns, P: [&NodeName](auto &Pattern) {
560 return !::clang::ast_matchers::internal::consumeNameSuffix(FullName&: Pattern.P,
561 Suffix: NodeName);
562 });
563 }
564 return !Patterns.empty();
565 }
566
567 /// Check if any of the patterns are a match.
568 /// A match will be a pattern that was fully consumed, that also matches the
569 /// 'fully qualified' requirement.
570 bool foundMatch(bool AllowFullyQualified) const {
571 return llvm::any_of(Range: Patterns, P: [&](const Pattern &Pattern) {
572 return Pattern.P.empty() &&
573 (AllowFullyQualified || !Pattern.IsFullyQualified);
574 });
575 }
576
577private:
578 struct Pattern {
579 StringRef P;
580 bool IsFullyQualified;
581 };
582
583 llvm::SmallVector<Pattern, 8> Patterns;
584};
585
586} // namespace
587
588bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const {
589 assert(UseUnqualifiedMatch);
590 llvm::SmallString<128> Scratch;
591 StringRef NodeName = getNodeName(Node, Scratch);
592 return llvm::any_of(Range: Names, P: [&](StringRef Name) {
593 return consumeNameSuffix(FullName&: Name, Suffix: NodeName) && Name.empty();
594 });
595}
596
597bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const {
598 PatternSet Patterns(Names);
599 llvm::SmallString<128> Scratch;
600
601 // This function is copied and adapted from NamedDecl::printQualifiedName()
602 // By matching each part individually we optimize in a couple of ways:
603 // - We can exit early on the first failure.
604 // - We can skip inline/anonymous namespaces without another pass.
605 // - We print one name at a time, reducing the chance of overflowing the
606 // inlined space of the SmallString.
607
608 // First, match the name.
609 if (!Patterns.consumeNameSuffix(NodeName: getNodeName(Node, Scratch),
610 /*CanSkip=*/false))
611 return false;
612
613 // Try to match each declaration context.
614 // We are allowed to skip anonymous and inline namespaces if they don't match.
615 const DeclContext *Ctx = Node.getDeclContext();
616
617 if (Ctx->isFunctionOrMethod())
618 return Patterns.foundMatch(/*AllowFullyQualified=*/false);
619
620 for (; Ctx; Ctx = Ctx->getParent()) {
621 // Linkage Spec can just be ignored
622 // FIXME: Any other DeclContext kinds that can be safely disregarded
623 if (isa<LinkageSpecDecl>(Val: Ctx))
624 continue;
625 if (!isa<NamedDecl>(Val: Ctx))
626 break;
627 if (Patterns.foundMatch(/*AllowFullyQualified=*/false))
628 return true;
629
630 if (const auto *ND = dyn_cast<NamespaceDecl>(Val: Ctx)) {
631 // If it matches (or we can skip it), continue.
632 if (Patterns.consumeNameSuffix(NodeName: getNodeName(Node: *ND, Scratch),
633 /*CanSkip=*/ND->isAnonymousNamespace() ||
634 ND->isInline()))
635 continue;
636 return false;
637 }
638 if (const auto *RD = dyn_cast<RecordDecl>(Val: Ctx)) {
639 if (!isa<ClassTemplateSpecializationDecl>(Val: Ctx)) {
640 if (Patterns.consumeNameSuffix(NodeName: getNodeName(Node: *RD, Scratch),
641 /*CanSkip=*/false))
642 continue;
643
644 return false;
645 }
646 }
647
648 // We don't know how to deal with this DeclContext.
649 // Fallback to the slow version of the code.
650 return matchesNodeFullSlow(Node);
651 }
652
653 return Patterns.foundMatch(/*AllowFullyQualified=*/true);
654}
655
656bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
657 const bool SkipUnwrittenCases[] = {false, true};
658 for (bool SkipUnwritten : SkipUnwrittenCases) {
659 llvm::SmallString<128> NodeName = StringRef("::");
660 llvm::raw_svector_ostream OS(NodeName);
661
662 PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy();
663 Policy.SuppressUnwrittenScope = SkipUnwritten;
664 Policy.SuppressInlineNamespace = llvm::to_underlying(
665 E: SkipUnwritten ? PrintingPolicy::SuppressInlineNamespaceMode::All
666 : PrintingPolicy::SuppressInlineNamespaceMode::None);
667 Node.printQualifiedName(OS, Policy);
668
669 const StringRef FullName = OS.str();
670
671 for (const StringRef Pattern : Names) {
672 if (Pattern.starts_with(Prefix: "::")) {
673 if (FullName == Pattern)
674 return true;
675 } else if (FullName.ends_with(Suffix: Pattern) &&
676 FullName.drop_back(N: Pattern.size()).ends_with(Suffix: "::")) {
677 return true;
678 }
679 }
680 }
681
682 return false;
683}
684
685bool HasNameMatcher::matchesNode(const NamedDecl &Node) const {
686 assert(matchesNodeFullFast(Node) == matchesNodeFullSlow(Node));
687 if (UseUnqualifiedMatch) {
688 assert(matchesNodeUnqualified(Node) == matchesNodeFullFast(Node));
689 return matchesNodeUnqualified(Node);
690 }
691 return matchesNodeFullFast(Node);
692}
693
694// Checks whether \p Loc points to a token with source text of \p TokenText.
695static bool isTokenAtLoc(const SourceManager &SM, const LangOptions &LangOpts,
696 StringRef Text, SourceLocation Loc) {
697 llvm::SmallString<16> Buffer;
698 bool Invalid = false;
699 // Since `Loc` may point into an expansion buffer, which has no corresponding
700 // source, we need to look at the spelling location to read the actual source.
701 StringRef TokenText = Lexer::getSpelling(loc: SM.getSpellingLoc(Loc), buffer&: Buffer, SM,
702 options: LangOpts, invalid: &Invalid);
703 return !Invalid && Text == TokenText;
704}
705
706static std::optional<SourceLocation> getExpansionLocOfMacroRecursive(
707 StringRef MacroName, SourceLocation Loc, const ASTContext &Context,
708 llvm::DenseSet<SourceLocation> &CheckedLocations) {
709 auto &SM = Context.getSourceManager();
710 const LangOptions &LangOpts = Context.getLangOpts();
711 while (Loc.isMacroID()) {
712 if (CheckedLocations.count(V: Loc))
713 return std::nullopt;
714 CheckedLocations.insert(V: Loc);
715 SrcMgr::ExpansionInfo Expansion =
716 SM.getSLocEntry(FID: SM.getFileID(SpellingLoc: Loc)).getExpansion();
717 if (Expansion.isMacroArgExpansion()) {
718 // Check macro argument for an expansion of the given macro. For example,
719 // `F(G(3))`, where `MacroName` is `G`.
720 if (std::optional<SourceLocation> ArgLoc =
721 getExpansionLocOfMacroRecursive(MacroName,
722 Loc: Expansion.getSpellingLoc(),
723 Context, CheckedLocations)) {
724 return ArgLoc;
725 }
726 }
727 Loc = Expansion.getExpansionLocStart();
728 if (isTokenAtLoc(SM, LangOpts, Text: MacroName, Loc))
729 return Loc;
730 }
731 return std::nullopt;
732}
733
734std::optional<SourceLocation>
735getExpansionLocOfMacro(StringRef MacroName, SourceLocation Loc,
736 const ASTContext &Context) {
737 llvm::DenseSet<SourceLocation> CheckedLocations;
738 return getExpansionLocOfMacroRecursive(MacroName, Loc, Context,
739 CheckedLocations);
740}
741
742std::shared_ptr<llvm::Regex> createAndVerifyRegex(StringRef Regex,
743 llvm::Regex::RegexFlags Flags,
744 StringRef MatcherID) {
745 assert(!Regex.empty() && "Empty regex string");
746 auto SharedRegex = std::make_shared<llvm::Regex>(args&: Regex, args&: Flags);
747 std::string Error;
748 if (!SharedRegex->isValid(Error)) {
749 llvm::WithColor::error()
750 << "building matcher '" << MatcherID << "': " << Error << "\n";
751 llvm::WithColor::note() << " input was '" << Regex << "'\n";
752 }
753 return SharedRegex;
754}
755} // end namespace internal
756
757const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAutoreleasePoolStmt>
758 autoreleasePoolStmt;
759const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
760 translationUnitDecl;
761const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> typedefDecl;
762const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
763 typedefNameDecl;
764const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> typeAliasDecl;
765const internal::VariadicDynCastAllOfMatcher<Decl, UsingShadowDecl>
766 usingShadowDecl;
767const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
768 typeAliasTemplateDecl;
769const internal::VariadicAllOfMatcher<Decl> decl;
770const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl> decompositionDecl;
771const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl> bindingDecl;
772const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
773 linkageSpecDecl;
774const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl;
775const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl;
776const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> namespaceDecl;
777const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
778 namespaceAliasDecl;
779const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl;
780const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> cxxRecordDecl;
781const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
782 classTemplateDecl;
783const internal::VariadicDynCastAllOfMatcher<Decl,
784 ClassTemplateSpecializationDecl>
785 classTemplateSpecializationDecl;
786const internal::VariadicDynCastAllOfMatcher<
787 Decl, ClassTemplatePartialSpecializationDecl>
788 classTemplatePartialSpecializationDecl;
789const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
790 declaratorDecl;
791const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> parmVarDecl;
792const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
793 accessSpecDecl;
794const internal::VariadicAllOfMatcher<CXXBaseSpecifier> cxxBaseSpecifier;
795const internal::VariadicAllOfMatcher<CXXCtorInitializer> cxxCtorInitializer;
796const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
797const internal::VariadicAllOfMatcher<TemplateArgumentLoc> templateArgumentLoc;
798const internal::VariadicAllOfMatcher<TemplateName> templateName;
799const internal::VariadicDynCastAllOfMatcher<Decl, NonTypeTemplateParmDecl>
800 nonTypeTemplateParmDecl;
801const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
802 templateTypeParmDecl;
803const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTemplateParmDecl>
804 templateTemplateParmDecl;
805
806const internal::VariadicAllOfMatcher<LambdaCapture> lambdaCapture;
807const internal::VariadicAllOfMatcher<QualType> qualType;
808const internal::VariadicAllOfMatcher<Type> type;
809const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
810
811const internal::VariadicDynCastAllOfMatcher<TypeLoc, QualifiedTypeLoc>
812 qualifiedTypeLoc;
813const internal::VariadicDynCastAllOfMatcher<TypeLoc, PointerTypeLoc>
814 pointerTypeLoc;
815const internal::VariadicDynCastAllOfMatcher<TypeLoc, ReferenceTypeLoc>
816 referenceTypeLoc;
817const internal::VariadicDynCastAllOfMatcher<TypeLoc, ArrayTypeLoc> arrayTypeLoc;
818const internal::VariadicDynCastAllOfMatcher<TypeLoc, FunctionTypeLoc>
819 functionTypeLoc;
820const internal::VariadicDynCastAllOfMatcher<TypeLoc,
821 TemplateSpecializationTypeLoc>
822 templateSpecializationTypeLoc;
823
824const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryExprOrTypeTraitExpr>
825 unaryExprOrTypeTraitExpr;
826const internal::VariadicDynCastAllOfMatcher<Decl, ExportDecl> exportDecl;
827const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
828const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
829 cxxConstructorDecl;
830const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
831 cxxDestructorDecl;
832const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
833const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
834 enumConstantDecl;
835const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl;
836const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> cxxMethodDecl;
837const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
838 cxxConversionDecl;
839const internal::VariadicDynCastAllOfMatcher<Decl, ConceptDecl> conceptDecl;
840const internal::VariadicDynCastAllOfMatcher<Expr, RequiresExpr> requiresExpr;
841const internal::VariadicDynCastAllOfMatcher<Decl, RequiresExprBodyDecl>
842 requiresExprBodyDecl;
843const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
844const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
845const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
846 indirectFieldDecl;
847const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl;
848const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
849 functionTemplateDecl;
850const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
851const internal::VariadicAllOfMatcher<Stmt> stmt;
852const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
853const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
854const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
855 unresolvedMemberExpr;
856const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDependentScopeMemberExpr>
857 cxxDependentScopeMemberExpr;
858const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
859const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
860const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
861 cxxMemberCallExpr;
862const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
863 objcMessageExpr;
864const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
865 objcInterfaceDecl;
866const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
867 objcImplementationDecl;
868const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
869 objcProtocolDecl;
870const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
871 objcCategoryDecl;
872const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
873 objcCategoryImplDecl;
874const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
875 objcMethodDecl;
876const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
877 blockDecl;
878const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> objcIvarDecl;
879const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
880 objcPropertyDecl;
881const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
882 objcThrowStmt;
883const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> objcTryStmt;
884const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
885 objcCatchStmt;
886const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
887 objcFinallyStmt;
888const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
889 exprWithCleanups;
890const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
891const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStdInitializerListExpr>
892 cxxStdInitializerListExpr;
893const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
894 implicitValueInitExpr;
895const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> parenListExpr;
896const internal::VariadicDynCastAllOfMatcher<Stmt, SubstNonTypeTemplateParmExpr>
897 substNonTypeTemplateParmExpr;
898const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
899const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl> usingEnumDecl;
900const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
901 usingDirectiveDecl;
902const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
903 unresolvedLookupExpr;
904const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingValueDecl>
905 unresolvedUsingValueDecl;
906const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingTypenameDecl>
907 unresolvedUsingTypenameDecl;
908const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr;
909const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
910const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
911 cxxConstructExpr;
912const internal::VariadicDynCastAllOfMatcher<Stmt, CXXUnresolvedConstructExpr>
913 cxxUnresolvedConstructExpr;
914const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> cxxThisExpr;
915const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
916 cxxBindTemporaryExpr;
917const internal::VariadicDynCastAllOfMatcher<Stmt, MaterializeTemporaryExpr>
918 materializeTemporaryExpr;
919const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
920const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> cxxDeleteExpr;
921const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
922 cxxNoexceptExpr;
923const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
924 arraySubscriptExpr;
925const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitIndexExpr>
926 arrayInitIndexExpr;
927const internal::VariadicDynCastAllOfMatcher<Stmt, ArrayInitLoopExpr>
928 arrayInitLoopExpr;
929const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
930 cxxDefaultArgExpr;
931const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
932 cxxOperatorCallExpr;
933const internal::VariadicDynCastAllOfMatcher<Stmt, CXXRewrittenBinaryOperator>
934 cxxRewrittenBinaryOperator;
935const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFoldExpr> cxxFoldExpr;
936const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
937const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr;
938const internal::VariadicDynCastAllOfMatcher<Stmt, DependentScopeDeclRefExpr>
939 dependentScopeDeclRefExpr;
940const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> objcIvarRefExpr;
941const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
942const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
943const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
944const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
945 cxxForRangeStmt;
946const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
947const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
948const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
949const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt;
950const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt> coreturnStmt;
951const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
952const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
953const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
954const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> addrLabelExpr;
955const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
956const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
957const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
958const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt;
959const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt;
960const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
961 coroutineBodyStmt;
962const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt;
963const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
964const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr;
965const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
966const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
967const internal::VariadicDynCastAllOfMatcher<Decl, FileScopeAsmDecl>
968 fileScopeAsmDecl;
969const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
970 cxxBoolLiteral;
971const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> stringLiteral;
972const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral> objcStringLiteral;
973const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
974 characterLiteral;
975const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
976 integerLiteral;
977const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral;
978const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral;
979const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
980 fixedPointLiteral;
981const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
982 userDefinedLiteral;
983const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
984 compoundLiteralExpr;
985const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
986 cxxNullPtrLiteralExpr;
987const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> chooseExpr;
988const internal::VariadicDynCastAllOfMatcher<Stmt, ConvertVectorExpr>
989 convertVectorExpr;
990const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
991 coawaitExpr;
992const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
993 dependentCoawaitExpr;
994const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
995 coyieldExpr;
996const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr;
997const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
998 genericSelectionExpr;
999const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
1000const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
1001const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
1002 binaryOperator;
1003const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr,
1004 CXXRewrittenBinaryOperator>
1005 binaryOperation;
1006const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation;
1007const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> unaryOperator;
1008const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
1009 conditionalOperator;
1010const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryConditionalOperator>
1011 binaryConditionalOperator;
1012const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
1013 opaqueValueExpr;
1014const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
1015 staticAssertDecl;
1016const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
1017 cxxReinterpretCastExpr;
1018const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
1019 cxxStaticCastExpr;
1020const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
1021 cxxDynamicCastExpr;
1022const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
1023 cxxConstCastExpr;
1024const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNamedCastExpr>
1025 cxxNamedCastExpr;
1026const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
1027 cStyleCastExpr;
1028const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
1029 explicitCastExpr;
1030const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
1031 implicitCastExpr;
1032const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
1033const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
1034 cxxFunctionalCastExpr;
1035const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
1036 cxxTemporaryObjectExpr;
1037const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
1038 predefinedExpr;
1039const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
1040 designatedInitExpr;
1041const internal::VariadicOperatorMatcherFunc<
1042 2, std::numeric_limits<unsigned>::max()>
1043 eachOf = {.Op: internal::DynTypedMatcher::VO_EachOf};
1044const internal::VariadicOperatorMatcherFunc<
1045 2, std::numeric_limits<unsigned>::max()>
1046 anyOf = {.Op: internal::DynTypedMatcher::VO_AnyOf};
1047const internal::VariadicOperatorMatcherFunc<
1048 2, std::numeric_limits<unsigned>::max()>
1049 allOf = {.Op: internal::DynTypedMatcher::VO_AllOf};
1050const internal::VariadicOperatorMatcherFunc<1, 1> optionally = {
1051 .Op: internal::DynTypedMatcher::VO_Optionally};
1052const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
1053 internal::hasAnyNameFunc>
1054 hasAnyName = {};
1055
1056const internal::VariadicFunction<internal::HasOpNameMatcher, StringRef,
1057 internal::hasAnyOperatorNameFunc>
1058 hasAnyOperatorName = {};
1059const internal::VariadicFunction<internal::HasOverloadOpNameMatcher, StringRef,
1060 internal::hasAnyOverloadedOperatorNameFunc>
1061 hasAnyOverloadedOperatorName = {};
1062const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>, StringRef,
1063 internal::hasAnySelectorFunc>
1064 hasAnySelector = {};
1065const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has = {};
1066const internal::ArgumentAdaptingMatcherFunc<internal::HasDescendantMatcher>
1067 hasDescendant = {};
1068const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> forEach =
1069 {};
1070const internal::ArgumentAdaptingMatcherFunc<internal::ForEachDescendantMatcher>
1071 forEachDescendant = {};
1072const internal::ArgumentAdaptingMatcherFunc<
1073 internal::HasParentMatcher,
1074 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
1075 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
1076 hasParent = {};
1077const internal::ArgumentAdaptingMatcherFunc<
1078 internal::HasAncestorMatcher,
1079 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
1080 internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
1081 hasAncestor = {};
1082const internal::VariadicOperatorMatcherFunc<1, 1> unless = {
1083 .Op: internal::DynTypedMatcher::VO_UnaryNot};
1084const internal::VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
1085const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
1086 nestedNameSpecifierLoc;
1087const internal::VariadicAllOfMatcher<Attr> attr;
1088const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
1089 cudaKernelCallExpr;
1090const AstTypeMatcher<BuiltinType> builtinType;
1091const AstTypeMatcher<ArrayType> arrayType;
1092const AstTypeMatcher<ComplexType> complexType;
1093const AstTypeMatcher<ConstantArrayType> constantArrayType;
1094const AstTypeMatcher<DeducedTemplateSpecializationType>
1095 deducedTemplateSpecializationType;
1096const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
1097const AstTypeMatcher<DependentSizedExtVectorType> dependentSizedExtVectorType;
1098const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
1099const AstTypeMatcher<VariableArrayType> variableArrayType;
1100const AstTypeMatcher<AtomicType> atomicType;
1101const AstTypeMatcher<AutoType> autoType;
1102const AstTypeMatcher<DecltypeType> decltypeType;
1103const AstTypeMatcher<FunctionType> functionType;
1104const AstTypeMatcher<FunctionProtoType> functionProtoType;
1105const AstTypeMatcher<ParenType> parenType;
1106const AstTypeMatcher<BlockPointerType> blockPointerType;
1107const AstTypeMatcher<MacroQualifiedType> macroQualifiedType;
1108const AstTypeMatcher<MemberPointerType> memberPointerType;
1109const AstTypeMatcher<PointerType> pointerType;
1110const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
1111const AstTypeMatcher<ReferenceType> referenceType;
1112const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
1113const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
1114const AstTypeMatcher<TypedefType> typedefType;
1115const AstTypeMatcher<EnumType> enumType;
1116const AstTypeMatcher<TemplateSpecializationType> templateSpecializationType;
1117const AstTypeMatcher<UnaryTransformType> unaryTransformType;
1118const AstTypeMatcher<RecordType> recordType;
1119const AstTypeMatcher<TagType> tagType;
1120const AstTypeMatcher<UsingType> usingType;
1121const AstTypeMatcher<SubstTemplateTypeParmType> substTemplateTypeParmType;
1122const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
1123const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
1124const AstTypeMatcher<DecayedType> decayedType;
1125const AstTypeMatcher<DependentNameType> dependentNameType;
1126AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType,
1127 AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType,
1128 ComplexType));
1129AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType,
1130 AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType));
1131AST_TYPELOC_TRAVERSE_MATCHER_DEF(
1132 pointee,
1133 AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType,
1134 PointerType, ReferenceType,
1135 ObjCObjectPointerType));
1136
1137const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
1138 ompExecutableDirective;
1139const internal::VariadicDynCastAllOfMatcher<Stmt, OMPTargetUpdateDirective>
1140 ompTargetUpdateDirective;
1141const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause>
1142 ompDefaultClause;
1143const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPFromClause>
1144 ompFromClause;
1145const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPToClause> ompToClause;
1146const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
1147 cxxDeductionGuideDecl;
1148
1149} // end namespace ast_matchers
1150} // end namespace clang
1151