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