clang 10.0.0git

ASTMatchersInternal.h
Go to the documentation of this file.
1 //===- ASTMatchersInternal.h - Structural query framework -------*- C++ -*-===//
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 // Matchers are methods that return a Matcher<T> which provides a method
12 // Matches(...) which is a predicate on an AST node. The Matches method's
13 // parameters define the context of the match, which allows matchers to recurse
14 // or store the current node as bound to a specific string, so that it can be
15 // retrieved later.
16 //
17 // In general, matchers have two parts:
18 // 1. A function Matcher<T> MatcherName(<arguments>) which returns a Matcher<T>
19 // based on the arguments and optionally on template type deduction based
20 // on the arguments. Matcher<T>s form an implicit reverse hierarchy
21 // to clang's AST class hierarchy, meaning that you can use a Matcher<Base>
22 // everywhere a Matcher<Derived> is required.
23 // 2. An implementation of a class derived from MatcherInterface<T>.
24 //
25 // The matcher functions are defined in ASTMatchers.h. To make it possible
26 // to implement both the matcher function and the implementation of the matcher
27 // interface in one place, ASTMatcherMacros.h defines macros that allow
28 // implementing a matcher in a single place.
29 //
30 // This file contains the base classes needed to construct the actual matchers.
31 //
32 //===----------------------------------------------------------------------===//
33
34 #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
35 #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
36
37 #include "clang/AST/ASTTypeTraits.h"
38 #include "clang/AST/Decl.h"
39 #include "clang/AST/DeclCXX.h"
40 #include "clang/AST/DeclFriend.h"
41 #include "clang/AST/DeclTemplate.h"
42 #include "clang/AST/Expr.h"
43 #include "clang/AST/ExprObjC.h"
44 #include "clang/AST/ExprCXX.h"
45 #include "clang/AST/ExprObjC.h"
46 #include "clang/AST/NestedNameSpecifier.h"
47 #include "clang/AST/Stmt.h"
48 #include "clang/AST/TemplateName.h"
49 #include "clang/AST/Type.h"
50 #include "clang/AST/TypeLoc.h"
51 #include "clang/Basic/LLVM.h"
52 #include "clang/Basic/OperatorKinds.h"
53 #include "llvm/ADT/APFloat.h"
54 #include "llvm/ADT/ArrayRef.h"
55 #include "llvm/ADT/IntrusiveRefCntPtr.h"
56 #include "llvm/ADT/None.h"
57 #include "llvm/ADT/Optional.h"
58 #include "llvm/ADT/STLExtras.h"
59 #include "llvm/ADT/SmallVector.h"
60 #include "llvm/ADT/StringRef.h"
61 #include "llvm/ADT/iterator.h"
62 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/ManagedStatic.h"
64 #include <algorithm>
65 #include <cassert>
66 #include <cstddef>
67 #include <cstdint>
68 #include <map>
69 #include <string>
70 #include <tuple>
71 #include <type_traits>
72 #include <utility>
73 #include <vector>
74
75 namespace clang {
76
77 class ASTContext;
78
79 namespace ast_matchers {
80
81 class BoundNodes;
82
83 namespace internal {
84
85 /// Variadic function object.
86 ///
87 /// Most of the functions below that use VariadicFunction could be implemented
88 /// using plain C++11 variadic functions, but the function object allows us to
89 /// capture it on the dynamic matcher registry.
90 template <typename ResultT, typename ArgT,
91 ResultT (*Func)(ArrayRef<const ArgT *>)>
92 struct VariadicFunction {
93 ResultT operator()() const { return Func(None); }
94
95 template <typename... ArgsT>
96 ResultT operator()(const ArgT &Arg1, const ArgsT &... Args) const {
97 return Execute(Arg1, static_cast<const ArgT &>(Args)...);
98 }
99
100 // We also allow calls with an already created array, in case the caller
101 // already had it.
102 ResultT operator()(ArrayRef<ArgT> Args) const {
103 SmallVector<const ArgT*, 8> InnerArgs;
104 for (const ArgT &Arg : Args)
105 InnerArgs.push_back(&Arg);
106 return Func(InnerArgs);
107 }
108
109 private:
110 // Trampoline function to allow for implicit conversions to take place
111 // before we make the array.
112 template <typename... ArgsT> ResultT Execute(const ArgsT &... Args) const {
113 const ArgT *const ArgsArray[] = {&Args...};
114 return Func(ArrayRef<const ArgT *>(ArgsArray, sizeof...(ArgsT)));
115 }
116 };
117
118 /// Unifies obtaining the underlying type of a regular node through
119 /// `getType` and a TypedefNameDecl node through `getUnderlyingType`.
120 inline QualType getUnderlyingType(const Expr &Node) { return Node.getType(); }
121
122 inline QualType getUnderlyingType(const ValueDecl &Node) {
123 return Node.getType();
124 }
125 inline QualType getUnderlyingType(const TypedefNameDecl &Node) {
126 return Node.getUnderlyingType();
127 }
128 inline QualType getUnderlyingType(const FriendDecl &Node) {
129 if (const TypeSourceInfo *TSI = Node.getFriendType())
130 return TSI->getType();
131 return QualType();
132 }
133
134 /// Unifies obtaining the FunctionProtoType pointer from both
135 /// FunctionProtoType and FunctionDecl nodes..
136 inline const FunctionProtoType *
137 getFunctionProtoType(const FunctionProtoType &Node) {
138 return &Node;
139 }
140
141 inline const FunctionProtoType *getFunctionProtoType(const FunctionDecl &Node) {
142 return Node.getType()->getAs<FunctionProtoType>();
143 }
144
145 /// Internal version of BoundNodes. Holds all the bound nodes.
146 class BoundNodesMap {
147 public:
148 /// Adds \c Node to the map with key \c ID.
149 ///
150 /// The node's base type should be in NodeBaseType or it will be unaccessible.
151 void addNode(StringRef ID, const ast_type_traits::DynTypedNode& DynNode) {
152 NodeMap[ID] = DynNode;
153 }
154
155 /// Returns the AST node bound to \c ID.
156 ///
157 /// Returns NULL if there was no node bound to \c ID or if there is a node but
158 /// it cannot be converted to the specified type.
159 template <typename T>
160 const T *getNodeAs(StringRef ID) const {
161 IDToNodeMap::const_iterator It = NodeMap.find(ID);
162 if (It == NodeMap.end()) {
163 return nullptr;
164 }
165 return It->second.get<T>();
166 }
167
168 ast_type_traits::DynTypedNode getNode(StringRef ID) const {
169 IDToNodeMap::const_iterator It = NodeMap.find(ID);
170 if (It == NodeMap.end()) {
171 return ast_type_traits::DynTypedNode();
172 }
173 return It->second;
174 }
175
176 /// Imposes an order on BoundNodesMaps.
177 bool operator<(const BoundNodesMap &Other) const {
178 return NodeMap < Other.NodeMap;
179 }
180
181 /// A map from IDs to the bound nodes.
182 ///
183 /// Note that we're using std::map here, as for memoization:
184 /// - we need a comparison operator
185 /// - we need an assignment operator
186 using IDToNodeMap =
187 std::map<std::string, ast_type_traits::DynTypedNode, std::less<>>;
188
189 const IDToNodeMap &getMap() const {
190 return NodeMap;
191 }
192
193 /// Returns \c true if this \c BoundNodesMap can be compared, i.e. all
194 /// stored nodes have memoization data.
195 bool isComparable() const {
196 for (const auto &IDAndNode : NodeMap) {
197 if (!IDAndNode.second.getMemoizationData())
198 return false;
199 }
200 return true;
201 }
202
203 private:
204 IDToNodeMap NodeMap;
205 };
206
207 /// Creates BoundNodesTree objects.
208 ///
209 /// The tree builder is used during the matching process to insert the bound
210 /// nodes from the Id matcher.
211 class BoundNodesTreeBuilder {
212 public:
213 /// A visitor interface to visit all BoundNodes results for a
214 /// BoundNodesTree.
215 class Visitor {
216 public:
217 virtual ~Visitor() = default;
218
219 /// Called multiple times during a single call to VisitMatches(...).
220 ///
221 /// 'BoundNodesView' contains the bound nodes for a single match.
222 virtual void visitMatch(const BoundNodes& BoundNodesView) = 0;
223 };
224
225 /// Add a binding from an id to a node.
226 void setBinding(StringRef Id, const ast_type_traits::DynTypedNode &DynNode) {
227 if (Bindings.empty())
228 Bindings.emplace_back();
229 for (BoundNodesMap &Binding : Bindings)
230 Binding.addNode(Id, DynNode);
231 }
232
233 /// Adds a branch in the tree.
234 void addMatch(const BoundNodesTreeBuilder &Bindings);
235
236 /// Visits all matches that this BoundNodesTree represents.
237 ///
238 /// The ownership of 'ResultVisitor' remains at the caller.
239 void visitMatches(Visitor* ResultVisitor);
240
241 template <typename ExcludePredicate>
242 bool removeBindings(const ExcludePredicate &Predicate) {
243 Bindings.erase(std::remove_if(Bindings.begin(), Bindings.end(), Predicate),
244 Bindings.end());
245 return !Bindings.empty();
246 }
247
248 /// Imposes an order on BoundNodesTreeBuilders.
249 bool operator<(const BoundNodesTreeBuilder &Other) const {
250 return Bindings < Other.Bindings;
251 }
252
253 /// Returns \c true if this \c BoundNodesTreeBuilder can be compared,
254 /// i.e. all stored node maps have memoization data.
255 bool isComparable() const {
256 for (const BoundNodesMap &NodesMap : Bindings) {
257 if (!NodesMap.isComparable())
258 return false;
259 }
260 return true;
261 }
262
263 private:
264 SmallVector<BoundNodesMap, 1> Bindings;
265 };
266
267 class ASTMatchFinder;
268
269 /// Generic interface for all matchers.
270 ///
271 /// Used by the implementation of Matcher<T> and DynTypedMatcher.
272 /// In general, implement MatcherInterface<T> or SingleNodeMatcherInterface<T>
273 /// instead.
274 class DynMatcherInterface
275 : public llvm::ThreadSafeRefCountedBase<DynMatcherInterface> {
276 public:
277 virtual ~DynMatcherInterface() = default;
278
279 /// Returns true if \p DynNode can be matched.
280 ///
281 /// May bind \p DynNode to an ID via \p Builder, or recurse into
282 /// the AST via \p Finder.
283 virtual bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
284 ASTMatchFinder *Finder,
285 BoundNodesTreeBuilder *Builder) const = 0;
286
287 virtual llvm::Optional<ast_type_traits::TraversalKind> TraversalKind() const {
288 return llvm::None;
289 }
290 };
291
292 /// Generic interface for matchers on an AST node of type T.
293 ///
294 /// Implement this if your matcher may need to inspect the children or
295 /// descendants of the node or bind matched nodes to names. If you are
296 /// writing a simple matcher that only inspects properties of the
297 /// current node and doesn't care about its children or descendants,
298 /// implement SingleNodeMatcherInterface instead.
299 template <typename T>
300 class MatcherInterface : public DynMatcherInterface {
301 public:
302 /// Returns true if 'Node' can be matched.
303 ///
304 /// May bind 'Node' to an ID via 'Builder', or recurse into
305 /// the AST via 'Finder'.
306 virtual bool matches(const T &Node,
307 ASTMatchFinder *Finder,
308 BoundNodesTreeBuilder *Builder) const = 0;
309
310 bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
311 ASTMatchFinder *Finder,
312 BoundNodesTreeBuilder *Builder) const override {
313 return matches(DynNode.getUnchecked<T>(), Finder, Builder);
314 }
315 };
316
317 /// Interface for matchers that only evaluate properties on a single
318 /// node.
319 template <typename T>
320 class SingleNodeMatcherInterface : public MatcherInterface<T> {
321 public:
322 /// Returns true if the matcher matches the provided node.
323 ///
324 /// A subclass must implement this instead of Matches().
325 virtual bool matchesNode(const T &Node) const = 0;
326
327 private:
328 /// Implements MatcherInterface::Matches.
329 bool matches(const T &Node,
330 ASTMatchFinder * /* Finder */,
331 BoundNodesTreeBuilder * /* Builder */) const override {
332 return matchesNode(Node);
333 }
334 };
335
336 template <typename> class Matcher;
337
338 /// Matcher that works on a \c DynTypedNode.
339 ///
340 /// It is constructed from a \c Matcher<T> object and redirects most calls to
341 /// underlying matcher.
342 /// It checks whether the \c DynTypedNode is convertible into the type of the
343 /// underlying matcher and then do the actual match on the actual node, or
344 /// return false if it is not convertible.
345 class DynTypedMatcher {
346 public:
347 /// Takes ownership of the provided implementation pointer.
348 template <typename T>
349 DynTypedMatcher(MatcherInterface<T> *Implementation)
350 : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
351 RestrictKind(SupportedKind), Implementation(Implementation) {}
352
353 /// Construct from a variadic function.
354 enum VariadicOperator {
355 /// Matches nodes for which all provided matchers match.
356 VO_AllOf,
357
358 /// Matches nodes for which at least one of the provided matchers
359 /// matches.
360 VO_AnyOf,
361
362 /// Matches nodes for which at least one of the provided matchers
363 /// matches, but doesn't stop at the first match.
364 VO_EachOf,
365
366 /// Matches any node but executes all inner matchers to find result
367 /// bindings.
368 VO_Optionally,
369
370 /// Matches nodes that do not match the provided matcher.
371 ///
372 /// Uses the variadic matcher interface, but fails if
373 /// InnerMatchers.size() != 1.
374 VO_UnaryNot
375 };
376
377 static DynTypedMatcher
378 constructVariadic(VariadicOperator Op,
379 ast_type_traits::ASTNodeKind SupportedKind,
380 std::vector<DynTypedMatcher> InnerMatchers);
381
382 static DynTypedMatcher
383 constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
384 ast_type_traits::ASTNodeKind RestrictKind);
385
386 /// Get a "true" matcher for \p NodeKind.
387 ///
388 /// It only checks that the node is of the right kind.
389 static DynTypedMatcher trueMatcher(ast_type_traits::ASTNodeKind NodeKind);
390
391 void setAllowBind(bool AB) { AllowBind = AB; }
392
393 /// Check whether this matcher could ever match a node of kind \p Kind.
394 /// \return \c false if this matcher will never match such a node. Otherwise,
395 /// return \c true.
396 bool canMatchNodesOfKind(ast_type_traits::ASTNodeKind Kind) const;
397
398 /// Return a matcher that points to the same implementation, but
399 /// restricts the node types for \p Kind.
400 DynTypedMatcher dynCastTo(const ast_type_traits::ASTNodeKind Kind) const;
401
402 /// Returns true if the matcher matches the given \c DynNode.
403 bool matches(const ast_type_traits::DynTypedNode &DynNode,
404 ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const;
405
406 /// Same as matches(), but skips the kind check.
407 ///
408 /// It is faster, but the caller must ensure the node is valid for the
409 /// kind of this matcher.
410 bool matchesNoKindCheck(const ast_type_traits::DynTypedNode &DynNode,
411 ASTMatchFinder *Finder,
412 BoundNodesTreeBuilder *Builder) const;
413
414 /// Bind the specified \p ID to the matcher.
415 /// \return A new matcher with the \p ID bound to it if this matcher supports
416 /// binding. Otherwise, returns an empty \c Optional<>.
417 llvm::Optional<DynTypedMatcher> tryBind(StringRef ID) const;
418
419 /// Returns a unique \p ID for the matcher.
420 ///
421 /// Casting a Matcher<T> to Matcher<U> creates a matcher that has the
422 /// same \c Implementation pointer, but different \c RestrictKind. We need to
423 /// include both in the ID to make it unique.
424 ///
425 /// \c MatcherIDType supports operator< and provides strict weak ordering.
426 using MatcherIDType = std::pair<ast_type_traits::ASTNodeKind, uint64_t>;
427 MatcherIDType getID() const {
428 /// FIXME: Document the requirements this imposes on matcher
429 /// implementations (no new() implementation_ during a Matches()).
430 return std::make_pair(RestrictKind,
431 reinterpret_cast<uint64_t>(Implementation.get()));
432 }
433
434 /// Returns the type this matcher works on.
435 ///
436 /// \c matches() will always return false unless the node passed is of this
437 /// or a derived type.
438 ast_type_traits::ASTNodeKind getSupportedKind() const {
439 return SupportedKind;
440 }
441
442 /// Returns \c true if the passed \c DynTypedMatcher can be converted
443 /// to a \c Matcher<T>.
444 ///
445 /// This method verifies that the underlying matcher in \c Other can process
446 /// nodes of types T.
447 template <typename T> bool canConvertTo() const {
448 return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
449 }
450 bool canConvertTo(ast_type_traits::ASTNodeKind To) const;
451
452 /// Construct a \c Matcher<T> interface around the dynamic matcher.
453 ///
454 /// This method asserts that \c canConvertTo() is \c true. Callers
455 /// should call \c canConvertTo() first to make sure that \c this is
456 /// compatible with T.
457 template <typename T> Matcher<T> convertTo() const {
458 assert(canConvertTo<T>());
459 return unconditionalConvertTo<T>();
460 }
461
462 /// Same as \c convertTo(), but does not check that the underlying
463 /// matcher can handle a value of T.
464 ///
465 /// If it is not compatible, then this matcher will never match anything.
466 template <typename T> Matcher<T> unconditionalConvertTo() const;
467
468 private:
469 DynTypedMatcher(ast_type_traits::ASTNodeKind SupportedKind,
470 ast_type_traits::ASTNodeKind RestrictKind,
471 IntrusiveRefCntPtr<DynMatcherInterface> Implementation)
472 : SupportedKind(SupportedKind), RestrictKind(RestrictKind),
473 Implementation(std::move(Implementation)) {}
474
475 bool AllowBind = false;
476 ast_type_traits::ASTNodeKind SupportedKind;
477
478 /// A potentially stricter node kind.
479 ///
480 /// It allows to perform implicit and dynamic cast of matchers without
481 /// needing to change \c Implementation.
482 ast_type_traits::ASTNodeKind RestrictKind;
483 IntrusiveRefCntPtr<DynMatcherInterface> Implementation;
484 };
485
486 /// Wrapper base class for a wrapping matcher.
487 ///
488 /// This is just a container for a DynTypedMatcher that can be used as a base
489 /// class for another matcher.
490 template <typename T>
491 class WrapperMatcherInterface : public MatcherInterface<T> {
492 protected:
493 explicit WrapperMatcherInterface(DynTypedMatcher &&InnerMatcher)
494 : InnerMatcher(std::move(InnerMatcher)) {}
495
496 const DynTypedMatcher InnerMatcher;
497 };
498
499 /// Wrapper of a MatcherInterface<T> *that allows copying.
500 ///
501 /// A Matcher<Base> can be used anywhere a Matcher<Derived> is
502 /// required. This establishes an is-a relationship which is reverse
503 /// to the AST hierarchy. In other words, Matcher<T> is contravariant
504 /// with respect to T. The relationship is built via a type conversion
505 /// operator rather than a type hierarchy to be able to templatize the
506 /// type hierarchy instead of spelling it out.
507 template <typename T>
508 class Matcher {
509 public:
510 /// Takes ownership of the provided implementation pointer.
511 explicit Matcher(MatcherInterface<T> *Implementation)
512 : Implementation(Implementation) {}
513
514 /// Implicitly converts \c Other to a Matcher<T>.
515 ///
516 /// Requires \c T to be derived from \c From.
517 template <typename From>
518 Matcher(const Matcher<From> &Other,
519 typename std::enable_if<std::is_base_of<From, T>::value &&
520 !std::is_same<From, T>::value>::type * = nullptr)
521 : Implementation(restrictMatcher(Other.Implementation)) {
522 assert(Implementation.getSupportedKind().isSame(
523 ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
524 }
525
526 /// Implicitly converts \c Matcher<Type> to \c Matcher<QualType>.
527 ///
528 /// The resulting matcher is not strict, i.e. ignores qualifiers.
529 template <typename TypeT>
530 Matcher(const Matcher<TypeT> &Other,
531 typename std::enable_if<
532 std::is_same<T, QualType>::value &&
533 std::is_same<TypeT, Type>::value>::type* = nullptr)
534 : Implementation(new TypeToQualType<TypeT>(Other)) {}
535
536 /// Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the
537 /// argument.
538 /// \c To must be a base class of \c T.
539 template <typename To>
540 Matcher<To> dynCastTo() const {
541 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
542 return Matcher<To>(Implementation);
543 }
544
545 /// Forwards the call to the underlying MatcherInterface<T> pointer.
546 bool matches(const T &Node,
547 ASTMatchFinder *Finder,
548 BoundNodesTreeBuilder *Builder) const {
549 return Implementation.matches(ast_type_traits::DynTypedNode::create(Node),
550 Finder, Builder);
551 }
552
553 /// Returns an ID that uniquely identifies the matcher.
554 DynTypedMatcher::MatcherIDType getID() const {
555 return Implementation.getID();
556 }
557
558 /// Extract the dynamic matcher.
559 ///
560 /// The returned matcher keeps the same restrictions as \c this and remembers
561 /// that it is meant to support nodes of type \c T.
562 operator DynTypedMatcher() const { return Implementation; }
563
564 /// Allows the conversion of a \c Matcher<Type> to a \c
565 /// Matcher<QualType>.
566 ///
567 /// Depending on the constructor argument, the matcher is either strict, i.e.
568 /// does only matches in the absence of qualifiers, or not, i.e. simply
569 /// ignores any qualifiers.
570 template <typename TypeT>
571 class TypeToQualType : public WrapperMatcherInterface<QualType> {
572 public:
573 TypeToQualType(const Matcher<TypeT> &InnerMatcher)
574 : TypeToQualType::WrapperMatcherInterface(InnerMatcher) {}
575
576 bool matches(const QualType &Node, ASTMatchFinder *Finder,
577 BoundNodesTreeBuilder *Builder) const override {
578 if (Node.isNull())
579 return false;
580 return this->InnerMatcher.matches(
581 ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
582 }
583 };
584
585 private:
586 // For Matcher<T> <=> Matcher<U> conversions.
587 template <typename U> friend class Matcher;
588
589 // For DynTypedMatcher::unconditionalConvertTo<T>.
590 friend class DynTypedMatcher;
591
592 static DynTypedMatcher restrictMatcher(const DynTypedMatcher &Other) {
593 return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
594 }
595
596 explicit Matcher(const DynTypedMatcher &Implementation)
597 : Implementation(restrictMatcher(Implementation)) {
598 assert(this->Implementation.getSupportedKind()
599 .isSame(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
600 }
601
602 DynTypedMatcher Implementation;
603 }; // class Matcher
604
605 /// A convenient helper for creating a Matcher<T> without specifying
606 /// the template type argument.
607 template <typename T>
608 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
609 return Matcher<T>(Implementation);
610 }
611
612 /// Specialization of the conversion functions for QualType.
613 ///
614 /// This specialization provides the Matcher<Type>->Matcher<QualType>
615 /// conversion that the static API does.
616 template <>
617 inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>() const {
618 assert(canConvertTo<QualType>());
619 const ast_type_traits::ASTNodeKind SourceKind = getSupportedKind();
620 if (SourceKind.isSame(
621 ast_type_traits::ASTNodeKind::getFromNodeKind<Type>())) {
622 // We support implicit conversion from Matcher<Type> to Matcher<QualType>
623 return unconditionalConvertTo<Type>();
624 }
625 return unconditionalConvertTo<QualType>();
626 }
627
628 /// Finds the first node in a range that matches the given matcher.
629 template <typename MatcherT, typename IteratorT>
630 bool matchesFirstInRange(const MatcherT &Matcher, IteratorT Start,
631 IteratorT End, ASTMatchFinder *Finder,
632 BoundNodesTreeBuilder *Builder) {
633 for (IteratorT I = Start; I != End; ++I) {
634 BoundNodesTreeBuilder Result(*Builder);
635 if (Matcher.matches(*I, Finder, &Result)) {
636 *Builder = std::move(Result);
637 return true;
638 }
639 }
640 return false;
641 }
642
643 /// Finds the first node in a pointer range that matches the given
644 /// matcher.
645 template <typename MatcherT, typename IteratorT>
646 bool matchesFirstInPointerRange(const MatcherT &Matcher, IteratorT Start,
647 IteratorT End, ASTMatchFinder *Finder,
648 BoundNodesTreeBuilder *Builder) {
649 for (IteratorT I = Start; I != End; ++I) {
650 BoundNodesTreeBuilder Result(*Builder);
651 if (Matcher.matches(**I, Finder, &Result)) {
652 *Builder = std::move(Result);
653 return true;
654 }
655 }
656 return false;
657 }
658
659 // Metafunction to determine if type T has a member called getDecl.
660 template <typename Ty>
661 class has_getDecl {
662 using yes = char[1];
663 using no = char[2];
664
665 template <typename Inner>
666 static yes& test(Inner *I, decltype(I->getDecl()) * = nullptr);
667
668 template <typename>
669 static no& test(...);
670
671 public:
672 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
673 };
674
675 /// Matches overloaded operators with a specific name.
676 ///
677 /// The type argument ArgT is not used by this matcher but is used by
678 /// PolymorphicMatcherWithParam1 and should be StringRef.
679 template <typename T, typename ArgT>
680 class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
681 static_assert(std::is_same<T, CXXOperatorCallExpr>::value ||
682 std::is_base_of<FunctionDecl, T>::value,
683 "unsupported class for matcher");
684 static_assert(std::is_same<ArgT, StringRef>::value,
685 "argument type must be StringRef");
686
687 public:
688 explicit HasOverloadedOperatorNameMatcher(const StringRef Name)
689 : SingleNodeMatcherInterface<T>(), Name(Name) {}
690
691 bool matchesNode(const T &Node) const override {
692 return matchesSpecialized(Node);
693 }
694
695 private:
696
697 /// CXXOperatorCallExpr exist only for calls to overloaded operators
698 /// so this function returns true if the call is to an operator of the given
699 /// name.
700 bool matchesSpecialized(const CXXOperatorCallExpr &Node) const {
701 return getOperatorSpelling(Node.getOperator()) == Name;
702 }
703
704 /// Returns true only if CXXMethodDecl represents an overloaded
705 /// operator and has the given operator name.
706 bool matchesSpecialized(const FunctionDecl &Node) const {
707 return Node.isOverloadedOperator() &&
708 getOperatorSpelling(Node.getOverloadedOperator()) == Name;
709 }
710
711 std::string Name;
712 };
713
714 /// Matches named declarations with a specific name.
715 ///
716 /// See \c hasName() and \c hasAnyName() in ASTMatchers.h for details.
717 class HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> {
718 public:
719 explicit HasNameMatcher(std::vector<std::string> Names);
720
721 bool matchesNode(const NamedDecl &Node) const override;
722
723 private:
724 /// Unqualified match routine.
725 ///
726 /// It is much faster than the full match, but it only works for unqualified
727 /// matches.
728 bool matchesNodeUnqualified(const NamedDecl &Node) const;
729
730 /// Full match routine
731 ///
732 /// Fast implementation for the simple case of a named declaration at
733 /// namespace or RecordDecl scope.
734 /// It is slower than matchesNodeUnqualified, but faster than
735 /// matchesNodeFullSlow.
736 bool matchesNodeFullFast(const NamedDecl &Node) const;
737
738 /// Full match routine
739 ///
740 /// It generates the fully qualified name of the declaration (which is
741 /// expensive) before trying to match.
742 /// It is slower but simple and works on all cases.
743 bool matchesNodeFullSlow(const NamedDecl &Node) const;
744
745 const bool UseUnqualifiedMatch;
746 const std::vector<std::string> Names;
747 };
748
749 /// Trampoline function to use VariadicFunction<> to construct a
750 /// HasNameMatcher.
751 Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs);
752
753 /// Trampoline function to use VariadicFunction<> to construct a
754 /// hasAnySelector matcher.
755 Matcher<ObjCMessageExpr> hasAnySelectorFunc(
756 ArrayRef<const StringRef *> NameRefs);
757
758 /// Matches declarations for QualType and CallExpr.
759 ///
760 /// Type argument DeclMatcherT is required by PolymorphicMatcherWithParam1 but
761 /// not actually used.
762 template <typename T, typename DeclMatcherT>
763 class HasDeclarationMatcher : public WrapperMatcherInterface<T> {
764 static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value,
765 "instantiated with wrong types");
766
767 public:
768 explicit HasDeclarationMatcher(const Matcher<Decl> &InnerMatcher)
769 : HasDeclarationMatcher::WrapperMatcherInterface(InnerMatcher) {}
770
771 bool matches(const T &Node, ASTMatchFinder *Finder,
772 BoundNodesTreeBuilder *Builder) const override {
773 return matchesSpecialized(Node, Finder, Builder);
774 }
775
776 private:
777 /// Forwards to matching on the underlying type of the QualType.
778 bool matchesSpecialized(const QualType &Node, ASTMatchFinder *Finder,
779 BoundNodesTreeBuilder *Builder) const {
780 if (Node.isNull())
781 return false;
782
783 return matchesSpecialized(*Node, Finder, Builder);
784 }
785
786 /// Finds the best declaration for a type and returns whether the inner
787 /// matcher matches on it.
788 bool matchesSpecialized(const Type &Node, ASTMatchFinder *Finder,
789 BoundNodesTreeBuilder *Builder) const {
790 // DeducedType does not have declarations of its own, so
791 // match the deduced type instead.
792 const Type *EffectiveType = &Node;
793 if (const auto *S = dyn_cast<DeducedType>(&Node)) {
794 EffectiveType = S->getDeducedType().getTypePtrOrNull();
795 if (!EffectiveType)
796 return false;
797 }
798
799 // First, for any types that have a declaration, extract the declaration and
800 // match on it.
801 if (const auto *S = dyn_cast<TagType>(EffectiveType)) {
802 return matchesDecl(S->getDecl(), Finder, Builder);
803 }
804 if (const auto *S = dyn_cast<InjectedClassNameType>(EffectiveType)) {
805 return matchesDecl(S->getDecl(), Finder, Builder);
806 }
807 if (const auto *S = dyn_cast<TemplateTypeParmType>(EffectiveType)) {
808 return matchesDecl(S->getDecl(), Finder, Builder);
809 }
810 if (const auto *S = dyn_cast<TypedefType>(EffectiveType)) {
811 return matchesDecl(S->getDecl(), Finder, Builder);
812 }
813 if (const auto *S = dyn_cast<UnresolvedUsingType>(EffectiveType)) {
814 return matchesDecl(S->getDecl(), Finder, Builder);
815 }
816 if (const auto *S = dyn_cast<ObjCObjectType>(EffectiveType)) {
817 return matchesDecl(S->getInterface(), Finder, Builder);
818 }
819
820 // A SubstTemplateTypeParmType exists solely to mark a type substitution
821 // on the instantiated template. As users usually want to match the
822 // template parameter on the uninitialized template, we can always desugar
823 // one level without loss of expressivness.
824 // For example, given:
825 // template<typename T> struct X { T t; } class A {}; X<A> a;
826 // The following matcher will match, which otherwise would not:
827 // fieldDecl(hasType(pointerType())).
828 if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(EffectiveType)) {
829 return matchesSpecialized(S->getReplacementType(), Finder, Builder);
830 }
831
832 // For template specialization types, we want to match the template
833 // declaration, as long as the type is still dependent, and otherwise the
834 // declaration of the instantiated tag type.
835 if (const auto *S = dyn_cast<TemplateSpecializationType>(EffectiveType)) {
836 if (!S->isTypeAlias() && S->isSugared()) {
837 // If the template is non-dependent, we want to match the instantiated
838 // tag type.
839 // For example, given:
840 // template<typename T> struct X {}; X<int> a;
841 // The following matcher will match, which otherwise would not:
842 // templateSpecializationType(hasDeclaration(cxxRecordDecl())).
843 return matchesSpecialized(*S->desugar(), Finder, Builder);
844 }
845 // If the template is dependent or an alias, match the template
846 // declaration.
847 return matchesDecl(S->getTemplateName().getAsTemplateDecl(), Finder,
848 Builder);
849 }
850
851 // FIXME: We desugar elaborated types. This makes the assumption that users
852 // do never want to match on whether a type is elaborated - there are
853 // arguments for both sides; for now, continue desugaring.
854 if (const auto *S = dyn_cast<ElaboratedType>(EffectiveType)) {
855 return matchesSpecialized(S->desugar(), Finder, Builder);
856 }
857 return false;
858 }
859
860 /// Extracts the Decl the DeclRefExpr references and returns whether
861 /// the inner matcher matches on it.
862 bool matchesSpecialized(const DeclRefExpr &Node, ASTMatchFinder *Finder,
863 BoundNodesTreeBuilder *Builder) const {
864 return matchesDecl(Node.getDecl(), Finder, Builder);
865 }
866
867 /// Extracts the Decl of the callee of a CallExpr and returns whether
868 /// the inner matcher matches on it.
869 bool matchesSpecialized(const CallExpr &Node, ASTMatchFinder *Finder,
870 BoundNodesTreeBuilder *Builder) const {
871 return matchesDecl(Node.getCalleeDecl(), Finder, Builder);
872 }
873
874 /// Extracts the Decl of the constructor call and returns whether the
875 /// inner matcher matches on it.
876 bool matchesSpecialized(const CXXConstructExpr &Node,
877 ASTMatchFinder *Finder,
878 BoundNodesTreeBuilder *Builder) const {
879 return matchesDecl(Node.getConstructor(), Finder, Builder);
880 }
881
882 bool matchesSpecialized(const ObjCIvarRefExpr &Node,
883 ASTMatchFinder *Finder,
884 BoundNodesTreeBuilder *Builder) const {
885 return matchesDecl(Node.getDecl(), Finder, Builder);
886 }
887
888 /// Extracts the operator new of the new call and returns whether the
889 /// inner matcher matches on it.
890 bool matchesSpecialized(const CXXNewExpr &Node,
891 ASTMatchFinder *Finder,
892 BoundNodesTreeBuilder *Builder) const {
893 return matchesDecl(Node.getOperatorNew(), Finder, Builder);
894 }
895
896 /// Extracts the \c ValueDecl a \c MemberExpr refers to and returns
897 /// whether the inner matcher matches on it.
898 bool matchesSpecialized(const MemberExpr &Node,
899 ASTMatchFinder *Finder,
900 BoundNodesTreeBuilder *Builder) const {
901 return matchesDecl(Node.getMemberDecl(), Finder, Builder);
902 }
903
904 /// Extracts the \c LabelDecl a \c AddrLabelExpr refers to and returns
905 /// whether the inner matcher matches on it.
906 bool matchesSpecialized(const AddrLabelExpr &Node,
907 ASTMatchFinder *Finder,
908 BoundNodesTreeBuilder *Builder) const {
909 return matchesDecl(Node.getLabel(), Finder, Builder);
910 }
911
912 /// Extracts the declaration of a LabelStmt and returns whether the
913 /// inner matcher matches on it.
914 bool matchesSpecialized(const LabelStmt &Node, ASTMatchFinder *Finder,
915 BoundNodesTreeBuilder *Builder) const {
916 return matchesDecl(Node.getDecl(), Finder, Builder);
917 }
918
919 /// Returns whether the inner matcher \c Node. Returns false if \c Node
920 /// is \c NULL.
921 bool matchesDecl(const Decl *Node, ASTMatchFinder *Finder,
922 BoundNodesTreeBuilder *Builder) const {
923 return Node != nullptr &&
924 this->InnerMatcher.matches(
925 ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
926 }
927 };
928
929 /// IsBaseType<T>::value is true if T is a "base" type in the AST
930 /// node class hierarchies.
931 template <typename T>
932 struct IsBaseType {
933 static const bool value =
934 std::is_same<T, Decl>::value ||
935 std::is_same<T, Stmt>::value ||
936 std::is_same<T, QualType>::value ||
937 std::is_same<T, Type>::value ||
938 std::is_same<T, TypeLoc>::value ||
939 std::is_same<T, NestedNameSpecifier>::value ||
940 std::is_same<T, NestedNameSpecifierLoc>::value ||
941 std::is_same<T, CXXCtorInitializer>::value;
942 };
943 template <typename T>
944 const bool IsBaseType<T>::value;
945
946 /// Interface that allows matchers to traverse the AST.
947 /// FIXME: Find a better name.
948 ///
949 /// This provides three entry methods for each base node type in the AST:
950 /// - \c matchesChildOf:
951 /// Matches a matcher on every child node of the given node. Returns true
952 /// if at least one child node could be matched.
953 /// - \c matchesDescendantOf:
954 /// Matches a matcher on all descendant nodes of the given node. Returns true
955 /// if at least one descendant matched.
956 /// - \c matchesAncestorOf:
957 /// Matches a matcher on all ancestors of the given node. Returns true if
958 /// at least one ancestor matched.
959 ///
960 /// FIXME: Currently we only allow Stmt and Decl nodes to start a traversal.
961 /// In the future, we want to implement this for all nodes for which it makes
962 /// sense. In the case of matchesAncestorOf, we'll want to implement it for
963 /// all nodes, as all nodes have ancestors.
964 class ASTMatchFinder {
965 public:
966
967 /// Defines how bindings are processed on recursive matches.
968 enum BindKind {
969 /// Stop at the first match and only bind the first match.
970 BK_First,
971
972 /// Create results for all combinations of bindings that match.
973 BK_All
974 };
975
976 /// Defines which ancestors are considered for a match.
977 enum AncestorMatchMode {
978 /// All ancestors.
979 AMM_All,
980
981 /// Direct parent only.
982 AMM_ParentOnly
983 };
984
985 virtual ~ASTMatchFinder() = default;
986
987 /// Returns true if the given C++ class is directly or indirectly derived
988 /// from a base type matching \c base.
989 ///
990 /// A class is not considered to be derived from itself.
991 virtual bool classIsDerivedFrom(const CXXRecordDecl *Declaration,
992 const Matcher<NamedDecl> &Base,
993 BoundNodesTreeBuilder *Builder,
994 bool Directly) = 0;
995
996 /// Returns true if the given Objective-C class is directly or indirectly
997 /// derived from a base class matching \c base.
998 ///
999 /// A class is not considered to be derived from itself.
1000 virtual bool objcClassIsDerivedFrom(const ObjCInterfaceDecl *Declaration,
1001 const Matcher<NamedDecl> &Base,
1002 BoundNodesTreeBuilder *Builder,
1003 bool Directly) = 0;
1004
1005 template <typename T>
1006 bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
1007 BoundNodesTreeBuilder *Builder,
1008 ast_type_traits::TraversalKind Traverse, BindKind Bind) {
1009 static_assert(std::is_base_of<Decl, T>::value ||
1010 std::is_base_of<Stmt, T>::value ||
1011 std::is_base_of<NestedNameSpecifier, T>::value ||
1012 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1013 std::is_base_of<TypeLoc, T>::value ||
1014 std::is_base_of<QualType, T>::value,
1015 "unsupported type for recursive matching");
1016 return matchesChildOf(ast_type_traits::DynTypedNode::create(Node),
1017 getASTContext(), Matcher, Builder, Traverse, Bind);
1018 }
1019
1020 template <typename T>
1021 bool matchesDescendantOf(const T &Node,
1022 const DynTypedMatcher &Matcher,
1023 BoundNodesTreeBuilder *Builder,
1024 BindKind Bind) {
1025 static_assert(std::is_base_of<Decl, T>::value ||
1026 std::is_base_of<Stmt, T>::value ||
1027 std::is_base_of<NestedNameSpecifier, T>::value ||
1028 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1029 std::is_base_of<TypeLoc, T>::value ||
1030 std::is_base_of<QualType, T>::value,
1031 "unsupported type for recursive matching");
1032 return matchesDescendantOf(ast_type_traits::DynTypedNode::create(Node),
1033 getASTContext(), Matcher, Builder, Bind);
1034 }
1035
1036 // FIXME: Implement support for BindKind.
1037 template <typename T>
1038 bool matchesAncestorOf(const T &Node,
1039 const DynTypedMatcher &Matcher,
1040 BoundNodesTreeBuilder *Builder,
1041 AncestorMatchMode MatchMode) {
1042 static_assert(std::is_base_of<Decl, T>::value ||
1043 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1044 std::is_base_of<Stmt, T>::value ||
1045 std::is_base_of<TypeLoc, T>::value,
1046 "type not allowed for recursive matching");
1047 return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node),
1048 getASTContext(), Matcher, Builder, MatchMode);
1049 }
1050
1051 virtual ASTContext &getASTContext() const = 0;
1052
1053 protected:
1054 virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
1055 ASTContext &Ctx, const DynTypedMatcher &Matcher,
1056 BoundNodesTreeBuilder *Builder,
1057 ast_type_traits::TraversalKind Traverse,
1058 BindKind Bind) = 0;
1059
1060 virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
1061 ASTContext &Ctx,
1062 const DynTypedMatcher &Matcher,
1063 BoundNodesTreeBuilder *Builder,
1064 BindKind Bind) = 0;
1065
1066 virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
1067 ASTContext &Ctx,
1068 const DynTypedMatcher &Matcher,
1069 BoundNodesTreeBuilder *Builder,
1070 AncestorMatchMode MatchMode) = 0;
1071 };
1072
1073 /// A type-list implementation.
1074 ///
1075 /// A "linked list" of types, accessible by using the ::head and ::tail
1076 /// typedefs.
1077 template <typename... Ts> struct TypeList {}; // Empty sentinel type list.
1078
1079 template <typename T1, typename... Ts> struct TypeList<T1, Ts...> {
1080 /// The first type on the list.
1081 using head = T1;
1082
1083 /// A sublist with the tail. ie everything but the head.
1084 ///
1085 /// This type is used to do recursion. TypeList<>/EmptyTypeList indicates the
1086 /// end of the list.
1087 using tail = TypeList<Ts...>;
1088 };
1089
1090 /// The empty type list.
1091 using EmptyTypeList = TypeList<>;
1092
1093 /// Helper meta-function to determine if some type \c T is present or
1094 /// a parent type in the list.
1095 template <typename AnyTypeList, typename T>
1096 struct TypeListContainsSuperOf {
1097 static const bool value =
1098 std::is_base_of<typename AnyTypeList::head, T>::value ||
1099 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
1100 };
1101 template <typename T>
1102 struct TypeListContainsSuperOf<EmptyTypeList, T> {
1103 static const bool value = false;
1104 };
1105
1106 /// A "type list" that contains all types.
1107 ///
1108 /// Useful for matchers like \c anything and \c unless.
1109 using AllNodeBaseTypes =
1110 TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, QualType,
1111 Type, TypeLoc, CXXCtorInitializer>;
1112
1113 /// Helper meta-function to extract the argument out of a function of
1114 /// type void(Arg).
1115 ///
1116 /// See AST_POLYMORPHIC_SUPPORTED_TYPES for details.
1117 template <class T> struct ExtractFunctionArgMeta;
1118 template <class T> struct ExtractFunctionArgMeta<void(T)> {
1119 using type = T;
1120 };
1121
1122 /// Default type lists for ArgumentAdaptingMatcher matchers.
1123 using AdaptativeDefaultFromTypes = AllNodeBaseTypes;
1124 using AdaptativeDefaultToTypes =
1125 TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, TypeLoc,
1126 QualType>;
1127
1128 /// All types that are supported by HasDeclarationMatcher above.
1129 using HasDeclarationSupportedTypes =
1130 TypeList<CallExpr, CXXConstructExpr, CXXNewExpr, DeclRefExpr, EnumType,
1131 ElaboratedType, InjectedClassNameType, LabelStmt, AddrLabelExpr,
1132 MemberExpr, QualType, RecordType, TagType,
1133 TemplateSpecializationType, TemplateTypeParmType, TypedefType,
1134 UnresolvedUsingType, ObjCIvarRefExpr>;
1135
1136 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
1137 typename T, typename ToTypes>
1138 class ArgumentAdaptingMatcherFuncAdaptor {
1139 public:
1140 explicit ArgumentAdaptingMatcherFuncAdaptor(const Matcher<T> &InnerMatcher)
1141 : InnerMatcher(InnerMatcher) {}
1142
1143 using ReturnTypes = ToTypes;
1144
1145 template <typename To> operator Matcher<To>() const {
1146 return Matcher<To>(new ArgumentAdapterT<To, T>(InnerMatcher));
1147 }
1148
1149 private:
1150 const Matcher<T> InnerMatcher;
1151 };
1152
1153 /// Converts a \c Matcher<T> to a matcher of desired type \c To by
1154 /// "adapting" a \c To into a \c T.
1155 ///
1156 /// The \c ArgumentAdapterT argument specifies how the adaptation is done.
1157 ///
1158 /// For example:
1159 /// \c ArgumentAdaptingMatcher<HasMatcher, T>(InnerMatcher);
1160 /// Given that \c InnerMatcher is of type \c Matcher<T>, this returns a matcher
1161 /// that is convertible into any matcher of type \c To by constructing
1162 /// \c HasMatcher<To, T>(InnerMatcher).
1163 ///
1164 /// If a matcher does not need knowledge about the inner type, prefer to use
1165 /// PolymorphicMatcherWithParam1.
1166 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
1167 typename FromTypes = AdaptativeDefaultFromTypes,
1168 typename ToTypes = AdaptativeDefaultToTypes>
1169 struct ArgumentAdaptingMatcherFunc {
1170 template <typename T>
1171 static ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>
1172 create(const Matcher<T> &InnerMatcher) {
1173 return ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>(
1174 InnerMatcher);
1175 }
1176
1177 template <typename T>
1178 ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>
1179 operator()(const Matcher<T> &InnerMatcher) const {
1180 return create(InnerMatcher);
1181 }
1182 };
1183
1184 template <typename T>
1185 class TraversalMatcher : public WrapperMatcherInterface<T> {
1186 ast_type_traits::TraversalKind Traversal;
1187
1188 public:
1189 explicit TraversalMatcher(ast_type_traits::TraversalKind TK,
1190 const Matcher<T> &ChildMatcher)
1191 : TraversalMatcher::WrapperMatcherInterface(ChildMatcher), Traversal(TK) {
1192 }
1193
1194 bool matches(const T &Node, ASTMatchFinder *Finder,
1195 BoundNodesTreeBuilder *Builder) const override {
1196 return this->InnerMatcher.matches(
1197 ast_type_traits::DynTypedNode::create(Node), Finder, Builder);
1198 }
1199
1200 llvm::Optional<ast_type_traits::TraversalKind>
1201 TraversalKind() const override {
1202 return Traversal;
1203 }
1204 };
1205
1206 template <typename MatcherType> class TraversalWrapper {
1207 public:
1208 TraversalWrapper(ast_type_traits::TraversalKind TK,
1209 const MatcherType &InnerMatcher)
1210 : TK(TK), InnerMatcher(InnerMatcher) {}
1211
1212 template <typename T> operator Matcher<T>() const {
1213 return internal::DynTypedMatcher::constructRestrictedWrapper(
1214 new internal::TraversalMatcher<T>(TK, InnerMatcher),
1215 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1216 .template unconditionalConvertTo<T>();
1217 }
1218
1219 private:
1220 ast_type_traits::TraversalKind TK;
1221 MatcherType InnerMatcher;
1222 };
1223
1224 /// A PolymorphicMatcherWithParamN<MatcherT, P1, ..., PN> object can be
1225 /// created from N parameters p1, ..., pN (of type P1, ..., PN) and
1226 /// used as a Matcher<T> where a MatcherT<T, P1, ..., PN>(p1, ..., pN)
1227 /// can be constructed.
1228 ///
1229 /// For example:
1230 /// - PolymorphicMatcherWithParam0<IsDefinitionMatcher>()
1231 /// creates an object that can be used as a Matcher<T> for any type T
1232 /// where an IsDefinitionMatcher<T>() can be constructed.
1233 /// - PolymorphicMatcherWithParam1<ValueEqualsMatcher, int>(42)
1234 /// creates an object that can be used as a Matcher<T> for any type T
1235 /// where a ValueEqualsMatcher<T, int>(42) can be constructed.
1236 template <template <typename T> class MatcherT,
1237 typename ReturnTypesF = void(AllNodeBaseTypes)>
1238 class PolymorphicMatcherWithParam0 {
1239 public:
1240 using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
1241
1242 template <typename T>
1243 operator Matcher<T>() const {
1244 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1245 "right polymorphic conversion");
1246 return Matcher<T>(new MatcherT<T>());
1247 }
1248 };
1249
1250 template <template <typename T, typename P1> class MatcherT,
1251 typename P1,
1252 typename ReturnTypesF = void(AllNodeBaseTypes)>
1253 class PolymorphicMatcherWithParam1 {
1254 public:
1255 explicit PolymorphicMatcherWithParam1(const P1 &Param1)
1256 : Param1(Param1) {}
1257
1258 using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
1259
1260 template <typename T>
1261 operator Matcher<T>() const {
1262 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1263 "right polymorphic conversion");
1264 return Matcher<T>(new MatcherT<T, P1>(Param1));
1265 }
1266
1267 private:
1268 const P1 Param1;
1269 };
1270
1271 template <template <typename T, typename P1, typename P2> class MatcherT,
1272 typename P1, typename P2,
1273 typename ReturnTypesF = void(AllNodeBaseTypes)>
1274 class PolymorphicMatcherWithParam2 {
1275 public:
1276 PolymorphicMatcherWithParam2(const P1 &Param1, const P2 &Param2)
1277 : Param1(Param1), Param2(Param2) {}
1278
1279 using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
1280
1281 template <typename T>
1282 operator Matcher<T>() const {
1283 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1284 "right polymorphic conversion");
1285 return Matcher<T>(new MatcherT<T, P1, P2>(Param1, Param2));
1286 }
1287
1288 private:
1289 const P1 Param1;
1290 const P2 Param2;
1291 };
1292
1293 /// Matches any instance of the given NodeType.
1294 ///
1295 /// This is useful when a matcher syntactically requires a child matcher,
1296 /// but the context doesn't care. See for example: anything().
1297 class TrueMatcher {
1298 public:
1299 using ReturnTypes = AllNodeBaseTypes;
1300
1301 template <typename T>
1302 operator Matcher<T>() const {
1303 return DynTypedMatcher::trueMatcher(
1304 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1305 .template unconditionalConvertTo<T>();
1306 }
1307 };
1308
1309 /// A Matcher that allows binding the node it matches to an id.
1310 ///
1311 /// BindableMatcher provides a \a bind() method that allows binding the
1312 /// matched node to an id if the match was successful.
1313 template <typename T>
1314 class BindableMatcher : public Matcher<T> {
1315 public:
1316 explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
1317 explicit BindableMatcher(MatcherInterface<T> *Implementation)
1318 : Matcher<T>(Implementation) {}
1319
1320 /// Returns a matcher that will bind the matched node on a match.
1321 ///
1322 /// The returned matcher is equivalent to this matcher, but will
1323 /// bind the matched node on a match.
1324 Matcher<T> bind(StringRef ID) const {
1325 return DynTypedMatcher(*this)
1326 .tryBind(ID)
1327 ->template unconditionalConvertTo<T>();
1328 }
1329
1330 /// Same as Matcher<T>'s conversion operator, but enables binding on
1331 /// the returned matcher.
1332 operator DynTypedMatcher() const {
1333 DynTypedMatcher Result = static_cast<const Matcher<T>&>(*this);
1334 Result.setAllowBind(true);
1335 return Result;
1336 }
1337 };
1338
1339 /// Matches nodes of type T that have child nodes of type ChildT for
1340 /// which a specified child matcher matches.
1341 ///
1342 /// ChildT must be an AST base type.
1343 template <typename T, typename ChildT>
1344 class HasMatcher : public WrapperMatcherInterface<T> {
1345 public:
1346 explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
1347 : HasMatcher::WrapperMatcherInterface(ChildMatcher) {}
1348
1349 bool matches(const T &Node, ASTMatchFinder *Finder,
1350 BoundNodesTreeBuilder *Builder) const override {
1351 return Finder->matchesChildOf(Node, this->InnerMatcher, Builder,
1352 ast_type_traits::TraversalKind::TK_AsIs,
1353 ASTMatchFinder::BK_First);
1354 }
1355 };
1356
1357 /// Matches nodes of type T that have child nodes of type ChildT for
1358 /// which a specified child matcher matches. ChildT must be an AST base
1359 /// type.
1360 /// As opposed to the HasMatcher, the ForEachMatcher will produce a match
1361 /// for each child that matches.
1362 template <typename T, typename ChildT>
1363 class ForEachMatcher : public WrapperMatcherInterface<T> {
1364 static_assert(IsBaseType<ChildT>::value,
1365 "for each only accepts base type matcher");
1366
1367 public:
1368 explicit ForEachMatcher(const Matcher<ChildT> &ChildMatcher)
1369 : ForEachMatcher::WrapperMatcherInterface(ChildMatcher) {}
1370
1371 bool matches(const T& Node, ASTMatchFinder* Finder,
1372 BoundNodesTreeBuilder* Builder) const override {
1373 return Finder->matchesChildOf(
1374 Node, this->InnerMatcher, Builder,
1375 ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
1376 ASTMatchFinder::BK_All);
1377 }
1378 };
1379
1380 /// VariadicOperatorMatcher related types.
1381 /// @{
1382
1383 /// Polymorphic matcher object that uses a \c
1384 /// DynTypedMatcher::VariadicOperator operator.
1385 ///
1386 /// Input matchers can have any type (including other polymorphic matcher
1387 /// types), and the actual Matcher<T> is generated on demand with an implicit
1388 /// conversion operator.
1389 template <typename... Ps> class VariadicOperatorMatcher {
1390 public:
1391 VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params)
1392 : Op(Op), Params(std::forward<Ps>(Params)...) {}
1393
1394 template <typename T> operator Matcher<T>() const {
1395 return DynTypedMatcher::constructVariadic(
1396 Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1397 getMatchers<T>(std::index_sequence_for<Ps...>()))
1398 .template unconditionalConvertTo<T>();
1399 }
1400
1401 private:
1402 // Helper method to unpack the tuple into a vector.
1403 template <typename T, std::size_t... Is>
1404 std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) const {
1405 return {Matcher<T>(std::get<Is>(Params))...};
1406 }
1407
1408 const DynTypedMatcher::VariadicOperator Op;
1409 std::tuple<Ps...> Params;
1410 };
1411
1412 /// Overloaded function object to generate VariadicOperatorMatcher
1413 /// objects from arbitrary matchers.
1414 template <unsigned MinCount, unsigned MaxCount>
1415 struct VariadicOperatorMatcherFunc {
1416 DynTypedMatcher::VariadicOperator Op;
1417
1418 template <typename... Ms>
1419 VariadicOperatorMatcher<Ms...> operator()(Ms &&... Ps) const {
1420 static_assert(MinCount <= sizeof...(Ms) && sizeof...(Ms) <= MaxCount,
1421 "invalid number of parameters for variadic matcher");
1422 return VariadicOperatorMatcher<Ms...>(Op, std::forward<Ms>(Ps)...);
1423 }
1424 };
1425
1426 /// @}
1427
1428 template <typename T>
1429 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
1430 return Matcher<T>(*this);
1431 }
1432
1433 /// Creates a Matcher<T> that matches if all inner matchers match.
1434 template<typename T>
1435 BindableMatcher<T> makeAllOfComposite(
1436 ArrayRef<const Matcher<T> *> InnerMatchers) {
1437 // For the size() == 0 case, we return a "true" matcher.
1438 if (InnerMatchers.empty()) {
1439 return BindableMatcher<T>(TrueMatcher());
1440 }
1441 // For the size() == 1 case, we simply return that one matcher.
1442 // No need to wrap it in a variadic operation.
1443 if (InnerMatchers.size() == 1) {
1444 return BindableMatcher<T>(*InnerMatchers[0]);
1445 }
1446
1447 using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
1448
1449 std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()),
1450 PI(InnerMatchers.end()));
1451 return BindableMatcher<T>(
1452 DynTypedMatcher::constructVariadic(
1453 DynTypedMatcher::VO_AllOf,
1454 ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1455 std::move(DynMatchers))
1456 .template unconditionalConvertTo<T>());
1457 }
1458
1459 /// Creates a Matcher<T> that matches if
1460 /// T is dyn_cast'able into InnerT and all inner matchers match.
1461 ///
1462 /// Returns BindableMatcher, as matchers that use dyn_cast have
1463 /// the same object both to match on and to run submatchers on,
1464 /// so there is no ambiguity with what gets bound.
1465 template<typename T, typename InnerT>
1466 BindableMatcher<T> makeDynCastAllOfComposite(
1467 ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
1468 return BindableMatcher<T>(
1469 makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
1470 }
1471
1472 /// Matches nodes of type T that have at least one descendant node of
1473 /// type DescendantT for which the given inner matcher matches.
1474 ///
1475 /// DescendantT must be an AST base type.
1476 template <typename T, typename DescendantT>
1477 class HasDescendantMatcher : public WrapperMatcherInterface<T> {
1478 static_assert(IsBaseType<DescendantT>::value,
1479 "has descendant only accepts base type matcher");
1480
1481 public:
1482 explicit HasDescendantMatcher(const Matcher<DescendantT> &DescendantMatcher)
1483 : HasDescendantMatcher::WrapperMatcherInterface(DescendantMatcher) {}
1484
1485 bool matches(const T &Node, ASTMatchFinder *Finder,
1486 BoundNodesTreeBuilder *Builder) const override {
1487 return Finder->matchesDescendantOf(Node, this->InnerMatcher, Builder,
1488 ASTMatchFinder::BK_First);
1489 }
1490 };
1491
1492 /// Matches nodes of type \c T that have a parent node of type \c ParentT
1493 /// for which the given inner matcher matches.
1494 ///
1495 /// \c ParentT must be an AST base type.
1496 template <typename T, typename ParentT>
1497 class HasParentMatcher : public WrapperMatcherInterface<T> {
1498 static_assert(IsBaseType<ParentT>::value,
1499 "has parent only accepts base type matcher");
1500
1501 public:
1502 explicit HasParentMatcher(const Matcher<ParentT> &ParentMatcher)
1503 : HasParentMatcher::WrapperMatcherInterface(ParentMatcher) {}
1504
1505 bool matches(const T &Node, ASTMatchFinder *Finder,
1506 BoundNodesTreeBuilder *Builder) const override {
1507 return Finder->matchesAncestorOf(Node, this->InnerMatcher, Builder,
1508 ASTMatchFinder::AMM_ParentOnly);
1509 }
1510 };
1511
1512 /// Matches nodes of type \c T that have at least one ancestor node of
1513 /// type \c AncestorT for which the given inner matcher matches.
1514 ///
1515 /// \c AncestorT must be an AST base type.
1516 template <typename T, typename AncestorT>
1517 class HasAncestorMatcher : public WrapperMatcherInterface<T> {
1518 static_assert(IsBaseType<AncestorT>::value,
1519 "has ancestor only accepts base type matcher");
1520
1521 public:
1522 explicit HasAncestorMatcher(const Matcher<AncestorT> &AncestorMatcher)
1523 : HasAncestorMatcher::WrapperMatcherInterface(AncestorMatcher) {}
1524
1525 bool matches(const T &Node, ASTMatchFinder *Finder,
1526 BoundNodesTreeBuilder *Builder) const override {
1527 return Finder->matchesAncestorOf(Node, this->InnerMatcher, Builder,
1528 ASTMatchFinder::AMM_All);
1529 }
1530 };
1531
1532 /// Matches nodes of type T that have at least one descendant node of
1533 /// type DescendantT for which the given inner matcher matches.
1534 ///
1535 /// DescendantT must be an AST base type.
1536 /// As opposed to HasDescendantMatcher, ForEachDescendantMatcher will match
1537 /// for each descendant node that matches instead of only for the first.
1538 template <typename T, typename DescendantT>
1539 class ForEachDescendantMatcher : public WrapperMatcherInterface<T> {
1540 static_assert(IsBaseType<DescendantT>::value,
1541 "for each descendant only accepts base type matcher");
1542
1543 public:
1544 explicit ForEachDescendantMatcher(
1545 const Matcher<DescendantT> &DescendantMatcher)
1546 : ForEachDescendantMatcher::WrapperMatcherInterface(DescendantMatcher) {}
1547
1548 bool matches(const T &Node, ASTMatchFinder *Finder,
1549 BoundNodesTreeBuilder *Builder) const override {
1550 return Finder->matchesDescendantOf(Node, this->InnerMatcher, Builder,
1551 ASTMatchFinder::BK_All);
1552 }
1553 };
1554
1555 /// Matches on nodes that have a getValue() method if getValue() equals
1556 /// the value the ValueEqualsMatcher was constructed with.
1557 template <typename T, typename ValueT>
1558 class ValueEqualsMatcher : public SingleNodeMatcherInterface<T> {
1559 static_assert(std::is_base_of<CharacterLiteral, T>::value ||
1560 std::is_base_of<CXXBoolLiteralExpr, T>::value ||
1561 std::is_base_of<FloatingLiteral, T>::value ||
1562 std::is_base_of<IntegerLiteral, T>::value,
1563 "the node must have a getValue method");
1564
1565 public:
1566 explicit ValueEqualsMatcher(const ValueT &ExpectedValue)
1567 : ExpectedValue(ExpectedValue) {}
1568
1569 bool matchesNode(const T &Node) const override {
1570 return Node.getValue() == ExpectedValue;
1571 }
1572
1573 private:
1574 const ValueT ExpectedValue;
1575 };
1576
1577 /// Template specializations to easily write matchers for floating point
1578 /// literals.
1579 template <>
1580 inline bool ValueEqualsMatcher<FloatingLiteral, double>::matchesNode(
1581 const FloatingLiteral &Node) const {
1582 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
1583 return Node.getValue().convertToFloat() == ExpectedValue;
1584 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
1585 return Node.getValue().convertToDouble() == ExpectedValue;
1586 return false;
1587 }
1588 template <>
1589 inline bool ValueEqualsMatcher<FloatingLiteral, float>::matchesNode(
1590 const FloatingLiteral &Node) const {
1591 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
1592 return Node.getValue().convertToFloat() == ExpectedValue;
1593 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
1594 return Node.getValue().convertToDouble() == ExpectedValue;
1595 return false;
1596 }
1597 template <>
1598 inline bool ValueEqualsMatcher<FloatingLiteral, llvm::APFloat>::matchesNode(
1599 const FloatingLiteral &Node) const {
1600 return ExpectedValue.compare(Node.getValue()) == llvm::APFloat::cmpEqual;
1601 }
1602
1603 /// A VariadicDynCastAllOfMatcher<SourceT, TargetT> object is a
1604 /// variadic functor that takes a number of Matcher<TargetT> and returns a
1605 /// Matcher<SourceT> that matches TargetT nodes that are matched by all of the
1606 /// given matchers, if SourceT can be dynamically casted into TargetT.
1607 ///
1608 /// For example:
1609 /// const VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> record;
1610 /// Creates a functor record(...) that creates a Matcher<Decl> given
1611 /// a variable number of arguments of type Matcher<CXXRecordDecl>.
1612 /// The returned matcher matches if the given Decl can by dynamically
1613 /// casted to CXXRecordDecl and all given matchers match.
1614 template <typename SourceT, typename TargetT>
1615 class VariadicDynCastAllOfMatcher
1616 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1617 makeDynCastAllOfComposite<SourceT, TargetT>> {
1618 public:
1619 VariadicDynCastAllOfMatcher() {}
1620 };
1621
1622 /// A \c VariadicAllOfMatcher<T> object is a variadic functor that takes
1623 /// a number of \c Matcher<T> and returns a \c Matcher<T> that matches \c T
1624 /// nodes that are matched by all of the given matchers.
1625 ///
1626 /// For example:
1627 /// const VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
1628 /// Creates a functor nestedNameSpecifier(...) that creates a
1629 /// \c Matcher<NestedNameSpecifier> given a variable number of arguments of type
1630 /// \c Matcher<NestedNameSpecifier>.
1631 /// The returned matcher matches if all given matchers match.
1632 template <typename T>
1633 class VariadicAllOfMatcher
1634 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1635 makeAllOfComposite<T>> {
1636 public:
1637 VariadicAllOfMatcher() {}
1638 };
1639
1640 /// Matches nodes of type \c TLoc for which the inner
1641 /// \c Matcher<T> matches.
1642 template <typename TLoc, typename T>
1643 class LocMatcher : public WrapperMatcherInterface<TLoc> {
1644 public:
1645 explicit LocMatcher(const Matcher<T> &InnerMatcher)
1646 : LocMatcher::WrapperMatcherInterface(InnerMatcher) {}
1647
1648 bool matches(const TLoc &Node, ASTMatchFinder *Finder,
1649 BoundNodesTreeBuilder *Builder) const override {
1650 if (!Node)
1651 return false;
1652 return this->InnerMatcher.matches(extract(Node), Finder, Builder);
1653 }
1654
1655 private:
1656 static ast_type_traits::DynTypedNode
1657 extract(const NestedNameSpecifierLoc &Loc) {
1658 return ast_type_traits::DynTypedNode::create(*Loc.getNestedNameSpecifier());
1659 }
1660 };
1661
1662 /// Matches \c TypeLocs based on an inner matcher matching a certain
1663 /// \c QualType.
1664 ///
1665 /// Used to implement the \c loc() matcher.
1666 class TypeLocTypeMatcher : public WrapperMatcherInterface<TypeLoc> {
1667 public:
1668 explicit TypeLocTypeMatcher(const Matcher<QualType> &InnerMatcher)
1669 : TypeLocTypeMatcher::WrapperMatcherInterface(InnerMatcher) {}
1670
1671 bool matches(const TypeLoc &Node, ASTMatchFinder *Finder,
1672 BoundNodesTreeBuilder *Builder) const override {
1673 if (!Node)
1674 return false;
1675 return this->InnerMatcher.matches(
1676 ast_type_traits::DynTypedNode::create(Node.getType()), Finder, Builder);
1677 }
1678 };
1679
1680 /// Matches nodes of type \c T for which the inner matcher matches on a
1681 /// another node of type \c T that can be reached using a given traverse
1682 /// function.
1683 template <typename T>
1684 class TypeTraverseMatcher : public WrapperMatcherInterface<T> {
1685 public:
1686 explicit TypeTraverseMatcher(const Matcher<QualType> &InnerMatcher,
1687 QualType (T::*TraverseFunction)() const)
1688 : TypeTraverseMatcher::WrapperMatcherInterface(InnerMatcher),
1689 TraverseFunction(TraverseFunction) {}
1690
1691 bool matches(const T &Node, ASTMatchFinder *Finder,
1692 BoundNodesTreeBuilder *Builder) const override {
1693 QualType NextNode = (Node.*TraverseFunction)();
1694 if (NextNode.isNull())
1695 return false;
1696 return this->InnerMatcher.matches(
1697 ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder);
1698 }
1699
1700 private:
1701 QualType (T::*TraverseFunction)() const;
1702 };
1703
1704 /// Matches nodes of type \c T in a ..Loc hierarchy, for which the inner
1705 /// matcher matches on a another node of type \c T that can be reached using a
1706 /// given traverse function.
1707 template <typename T>
1708 class TypeLocTraverseMatcher : public WrapperMatcherInterface<T> {
1709 public:
1710 explicit TypeLocTraverseMatcher(const Matcher<TypeLoc> &InnerMatcher,
1711 TypeLoc (T::*TraverseFunction)() const)
1712 : TypeLocTraverseMatcher::WrapperMatcherInterface(InnerMatcher),
1713 TraverseFunction(TraverseFunction) {}
1714
1715 bool matches(const T &Node, ASTMatchFinder *Finder,
1716 BoundNodesTreeBuilder *Builder) const override {
1717 TypeLoc NextNode = (Node.*TraverseFunction)();
1718 if (!NextNode)
1719 return false;
1720 return this->InnerMatcher.matches(
1721 ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder);
1722 }
1723
1724 private:
1725 TypeLoc (T::*TraverseFunction)() const;
1726 };
1727
1728 /// Converts a \c Matcher<InnerT> to a \c Matcher<OuterT>, where
1729 /// \c OuterT is any type that is supported by \c Getter.
1730 ///
1731 /// \code Getter<OuterT>::value() \endcode returns a
1732 /// \code InnerTBase (OuterT::*)() \endcode, which is used to adapt a \c OuterT
1733 /// object into a \c InnerT
1734 template <typename InnerTBase,
1735 template <typename OuterT> class Getter,
1736 template <typename OuterT> class MatcherImpl,
1737 typename ReturnTypesF>
1738 class TypeTraversePolymorphicMatcher {
1739 private:
1740 using Self = TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl,
1741 ReturnTypesF>;
1742
1743 static Self create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers);
1744
1745 public:
1746 using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
1747
1748 explicit TypeTraversePolymorphicMatcher(
1749 ArrayRef<const Matcher<InnerTBase> *> InnerMatchers)
1750 : InnerMatcher(makeAllOfComposite(InnerMatchers)) {}
1751
1752 template <typename OuterT> operator Matcher<OuterT>() const {
1753 return Matcher<OuterT>(
1754 new MatcherImpl<OuterT>(InnerMatcher, Getter<OuterT>::value()));
1755 }
1756
1757 struct Func
1758 : public VariadicFunction<Self, Matcher<InnerTBase>, &Self::create> {
1759 Func() {}
1760 };
1761
1762 private:
1763 const Matcher<InnerTBase> InnerMatcher;
1764 };
1765
1766 /// A simple memoizer of T(*)() functions.
1767 ///
1768 /// It will call the passed 'Func' template parameter at most once.
1769 /// Used to support AST_MATCHER_FUNCTION() macro.
1770 template <typename Matcher, Matcher (*Func)()> class MemoizedMatcher {
1771 struct Wrapper {
1772 Wrapper() : M(Func()) {}
1773
1774 Matcher M;
1775 };
1776
1777 public:
1778 static const Matcher &getInstance() {
1779 static llvm::ManagedStatic<Wrapper> Instance;
1780 return Instance->M;
1781 }
1782 };
1783
1784 // Define the create() method out of line to silence a GCC warning about
1785 // the struct "Func" having greater visibility than its base, which comes from
1786 // using the flag -fvisibility-inlines-hidden.
1787 template <typename InnerTBase, template <typename OuterT> class Getter,
1788 template <typename OuterT> class MatcherImpl, typename ReturnTypesF>
1789 TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, ReturnTypesF>
1790 TypeTraversePolymorphicMatcher<
1791 InnerTBase, Getter, MatcherImpl,
1792 ReturnTypesF>::create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers) {
1793 return Self(InnerMatchers);
1794 }
1795
1796 // FIXME: unify ClassTemplateSpecializationDecl and TemplateSpecializationType's
1797 // APIs for accessing the template argument list.
1798 inline ArrayRef<TemplateArgument>
1799 getTemplateSpecializationArgs(const ClassTemplateSpecializationDecl &D) {
1800 return D.getTemplateArgs().asArray();
1801 }
1802
1803 inline ArrayRef<TemplateArgument>
1804 getTemplateSpecializationArgs(const TemplateSpecializationType &T) {
1805 return llvm::makeArrayRef(T.getArgs(), T.getNumArgs());
1806 }
1807
1808 inline ArrayRef<TemplateArgument>
1809 getTemplateSpecializationArgs(const FunctionDecl &FD) {
1810 if (const auto* TemplateArgs = FD.getTemplateSpecializationArgs())
1811 return TemplateArgs->asArray();
1812 return ArrayRef<TemplateArgument>();
1813 }
1814
1815 struct NotEqualsBoundNodePredicate {
1816 bool operator()(const internal::BoundNodesMap &Nodes) const {
1817 return Nodes.getNode(ID) != Node;
1818 }
1819
1820 std::string ID;
1821 ast_type_traits::DynTypedNode Node;
1822 };
1823
1824 template <typename Ty>
1825 struct GetBodyMatcher {
1826 static const Stmt *get(const Ty &Node) {
1827 return Node.getBody();
1828 }
1829 };
1830
1831 template <>
1832 inline const Stmt *GetBodyMatcher<FunctionDecl>::get(const FunctionDecl &Node) {
1833 return Node.doesThisDeclarationHaveABody() ? Node.getBody() : nullptr;
1834 }
1835
1836 template <typename Ty>
1837 struct HasSizeMatcher {
1838 static bool hasSize(const Ty &Node, unsigned int N) {
1839 return Node.getSize() == N;
1840 }
1841 };
1842
1843 template <>
1844 inline bool HasSizeMatcher<StringLiteral>::hasSize(
1845 const StringLiteral &Node, unsigned int N) {
1846 return Node.getLength() == N;
1847 }
1848
1849 template <typename Ty>
1850 struct GetSourceExpressionMatcher {
1851 static const Expr *get(const Ty &Node) {
1852 return Node.getSubExpr();
1853 }
1854 };
1855
1856 template <>
1857 inline const Expr *GetSourceExpressionMatcher<OpaqueValueExpr>::get(
1858 const OpaqueValueExpr &Node) {
1859 return Node.getSourceExpr();
1860 }
1861
1862 template <typename Ty>
1863 struct CompoundStmtMatcher {
1864 static const CompoundStmt *get(const Ty &Node) {
1865 return &Node;
1866 }
1867 };
1868
1869 template <>
1870 inline const CompoundStmt *
1871 CompoundStmtMatcher<StmtExpr>::get(const StmtExpr &Node) {
1872 return Node.getSubStmt();
1873 }
1874
1875 } // namespace internal
1876
1877 } // namespace ast_matchers
1878
1879 } // namespace clang
1880
1881 #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
clang::Builtin::ID
ID
Definition: Builtins.h:46
clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:638
Base
Type.h
C Language Family Type Representation.
DeclTemplate.h
Defines the C++ template declaration subclasses.
clang::CodeGen::AlignmentSource::Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
clang::ast_matchers::internal::hasAnyNameFunc
Matcher< NamedDecl > hasAnyNameFunc(ArrayRef< const StringRef *> NameRefs)
Definition: ASTMatchersInternal.cpp:382
ExprCXX.h
Defines the clang::Expr interface and subclasses for C++ expressions.
Nodes
BoundNodesTreeBuilder Nodes
Definition: ASTMatchFinder.cpp:74
llvm::Optional
Definition: LLVM.h:37
clang::ast_type_traits::TK_AsIs
Will traverse all child nodes.
Definition: ASTTypeTraits.h:42
std
Definition: Format.h:2445
size_t
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c-base.h:40
LLVM.h
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
ExprObjC.h
TemplateName.h
Traversal
ast_type_traits::TraversalKind Traversal
Definition: ASTMatchFinder.cpp:62
ASTTypeTraits.h
End
SourceLocation End
Definition: USRLocFinder.cpp:166
Id
int Id
Definition: ASTDiff.cpp:190
clang::ast_type_traits::TK_IgnoreImplicitCastsAndParentheses
Will not traverse implicit casts and parentheses.
Definition: ASTTypeTraits.h:46
OperatorKinds.h
Defines an enumeration for C++ overloaded operators.
TypeLoc.h
Defines the clang::TypeLoc interface and its subclasses.
Stmt.h
clang::syntax::NodeKind
NodeKind
A kind of a syntax node, used for implementing casts.
Definition: Nodes.h:37
Kind
Kind
Definition: ChrootChecker.cpp:29
getUnderlyingType
static QualType getUnderlyingType(const SubRegion *R)
Definition: RegionStore.cpp:1573
clang::operator<
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Definition: DeclarationName.h:540
clang::ast_type_traits::DynTypedNode::create
static DynTypedNode create(const T &Node)
Creates a DynTypedNode from Node.
Definition: ASTTypeTraits.h:234
clang::MultiVersionKind::None
BoundNodes
BoundNodesTreeBuilder BoundNodes
Definition: ASTMatchFinder.cpp:61
clang::diff::DynTypedNode
ast_type_traits::DynTypedNode DynTypedNode
Definition: ASTDiffInternal.h:18
NestedNameSpecifier.h
Node
ast_type_traits::DynTypedNode Node
Definition: ASTMatchFinder.cpp:60
Type
Optional< types::ID > Type
Definition: InterpolatingCompilationDatabase.cpp:127
Decl.h
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
ast_matchers
type
clang::serialized_diags::create
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Definition: SerializedDiagnosticPrinter.cpp:298
DeclFriend.h
clang::getOperatorSpelling
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
Definition: IdentifierTable.cpp:685
getNode
static Expected< DynTypedNode > getNode(const ast_matchers::BoundNodes &Nodes, StringRef ID)
Definition: RangeSelector.cpp:55
clang::ast_type_traits::TraversalKind
TraversalKind
Defines how we descend a level in the AST when we pass through expressions.
Definition: ASTTypeTraits.h:40
DeclCXX.h
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Expr.h
clang::threadSafety::sx::matches
bool matches(const til::SExpr *E1, const til::SExpr *E2)
Definition: ThreadSafetyCommon.h:67
clang::ast_matchers::internal::hasAnySelectorFunc
Matcher< ObjCMessageExpr > hasAnySelectorFunc(ArrayRef< const StringRef *> NameRefs)
Definition: ASTMatchersInternal.cpp:387