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