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 1882