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/ExprCXX.h" 44 #include "clang/AST/ExprObjC.h" 45 #include "clang/AST/NestedNameSpecifier.h" 46 #include "clang/AST/Stmt.h" 47 #include "clang/AST/TemplateName.h" 48 #include "clang/AST/Type.h" 49 #include "clang/AST/TypeLoc.h" 50 #include "clang/Basic/LLVM.h" 51 #include "clang/Basic/OperatorKinds.h" 52 #include "llvm/ADT/APFloat.h" 53 #include "llvm/ADT/ArrayRef.h" 54 #include "llvm/ADT/IntrusiveRefCntPtr.h" 55 #include "llvm/ADT/STLExtras.h" 56 #include "llvm/ADT/SmallVector.h" 57 #include "llvm/ADT/StringRef.h" 58 #include "llvm/ADT/iterator.h" 59 #include "llvm/Support/Casting.h" 60 #include "llvm/Support/ManagedStatic.h" 61 #include "llvm/Support/Regex.h" 62 #include <algorithm> 63 #include <cassert> 64 #include <cstddef> 65 #include <cstdint> 66 #include <map> 67 #include <memory> 68 #include <optional> 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 /// A type-list implementation. 86 /// 87 /// A "linked list" of types, accessible by using the ::head and ::tail 88 /// typedefs. 89 template <typename... Ts> struct TypeList {}; // Empty sentinel type list. 90 91 template <typename T1, typename... Ts> struct TypeList<T1, Ts...> { 92 /// The first type on the list. 93 using head = T1; 94 95 /// A sublist with the tail. ie everything but the head. 96 /// 97 /// This type is used to do recursion. TypeList<>/EmptyTypeList indicates the 98 /// end of the list. 99 using tail = TypeList<Ts...>; 100 }; 101 102 /// The empty type list. 103 using EmptyTypeList = TypeList<>; 104 105 /// Helper meta-function to determine if some type \c T is present or 106 /// a parent type in the list. 107 template <typename AnyTypeList, typename T> struct TypeListContainsSuperOf { 108 static const bool value = 109 std::is_base_of<typename AnyTypeList::head, T>::value || 110 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value; 111 }; 112 template <typename T> struct TypeListContainsSuperOf<EmptyTypeList, T> { 113 static const bool value = false; 114 }; 115 116 /// Variadic function object. 117 /// 118 /// Most of the functions below that use VariadicFunction could be implemented 119 /// using plain C++11 variadic functions, but the function object allows us to 120 /// capture it on the dynamic matcher registry. 121 template <typename ResultT, typename ArgT, 122 ResultT (*Func)(ArrayRef<const ArgT *>)> 123 struct VariadicFunction { 124 ResultT operator()() const { return Func(std::nullopt); } 125 126 template <typename... ArgsT> 127 ResultT operator()(const ArgT &Arg1, const ArgsT &... Args) const { 128 return Execute(Arg1, static_cast<const ArgT &>(Args)...); 129 } 130 131 // We also allow calls with an already created array, in case the caller 132 // already had it. 133 ResultT operator()(ArrayRef<ArgT> Args) const { 134 return Func(llvm::to_vector<8>(llvm::make_pointer_range(Args))); 135 } 136 137 private: 138 // Trampoline function to allow for implicit conversions to take place 139 // before we make the array. 140 template <typename... ArgsT> ResultT Execute(const ArgsT &... Args) const { 141 const ArgT *const ArgsArray[] = {&Args...}; 142 return Func(ArrayRef<const ArgT *>(ArgsArray, sizeof...(ArgsT))); 143 } 144 }; 145 146 /// Unifies obtaining the underlying type of a regular node through 147 /// `getType` and a TypedefNameDecl node through `getUnderlyingType`. 148 inline QualType getUnderlyingType(const Expr &Node) { return Node.getType(); } 149 150 inline QualType getUnderlyingType(const ValueDecl &Node) { 151 return Node.getType(); 152 } 153 inline QualType getUnderlyingType(const TypedefNameDecl &Node) { 154 return Node.getUnderlyingType(); 155 } 156 inline QualType getUnderlyingType(const FriendDecl &Node) { 157 if (const TypeSourceInfo *TSI = Node.getFriendType()) 158 return TSI->getType(); 159 return QualType(); 160 } 161 inline QualType getUnderlyingType(const CXXBaseSpecifier &Node) { 162 return Node.getType(); 163 } 164 165 /// Unifies obtaining a `TypeSourceInfo` from different node types. 166 template <typename T, 167 std::enable_if_t<TypeListContainsSuperOf< 168 TypeList<CXXBaseSpecifier, CXXCtorInitializer, 169 CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr, 170 CompoundLiteralExpr, DeclaratorDecl, ObjCPropertyDecl, 171 TemplateArgumentLoc, TypedefNameDecl>, 172 T>::value> * = nullptr> 173 inline TypeSourceInfo *GetTypeSourceInfo(const T &Node) { 174 return Node.getTypeSourceInfo(); 175 } 176 template <typename T, 177 std::enable_if_t<TypeListContainsSuperOf< 178 TypeList<CXXFunctionalCastExpr, ExplicitCastExpr>, T>::value> * = 179 nullptr> 180 inline TypeSourceInfo *GetTypeSourceInfo(const T &Node) { 181 return Node.getTypeInfoAsWritten(); 182 } 183 inline TypeSourceInfo *GetTypeSourceInfo(const BlockDecl &Node) { 184 return Node.getSignatureAsWritten(); 185 } 186 inline TypeSourceInfo *GetTypeSourceInfo(const CXXNewExpr &Node) { 187 return Node.getAllocatedTypeSourceInfo(); 188 } 189 inline TypeSourceInfo * 190 GetTypeSourceInfo(const ClassTemplateSpecializationDecl &Node) { 191 return Node.getTypeAsWritten(); 192 } 193 194 /// Unifies obtaining the FunctionProtoType pointer from both 195 /// FunctionProtoType and FunctionDecl nodes.. 196 inline const FunctionProtoType * 197 getFunctionProtoType(const FunctionProtoType &Node) { 198 return &Node; 199 } 200 201 inline const FunctionProtoType *getFunctionProtoType(const FunctionDecl &Node) { 202 return Node.getType()->getAs<FunctionProtoType>(); 203 } 204 205 /// Unifies obtaining the access specifier from Decl and CXXBaseSpecifier nodes. 206 inline clang::AccessSpecifier getAccessSpecifier(const Decl &Node) { 207 return Node.getAccess(); 208 } 209 210 inline clang::AccessSpecifier getAccessSpecifier(const CXXBaseSpecifier &Node) { 211 return Node.getAccessSpecifier(); 212 } 213 214 /// Internal version of BoundNodes. Holds all the bound nodes. 215 class BoundNodesMap { 216 public: 217 /// Adds \c Node to the map with key \c ID. 218 /// 219 /// The node's base type should be in NodeBaseType or it will be unaccessible. 220 void addNode(StringRef ID, const DynTypedNode &DynNode) { 221 NodeMap[std::string(ID)] = DynNode; 222 } 223 224 /// Returns the AST node bound to \c ID. 225 /// 226 /// Returns NULL if there was no node bound to \c ID or if there is a node but 227 /// it cannot be converted to the specified type. 228 template <typename T> 229 const T *getNodeAs(StringRef ID) const { 230 IDToNodeMap::const_iterator It = NodeMap.find(ID); 231 if (It == NodeMap.end()) { 232 return nullptr; 233 } 234 return It->second.get<T>(); 235 } 236 237 DynTypedNode getNode(StringRef ID) const { 238 IDToNodeMap::const_iterator It = NodeMap.find(ID); 239 if (It == NodeMap.end()) { 240 return DynTypedNode(); 241 } 242 return It->second; 243 } 244 245 /// Imposes an order on BoundNodesMaps. 246 bool operator<(const BoundNodesMap &Other) const { 247 return NodeMap < Other.NodeMap; 248 } 249 250 /// A map from IDs to the bound nodes. 251 /// 252 /// Note that we're using std::map here, as for memoization: 253 /// - we need a comparison operator 254 /// - we need an assignment operator 255 using IDToNodeMap = std::map<std::string, DynTypedNode, std::less<>>; 256 257 const IDToNodeMap &getMap() const { 258 return NodeMap; 259 } 260 261 /// Returns \c true if this \c BoundNodesMap can be compared, i.e. all 262 /// stored nodes have memoization data. 263 bool isComparable() const { 264 for (const auto &IDAndNode : NodeMap) { 265 if (!IDAndNode.second.getMemoizationData()) 266 return false; 267 } 268 return true; 269 } 270 271 private: 272 IDToNodeMap NodeMap; 273 }; 274 275 /// Creates BoundNodesTree objects. 276 /// 277 /// The tree builder is used during the matching process to insert the bound 278 /// nodes from the Id matcher. 279 class BoundNodesTreeBuilder { 280 public: 281 /// A visitor interface to visit all BoundNodes results for a 282 /// BoundNodesTree. 283 class Visitor { 284 public: 285 virtual ~Visitor() = default; 286 287 /// Called multiple times during a single call to VisitMatches(...). 288 /// 289 /// 'BoundNodesView' contains the bound nodes for a single match. 290 virtual void visitMatch(const BoundNodes& BoundNodesView) = 0; 291 }; 292 293 /// Add a binding from an id to a node. 294 void setBinding(StringRef Id, const DynTypedNode &DynNode) { 295 if (Bindings.empty()) 296 Bindings.emplace_back(); 297 for (BoundNodesMap &Binding : Bindings) 298 Binding.addNode(Id, DynNode); 299 } 300 301 /// Adds a branch in the tree. 302 void addMatch(const BoundNodesTreeBuilder &Bindings); 303 304 /// Visits all matches that this BoundNodesTree represents. 305 /// 306 /// The ownership of 'ResultVisitor' remains at the caller. 307 void visitMatches(Visitor* ResultVisitor); 308 309 template <typename ExcludePredicate> 310 bool removeBindings(const ExcludePredicate &Predicate) { 311 llvm::erase_if(Bindings, Predicate); 312 return !Bindings.empty(); 313 } 314 315 /// Imposes an order on BoundNodesTreeBuilders. 316 bool operator<(const BoundNodesTreeBuilder &Other) const { 317 return Bindings < Other.Bindings; 318 } 319 320 /// Returns \c true if this \c BoundNodesTreeBuilder can be compared, 321 /// i.e. all stored node maps have memoization data. 322 bool isComparable() const { 323 for (const BoundNodesMap &NodesMap : Bindings) { 324 if (!NodesMap.isComparable()) 325 return false; 326 } 327 return true; 328 } 329 330 private: 331 SmallVector<BoundNodesMap, 1> Bindings; 332 }; 333 334 class ASTMatchFinder; 335 336 /// Generic interface for all matchers. 337 /// 338 /// Used by the implementation of Matcher<T> and DynTypedMatcher. 339 /// In general, implement MatcherInterface<T> or SingleNodeMatcherInterface<T> 340 /// instead. 341 class DynMatcherInterface 342 : public llvm::ThreadSafeRefCountedBase<DynMatcherInterface> { 343 public: 344 virtual ~DynMatcherInterface() = default; 345 346 /// Returns true if \p DynNode can be matched. 347 /// 348 /// May bind \p DynNode to an ID via \p Builder, or recurse into 349 /// the AST via \p Finder. 350 virtual bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder, 351 BoundNodesTreeBuilder *Builder) const = 0; 352 353 virtual std::optional<clang::TraversalKind> TraversalKind() const { 354 return std::nullopt; 355 } 356 }; 357 358 /// Generic interface for matchers on an AST node of type T. 359 /// 360 /// Implement this if your matcher may need to inspect the children or 361 /// descendants of the node or bind matched nodes to names. If you are 362 /// writing a simple matcher that only inspects properties of the 363 /// current node and doesn't care about its children or descendants, 364 /// implement SingleNodeMatcherInterface instead. 365 template <typename T> 366 class MatcherInterface : public DynMatcherInterface { 367 public: 368 /// Returns true if 'Node' can be matched. 369 /// 370 /// May bind 'Node' to an ID via 'Builder', or recurse into 371 /// the AST via 'Finder'. 372 virtual bool matches(const T &Node, 373 ASTMatchFinder *Finder, 374 BoundNodesTreeBuilder *Builder) const = 0; 375 376 bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder, 377 BoundNodesTreeBuilder *Builder) const override { 378 return matches(DynNode.getUnchecked<T>(), Finder, Builder); 379 } 380 }; 381 382 /// Interface for matchers that only evaluate properties on a single 383 /// node. 384 template <typename T> 385 class SingleNodeMatcherInterface : public MatcherInterface<T> { 386 public: 387 /// Returns true if the matcher matches the provided node. 388 /// 389 /// A subclass must implement this instead of Matches(). 390 virtual bool matchesNode(const T &Node) const = 0; 391 392 private: 393 /// Implements MatcherInterface::Matches. 394 bool matches(const T &Node, 395 ASTMatchFinder * /* Finder */, 396 BoundNodesTreeBuilder * /* Builder */) const override { 397 return matchesNode(Node); 398 } 399 }; 400 401 template <typename> class Matcher; 402 403 /// Matcher that works on a \c DynTypedNode. 404 /// 405 /// It is constructed from a \c Matcher<T> object and redirects most calls to 406 /// underlying matcher. 407 /// It checks whether the \c DynTypedNode is convertible into the type of the 408 /// underlying matcher and then do the actual match on the actual node, or 409 /// return false if it is not convertible. 410 class DynTypedMatcher { 411 public: 412 /// Takes ownership of the provided implementation pointer. 413 template <typename T> 414 DynTypedMatcher(MatcherInterface<T> *Implementation) 415 : SupportedKind(ASTNodeKind::getFromNodeKind<T>()), 416 RestrictKind(SupportedKind), Implementation(Implementation) {} 417 418 /// Construct from a variadic function. 419 enum VariadicOperator { 420 /// Matches nodes for which all provided matchers match. 421 VO_AllOf, 422 423 /// Matches nodes for which at least one of the provided matchers 424 /// matches. 425 VO_AnyOf, 426 427 /// Matches nodes for which at least one of the provided matchers 428 /// matches, but doesn't stop at the first match. 429 VO_EachOf, 430 431 /// Matches any node but executes all inner matchers to find result 432 /// bindings. 433 VO_Optionally, 434 435 /// Matches nodes that do not match the provided matcher. 436 /// 437 /// Uses the variadic matcher interface, but fails if 438 /// InnerMatchers.size() != 1. 439 VO_UnaryNot 440 }; 441 442 static DynTypedMatcher 443 constructVariadic(VariadicOperator Op, ASTNodeKind SupportedKind, 444 std::vector<DynTypedMatcher> InnerMatchers); 445 446 static DynTypedMatcher 447 constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher, 448 ASTNodeKind RestrictKind); 449 450 /// Get a "true" matcher for \p NodeKind. 451 /// 452 /// It only checks that the node is of the right kind. 453 static DynTypedMatcher trueMatcher(ASTNodeKind NodeKind); 454 455 void setAllowBind(bool AB) { AllowBind = AB; } 456 457 /// Check whether this matcher could ever match a node of kind \p Kind. 458 /// \return \c false if this matcher will never match such a node. Otherwise, 459 /// return \c true. 460 bool canMatchNodesOfKind(ASTNodeKind Kind) const; 461 462 /// Return a matcher that points to the same implementation, but 463 /// restricts the node types for \p Kind. 464 DynTypedMatcher dynCastTo(const ASTNodeKind Kind) const; 465 466 /// Return a matcher that points to the same implementation, but sets the 467 /// traversal kind. 468 /// 469 /// If the traversal kind is already set, then \c TK overrides it. 470 DynTypedMatcher withTraversalKind(TraversalKind TK); 471 472 /// Returns true if the matcher matches the given \c DynNode. 473 bool matches(const DynTypedNode &DynNode, ASTMatchFinder *Finder, 474 BoundNodesTreeBuilder *Builder) const; 475 476 /// Same as matches(), but skips the kind check. 477 /// 478 /// It is faster, but the caller must ensure the node is valid for the 479 /// kind of this matcher. 480 bool matchesNoKindCheck(const DynTypedNode &DynNode, ASTMatchFinder *Finder, 481 BoundNodesTreeBuilder *Builder) const; 482 483 /// Bind the specified \p ID to the matcher. 484 /// \return A new matcher with the \p ID bound to it if this matcher supports 485 /// binding. Otherwise, returns an empty \c std::optional<>. 486 std::optional<DynTypedMatcher> tryBind(StringRef ID) const; 487 488 /// Returns a unique \p ID for the matcher. 489 /// 490 /// Casting a Matcher<T> to Matcher<U> creates a matcher that has the 491 /// same \c Implementation pointer, but different \c RestrictKind. We need to 492 /// include both in the ID to make it unique. 493 /// 494 /// \c MatcherIDType supports operator< and provides strict weak ordering. 495 using MatcherIDType = std::pair<ASTNodeKind, uint64_t>; 496 MatcherIDType getID() const { 497 /// FIXME: Document the requirements this imposes on matcher 498 /// implementations (no new() implementation_ during a Matches()). 499 return std::make_pair(RestrictKind, 500 reinterpret_cast<uint64_t>(Implementation.get())); 501 } 502 503 /// Returns the type this matcher works on. 504 /// 505 /// \c matches() will always return false unless the node passed is of this 506 /// or a derived type. 507 ASTNodeKind getSupportedKind() const { return SupportedKind; } 508 509 /// Returns \c true if the passed \c DynTypedMatcher can be converted 510 /// to a \c Matcher<T>. 511 /// 512 /// This method verifies that the underlying matcher in \c Other can process 513 /// nodes of types T. 514 template <typename T> bool canConvertTo() const { 515 return canConvertTo(ASTNodeKind::getFromNodeKind<T>()); 516 } 517 bool canConvertTo(ASTNodeKind To) const; 518 519 /// Construct a \c Matcher<T> interface around the dynamic matcher. 520 /// 521 /// This method asserts that \c canConvertTo() is \c true. Callers 522 /// should call \c canConvertTo() first to make sure that \c this is 523 /// compatible with T. 524 template <typename T> Matcher<T> convertTo() const { 525 assert(canConvertTo<T>()); 526 return unconditionalConvertTo<T>(); 527 } 528 529 /// Same as \c convertTo(), but does not check that the underlying 530 /// matcher can handle a value of T. 531 /// 532 /// If it is not compatible, then this matcher will never match anything. 533 template <typename T> Matcher<T> unconditionalConvertTo() const; 534 535 /// Returns the \c TraversalKind respected by calls to `match()`, if any. 536 /// 537 /// Most matchers will not have a traversal kind set, instead relying on the 538 /// surrounding context. For those, \c std::nullopt is returned. 539 std::optional<clang::TraversalKind> getTraversalKind() const { 540 return Implementation->TraversalKind(); 541 } 542 543 private: 544 DynTypedMatcher(ASTNodeKind SupportedKind, ASTNodeKind RestrictKind, 545 IntrusiveRefCntPtr<DynMatcherInterface> Implementation) 546 : SupportedKind(SupportedKind), RestrictKind(RestrictKind), 547 Implementation(std::move(Implementation)) {} 548 549 bool AllowBind = false; 550 ASTNodeKind SupportedKind; 551 552 /// A potentially stricter node kind. 553 /// 554 /// It allows to perform implicit and dynamic cast of matchers without 555 /// needing to change \c Implementation. 556 ASTNodeKind RestrictKind; 557 IntrusiveRefCntPtr<DynMatcherInterface> Implementation; 558 }; 559 560 /// Wrapper of a MatcherInterface<T> *that allows copying. 561 /// 562 /// A Matcher<Base> can be used anywhere a Matcher<Derived> is 563 /// required. This establishes an is-a relationship which is reverse 564 /// to the AST hierarchy. In other words, Matcher<T> is contravariant 565 /// with respect to T. The relationship is built via a type conversion 566 /// operator rather than a type hierarchy to be able to templatize the 567 /// type hierarchy instead of spelling it out. 568 template <typename T> 569 class Matcher { 570 public: 571 /// Takes ownership of the provided implementation pointer. 572 explicit Matcher(MatcherInterface<T> *Implementation) 573 : Implementation(Implementation) {} 574 575 /// Implicitly converts \c Other to a Matcher<T>. 576 /// 577 /// Requires \c T to be derived from \c From. 578 template <typename From> 579 Matcher(const Matcher<From> &Other, 580 std::enable_if_t<std::is_base_of<From, T>::value && 581 !std::is_same<From, T>::value> * = nullptr) 582 : Implementation(restrictMatcher(Other.Implementation)) { 583 assert(Implementation.getSupportedKind().isSame( 584 ASTNodeKind::getFromNodeKind<T>())); 585 } 586 587 /// Implicitly converts \c Matcher<Type> to \c Matcher<QualType>. 588 /// 589 /// The resulting matcher is not strict, i.e. ignores qualifiers. 590 template <typename TypeT> 591 Matcher(const Matcher<TypeT> &Other, 592 std::enable_if_t<std::is_same<T, QualType>::value && 593 std::is_same<TypeT, Type>::value> * = nullptr) 594 : Implementation(new TypeToQualType<TypeT>(Other)) {} 595 596 /// Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the 597 /// argument. 598 /// \c To must be a base class of \c T. 599 template <typename To> Matcher<To> dynCastTo() const & { 600 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call."); 601 return Matcher<To>(Implementation); 602 } 603 604 template <typename To> Matcher<To> dynCastTo() && { 605 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call."); 606 return Matcher<To>(std::move(Implementation)); 607 } 608 609 /// Forwards the call to the underlying MatcherInterface<T> pointer. 610 bool matches(const T &Node, 611 ASTMatchFinder *Finder, 612 BoundNodesTreeBuilder *Builder) const { 613 return Implementation.matches(DynTypedNode::create(Node), Finder, Builder); 614 } 615 616 /// Returns an ID that uniquely identifies the matcher. 617 DynTypedMatcher::MatcherIDType getID() const { 618 return Implementation.getID(); 619 } 620 621 /// Extract the dynamic matcher. 622 /// 623 /// The returned matcher keeps the same restrictions as \c this and remembers 624 /// that it is meant to support nodes of type \c T. 625 operator DynTypedMatcher() const & { return Implementation; } 626 627 operator DynTypedMatcher() && { return std::move(Implementation); } 628 629 /// Allows the conversion of a \c Matcher<Type> to a \c 630 /// Matcher<QualType>. 631 /// 632 /// Depending on the constructor argument, the matcher is either strict, i.e. 633 /// does only matches in the absence of qualifiers, or not, i.e. simply 634 /// ignores any qualifiers. 635 template <typename TypeT> 636 class TypeToQualType : public MatcherInterface<QualType> { 637 const DynTypedMatcher InnerMatcher; 638 639 public: 640 TypeToQualType(const Matcher<TypeT> &InnerMatcher) 641 : InnerMatcher(InnerMatcher) {} 642 643 bool matches(const QualType &Node, ASTMatchFinder *Finder, 644 BoundNodesTreeBuilder *Builder) const override { 645 if (Node.isNull()) 646 return false; 647 return this->InnerMatcher.matches(DynTypedNode::create(*Node), Finder, 648 Builder); 649 } 650 651 std::optional<clang::TraversalKind> TraversalKind() const override { 652 return this->InnerMatcher.getTraversalKind(); 653 } 654 }; 655 656 private: 657 // For Matcher<T> <=> Matcher<U> conversions. 658 template <typename U> friend class Matcher; 659 660 // For DynTypedMatcher::unconditionalConvertTo<T>. 661 friend class DynTypedMatcher; 662 663 static DynTypedMatcher restrictMatcher(const DynTypedMatcher &Other) { 664 return Other.dynCastTo(ASTNodeKind::getFromNodeKind<T>()); 665 } 666 667 explicit Matcher(const DynTypedMatcher &Implementation) 668 : Implementation(restrictMatcher(Implementation)) { 669 assert(this->Implementation.getSupportedKind().isSame( 670 ASTNodeKind::getFromNodeKind<T>())); 671 } 672 673 DynTypedMatcher Implementation; 674 }; // class Matcher 675 676 /// A convenient helper for creating a Matcher<T> without specifying 677 /// the template type argument. 678 template <typename T> 679 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) { 680 return Matcher<T>(Implementation); 681 } 682 683 /// Interface that allows matchers to traverse the AST. 684 /// FIXME: Find a better name. 685 /// 686 /// This provides three entry methods for each base node type in the AST: 687 /// - \c matchesChildOf: 688 /// Matches a matcher on every child node of the given node. Returns true 689 /// if at least one child node could be matched. 690 /// - \c matchesDescendantOf: 691 /// Matches a matcher on all descendant nodes of the given node. Returns true 692 /// if at least one descendant matched. 693 /// - \c matchesAncestorOf: 694 /// Matches a matcher on all ancestors of the given node. Returns true if 695 /// at least one ancestor matched. 696 /// 697 /// FIXME: Currently we only allow Stmt and Decl nodes to start a traversal. 698 /// In the future, we want to implement this for all nodes for which it makes 699 /// sense. In the case of matchesAncestorOf, we'll want to implement it for 700 /// all nodes, as all nodes have ancestors. 701 class ASTMatchFinder { 702 public: 703 /// Defines how bindings are processed on recursive matches. 704 enum BindKind { 705 /// Stop at the first match and only bind the first match. 706 BK_First, 707 708 /// Create results for all combinations of bindings that match. 709 BK_All 710 }; 711 712 /// Defines which ancestors are considered for a match. 713 enum AncestorMatchMode { 714 /// All ancestors. 715 AMM_All, 716 717 /// Direct parent only. 718 AMM_ParentOnly 719 }; 720 721 virtual ~ASTMatchFinder() = default; 722 723 /// Returns true if the given C++ class is directly or indirectly derived 724 /// from a base type matching \c base. 725 /// 726 /// A class is not considered to be derived from itself. 727 virtual bool classIsDerivedFrom(const CXXRecordDecl *Declaration, 728 const Matcher<NamedDecl> &Base, 729 BoundNodesTreeBuilder *Builder, 730 bool Directly) = 0; 731 732 /// Returns true if the given Objective-C class is directly or indirectly 733 /// derived from a base class matching \c base. 734 /// 735 /// A class is not considered to be derived from itself. 736 virtual bool objcClassIsDerivedFrom(const ObjCInterfaceDecl *Declaration, 737 const Matcher<NamedDecl> &Base, 738 BoundNodesTreeBuilder *Builder, 739 bool Directly) = 0; 740 741 template <typename T> 742 bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher, 743 BoundNodesTreeBuilder *Builder, BindKind Bind) { 744 static_assert(std::is_base_of<Decl, T>::value || 745 std::is_base_of<Stmt, T>::value || 746 std::is_base_of<NestedNameSpecifier, T>::value || 747 std::is_base_of<NestedNameSpecifierLoc, T>::value || 748 std::is_base_of<TypeLoc, T>::value || 749 std::is_base_of<QualType, T>::value || 750 std::is_base_of<Attr, T>::value, 751 "unsupported type for recursive matching"); 752 return matchesChildOf(DynTypedNode::create(Node), getASTContext(), Matcher, 753 Builder, Bind); 754 } 755 756 template <typename T> 757 bool matchesDescendantOf(const T &Node, const DynTypedMatcher &Matcher, 758 BoundNodesTreeBuilder *Builder, BindKind Bind) { 759 static_assert(std::is_base_of<Decl, T>::value || 760 std::is_base_of<Stmt, T>::value || 761 std::is_base_of<NestedNameSpecifier, T>::value || 762 std::is_base_of<NestedNameSpecifierLoc, T>::value || 763 std::is_base_of<TypeLoc, T>::value || 764 std::is_base_of<QualType, T>::value || 765 std::is_base_of<Attr, T>::value, 766 "unsupported type for recursive matching"); 767 return matchesDescendantOf(DynTypedNode::create(Node), getASTContext(), 768 Matcher, Builder, Bind); 769 } 770 771 // FIXME: Implement support for BindKind. 772 template <typename T> 773 bool matchesAncestorOf(const T &Node, const DynTypedMatcher &Matcher, 774 BoundNodesTreeBuilder *Builder, 775 AncestorMatchMode MatchMode) { 776 static_assert(std::is_base_of<Decl, T>::value || 777 std::is_base_of<NestedNameSpecifierLoc, T>::value || 778 std::is_base_of<Stmt, T>::value || 779 std::is_base_of<TypeLoc, T>::value || 780 std::is_base_of<Attr, T>::value, 781 "type not allowed for recursive matching"); 782 return matchesAncestorOf(DynTypedNode::create(Node), getASTContext(), 783 Matcher, Builder, MatchMode); 784 } 785 786 virtual ASTContext &getASTContext() const = 0; 787 788 virtual bool IsMatchingInASTNodeNotSpelledInSource() const = 0; 789 790 virtual bool IsMatchingInASTNodeNotAsIs() const = 0; 791 792 bool isTraversalIgnoringImplicitNodes() const; 793 794 protected: 795 virtual bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx, 796 const DynTypedMatcher &Matcher, 797 BoundNodesTreeBuilder *Builder, 798 BindKind Bind) = 0; 799 800 virtual bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx, 801 const DynTypedMatcher &Matcher, 802 BoundNodesTreeBuilder *Builder, 803 BindKind Bind) = 0; 804 805 virtual bool matchesAncestorOf(const DynTypedNode &Node, ASTContext &Ctx, 806 const DynTypedMatcher &Matcher, 807 BoundNodesTreeBuilder *Builder, 808 AncestorMatchMode MatchMode) = 0; 809 private: 810 friend struct ASTChildrenNotSpelledInSourceScope; 811 virtual bool isMatchingChildrenNotSpelledInSource() const = 0; 812 virtual void setMatchingChildrenNotSpelledInSource(bool Set) = 0; 813 }; 814 815 struct ASTChildrenNotSpelledInSourceScope { 816 ASTChildrenNotSpelledInSourceScope(ASTMatchFinder *V, bool B) 817 : MV(V), MB(V->isMatchingChildrenNotSpelledInSource()) { 818 V->setMatchingChildrenNotSpelledInSource(B); 819 } 820 ~ASTChildrenNotSpelledInSourceScope() { 821 MV->setMatchingChildrenNotSpelledInSource(MB); 822 } 823 824 private: 825 ASTMatchFinder *MV; 826 bool MB; 827 }; 828 829 /// Specialization of the conversion functions for QualType. 830 /// 831 /// This specialization provides the Matcher<Type>->Matcher<QualType> 832 /// conversion that the static API does. 833 template <> 834 inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>() const { 835 assert(canConvertTo<QualType>()); 836 const ASTNodeKind SourceKind = getSupportedKind(); 837 if (SourceKind.isSame(ASTNodeKind::getFromNodeKind<Type>())) { 838 // We support implicit conversion from Matcher<Type> to Matcher<QualType> 839 return unconditionalConvertTo<Type>(); 840 } 841 return unconditionalConvertTo<QualType>(); 842 } 843 844 /// Finds the first node in a range that matches the given matcher. 845 template <typename MatcherT, typename IteratorT> 846 IteratorT matchesFirstInRange(const MatcherT &Matcher, IteratorT Start, 847 IteratorT End, ASTMatchFinder *Finder, 848 BoundNodesTreeBuilder *Builder) { 849 for (IteratorT I = Start; I != End; ++I) { 850 BoundNodesTreeBuilder Result(*Builder); 851 if (Matcher.matches(*I, Finder, &Result)) { 852 *Builder = std::move(Result); 853 return I; 854 } 855 } 856 return End; 857 } 858 859 /// Finds the first node in a pointer range that matches the given 860 /// matcher. 861 template <typename MatcherT, typename IteratorT> 862 IteratorT matchesFirstInPointerRange(const MatcherT &Matcher, IteratorT Start, 863 IteratorT End, ASTMatchFinder *Finder, 864 BoundNodesTreeBuilder *Builder) { 865 for (IteratorT I = Start; I != End; ++I) { 866 BoundNodesTreeBuilder Result(*Builder); 867 if (Matcher.matches(**I, Finder, &Result)) { 868 *Builder = std::move(Result); 869 return I; 870 } 871 } 872 return End; 873 } 874 875 template <typename T, std::enable_if_t<!std::is_base_of<FunctionDecl, T>::value> 876 * = nullptr> 877 inline bool isDefaultedHelper(const T *) { 878 return false; 879 } 880 inline bool isDefaultedHelper(const FunctionDecl *FD) { 881 return FD->isDefaulted(); 882 } 883 884 // Metafunction to determine if type T has a member called getDecl. 885 template <typename Ty> 886 class has_getDecl { 887 using yes = char[1]; 888 using no = char[2]; 889 890 template <typename Inner> 891 static yes& test(Inner *I, decltype(I->getDecl()) * = nullptr); 892 893 template <typename> 894 static no& test(...); 895 896 public: 897 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes); 898 }; 899 900 /// Matches overloaded operators with a specific name. 901 /// 902 /// The type argument ArgT is not used by this matcher but is used by 903 /// PolymorphicMatcher and should be StringRef. 904 template <typename T, typename ArgT> 905 class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> { 906 static_assert(std::is_same<T, CXXOperatorCallExpr>::value || 907 std::is_base_of<FunctionDecl, T>::value, 908 "unsupported class for matcher"); 909 static_assert(std::is_same<ArgT, std::vector<std::string>>::value, 910 "argument type must be std::vector<std::string>"); 911 912 public: 913 explicit HasOverloadedOperatorNameMatcher(std::vector<std::string> Names) 914 : SingleNodeMatcherInterface<T>(), Names(std::move(Names)) {} 915 916 bool matchesNode(const T &Node) const override { 917 return matchesSpecialized(Node); 918 } 919 920 private: 921 922 /// CXXOperatorCallExpr exist only for calls to overloaded operators 923 /// so this function returns true if the call is to an operator of the given 924 /// name. 925 bool matchesSpecialized(const CXXOperatorCallExpr &Node) const { 926 return llvm::is_contained(Names, getOperatorSpelling(Node.getOperator())); 927 } 928 929 /// Returns true only if CXXMethodDecl represents an overloaded 930 /// operator and has the given operator name. 931 bool matchesSpecialized(const FunctionDecl &Node) const { 932 return Node.isOverloadedOperator() && 933 llvm::is_contained( 934 Names, getOperatorSpelling(Node.getOverloadedOperator())); 935 } 936 937 std::vector<std::string> Names; 938 }; 939 940 /// Matches named declarations with a specific name. 941 /// 942 /// See \c hasName() and \c hasAnyName() in ASTMatchers.h for details. 943 class HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> { 944 public: 945 explicit HasNameMatcher(std::vector<std::string> Names); 946 947 bool matchesNode(const NamedDecl &Node) const override; 948 949 private: 950 /// Unqualified match routine. 951 /// 952 /// It is much faster than the full match, but it only works for unqualified 953 /// matches. 954 bool matchesNodeUnqualified(const NamedDecl &Node) const; 955 956 /// Full match routine 957 /// 958 /// Fast implementation for the simple case of a named declaration at 959 /// namespace or RecordDecl scope. 960 /// It is slower than matchesNodeUnqualified, but faster than 961 /// matchesNodeFullSlow. 962 bool matchesNodeFullFast(const NamedDecl &Node) const; 963 964 /// Full match routine 965 /// 966 /// It generates the fully qualified name of the declaration (which is 967 /// expensive) before trying to match. 968 /// It is slower but simple and works on all cases. 969 bool matchesNodeFullSlow(const NamedDecl &Node) const; 970 971 bool UseUnqualifiedMatch; 972 std::vector<std::string> Names; 973 }; 974 975 /// Trampoline function to use VariadicFunction<> to construct a 976 /// HasNameMatcher. 977 Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs); 978 979 /// Trampoline function to use VariadicFunction<> to construct a 980 /// hasAnySelector matcher. 981 Matcher<ObjCMessageExpr> hasAnySelectorFunc( 982 ArrayRef<const StringRef *> NameRefs); 983 984 /// Matches declarations for QualType and CallExpr. 985 /// 986 /// Type argument DeclMatcherT is required by PolymorphicMatcher but 987 /// not actually used. 988 template <typename T, typename DeclMatcherT> 989 class HasDeclarationMatcher : public MatcherInterface<T> { 990 static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value, 991 "instantiated with wrong types"); 992 993 DynTypedMatcher InnerMatcher; 994 995 public: 996 explicit HasDeclarationMatcher(const Matcher<Decl> &InnerMatcher) 997 : InnerMatcher(InnerMatcher) {} 998 999 bool matches(const T &Node, ASTMatchFinder *Finder, 1000 BoundNodesTreeBuilder *Builder) const override { 1001 return matchesSpecialized(Node, Finder, Builder); 1002 } 1003 1004 private: 1005 /// Forwards to matching on the underlying type of the QualType. 1006 bool matchesSpecialized(const QualType &Node, ASTMatchFinder *Finder, 1007 BoundNodesTreeBuilder *Builder) const { 1008 if (Node.isNull()) 1009 return false; 1010 1011 return matchesSpecialized(*Node, Finder, Builder); 1012 } 1013 1014 /// Finds the best declaration for a type and returns whether the inner 1015 /// matcher matches on it. 1016 bool matchesSpecialized(const Type &Node, ASTMatchFinder *Finder, 1017 BoundNodesTreeBuilder *Builder) const { 1018 // DeducedType does not have declarations of its own, so 1019 // match the deduced type instead. 1020 if (const auto *S = dyn_cast<DeducedType>(&Node)) { 1021 QualType DT = S->getDeducedType(); 1022 return !DT.isNull() ? matchesSpecialized(*DT, Finder, Builder) : false; 1023 } 1024 1025 // First, for any types that have a declaration, extract the declaration and 1026 // match on it. 1027 if (const auto *S = dyn_cast<TagType>(&Node)) { 1028 return matchesDecl(S->getDecl(), Finder, Builder); 1029 } 1030 if (const auto *S = dyn_cast<InjectedClassNameType>(&Node)) { 1031 return matchesDecl(S->getDecl(), Finder, Builder); 1032 } 1033 if (const auto *S = dyn_cast<TemplateTypeParmType>(&Node)) { 1034 return matchesDecl(S->getDecl(), Finder, Builder); 1035 } 1036 if (const auto *S = dyn_cast<TypedefType>(&Node)) { 1037 return matchesDecl(S->getDecl(), Finder, Builder); 1038 } 1039 if (const auto *S = dyn_cast<UnresolvedUsingType>(&Node)) { 1040 return matchesDecl(S->getDecl(), Finder, Builder); 1041 } 1042 if (const auto *S = dyn_cast<ObjCObjectType>(&Node)) { 1043 return matchesDecl(S->getInterface(), Finder, Builder); 1044 } 1045 1046 // A SubstTemplateTypeParmType exists solely to mark a type substitution 1047 // on the instantiated template. As users usually want to match the 1048 // template parameter on the uninitialized template, we can always desugar 1049 // one level without loss of expressivness. 1050 // For example, given: 1051 // template<typename T> struct X { T t; } class A {}; X<A> a; 1052 // The following matcher will match, which otherwise would not: 1053 // fieldDecl(hasType(pointerType())). 1054 if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(&Node)) { 1055 return matchesSpecialized(S->getReplacementType(), Finder, Builder); 1056 } 1057 1058 // For template specialization types, we want to match the template 1059 // declaration, as long as the type is still dependent, and otherwise the 1060 // declaration of the instantiated tag type. 1061 if (const auto *S = dyn_cast<TemplateSpecializationType>(&Node)) { 1062 if (!S->isTypeAlias() && S->isSugared()) { 1063 // If the template is non-dependent, we want to match the instantiated 1064 // tag type. 1065 // For example, given: 1066 // template<typename T> struct X {}; X<int> a; 1067 // The following matcher will match, which otherwise would not: 1068 // templateSpecializationType(hasDeclaration(cxxRecordDecl())). 1069 return matchesSpecialized(*S->desugar(), Finder, Builder); 1070 } 1071 // If the template is dependent or an alias, match the template 1072 // declaration. 1073 return matchesDecl(S->getTemplateName().getAsTemplateDecl(), Finder, 1074 Builder); 1075 } 1076 1077 // FIXME: We desugar elaborated types. This makes the assumption that users 1078 // do never want to match on whether a type is elaborated - there are 1079 // arguments for both sides; for now, continue desugaring. 1080 if (const auto *S = dyn_cast<ElaboratedType>(&Node)) { 1081 return matchesSpecialized(S->desugar(), Finder, Builder); 1082 } 1083 // Similarly types found via using declarations. 1084 // These are *usually* meaningless sugar, and this matches the historical 1085 // behavior prior to the introduction of UsingType. 1086 if (const auto *S = dyn_cast<UsingType>(&Node)) { 1087 return matchesSpecialized(S->desugar(), Finder, Builder); 1088 } 1089 return false; 1090 } 1091 1092 /// Extracts the Decl the DeclRefExpr references and returns whether 1093 /// the inner matcher matches on it. 1094 bool matchesSpecialized(const DeclRefExpr &Node, ASTMatchFinder *Finder, 1095 BoundNodesTreeBuilder *Builder) const { 1096 return matchesDecl(Node.getDecl(), Finder, Builder); 1097 } 1098 1099 /// Extracts the Decl of the callee of a CallExpr and returns whether 1100 /// the inner matcher matches on it. 1101 bool matchesSpecialized(const CallExpr &Node, ASTMatchFinder *Finder, 1102 BoundNodesTreeBuilder *Builder) const { 1103 return matchesDecl(Node.getCalleeDecl(), Finder, Builder); 1104 } 1105 1106 /// Extracts the Decl of the constructor call and returns whether the 1107 /// inner matcher matches on it. 1108 bool matchesSpecialized(const CXXConstructExpr &Node, 1109 ASTMatchFinder *Finder, 1110 BoundNodesTreeBuilder *Builder) const { 1111 return matchesDecl(Node.getConstructor(), Finder, Builder); 1112 } 1113 1114 bool matchesSpecialized(const ObjCIvarRefExpr &Node, 1115 ASTMatchFinder *Finder, 1116 BoundNodesTreeBuilder *Builder) const { 1117 return matchesDecl(Node.getDecl(), Finder, Builder); 1118 } 1119 1120 /// Extracts the operator new of the new call and returns whether the 1121 /// inner matcher matches on it. 1122 bool matchesSpecialized(const CXXNewExpr &Node, 1123 ASTMatchFinder *Finder, 1124 BoundNodesTreeBuilder *Builder) const { 1125 return matchesDecl(Node.getOperatorNew(), Finder, Builder); 1126 } 1127 1128 /// Extracts the \c ValueDecl a \c MemberExpr refers to and returns 1129 /// whether the inner matcher matches on it. 1130 bool matchesSpecialized(const MemberExpr &Node, 1131 ASTMatchFinder *Finder, 1132 BoundNodesTreeBuilder *Builder) const { 1133 return matchesDecl(Node.getMemberDecl(), Finder, Builder); 1134 } 1135 1136 /// Extracts the \c LabelDecl a \c AddrLabelExpr refers to and returns 1137 /// whether the inner matcher matches on it. 1138 bool matchesSpecialized(const AddrLabelExpr &Node, 1139 ASTMatchFinder *Finder, 1140 BoundNodesTreeBuilder *Builder) const { 1141 return matchesDecl(Node.getLabel(), Finder, Builder); 1142 } 1143 1144 /// Extracts the declaration of a LabelStmt and returns whether the 1145 /// inner matcher matches on it. 1146 bool matchesSpecialized(const LabelStmt &Node, ASTMatchFinder *Finder, 1147 BoundNodesTreeBuilder *Builder) const { 1148 return matchesDecl(Node.getDecl(), Finder, Builder); 1149 } 1150 1151 /// Returns whether the inner matcher \c Node. Returns false if \c Node 1152 /// is \c NULL. 1153 bool matchesDecl(const Decl *Node, ASTMatchFinder *Finder, 1154 BoundNodesTreeBuilder *Builder) const { 1155 return Node != nullptr && 1156 !(Finder->isTraversalIgnoringImplicitNodes() && 1157 Node->isImplicit()) && 1158 this->InnerMatcher.matches(DynTypedNode::create(*Node), Finder, 1159 Builder); 1160 } 1161 }; 1162 1163 /// IsBaseType<T>::value is true if T is a "base" type in the AST 1164 /// node class hierarchies. 1165 template <typename T> 1166 struct IsBaseType { 1167 static const bool value = 1168 std::is_same<T, Decl>::value || std::is_same<T, Stmt>::value || 1169 std::is_same<T, QualType>::value || std::is_same<T, Type>::value || 1170 std::is_same<T, TypeLoc>::value || 1171 std::is_same<T, NestedNameSpecifier>::value || 1172 std::is_same<T, NestedNameSpecifierLoc>::value || 1173 std::is_same<T, CXXCtorInitializer>::value || 1174 std::is_same<T, TemplateArgumentLoc>::value || 1175 std::is_same<T, Attr>::value; 1176 }; 1177 template <typename T> 1178 const bool IsBaseType<T>::value; 1179 1180 /// A "type list" that contains all types. 1181 /// 1182 /// Useful for matchers like \c anything and \c unless. 1183 using AllNodeBaseTypes = 1184 TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, QualType, 1185 Type, TypeLoc, CXXCtorInitializer, Attr>; 1186 1187 /// Helper meta-function to extract the argument out of a function of 1188 /// type void(Arg). 1189 /// 1190 /// See AST_POLYMORPHIC_SUPPORTED_TYPES for details. 1191 template <class T> struct ExtractFunctionArgMeta; 1192 template <class T> struct ExtractFunctionArgMeta<void(T)> { 1193 using type = T; 1194 }; 1195 1196 template <class T, class Tuple, std::size_t... I> 1197 constexpr T *new_from_tuple_impl(Tuple &&t, std::index_sequence<I...>) { 1198 return new T(std::get<I>(std::forward<Tuple>(t))...); 1199 } 1200 1201 template <class T, class Tuple> constexpr T *new_from_tuple(Tuple &&t) { 1202 return new_from_tuple_impl<T>( 1203 std::forward<Tuple>(t), 1204 std::make_index_sequence< 1205 std::tuple_size<std::remove_reference_t<Tuple>>::value>{}); 1206 } 1207 1208 /// Default type lists for ArgumentAdaptingMatcher matchers. 1209 using AdaptativeDefaultFromTypes = AllNodeBaseTypes; 1210 using AdaptativeDefaultToTypes = 1211 TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, TypeLoc, 1212 QualType, Attr>; 1213 1214 /// All types that are supported by HasDeclarationMatcher above. 1215 using HasDeclarationSupportedTypes = 1216 TypeList<CallExpr, CXXConstructExpr, CXXNewExpr, DeclRefExpr, EnumType, 1217 ElaboratedType, InjectedClassNameType, LabelStmt, AddrLabelExpr, 1218 MemberExpr, QualType, RecordType, TagType, 1219 TemplateSpecializationType, TemplateTypeParmType, TypedefType, 1220 UnresolvedUsingType, ObjCIvarRefExpr>; 1221 1222 /// A Matcher that allows binding the node it matches to an id. 1223 /// 1224 /// BindableMatcher provides a \a bind() method that allows binding the 1225 /// matched node to an id if the match was successful. 1226 template <typename T> class BindableMatcher : public Matcher<T> { 1227 public: 1228 explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {} 1229 explicit BindableMatcher(MatcherInterface<T> *Implementation) 1230 : Matcher<T>(Implementation) {} 1231 1232 /// Returns a matcher that will bind the matched node on a match. 1233 /// 1234 /// The returned matcher is equivalent to this matcher, but will 1235 /// bind the matched node on a match. 1236 Matcher<T> bind(StringRef ID) const { 1237 return DynTypedMatcher(*this) 1238 .tryBind(ID) 1239 ->template unconditionalConvertTo<T>(); 1240 } 1241 1242 /// Same as Matcher<T>'s conversion operator, but enables binding on 1243 /// the returned matcher. 1244 operator DynTypedMatcher() const { 1245 DynTypedMatcher Result = static_cast<const Matcher<T> &>(*this); 1246 Result.setAllowBind(true); 1247 return Result; 1248 } 1249 }; 1250 1251 /// Matches any instance of the given NodeType. 1252 /// 1253 /// This is useful when a matcher syntactically requires a child matcher, 1254 /// but the context doesn't care. See for example: anything(). 1255 class TrueMatcher { 1256 public: 1257 using ReturnTypes = AllNodeBaseTypes; 1258 1259 template <typename T> operator Matcher<T>() const { 1260 return DynTypedMatcher::trueMatcher(ASTNodeKind::getFromNodeKind<T>()) 1261 .template unconditionalConvertTo<T>(); 1262 } 1263 }; 1264 1265 /// Creates a Matcher<T> that matches if all inner matchers match. 1266 template <typename T> 1267 BindableMatcher<T> 1268 makeAllOfComposite(ArrayRef<const Matcher<T> *> InnerMatchers) { 1269 // For the size() == 0 case, we return a "true" matcher. 1270 if (InnerMatchers.empty()) { 1271 return BindableMatcher<T>(TrueMatcher()); 1272 } 1273 // For the size() == 1 case, we simply return that one matcher. 1274 // No need to wrap it in a variadic operation. 1275 if (InnerMatchers.size() == 1) { 1276 return BindableMatcher<T>(*InnerMatchers[0]); 1277 } 1278 1279 using PI = llvm::pointee_iterator<const Matcher<T> *const *>; 1280 1281 std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()), 1282 PI(InnerMatchers.end())); 1283 return BindableMatcher<T>( 1284 DynTypedMatcher::constructVariadic(DynTypedMatcher::VO_AllOf, 1285 ASTNodeKind::getFromNodeKind<T>(), 1286 std::move(DynMatchers)) 1287 .template unconditionalConvertTo<T>()); 1288 } 1289 1290 /// Creates a Matcher<T> that matches if 1291 /// T is dyn_cast'able into InnerT and all inner matchers match. 1292 /// 1293 /// Returns BindableMatcher, as matchers that use dyn_cast have 1294 /// the same object both to match on and to run submatchers on, 1295 /// so there is no ambiguity with what gets bound. 1296 template <typename T, typename InnerT> 1297 BindableMatcher<T> 1298 makeDynCastAllOfComposite(ArrayRef<const Matcher<InnerT> *> InnerMatchers) { 1299 return BindableMatcher<T>( 1300 makeAllOfComposite(InnerMatchers).template dynCastTo<T>()); 1301 } 1302 1303 /// A VariadicDynCastAllOfMatcher<SourceT, TargetT> object is a 1304 /// variadic functor that takes a number of Matcher<TargetT> and returns a 1305 /// Matcher<SourceT> that matches TargetT nodes that are matched by all of the 1306 /// given matchers, if SourceT can be dynamically casted into TargetT. 1307 /// 1308 /// For example: 1309 /// const VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> record; 1310 /// Creates a functor record(...) that creates a Matcher<Decl> given 1311 /// a variable number of arguments of type Matcher<CXXRecordDecl>. 1312 /// The returned matcher matches if the given Decl can by dynamically 1313 /// casted to CXXRecordDecl and all given matchers match. 1314 template <typename SourceT, typename TargetT> 1315 class VariadicDynCastAllOfMatcher 1316 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>, 1317 makeDynCastAllOfComposite<SourceT, TargetT>> { 1318 public: 1319 VariadicDynCastAllOfMatcher() {} 1320 }; 1321 1322 /// A \c VariadicAllOfMatcher<T> object is a variadic functor that takes 1323 /// a number of \c Matcher<T> and returns a \c Matcher<T> that matches \c T 1324 /// nodes that are matched by all of the given matchers. 1325 /// 1326 /// For example: 1327 /// const VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier; 1328 /// Creates a functor nestedNameSpecifier(...) that creates a 1329 /// \c Matcher<NestedNameSpecifier> given a variable number of arguments of type 1330 /// \c Matcher<NestedNameSpecifier>. 1331 /// The returned matcher matches if all given matchers match. 1332 template <typename T> 1333 class VariadicAllOfMatcher 1334 : public VariadicFunction<BindableMatcher<T>, Matcher<T>, 1335 makeAllOfComposite<T>> { 1336 public: 1337 VariadicAllOfMatcher() {} 1338 }; 1339 1340 /// VariadicOperatorMatcher related types. 1341 /// @{ 1342 1343 /// Polymorphic matcher object that uses a \c 1344 /// DynTypedMatcher::VariadicOperator operator. 1345 /// 1346 /// Input matchers can have any type (including other polymorphic matcher 1347 /// types), and the actual Matcher<T> is generated on demand with an implicit 1348 /// conversion operator. 1349 template <typename... Ps> class VariadicOperatorMatcher { 1350 public: 1351 VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params) 1352 : Op(Op), Params(std::forward<Ps>(Params)...) {} 1353 1354 template <typename T> operator Matcher<T>() const & { 1355 return DynTypedMatcher::constructVariadic( 1356 Op, ASTNodeKind::getFromNodeKind<T>(), 1357 getMatchers<T>(std::index_sequence_for<Ps...>())) 1358 .template unconditionalConvertTo<T>(); 1359 } 1360 1361 template <typename T> operator Matcher<T>() && { 1362 return DynTypedMatcher::constructVariadic( 1363 Op, ASTNodeKind::getFromNodeKind<T>(), 1364 getMatchers<T>(std::index_sequence_for<Ps...>())) 1365 .template unconditionalConvertTo<T>(); 1366 } 1367 1368 private: 1369 // Helper method to unpack the tuple into a vector. 1370 template <typename T, std::size_t... Is> 1371 std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) const & { 1372 return {Matcher<T>(std::get<Is>(Params))...}; 1373 } 1374 1375 template <typename T, std::size_t... Is> 1376 std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) && { 1377 return {Matcher<T>(std::get<Is>(std::move(Params)))...}; 1378 } 1379 1380 const DynTypedMatcher::VariadicOperator Op; 1381 std::tuple<Ps...> Params; 1382 }; 1383 1384 /// Overloaded function object to generate VariadicOperatorMatcher 1385 /// objects from arbitrary matchers. 1386 template <unsigned MinCount, unsigned MaxCount> 1387 struct VariadicOperatorMatcherFunc { 1388 DynTypedMatcher::VariadicOperator Op; 1389 1390 template <typename... Ms> 1391 VariadicOperatorMatcher<Ms...> operator()(Ms &&... Ps) const { 1392 static_assert(MinCount <= sizeof...(Ms) && sizeof...(Ms) <= MaxCount, 1393 "invalid number of parameters for variadic matcher"); 1394 return VariadicOperatorMatcher<Ms...>(Op, std::forward<Ms>(Ps)...); 1395 } 1396 }; 1397 1398 template <typename T, bool IsBaseOf, typename Head, typename Tail> 1399 struct GetCladeImpl { 1400 using Type = Head; 1401 }; 1402 template <typename T, typename Head, typename Tail> 1403 struct GetCladeImpl<T, false, Head, Tail> 1404 : GetCladeImpl<T, std::is_base_of<typename Tail::head, T>::value, 1405 typename Tail::head, typename Tail::tail> {}; 1406 1407 template <typename T, typename... U> 1408 struct GetClade : GetCladeImpl<T, false, T, AllNodeBaseTypes> {}; 1409 1410 template <typename CladeType, typename... MatcherTypes> 1411 struct MapAnyOfMatcherImpl { 1412 1413 template <typename... InnerMatchers> 1414 BindableMatcher<CladeType> 1415 operator()(InnerMatchers &&... InnerMatcher) const { 1416 return VariadicAllOfMatcher<CladeType>()(std::apply( 1417 internal::VariadicOperatorMatcherFunc< 1418 0, std::numeric_limits<unsigned>::max()>{ 1419 internal::DynTypedMatcher::VO_AnyOf}, 1420 std::apply( 1421 [&](auto... Matcher) { 1422 return std::make_tuple(Matcher(InnerMatcher...)...); 1423 }, 1424 std::tuple< 1425 VariadicDynCastAllOfMatcher<CladeType, MatcherTypes>...>()))); 1426 } 1427 }; 1428 1429 template <typename... MatcherTypes> 1430 using MapAnyOfMatcher = 1431 MapAnyOfMatcherImpl<typename GetClade<MatcherTypes...>::Type, 1432 MatcherTypes...>; 1433 1434 template <typename... MatcherTypes> struct MapAnyOfHelper { 1435 using CladeType = typename GetClade<MatcherTypes...>::Type; 1436 1437 MapAnyOfMatcher<MatcherTypes...> with; 1438 1439 operator BindableMatcher<CladeType>() const { return with(); } 1440 1441 Matcher<CladeType> bind(StringRef ID) const { return with().bind(ID); } 1442 }; 1443 1444 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT, 1445 typename T, typename ToTypes> 1446 class ArgumentAdaptingMatcherFuncAdaptor { 1447 public: 1448 explicit ArgumentAdaptingMatcherFuncAdaptor(const Matcher<T> &InnerMatcher) 1449 : InnerMatcher(InnerMatcher) {} 1450 1451 using ReturnTypes = ToTypes; 1452 1453 template <typename To> operator Matcher<To>() const & { 1454 return Matcher<To>(new ArgumentAdapterT<To, T>(InnerMatcher)); 1455 } 1456 1457 template <typename To> operator Matcher<To>() && { 1458 return Matcher<To>(new ArgumentAdapterT<To, T>(std::move(InnerMatcher))); 1459 } 1460 1461 private: 1462 Matcher<T> InnerMatcher; 1463 }; 1464 1465 /// Converts a \c Matcher<T> to a matcher of desired type \c To by 1466 /// "adapting" a \c To into a \c T. 1467 /// 1468 /// The \c ArgumentAdapterT argument specifies how the adaptation is done. 1469 /// 1470 /// For example: 1471 /// \c ArgumentAdaptingMatcher<HasMatcher, T>(InnerMatcher); 1472 /// Given that \c InnerMatcher is of type \c Matcher<T>, this returns a matcher 1473 /// that is convertible into any matcher of type \c To by constructing 1474 /// \c HasMatcher<To, T>(InnerMatcher). 1475 /// 1476 /// If a matcher does not need knowledge about the inner type, prefer to use 1477 /// PolymorphicMatcher. 1478 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT, 1479 typename FromTypes = AdaptativeDefaultFromTypes, 1480 typename ToTypes = AdaptativeDefaultToTypes> 1481 struct ArgumentAdaptingMatcherFunc { 1482 template <typename T> 1483 static ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes> 1484 create(const Matcher<T> &InnerMatcher) { 1485 return ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>( 1486 InnerMatcher); 1487 } 1488 1489 template <typename T> 1490 ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes> 1491 operator()(const Matcher<T> &InnerMatcher) const { 1492 return create(InnerMatcher); 1493 } 1494 1495 template <typename... T> 1496 ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, 1497 typename GetClade<T...>::Type, ToTypes> 1498 operator()(const MapAnyOfHelper<T...> &InnerMatcher) const { 1499 return create(InnerMatcher.with()); 1500 } 1501 }; 1502 1503 template <typename T> class TraversalMatcher : public MatcherInterface<T> { 1504 DynTypedMatcher InnerMatcher; 1505 clang::TraversalKind Traversal; 1506 1507 public: 1508 explicit TraversalMatcher(clang::TraversalKind TK, 1509 const Matcher<T> &InnerMatcher) 1510 : InnerMatcher(InnerMatcher), Traversal(TK) {} 1511 1512 bool matches(const T &Node, ASTMatchFinder *Finder, 1513 BoundNodesTreeBuilder *Builder) const override { 1514 return this->InnerMatcher.matches(DynTypedNode::create(Node), Finder, 1515 Builder); 1516 } 1517 1518 std::optional<clang::TraversalKind> TraversalKind() const override { 1519 if (auto NestedKind = this->InnerMatcher.getTraversalKind()) 1520 return NestedKind; 1521 return Traversal; 1522 } 1523 }; 1524 1525 template <typename MatcherType> class TraversalWrapper { 1526 public: 1527 TraversalWrapper(TraversalKind TK, const MatcherType &InnerMatcher) 1528 : TK(TK), InnerMatcher(InnerMatcher) {} 1529 1530 template <typename T> operator Matcher<T>() const & { 1531 return internal::DynTypedMatcher::constructRestrictedWrapper( 1532 new internal::TraversalMatcher<T>(TK, InnerMatcher), 1533 ASTNodeKind::getFromNodeKind<T>()) 1534 .template unconditionalConvertTo<T>(); 1535 } 1536 1537 template <typename T> operator Matcher<T>() && { 1538 return internal::DynTypedMatcher::constructRestrictedWrapper( 1539 new internal::TraversalMatcher<T>(TK, std::move(InnerMatcher)), 1540 ASTNodeKind::getFromNodeKind<T>()) 1541 .template unconditionalConvertTo<T>(); 1542 } 1543 1544 private: 1545 TraversalKind TK; 1546 MatcherType InnerMatcher; 1547 }; 1548 1549 /// A PolymorphicMatcher<MatcherT, P1, ..., PN> object can be 1550 /// created from N parameters p1, ..., pN (of type P1, ..., PN) and 1551 /// used as a Matcher<T> where a MatcherT<T, P1, ..., PN>(p1, ..., pN) 1552 /// can be constructed. 1553 /// 1554 /// For example: 1555 /// - PolymorphicMatcher<IsDefinitionMatcher>() 1556 /// creates an object that can be used as a Matcher<T> for any type T 1557 /// where an IsDefinitionMatcher<T>() can be constructed. 1558 /// - PolymorphicMatcher<ValueEqualsMatcher, int>(42) 1559 /// creates an object that can be used as a Matcher<T> for any type T 1560 /// where a ValueEqualsMatcher<T, int>(42) can be constructed. 1561 template <template <typename T, typename... Params> class MatcherT, 1562 typename ReturnTypesF, typename... ParamTypes> 1563 class PolymorphicMatcher { 1564 public: 1565 PolymorphicMatcher(const ParamTypes &... Params) : Params(Params...) {} 1566 1567 using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type; 1568 1569 template <typename T> operator Matcher<T>() const & { 1570 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value, 1571 "right polymorphic conversion"); 1572 return Matcher<T>(new_from_tuple<MatcherT<T, ParamTypes...>>(Params)); 1573 } 1574 1575 template <typename T> operator Matcher<T>() && { 1576 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value, 1577 "right polymorphic conversion"); 1578 return Matcher<T>( 1579 new_from_tuple<MatcherT<T, ParamTypes...>>(std::move(Params))); 1580 } 1581 1582 private: 1583 std::tuple<ParamTypes...> Params; 1584 }; 1585 1586 /// Matches nodes of type T that have child nodes of type ChildT for 1587 /// which a specified child matcher matches. 1588 /// 1589 /// ChildT must be an AST base type. 1590 template <typename T, typename ChildT> 1591 class HasMatcher : public MatcherInterface<T> { 1592 DynTypedMatcher InnerMatcher; 1593 1594 public: 1595 explicit HasMatcher(const Matcher<ChildT> &InnerMatcher) 1596 : InnerMatcher(InnerMatcher) {} 1597 1598 bool matches(const T &Node, ASTMatchFinder *Finder, 1599 BoundNodesTreeBuilder *Builder) const override { 1600 return Finder->matchesChildOf(Node, this->InnerMatcher, Builder, 1601 ASTMatchFinder::BK_First); 1602 } 1603 }; 1604 1605 /// Matches nodes of type T that have child nodes of type ChildT for 1606 /// which a specified child matcher matches. ChildT must be an AST base 1607 /// type. 1608 /// As opposed to the HasMatcher, the ForEachMatcher will produce a match 1609 /// for each child that matches. 1610 template <typename T, typename ChildT> 1611 class ForEachMatcher : public MatcherInterface<T> { 1612 static_assert(IsBaseType<ChildT>::value, 1613 "for each only accepts base type matcher"); 1614 1615 DynTypedMatcher InnerMatcher; 1616 1617 public: 1618 explicit ForEachMatcher(const Matcher<ChildT> &InnerMatcher) 1619 : InnerMatcher(InnerMatcher) {} 1620 1621 bool matches(const T &Node, ASTMatchFinder *Finder, 1622 BoundNodesTreeBuilder *Builder) const override { 1623 return Finder->matchesChildOf( 1624 Node, this->InnerMatcher, Builder, 1625 ASTMatchFinder::BK_All); 1626 } 1627 }; 1628 1629 /// @} 1630 1631 template <typename T> 1632 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const { 1633 return Matcher<T>(*this); 1634 } 1635 1636 /// Matches nodes of type T that have at least one descendant node of 1637 /// type DescendantT for which the given inner matcher matches. 1638 /// 1639 /// DescendantT must be an AST base type. 1640 template <typename T, typename DescendantT> 1641 class HasDescendantMatcher : public MatcherInterface<T> { 1642 static_assert(IsBaseType<DescendantT>::value, 1643 "has descendant only accepts base type matcher"); 1644 1645 DynTypedMatcher DescendantMatcher; 1646 1647 public: 1648 explicit HasDescendantMatcher(const Matcher<DescendantT> &DescendantMatcher) 1649 : DescendantMatcher(DescendantMatcher) {} 1650 1651 bool matches(const T &Node, ASTMatchFinder *Finder, 1652 BoundNodesTreeBuilder *Builder) const override { 1653 return Finder->matchesDescendantOf(Node, this->DescendantMatcher, Builder, 1654 ASTMatchFinder::BK_First); 1655 } 1656 }; 1657 1658 /// Matches nodes of type \c T that have a parent node of type \c ParentT 1659 /// for which the given inner matcher matches. 1660 /// 1661 /// \c ParentT must be an AST base type. 1662 template <typename T, typename ParentT> 1663 class HasParentMatcher : public MatcherInterface<T> { 1664 static_assert(IsBaseType<ParentT>::value, 1665 "has parent only accepts base type matcher"); 1666 1667 DynTypedMatcher ParentMatcher; 1668 1669 public: 1670 explicit HasParentMatcher(const Matcher<ParentT> &ParentMatcher) 1671 : ParentMatcher(ParentMatcher) {} 1672 1673 bool matches(const T &Node, ASTMatchFinder *Finder, 1674 BoundNodesTreeBuilder *Builder) const override { 1675 return Finder->matchesAncestorOf(Node, this->ParentMatcher, Builder, 1676 ASTMatchFinder::AMM_ParentOnly); 1677 } 1678 }; 1679 1680 /// Matches nodes of type \c T that have at least one ancestor node of 1681 /// type \c AncestorT for which the given inner matcher matches. 1682 /// 1683 /// \c AncestorT must be an AST base type. 1684 template <typename T, typename AncestorT> 1685 class HasAncestorMatcher : public MatcherInterface<T> { 1686 static_assert(IsBaseType<AncestorT>::value, 1687 "has ancestor only accepts base type matcher"); 1688 1689 DynTypedMatcher AncestorMatcher; 1690 1691 public: 1692 explicit HasAncestorMatcher(const Matcher<AncestorT> &AncestorMatcher) 1693 : AncestorMatcher(AncestorMatcher) {} 1694 1695 bool matches(const T &Node, ASTMatchFinder *Finder, 1696 BoundNodesTreeBuilder *Builder) const override { 1697 return Finder->matchesAncestorOf(Node, this->AncestorMatcher, Builder, 1698 ASTMatchFinder::AMM_All); 1699 } 1700 }; 1701 1702 /// Matches nodes of type T that have at least one descendant node of 1703 /// type DescendantT for which the given inner matcher matches. 1704 /// 1705 /// DescendantT must be an AST base type. 1706 /// As opposed to HasDescendantMatcher, ForEachDescendantMatcher will match 1707 /// for each descendant node that matches instead of only for the first. 1708 template <typename T, typename DescendantT> 1709 class ForEachDescendantMatcher : public MatcherInterface<T> { 1710 static_assert(IsBaseType<DescendantT>::value, 1711 "for each descendant only accepts base type matcher"); 1712 1713 DynTypedMatcher DescendantMatcher; 1714 1715 public: 1716 explicit ForEachDescendantMatcher( 1717 const Matcher<DescendantT> &DescendantMatcher) 1718 : DescendantMatcher(DescendantMatcher) {} 1719 1720 bool matches(const T &Node, ASTMatchFinder *Finder, 1721 BoundNodesTreeBuilder *Builder) const override { 1722 return Finder->matchesDescendantOf(Node, this->DescendantMatcher, Builder, 1723 ASTMatchFinder::BK_All); 1724 } 1725 }; 1726 1727 /// Matches on nodes that have a getValue() method if getValue() equals 1728 /// the value the ValueEqualsMatcher was constructed with. 1729 template <typename T, typename ValueT> 1730 class ValueEqualsMatcher : public SingleNodeMatcherInterface<T> { 1731 static_assert(std::is_base_of<CharacterLiteral, T>::value || 1732 std::is_base_of<CXXBoolLiteralExpr, T>::value || 1733 std::is_base_of<FloatingLiteral, T>::value || 1734 std::is_base_of<IntegerLiteral, T>::value, 1735 "the node must have a getValue method"); 1736 1737 public: 1738 explicit ValueEqualsMatcher(const ValueT &ExpectedValue) 1739 : ExpectedValue(ExpectedValue) {} 1740 1741 bool matchesNode(const T &Node) const override { 1742 return Node.getValue() == ExpectedValue; 1743 } 1744 1745 private: 1746 ValueT ExpectedValue; 1747 }; 1748 1749 /// Template specializations to easily write matchers for floating point 1750 /// literals. 1751 template <> 1752 inline bool ValueEqualsMatcher<FloatingLiteral, double>::matchesNode( 1753 const FloatingLiteral &Node) const { 1754 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle()) 1755 return Node.getValue().convertToFloat() == ExpectedValue; 1756 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble()) 1757 return Node.getValue().convertToDouble() == ExpectedValue; 1758 return false; 1759 } 1760 template <> 1761 inline bool ValueEqualsMatcher<FloatingLiteral, float>::matchesNode( 1762 const FloatingLiteral &Node) const { 1763 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle()) 1764 return Node.getValue().convertToFloat() == ExpectedValue; 1765 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble()) 1766 return Node.getValue().convertToDouble() == ExpectedValue; 1767 return false; 1768 } 1769 template <> 1770 inline bool ValueEqualsMatcher<FloatingLiteral, llvm::APFloat>::matchesNode( 1771 const FloatingLiteral &Node) const { 1772 return ExpectedValue.compare(Node.getValue()) == llvm::APFloat::cmpEqual; 1773 } 1774 1775 /// Matches nodes of type \c TLoc for which the inner 1776 /// \c Matcher<T> matches. 1777 template <typename TLoc, typename T> 1778 class LocMatcher : public MatcherInterface<TLoc> { 1779 DynTypedMatcher InnerMatcher; 1780 1781 public: 1782 explicit LocMatcher(const Matcher<T> &InnerMatcher) 1783 : InnerMatcher(InnerMatcher) {} 1784 1785 bool matches(const TLoc &Node, ASTMatchFinder *Finder, 1786 BoundNodesTreeBuilder *Builder) const override { 1787 if (!Node) 1788 return false; 1789 return this->InnerMatcher.matches(extract(Node), Finder, Builder); 1790 } 1791 1792 private: 1793 static DynTypedNode extract(const NestedNameSpecifierLoc &Loc) { 1794 return DynTypedNode::create(*Loc.getNestedNameSpecifier()); 1795 } 1796 }; 1797 1798 /// Matches \c TypeLocs based on an inner matcher matching a certain 1799 /// \c QualType. 1800 /// 1801 /// Used to implement the \c loc() matcher. 1802 class TypeLocTypeMatcher : public MatcherInterface<TypeLoc> { 1803 DynTypedMatcher InnerMatcher; 1804 1805 public: 1806 explicit TypeLocTypeMatcher(const Matcher<QualType> &InnerMatcher) 1807 : InnerMatcher(InnerMatcher) {} 1808 1809 bool matches(const TypeLoc &Node, ASTMatchFinder *Finder, 1810 BoundNodesTreeBuilder *Builder) const override { 1811 if (!Node) 1812 return false; 1813 return this->InnerMatcher.matches(DynTypedNode::create(Node.getType()), 1814 Finder, Builder); 1815 } 1816 }; 1817 1818 /// Matches nodes of type \c T for which the inner matcher matches on a 1819 /// another node of type \c T that can be reached using a given traverse 1820 /// function. 1821 template <typename T> class TypeTraverseMatcher : public MatcherInterface<T> { 1822 DynTypedMatcher InnerMatcher; 1823 1824 public: 1825 explicit TypeTraverseMatcher(const Matcher<QualType> &InnerMatcher, 1826 QualType (T::*TraverseFunction)() const) 1827 : InnerMatcher(InnerMatcher), TraverseFunction(TraverseFunction) {} 1828 1829 bool matches(const T &Node, ASTMatchFinder *Finder, 1830 BoundNodesTreeBuilder *Builder) const override { 1831 QualType NextNode = (Node.*TraverseFunction)(); 1832 if (NextNode.isNull()) 1833 return false; 1834 return this->InnerMatcher.matches(DynTypedNode::create(NextNode), Finder, 1835 Builder); 1836 } 1837 1838 private: 1839 QualType (T::*TraverseFunction)() const; 1840 }; 1841 1842 /// Matches nodes of type \c T in a ..Loc hierarchy, for which the inner 1843 /// matcher matches on a another node of type \c T that can be reached using a 1844 /// given traverse function. 1845 template <typename T> 1846 class TypeLocTraverseMatcher : public MatcherInterface<T> { 1847 DynTypedMatcher InnerMatcher; 1848 1849 public: 1850 explicit TypeLocTraverseMatcher(const Matcher<TypeLoc> &InnerMatcher, 1851 TypeLoc (T::*TraverseFunction)() const) 1852 : InnerMatcher(InnerMatcher), TraverseFunction(TraverseFunction) {} 1853 1854 bool matches(const T &Node, ASTMatchFinder *Finder, 1855 BoundNodesTreeBuilder *Builder) const override { 1856 TypeLoc NextNode = (Node.*TraverseFunction)(); 1857 if (!NextNode) 1858 return false; 1859 return this->InnerMatcher.matches(DynTypedNode::create(NextNode), Finder, 1860 Builder); 1861 } 1862 1863 private: 1864 TypeLoc (T::*TraverseFunction)() const; 1865 }; 1866 1867 /// Converts a \c Matcher<InnerT> to a \c Matcher<OuterT>, where 1868 /// \c OuterT is any type that is supported by \c Getter. 1869 /// 1870 /// \code Getter<OuterT>::value() \endcode returns a 1871 /// \code InnerTBase (OuterT::*)() \endcode, which is used to adapt a \c OuterT 1872 /// object into a \c InnerT 1873 template <typename InnerTBase, 1874 template <typename OuterT> class Getter, 1875 template <typename OuterT> class MatcherImpl, 1876 typename ReturnTypesF> 1877 class TypeTraversePolymorphicMatcher { 1878 private: 1879 using Self = TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, 1880 ReturnTypesF>; 1881 1882 static Self create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers); 1883 1884 public: 1885 using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type; 1886 1887 explicit TypeTraversePolymorphicMatcher( 1888 ArrayRef<const Matcher<InnerTBase> *> InnerMatchers) 1889 : InnerMatcher(makeAllOfComposite(InnerMatchers)) {} 1890 1891 template <typename OuterT> operator Matcher<OuterT>() const { 1892 return Matcher<OuterT>( 1893 new MatcherImpl<OuterT>(InnerMatcher, Getter<OuterT>::value())); 1894 } 1895 1896 struct Func 1897 : public VariadicFunction<Self, Matcher<InnerTBase>, &Self::create> { 1898 Func() {} 1899 }; 1900 1901 private: 1902 Matcher<InnerTBase> InnerMatcher; 1903 }; 1904 1905 /// A simple memoizer of T(*)() functions. 1906 /// 1907 /// It will call the passed 'Func' template parameter at most once. 1908 /// Used to support AST_MATCHER_FUNCTION() macro. 1909 template <typename Matcher, Matcher (*Func)()> class MemoizedMatcher { 1910 struct Wrapper { 1911 Wrapper() : M(Func()) {} 1912 1913 Matcher M; 1914 }; 1915 1916 public: 1917 static const Matcher &getInstance() { 1918 static llvm::ManagedStatic<Wrapper> Instance; 1919 return Instance->M; 1920 } 1921 }; 1922 1923 // Define the create() method out of line to silence a GCC warning about 1924 // the struct "Func" having greater visibility than its base, which comes from 1925 // using the flag -fvisibility-inlines-hidden. 1926 template <typename InnerTBase, template <typename OuterT> class Getter, 1927 template <typename OuterT> class MatcherImpl, typename ReturnTypesF> 1928 TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, ReturnTypesF> 1929 TypeTraversePolymorphicMatcher< 1930 InnerTBase, Getter, MatcherImpl, 1931 ReturnTypesF>::create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers) { 1932 return Self(InnerMatchers); 1933 } 1934 1935 // FIXME: unify ClassTemplateSpecializationDecl and TemplateSpecializationType's 1936 // APIs for accessing the template argument list. 1937 inline ArrayRef<TemplateArgument> 1938 getTemplateSpecializationArgs(const ClassTemplateSpecializationDecl &D) { 1939 return D.getTemplateArgs().asArray(); 1940 } 1941 1942 inline ArrayRef<TemplateArgument> 1943 getTemplateSpecializationArgs(const TemplateSpecializationType &T) { 1944 return T.template_arguments(); 1945 } 1946 1947 inline ArrayRef<TemplateArgument> 1948 getTemplateSpecializationArgs(const FunctionDecl &FD) { 1949 if (const auto* TemplateArgs = FD.getTemplateSpecializationArgs()) 1950 return TemplateArgs->asArray(); 1951 return ArrayRef<TemplateArgument>(); 1952 } 1953 1954 struct NotEqualsBoundNodePredicate { 1955 bool operator()(const internal::BoundNodesMap &Nodes) const { 1956 return Nodes.getNode(ID) != Node; 1957 } 1958 1959 std::string ID; 1960 DynTypedNode Node; 1961 }; 1962 1963 template <typename Ty, typename Enable = void> struct GetBodyMatcher { 1964 static const Stmt *get(const Ty &Node) { return Node.getBody(); } 1965 }; 1966 1967 template <typename Ty> 1968 struct GetBodyMatcher< 1969 Ty, std::enable_if_t<std::is_base_of<FunctionDecl, Ty>::value>> { 1970 static const Stmt *get(const Ty &Node) { 1971 return Node.doesThisDeclarationHaveABody() ? Node.getBody() : nullptr; 1972 } 1973 }; 1974 1975 template <typename NodeType> 1976 inline std::optional<BinaryOperatorKind> 1977 equivalentBinaryOperator(const NodeType &Node) { 1978 return Node.getOpcode(); 1979 } 1980 1981 template <> 1982 inline std::optional<BinaryOperatorKind> 1983 equivalentBinaryOperator<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) { 1984 if (Node.getNumArgs() != 2) 1985 return std::nullopt; 1986 switch (Node.getOperator()) { 1987 default: 1988 return std::nullopt; 1989 case OO_ArrowStar: 1990 return BO_PtrMemI; 1991 case OO_Star: 1992 return BO_Mul; 1993 case OO_Slash: 1994 return BO_Div; 1995 case OO_Percent: 1996 return BO_Rem; 1997 case OO_Plus: 1998 return BO_Add; 1999 case OO_Minus: 2000 return BO_Sub; 2001 case OO_LessLess: 2002 return BO_Shl; 2003 case OO_GreaterGreater: 2004 return BO_Shr; 2005 case OO_Spaceship: 2006 return BO_Cmp; 2007 case OO_Less: 2008 return BO_LT; 2009 case OO_Greater: 2010 return BO_GT; 2011 case OO_LessEqual: 2012 return BO_LE; 2013 case OO_GreaterEqual: 2014 return BO_GE; 2015 case OO_EqualEqual: 2016 return BO_EQ; 2017 case OO_ExclaimEqual: 2018 return BO_NE; 2019 case OO_Amp: 2020 return BO_And; 2021 case OO_Caret: 2022 return BO_Xor; 2023 case OO_Pipe: 2024 return BO_Or; 2025 case OO_AmpAmp: 2026 return BO_LAnd; 2027 case OO_PipePipe: 2028 return BO_LOr; 2029 case OO_Equal: 2030 return BO_Assign; 2031 case OO_StarEqual: 2032 return BO_MulAssign; 2033 case OO_SlashEqual: 2034 return BO_DivAssign; 2035 case OO_PercentEqual: 2036 return BO_RemAssign; 2037 case OO_PlusEqual: 2038 return BO_AddAssign; 2039 case OO_MinusEqual: 2040 return BO_SubAssign; 2041 case OO_LessLessEqual: 2042 return BO_ShlAssign; 2043 case OO_GreaterGreaterEqual: 2044 return BO_ShrAssign; 2045 case OO_AmpEqual: 2046 return BO_AndAssign; 2047 case OO_CaretEqual: 2048 return BO_XorAssign; 2049 case OO_PipeEqual: 2050 return BO_OrAssign; 2051 case OO_Comma: 2052 return BO_Comma; 2053 } 2054 } 2055 2056 template <typename NodeType> 2057 inline std::optional<UnaryOperatorKind> 2058 equivalentUnaryOperator(const NodeType &Node) { 2059 return Node.getOpcode(); 2060 } 2061 2062 template <> 2063 inline std::optional<UnaryOperatorKind> 2064 equivalentUnaryOperator<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) { 2065 if (Node.getNumArgs() != 1 && Node.getOperator() != OO_PlusPlus && 2066 Node.getOperator() != OO_MinusMinus) 2067 return std::nullopt; 2068 switch (Node.getOperator()) { 2069 default: 2070 return std::nullopt; 2071 case OO_Plus: 2072 return UO_Plus; 2073 case OO_Minus: 2074 return UO_Minus; 2075 case OO_Amp: 2076 return UO_AddrOf; 2077 case OO_Star: 2078 return UO_Deref; 2079 case OO_Tilde: 2080 return UO_Not; 2081 case OO_Exclaim: 2082 return UO_LNot; 2083 case OO_PlusPlus: { 2084 const auto *FD = Node.getDirectCallee(); 2085 if (!FD) 2086 return std::nullopt; 2087 return FD->getNumParams() > 0 ? UO_PostInc : UO_PreInc; 2088 } 2089 case OO_MinusMinus: { 2090 const auto *FD = Node.getDirectCallee(); 2091 if (!FD) 2092 return std::nullopt; 2093 return FD->getNumParams() > 0 ? UO_PostDec : UO_PreDec; 2094 } 2095 case OO_Coawait: 2096 return UO_Coawait; 2097 } 2098 } 2099 2100 template <typename NodeType> inline const Expr *getLHS(const NodeType &Node) { 2101 return Node.getLHS(); 2102 } 2103 template <> 2104 inline const Expr * 2105 getLHS<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) { 2106 if (!internal::equivalentBinaryOperator(Node)) 2107 return nullptr; 2108 return Node.getArg(0); 2109 } 2110 template <typename NodeType> inline const Expr *getRHS(const NodeType &Node) { 2111 return Node.getRHS(); 2112 } 2113 template <> 2114 inline const Expr * 2115 getRHS<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) { 2116 if (!internal::equivalentBinaryOperator(Node)) 2117 return nullptr; 2118 return Node.getArg(1); 2119 } 2120 template <typename NodeType> 2121 inline const Expr *getSubExpr(const NodeType &Node) { 2122 return Node.getSubExpr(); 2123 } 2124 template <> 2125 inline const Expr * 2126 getSubExpr<CXXOperatorCallExpr>(const CXXOperatorCallExpr &Node) { 2127 if (!internal::equivalentUnaryOperator(Node)) 2128 return nullptr; 2129 return Node.getArg(0); 2130 } 2131 2132 template <typename Ty> 2133 struct HasSizeMatcher { 2134 static bool hasSize(const Ty &Node, unsigned int N) { 2135 return Node.getSize() == N; 2136 } 2137 }; 2138 2139 template <> 2140 inline bool HasSizeMatcher<StringLiteral>::hasSize( 2141 const StringLiteral &Node, unsigned int N) { 2142 return Node.getLength() == N; 2143 } 2144 2145 template <typename Ty> 2146 struct GetSourceExpressionMatcher { 2147 static const Expr *get(const Ty &Node) { 2148 return Node.getSubExpr(); 2149 } 2150 }; 2151 2152 template <> 2153 inline const Expr *GetSourceExpressionMatcher<OpaqueValueExpr>::get( 2154 const OpaqueValueExpr &Node) { 2155 return Node.getSourceExpr(); 2156 } 2157 2158 template <typename Ty> 2159 struct CompoundStmtMatcher { 2160 static const CompoundStmt *get(const Ty &Node) { 2161 return &Node; 2162 } 2163 }; 2164 2165 template <> 2166 inline const CompoundStmt * 2167 CompoundStmtMatcher<StmtExpr>::get(const StmtExpr &Node) { 2168 return Node.getSubStmt(); 2169 } 2170 2171 /// If \p Loc is (transitively) expanded from macro \p MacroName, returns the 2172 /// location (in the chain of expansions) at which \p MacroName was 2173 /// expanded. Since the macro may have been expanded inside a series of 2174 /// expansions, that location may itself be a MacroID. 2175 std::optional<SourceLocation> getExpansionLocOfMacro(StringRef MacroName, 2176 SourceLocation Loc, 2177 const ASTContext &Context); 2178 2179 inline std::optional<StringRef> getOpName(const UnaryOperator &Node) { 2180 return Node.getOpcodeStr(Node.getOpcode()); 2181 } 2182 inline std::optional<StringRef> getOpName(const BinaryOperator &Node) { 2183 return Node.getOpcodeStr(); 2184 } 2185 inline StringRef getOpName(const CXXRewrittenBinaryOperator &Node) { 2186 return Node.getOpcodeStr(); 2187 } 2188 inline std::optional<StringRef> getOpName(const CXXOperatorCallExpr &Node) { 2189 auto optBinaryOpcode = equivalentBinaryOperator(Node); 2190 if (!optBinaryOpcode) { 2191 auto optUnaryOpcode = equivalentUnaryOperator(Node); 2192 if (!optUnaryOpcode) 2193 return std::nullopt; 2194 return UnaryOperator::getOpcodeStr(*optUnaryOpcode); 2195 } 2196 return BinaryOperator::getOpcodeStr(*optBinaryOpcode); 2197 } 2198 2199 /// Matches overloaded operators with a specific name. 2200 /// 2201 /// The type argument ArgT is not used by this matcher but is used by 2202 /// PolymorphicMatcher and should be std::vector<std::string>>. 2203 template <typename T, typename ArgT = std::vector<std::string>> 2204 class HasAnyOperatorNameMatcher : public SingleNodeMatcherInterface<T> { 2205 static_assert(std::is_same<T, BinaryOperator>::value || 2206 std::is_same<T, CXXOperatorCallExpr>::value || 2207 std::is_same<T, CXXRewrittenBinaryOperator>::value || 2208 std::is_same<T, UnaryOperator>::value, 2209 "Matcher only supports `BinaryOperator`, `UnaryOperator`, " 2210 "`CXXOperatorCallExpr` and `CXXRewrittenBinaryOperator`"); 2211 static_assert(std::is_same<ArgT, std::vector<std::string>>::value, 2212 "Matcher ArgT must be std::vector<std::string>"); 2213 2214 public: 2215 explicit HasAnyOperatorNameMatcher(std::vector<std::string> Names) 2216 : SingleNodeMatcherInterface<T>(), Names(std::move(Names)) {} 2217 2218 bool matchesNode(const T &Node) const override { 2219 std::optional<StringRef> OptOpName = getOpName(Node); 2220 return OptOpName && llvm::is_contained(Names, *OptOpName); 2221 } 2222 2223 private: 2224 static std::optional<StringRef> getOpName(const UnaryOperator &Node) { 2225 return Node.getOpcodeStr(Node.getOpcode()); 2226 } 2227 static std::optional<StringRef> getOpName(const BinaryOperator &Node) { 2228 return Node.getOpcodeStr(); 2229 } 2230 static StringRef getOpName(const CXXRewrittenBinaryOperator &Node) { 2231 return Node.getOpcodeStr(); 2232 } 2233 static std::optional<StringRef> getOpName(const CXXOperatorCallExpr &Node) { 2234 auto optBinaryOpcode = equivalentBinaryOperator(Node); 2235 if (!optBinaryOpcode) { 2236 auto optUnaryOpcode = equivalentUnaryOperator(Node); 2237 if (!optUnaryOpcode) 2238 return std::nullopt; 2239 return UnaryOperator::getOpcodeStr(*optUnaryOpcode); 2240 } 2241 return BinaryOperator::getOpcodeStr(*optBinaryOpcode); 2242 } 2243 2244 std::vector<std::string> Names; 2245 }; 2246 2247 using HasOpNameMatcher = 2248 PolymorphicMatcher<HasAnyOperatorNameMatcher, 2249 void( 2250 TypeList<BinaryOperator, CXXOperatorCallExpr, 2251 CXXRewrittenBinaryOperator, UnaryOperator>), 2252 std::vector<std::string>>; 2253 2254 HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef<const StringRef *> NameRefs); 2255 2256 using HasOverloadOpNameMatcher = 2257 PolymorphicMatcher<HasOverloadedOperatorNameMatcher, 2258 void(TypeList<CXXOperatorCallExpr, FunctionDecl>), 2259 std::vector<std::string>>; 2260 2261 HasOverloadOpNameMatcher 2262 hasAnyOverloadedOperatorNameFunc(ArrayRef<const StringRef *> NameRefs); 2263 2264 /// Returns true if \p Node has a base specifier matching \p BaseSpec. 2265 /// 2266 /// A class is not considered to be derived from itself. 2267 bool matchesAnyBase(const CXXRecordDecl &Node, 2268 const Matcher<CXXBaseSpecifier> &BaseSpecMatcher, 2269 ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder); 2270 2271 std::shared_ptr<llvm::Regex> createAndVerifyRegex(StringRef Regex, 2272 llvm::Regex::RegexFlags Flags, 2273 StringRef MatcherID); 2274 2275 inline bool 2276 MatchTemplateArgLocAt(const DeclRefExpr &Node, unsigned int Index, 2277 internal::Matcher<TemplateArgumentLoc> InnerMatcher, 2278 internal::ASTMatchFinder *Finder, 2279 internal::BoundNodesTreeBuilder *Builder) { 2280 llvm::ArrayRef<TemplateArgumentLoc> ArgLocs = Node.template_arguments(); 2281 return Index < ArgLocs.size() && 2282 InnerMatcher.matches(ArgLocs[Index], Finder, Builder); 2283 } 2284 2285 inline bool 2286 MatchTemplateArgLocAt(const TemplateSpecializationTypeLoc &Node, 2287 unsigned int Index, 2288 internal::Matcher<TemplateArgumentLoc> InnerMatcher, 2289 internal::ASTMatchFinder *Finder, 2290 internal::BoundNodesTreeBuilder *Builder) { 2291 return !Node.isNull() && Index < Node.getNumArgs() && 2292 InnerMatcher.matches(Node.getArgLoc(Index), Finder, Builder); 2293 } 2294 2295 } // namespace internal 2296 2297 } // namespace ast_matchers 2298 2299 } // namespace clang 2300 2301 #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H 2302