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