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 = std::map<std::string, ast_type_traits::DynTypedNode>; |

187 | |

188 | const IDToNodeMap &getMap() const { |

189 | return NodeMap; |

190 | } |

191 | |

192 | /// Returns \c true if this \c BoundNodesMap can be compared, i.e. all |

193 | /// stored nodes have memoization data. |

194 | bool isComparable() const { |

195 | for (const auto &IDAndNode : NodeMap) { |

196 | if (!IDAndNode.second.getMemoizationData()) |

197 | return false; |

198 | } |

199 | return true; |

200 | } |

201 | |

202 | private: |

203 | IDToNodeMap NodeMap; |

204 | }; |

205 | |

206 | /// Creates BoundNodesTree objects. |

207 | /// |

208 | /// The tree builder is used during the matching process to insert the bound |

209 | /// nodes from the Id matcher. |

210 | class BoundNodesTreeBuilder { |

211 | public: |

212 | /// A visitor interface to visit all BoundNodes results for a |

213 | /// BoundNodesTree. |

214 | class Visitor { |

215 | public: |

216 | virtual ~Visitor() = default; |

217 | |

218 | /// Called multiple times during a single call to VisitMatches(...). |

219 | /// |

220 | /// 'BoundNodesView' contains the bound nodes for a single match. |

221 | virtual void visitMatch(const BoundNodes& BoundNodesView) = 0; |

222 | }; |

223 | |

224 | /// Add a binding from an id to a node. |

225 | void setBinding(StringRef Id, const ast_type_traits::DynTypedNode &DynNode) { |

226 | if (Bindings.empty()) |

227 | Bindings.emplace_back(); |

228 | for (BoundNodesMap &Binding : Bindings) |

229 | Binding.addNode(Id, DynNode); |

230 | } |

231 | |

232 | /// Adds a branch in the tree. |

233 | void addMatch(const BoundNodesTreeBuilder &Bindings); |

234 | |

235 | /// Visits all matches that this BoundNodesTree represents. |

236 | /// |

237 | /// The ownership of 'ResultVisitor' remains at the caller. |

238 | void visitMatches(Visitor* ResultVisitor); |

239 | |

240 | template <typename ExcludePredicate> |

241 | bool removeBindings(const ExcludePredicate &Predicate) { |

242 | Bindings.erase(std::remove_if(Bindings.begin(), Bindings.end(), Predicate), |

243 | Bindings.end()); |

244 | return !Bindings.empty(); |

245 | } |

246 | |

247 | /// Imposes an order on BoundNodesTreeBuilders. |

248 | bool operator<(const BoundNodesTreeBuilder &Other) const { |

249 | return Bindings < Other.Bindings; |

250 | } |

251 | |

252 | /// Returns \c true if this \c BoundNodesTreeBuilder can be compared, |

253 | /// i.e. all stored node maps have memoization data. |

254 | bool isComparable() const { |

255 | for (const BoundNodesMap &NodesMap : Bindings) { |

256 | if (!NodesMap.isComparable()) |

257 | return false; |

258 | } |

259 | return true; |

260 | } |

261 | |

262 | private: |

263 | SmallVector<BoundNodesMap, 1> Bindings; |

264 | }; |

265 | |

266 | class ASTMatchFinder; |

267 | |

268 | /// Generic interface for all matchers. |

269 | /// |

270 | /// Used by the implementation of Matcher<T> and DynTypedMatcher. |

271 | /// In general, implement MatcherInterface<T> or SingleNodeMatcherInterface<T> |

272 | /// instead. |

273 | class DynMatcherInterface |

274 | : public llvm::ThreadSafeRefCountedBase<DynMatcherInterface> { |

275 | public: |

276 | virtual ~DynMatcherInterface() = default; |

277 | |

278 | /// Returns true if \p DynNode can be matched. |

279 | /// |

280 | /// May bind \p DynNode to an ID via \p Builder, or recurse into |

281 | /// the AST via \p Finder. |

282 | virtual bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, |

283 | ASTMatchFinder *Finder, |

284 | BoundNodesTreeBuilder *Builder) const = 0; |

285 | }; |

286 | |

287 | /// Generic interface for matchers on an AST node of type T. |

288 | /// |

289 | /// Implement this if your matcher may need to inspect the children or |

290 | /// descendants of the node or bind matched nodes to names. If you are |

291 | /// writing a simple matcher that only inspects properties of the |

292 | /// current node and doesn't care about its children or descendants, |

293 | /// implement SingleNodeMatcherInterface instead. |

294 | template <typename T> |

295 | class MatcherInterface : public DynMatcherInterface { |

296 | public: |

297 | /// Returns true if 'Node' can be matched. |

298 | /// |

299 | /// May bind 'Node' to an ID via 'Builder', or recurse into |

300 | /// the AST via 'Finder'. |

301 | virtual bool matches(const T &Node, |

302 | ASTMatchFinder *Finder, |

303 | BoundNodesTreeBuilder *Builder) const = 0; |

304 | |

305 | bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, |

306 | ASTMatchFinder *Finder, |

307 | BoundNodesTreeBuilder *Builder) const override { |

308 | return matches(DynNode.getUnchecked<T>(), Finder, Builder); |

309 | } |

310 | }; |

311 | |

312 | /// Interface for matchers that only evaluate properties on a single |

313 | /// node. |

314 | template <typename T> |

315 | class SingleNodeMatcherInterface : public MatcherInterface<T> { |

316 | public: |

317 | /// Returns true if the matcher matches the provided node. |

318 | /// |

319 | /// A subclass must implement this instead of Matches(). |

320 | virtual bool matchesNode(const T &Node) const = 0; |

321 | |

322 | private: |

323 | /// Implements MatcherInterface::Matches. |

324 | bool matches(const T &Node, |

325 | ASTMatchFinder * /* Finder */, |

326 | BoundNodesTreeBuilder * /* Builder */) const override { |

327 | return matchesNode(Node); |

328 | } |

329 | }; |

330 | |

331 | template <typename> class Matcher; |

332 | |

333 | /// Matcher that works on a \c DynTypedNode. |

334 | /// |

335 | /// It is constructed from a \c Matcher<T> object and redirects most calls to |

336 | /// underlying matcher. |

337 | /// It checks whether the \c DynTypedNode is convertible into the type of the |

338 | /// underlying matcher and then do the actual match on the actual node, or |

339 | /// return false if it is not convertible. |

340 | class DynTypedMatcher { |

341 | public: |

342 | /// Takes ownership of the provided implementation pointer. |

343 | template <typename T> |

344 | DynTypedMatcher(MatcherInterface<T> *Implementation) |

345 | : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()), |

346 | RestrictKind(SupportedKind), Implementation(Implementation) {} |

347 | |

348 | /// Construct from a variadic function. |

349 | enum VariadicOperator { |

350 | /// Matches nodes for which all provided matchers match. |

351 | VO_AllOf, |

352 | |

353 | /// Matches nodes for which at least one of the provided matchers |

354 | /// matches. |

355 | VO_AnyOf, |

356 | |

357 | /// Matches nodes for which at least one of the provided matchers |

358 | /// matches, but doesn't stop at the first match. |

359 | VO_EachOf, |

360 | |

361 | /// Matches nodes that do not match the provided matcher. |

362 | /// |

363 | /// Uses the variadic matcher interface, but fails if |

364 | /// InnerMatchers.size() != 1. |

365 | VO_UnaryNot |

366 | }; |

367 | |

368 | static DynTypedMatcher |

369 | constructVariadic(VariadicOperator Op, |

370 | ast_type_traits::ASTNodeKind SupportedKind, |

371 | std::vector<DynTypedMatcher> InnerMatchers); |

372 | |

373 | /// Get a "true" matcher for \p NodeKind. |

374 | /// |

375 | /// It only checks that the node is of the right kind. |

376 | static DynTypedMatcher trueMatcher(ast_type_traits::ASTNodeKind NodeKind); |

377 | |

378 | void setAllowBind(bool AB) { AllowBind = AB; } |

379 | |

380 | /// Check whether this matcher could ever match a node of kind \p Kind. |

381 | /// \return \c false if this matcher will never match such a node. Otherwise, |

382 | /// return \c true. |

383 | bool canMatchNodesOfKind(ast_type_traits::ASTNodeKind Kind) const; |

384 | |

385 | /// Return a matcher that points to the same implementation, but |

386 | /// restricts the node types for \p Kind. |

387 | DynTypedMatcher dynCastTo(const ast_type_traits::ASTNodeKind Kind) const; |

388 | |

389 | /// Returns true if the matcher matches the given \c DynNode. |

390 | bool matches(const ast_type_traits::DynTypedNode &DynNode, |

391 | ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const; |

392 | |

393 | /// Same as matches(), but skips the kind check. |

394 | /// |

395 | /// It is faster, but the caller must ensure the node is valid for the |

396 | /// kind of this matcher. |

397 | bool matchesNoKindCheck(const ast_type_traits::DynTypedNode &DynNode, |

398 | ASTMatchFinder *Finder, |

399 | BoundNodesTreeBuilder *Builder) const; |

400 | |

401 | /// Bind the specified \p ID to the matcher. |

402 | /// \return A new matcher with the \p ID bound to it if this matcher supports |

403 | /// binding. Otherwise, returns an empty \c Optional<>. |

404 | llvm::Optional<DynTypedMatcher> tryBind(StringRef ID) const; |

405 | |

406 | /// Returns a unique \p ID for the matcher. |

407 | /// |

408 | /// Casting a Matcher<T> to Matcher<U> creates a matcher that has the |

409 | /// same \c Implementation pointer, but different \c RestrictKind. We need to |

410 | /// include both in the ID to make it unique. |

411 | /// |

412 | /// \c MatcherIDType supports operator< and provides strict weak ordering. |

413 | using MatcherIDType = std::pair<ast_type_traits::ASTNodeKind, uint64_t>; |

414 | MatcherIDType getID() const { |

415 | /// FIXME: Document the requirements this imposes on matcher |

416 | /// implementations (no new() implementation_ during a Matches()). |

417 | return std::make_pair(RestrictKind, |

418 | reinterpret_cast<uint64_t>(Implementation.get())); |

419 | } |

420 | |

421 | /// Returns the type this matcher works on. |

422 | /// |

423 | /// \c matches() will always return false unless the node passed is of this |

424 | /// or a derived type. |

425 | ast_type_traits::ASTNodeKind getSupportedKind() const { |

426 | return SupportedKind; |

427 | } |

428 | |

429 | /// Returns \c true if the passed \c DynTypedMatcher can be converted |

430 | /// to a \c Matcher<T>. |

431 | /// |

432 | /// This method verifies that the underlying matcher in \c Other can process |

433 | /// nodes of types T. |

434 | template <typename T> bool canConvertTo() const { |

435 | return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); |

436 | } |

437 | bool canConvertTo(ast_type_traits::ASTNodeKind To) const; |

438 | |

439 | /// Construct a \c Matcher<T> interface around the dynamic matcher. |

440 | /// |

441 | /// This method asserts that \c canConvertTo() is \c true. Callers |

442 | /// should call \c canConvertTo() first to make sure that \c this is |

443 | /// compatible with T. |

444 | template <typename T> Matcher<T> convertTo() const { |

445 | assert(canConvertTo<T>()); |

446 | return unconditionalConvertTo<T>(); |

447 | } |

448 | |

449 | /// Same as \c convertTo(), but does not check that the underlying |

450 | /// matcher can handle a value of T. |

451 | /// |

452 | /// If it is not compatible, then this matcher will never match anything. |

453 | template <typename T> Matcher<T> unconditionalConvertTo() const; |

454 | |

455 | private: |

456 | DynTypedMatcher(ast_type_traits::ASTNodeKind SupportedKind, |

457 | ast_type_traits::ASTNodeKind RestrictKind, |

458 | IntrusiveRefCntPtr<DynMatcherInterface> Implementation) |

459 | : SupportedKind(SupportedKind), RestrictKind(RestrictKind), |

460 | Implementation(std::move(Implementation)) {} |

461 | |

462 | bool AllowBind = false; |

463 | ast_type_traits::ASTNodeKind SupportedKind; |

464 | |

465 | /// A potentially stricter node kind. |

466 | /// |

467 | /// It allows to perform implicit and dynamic cast of matchers without |

468 | /// needing to change \c Implementation. |

469 | ast_type_traits::ASTNodeKind RestrictKind; |

470 | IntrusiveRefCntPtr<DynMatcherInterface> Implementation; |

471 | }; |

472 | |

473 | /// Wrapper base class for a wrapping matcher. |

474 | /// |

475 | /// This is just a container for a DynTypedMatcher that can be used as a base |

476 | /// class for another matcher. |

477 | template <typename T> |

478 | class WrapperMatcherInterface : public MatcherInterface<T> { |

479 | protected: |

480 | explicit WrapperMatcherInterface(DynTypedMatcher &&InnerMatcher) |

481 | : InnerMatcher(std::move(InnerMatcher)) {} |

482 | |

483 | const DynTypedMatcher InnerMatcher; |

484 | }; |

485 | |

486 | /// Wrapper of a MatcherInterface<T> *that allows copying. |

487 | /// |

488 | /// A Matcher<Base> can be used anywhere a Matcher<Derived> is |

489 | /// required. This establishes an is-a relationship which is reverse |

490 | /// to the AST hierarchy. In other words, Matcher<T> is contravariant |

491 | /// with respect to T. The relationship is built via a type conversion |

492 | /// operator rather than a type hierarchy to be able to templatize the |

493 | /// type hierarchy instead of spelling it out. |

494 | template <typename T> |

495 | class Matcher { |

496 | public: |

497 | /// Takes ownership of the provided implementation pointer. |

498 | explicit Matcher(MatcherInterface<T> *Implementation) |

499 | : Implementation(Implementation) {} |

500 | |

501 | /// Implicitly converts \c Other to a Matcher<T>. |

502 | /// |

503 | /// Requires \c T to be derived from \c From. |

504 | template <typename From> |

505 | Matcher(const Matcher<From> &Other, |

506 | typename std::enable_if<std::is_base_of<From, T>::value && |

507 | !std::is_same<From, T>::value>::type * = nullptr) |

508 | : Implementation(restrictMatcher(Other.Implementation)) { |

509 | assert(Implementation.getSupportedKind().isSame( |

510 | ast_type_traits::ASTNodeKind::getFromNodeKind<T>())); |

511 | } |

512 | |

513 | /// Implicitly converts \c Matcher<Type> to \c Matcher<QualType>. |

514 | /// |

515 | /// The resulting matcher is not strict, i.e. ignores qualifiers. |

516 | template <typename TypeT> |

517 | Matcher(const Matcher<TypeT> &Other, |

518 | typename std::enable_if< |

519 | std::is_same<T, QualType>::value && |

520 | std::is_same<TypeT, Type>::value>::type* = nullptr) |

521 | : Implementation(new TypeToQualType<TypeT>(Other)) {} |

522 | |

523 | /// Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the |

524 | /// argument. |

525 | /// \c To must be a base class of \c T. |

526 | template <typename To> |

527 | Matcher<To> dynCastTo() const { |

528 | static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call."); |

529 | return Matcher<To>(Implementation); |

530 | } |

531 | |

532 | /// Forwards the call to the underlying MatcherInterface<T> pointer. |

533 | bool matches(const T &Node, |

534 | ASTMatchFinder *Finder, |

535 | BoundNodesTreeBuilder *Builder) const { |

536 | return Implementation.matches(ast_type_traits::DynTypedNode::create(Node), |

537 | Finder, Builder); |

538 | } |

539 | |

540 | /// Returns an ID that uniquely identifies the matcher. |

541 | DynTypedMatcher::MatcherIDType getID() const { |

542 | return Implementation.getID(); |

543 | } |

544 | |

545 | /// Extract the dynamic matcher. |

546 | /// |

547 | /// The returned matcher keeps the same restrictions as \c this and remembers |

548 | /// that it is meant to support nodes of type \c T. |

549 | operator DynTypedMatcher() const { return Implementation; } |

550 | |

551 | /// Allows the conversion of a \c Matcher<Type> to a \c |

552 | /// Matcher<QualType>. |

553 | /// |

554 | /// Depending on the constructor argument, the matcher is either strict, i.e. |

555 | /// does only matches in the absence of qualifiers, or not, i.e. simply |

556 | /// ignores any qualifiers. |

557 | template <typename TypeT> |

558 | class TypeToQualType : public WrapperMatcherInterface<QualType> { |

559 | public: |

560 | TypeToQualType(const Matcher<TypeT> &InnerMatcher) |

561 | : TypeToQualType::WrapperMatcherInterface(InnerMatcher) {} |

562 | |

563 | bool matches(const QualType &Node, ASTMatchFinder *Finder, |

564 | BoundNodesTreeBuilder *Builder) const override { |

565 | if (Node.isNull()) |

566 | return false; |

567 | return this->InnerMatcher.matches( |

568 | ast_type_traits::DynTypedNode::create(*Node), Finder, Builder); |

569 | } |

570 | }; |

571 | |

572 | private: |

573 | // For Matcher<T> <=> Matcher<U> conversions. |

574 | template <typename U> friend class Matcher; |

575 | |

576 | // For DynTypedMatcher::unconditionalConvertTo<T>. |

577 | friend class DynTypedMatcher; |

578 | |

579 | static DynTypedMatcher restrictMatcher(const DynTypedMatcher &Other) { |

580 | return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); |

581 | } |

582 | |

583 | explicit Matcher(const DynTypedMatcher &Implementation) |

584 | : Implementation(restrictMatcher(Implementation)) { |

585 | assert(this->Implementation.getSupportedKind() |

586 | .isSame(ast_type_traits::ASTNodeKind::getFromNodeKind<T>())); |

587 | } |

588 | |

589 | DynTypedMatcher Implementation; |

590 | }; // class Matcher |

591 | |

592 | /// A convenient helper for creating a Matcher<T> without specifying |

593 | /// the template type argument. |

594 | template <typename T> |

595 | inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) { |

596 | return Matcher<T>(Implementation); |

597 | } |

598 | |

599 | /// Specialization of the conversion functions for QualType. |

600 | /// |

601 | /// This specialization provides the Matcher<Type>->Matcher<QualType> |

602 | /// conversion that the static API does. |

603 | template <> |

604 | inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>() const { |

605 | assert(canConvertTo<QualType>()); |

606 | const ast_type_traits::ASTNodeKind SourceKind = getSupportedKind(); |

607 | if (SourceKind.isSame( |

608 | ast_type_traits::ASTNodeKind::getFromNodeKind<Type>())) { |

609 | // We support implicit conversion from Matcher<Type> to Matcher<QualType> |

610 | return unconditionalConvertTo<Type>(); |

611 | } |

612 | return unconditionalConvertTo<QualType>(); |

613 | } |

614 | |

615 | /// Finds the first node in a range that matches the given matcher. |

616 | template <typename MatcherT, typename IteratorT> |

617 | bool matchesFirstInRange(const MatcherT &Matcher, IteratorT Start, |

618 | IteratorT End, ASTMatchFinder *Finder, |

619 | BoundNodesTreeBuilder *Builder) { |

620 | for (IteratorT I = Start; I != End; ++I) { |

621 | BoundNodesTreeBuilder Result(*Builder); |

622 | if (Matcher.matches(*I, Finder, &Result)) { |

623 | *Builder = std::move(Result); |

624 | return true; |

625 | } |

626 | } |

627 | return false; |

628 | } |

629 | |

630 | /// Finds the first node in a pointer range that matches the given |

631 | /// matcher. |

632 | template <typename MatcherT, typename IteratorT> |

633 | bool matchesFirstInPointerRange(const MatcherT &Matcher, IteratorT Start, |

634 | IteratorT End, ASTMatchFinder *Finder, |

635 | BoundNodesTreeBuilder *Builder) { |

636 | for (IteratorT I = Start; I != End; ++I) { |

637 | BoundNodesTreeBuilder Result(*Builder); |

638 | if (Matcher.matches(**I, Finder, &Result)) { |

639 | *Builder = std::move(Result); |

640 | return true; |

641 | } |

642 | } |

643 | return false; |

644 | } |

645 | |

646 | // Metafunction to determine if type T has a member called getDecl. |

647 | template <typename Ty> |

648 | class has_getDecl { |

649 | using yes = char[1]; |

650 | using no = char[2]; |

651 | |

652 | template <typename Inner> |

653 | static yes& test(Inner *I, decltype(I->getDecl()) * = nullptr); |

654 | |

655 | template <typename> |

656 | static no& test(...); |

657 | |

658 | public: |

659 | static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes); |

660 | }; |

661 | |

662 | /// Matches overloaded operators with a specific name. |

663 | /// |

664 | /// The type argument ArgT is not used by this matcher but is used by |

665 | /// PolymorphicMatcherWithParam1 and should be StringRef. |

666 | template <typename T, typename ArgT> |

667 | class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> { |

668 | static_assert(std::is_same<T, CXXOperatorCallExpr>::value || |

669 | std::is_base_of<FunctionDecl, T>::value, |

670 | "unsupported class for matcher"); |

671 | static_assert(std::is_same<ArgT, StringRef>::value, |

672 | "argument type must be StringRef"); |

673 | |

674 | public: |

675 | explicit HasOverloadedOperatorNameMatcher(const StringRef Name) |

676 | : SingleNodeMatcherInterface<T>(), Name(Name) {} |

677 | |

678 | bool matchesNode(const T &Node) const override { |

679 | return matchesSpecialized(Node); |

680 | } |

681 | |

682 | private: |

683 | |

684 | /// CXXOperatorCallExpr exist only for calls to overloaded operators |

685 | /// so this function returns true if the call is to an operator of the given |

686 | /// name. |

687 | bool matchesSpecialized(const CXXOperatorCallExpr &Node) const { |

688 | return getOperatorSpelling(Node.getOperator()) == Name; |

689 | } |

690 | |

691 | /// Returns true only if CXXMethodDecl represents an overloaded |

692 | /// operator and has the given operator name. |

693 | bool matchesSpecialized(const FunctionDecl &Node) const { |

694 | return Node.isOverloadedOperator() && |

695 | getOperatorSpelling(Node.getOverloadedOperator()) == Name; |

696 | } |

697 | |

698 | std::string Name; |

699 | }; |

700 | |

701 | /// Matches named declarations with a specific name. |

702 | /// |

703 | /// See \c hasName() and \c hasAnyName() in ASTMatchers.h for details. |

704 | class HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> { |

705 | public: |

706 | explicit HasNameMatcher(std::vector<std::string> Names); |

707 | |

708 | bool matchesNode(const NamedDecl &Node) const override; |

709 | |

710 | private: |

711 | /// Unqualified match routine. |

712 | /// |

713 | /// It is much faster than the full match, but it only works for unqualified |

714 | /// matches. |

715 | bool matchesNodeUnqualified(const NamedDecl &Node) const; |

716 | |

717 | /// Full match routine |

718 | /// |

719 | /// Fast implementation for the simple case of a named declaration at |

720 | /// namespace or RecordDecl scope. |

721 | /// It is slower than matchesNodeUnqualified, but faster than |

722 | /// matchesNodeFullSlow. |

723 | bool matchesNodeFullFast(const NamedDecl &Node) const; |

724 | |

725 | /// Full match routine |

726 | /// |

727 | /// It generates the fully qualified name of the declaration (which is |

728 | /// expensive) before trying to match. |

729 | /// It is slower but simple and works on all cases. |

730 | bool matchesNodeFullSlow(const NamedDecl &Node) const; |

731 | |

732 | const bool UseUnqualifiedMatch; |

733 | const std::vector<std::string> Names; |

734 | }; |

735 | |

736 | /// Trampoline function to use VariadicFunction<> to construct a |

737 | /// HasNameMatcher. |

738 | Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs); |

739 | |

740 | /// Trampoline function to use VariadicFunction<> to construct a |

741 | /// hasAnySelector matcher. |

742 | Matcher<ObjCMessageExpr> hasAnySelectorFunc( |

743 | ArrayRef<const StringRef *> NameRefs); |

744 | |

745 | /// Matches declarations for QualType and CallExpr. |

746 | /// |

747 | /// Type argument DeclMatcherT is required by PolymorphicMatcherWithParam1 but |

748 | /// not actually used. |

749 | template <typename T, typename DeclMatcherT> |

750 | class HasDeclarationMatcher : public WrapperMatcherInterface<T> { |

751 | static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value, |

752 | "instantiated with wrong types"); |

753 | |

754 | public: |

755 | explicit HasDeclarationMatcher(const Matcher<Decl> &InnerMatcher) |

756 | : HasDeclarationMatcher::WrapperMatcherInterface(InnerMatcher) {} |

757 | |

758 | bool matches(const T &Node, ASTMatchFinder *Finder, |

759 | BoundNodesTreeBuilder *Builder) const override { |

760 | return matchesSpecialized(Node, Finder, Builder); |

761 | } |

762 | |

763 | private: |

764 | /// Forwards to matching on the underlying type of the QualType. |

765 | bool matchesSpecialized(const QualType &Node, ASTMatchFinder *Finder, |

766 | BoundNodesTreeBuilder *Builder) const { |

767 | if (Node.isNull()) |

768 | return false; |

769 | |

770 | return matchesSpecialized(*Node, Finder, Builder); |

771 | } |

772 | |

773 | /// Finds the best declaration for a type and returns whether the inner |

774 | /// matcher matches on it. |

775 | bool matchesSpecialized(const Type &Node, ASTMatchFinder *Finder, |

776 | BoundNodesTreeBuilder *Builder) const { |

777 | // DeducedType does not have declarations of its own, so |

778 | // match the deduced type instead. |

779 | const Type *EffectiveType = &Node; |

780 | if (const auto *S = dyn_cast<DeducedType>(&Node)) { |

781 | EffectiveType = S->getDeducedType().getTypePtrOrNull(); |

782 | if (!EffectiveType) |

783 | return false; |

784 | } |

785 | |

786 | // First, for any types that have a declaration, extract the declaration and |

787 | // match on it. |

788 | if (const auto *S = dyn_cast<TagType>(EffectiveType)) { |

789 | return matchesDecl(S->getDecl(), Finder, Builder); |

790 | } |

791 | if (const auto *S = dyn_cast<InjectedClassNameType>(EffectiveType)) { |

792 | return matchesDecl(S->getDecl(), Finder, Builder); |

793 | } |

794 | if (const auto *S = dyn_cast<TemplateTypeParmType>(EffectiveType)) { |

795 | return matchesDecl(S->getDecl(), Finder, Builder); |

796 | } |

797 | if (const auto *S = dyn_cast<TypedefType>(EffectiveType)) { |

798 | return matchesDecl(S->getDecl(), Finder, Builder); |

799 | } |

800 | if (const auto *S = dyn_cast<UnresolvedUsingType>(EffectiveType)) { |

801 | return matchesDecl(S->getDecl(), Finder, Builder); |

802 | } |

803 | if (const auto *S = dyn_cast<ObjCObjectType>(EffectiveType)) { |

804 | return matchesDecl(S->getInterface(), Finder, Builder); |

805 | } |

806 | |

807 | // A SubstTemplateTypeParmType exists solely to mark a type substitution |

808 | // on the instantiated template. As users usually want to match the |

809 | // template parameter on the uninitialized template, we can always desugar |

810 | // one level without loss of expressivness. |

811 | // For example, given: |

812 | // template<typename T> struct X { T t; } class A {}; X<A> a; |

813 | // The following matcher will match, which otherwise would not: |

814 | // fieldDecl(hasType(pointerType())). |

815 | if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(EffectiveType)) { |

816 | return matchesSpecialized(S->getReplacementType(), Finder, Builder); |

817 | } |

818 | |

819 | // For template specialization types, we want to match the template |

820 | // declaration, as long as the type is still dependent, and otherwise the |

821 | // declaration of the instantiated tag type. |

822 | if (const auto *S = dyn_cast<TemplateSpecializationType>(EffectiveType)) { |

823 | if (!S->isTypeAlias() && S->isSugared()) { |

824 | // If the template is non-dependent, we want to match the instantiated |

825 | // tag type. |

826 | // For example, given: |

827 | // template<typename T> struct X {}; X<int> a; |

828 | // The following matcher will match, which otherwise would not: |

829 | // templateSpecializationType(hasDeclaration(cxxRecordDecl())). |

830 | return matchesSpecialized(*S->desugar(), Finder, Builder); |

831 | } |

832 | // If the template is dependent or an alias, match the template |

833 | // declaration. |

834 | return matchesDecl(S->getTemplateName().getAsTemplateDecl(), Finder, |

835 | Builder); |

836 | } |

837 | |

838 | // FIXME: We desugar elaborated types. This makes the assumption that users |

839 | // do never want to match on whether a type is elaborated - there are |

840 | // arguments for both sides; for now, continue desugaring. |

841 | if (const auto *S = dyn_cast<ElaboratedType>(EffectiveType)) { |

842 | return matchesSpecialized(S->desugar(), Finder, Builder); |

843 | } |

844 | return false; |

845 | } |

846 | |

847 | /// Extracts the Decl the DeclRefExpr references and returns whether |

848 | /// the inner matcher matches on it. |

849 | bool matchesSpecialized(const DeclRefExpr &Node, ASTMatchFinder *Finder, |

850 | BoundNodesTreeBuilder *Builder) const { |

851 | return matchesDecl(Node.getDecl(), Finder, Builder); |

852 | } |

853 | |

854 | /// Extracts the Decl of the callee of a CallExpr and returns whether |

855 | /// the inner matcher matches on it. |

856 | bool matchesSpecialized(const CallExpr &Node, ASTMatchFinder *Finder, |

857 | BoundNodesTreeBuilder *Builder) const { |

858 | return matchesDecl(Node.getCalleeDecl(), Finder, Builder); |

859 | } |

860 | |

861 | /// Extracts the Decl of the constructor call and returns whether the |

862 | /// inner matcher matches on it. |

863 | bool matchesSpecialized(const CXXConstructExpr &Node, |

864 | ASTMatchFinder *Finder, |

865 | BoundNodesTreeBuilder *Builder) const { |

866 | return matchesDecl(Node.getConstructor(), Finder, Builder); |

867 | } |

868 | |

869 | bool matchesSpecialized(const ObjCIvarRefExpr &Node, |

870 | ASTMatchFinder *Finder, |

871 | BoundNodesTreeBuilder *Builder) const { |

872 | return matchesDecl(Node.getDecl(), Finder, Builder); |

873 | } |

874 | |

875 | /// Extracts the operator new of the new call and returns whether the |

876 | /// inner matcher matches on it. |

877 | bool matchesSpecialized(const CXXNewExpr &Node, |

878 | ASTMatchFinder *Finder, |

879 | BoundNodesTreeBuilder *Builder) const { |

880 | return matchesDecl(Node.getOperatorNew(), Finder, Builder); |

881 | } |

882 | |

883 | /// Extracts the \c ValueDecl a \c MemberExpr refers to and returns |

884 | /// whether the inner matcher matches on it. |

885 | bool matchesSpecialized(const MemberExpr &Node, |

886 | ASTMatchFinder *Finder, |

887 | BoundNodesTreeBuilder *Builder) const { |

888 | return matchesDecl(Node.getMemberDecl(), Finder, Builder); |

889 | } |

890 | |

891 | /// Extracts the \c LabelDecl a \c AddrLabelExpr refers to and returns |

892 | /// whether the inner matcher matches on it. |

893 | bool matchesSpecialized(const AddrLabelExpr &Node, |

894 | ASTMatchFinder *Finder, |

895 | BoundNodesTreeBuilder *Builder) const { |

896 | return matchesDecl(Node.getLabel(), Finder, Builder); |

897 | } |

898 | |

899 | /// Extracts the declaration of a LabelStmt and returns whether the |

900 | /// inner matcher matches on it. |

901 | bool matchesSpecialized(const LabelStmt &Node, ASTMatchFinder *Finder, |

902 | BoundNodesTreeBuilder *Builder) const { |

903 | return matchesDecl(Node.getDecl(), Finder, Builder); |

904 | } |

905 | |

906 | /// Returns whether the inner matcher \c Node. Returns false if \c Node |

907 | /// is \c NULL. |

908 | bool matchesDecl(const Decl *Node, ASTMatchFinder *Finder, |

909 | BoundNodesTreeBuilder *Builder) const { |

910 | return Node != nullptr && |

911 | this->InnerMatcher.matches( |

912 | ast_type_traits::DynTypedNode::create(*Node), Finder, Builder); |

913 | } |

914 | }; |

915 | |

916 | /// IsBaseType<T>::value is true if T is a "base" type in the AST |

917 | /// node class hierarchies. |

918 | template <typename T> |

919 | struct IsBaseType { |

920 | static const bool value = |

921 | std::is_same<T, Decl>::value || |

922 | std::is_same<T, Stmt>::value || |

923 | std::is_same<T, QualType>::value || |

924 | std::is_same<T, Type>::value || |

925 | std::is_same<T, TypeLoc>::value || |

926 | std::is_same<T, NestedNameSpecifier>::value || |

927 | std::is_same<T, NestedNameSpecifierLoc>::value || |

928 | std::is_same<T, CXXCtorInitializer>::value; |

929 | }; |

930 | template <typename T> |

931 | const bool IsBaseType<T>::value; |

932 | |

933 | /// Interface that allows matchers to traverse the AST. |

934 | /// FIXME: Find a better name. |

935 | /// |

936 | /// This provides three entry methods for each base node type in the AST: |

937 | /// - \c matchesChildOf: |

938 | /// Matches a matcher on every child node of the given node. Returns true |

939 | /// if at least one child node could be matched. |

940 | /// - \c matchesDescendantOf: |

941 | /// Matches a matcher on all descendant nodes of the given node. Returns true |

942 | /// if at least one descendant matched. |

943 | /// - \c matchesAncestorOf: |

944 | /// Matches a matcher on all ancestors of the given node. Returns true if |

945 | /// at least one ancestor matched. |

946 | /// |

947 | /// FIXME: Currently we only allow Stmt and Decl nodes to start a traversal. |

948 | /// In the future, we want to implement this for all nodes for which it makes |

949 | /// sense. In the case of matchesAncestorOf, we'll want to implement it for |

950 | /// all nodes, as all nodes have ancestors. |

951 | class ASTMatchFinder { |

952 | public: |

953 | /// Defines how we descend a level in the AST when we pass |

954 | /// through expressions. |

955 | enum TraversalKind { |

956 | /// Will traverse any child nodes. |

957 | TK_AsIs, |

958 | |

959 | /// Will not traverse implicit casts and parentheses. |

960 | TK_IgnoreImplicitCastsAndParentheses |

961 | }; |

962 | |

963 | /// Defines how bindings are processed on recursive matches. |

964 | enum BindKind { |

965 | /// Stop at the first match and only bind the first match. |

966 | BK_First, |

967 | |

968 | /// Create results for all combinations of bindings that match. |

969 | BK_All |

970 | }; |

971 | |

972 | /// Defines which ancestors are considered for a match. |

973 | enum AncestorMatchMode { |

974 | /// All ancestors. |

975 | AMM_All, |

976 | |

977 | /// Direct parent only. |

978 | AMM_ParentOnly |

979 | }; |

980 | |

981 | virtual ~ASTMatchFinder() = default; |

982 | |

983 | /// Returns true if the given class is directly or indirectly derived |

984 | /// from a base type matching \c base. |

985 | /// |

986 | /// A class is considered to be also derived from itself. |

987 | virtual bool classIsDerivedFrom(const CXXRecordDecl *Declaration, |

988 | const Matcher<NamedDecl> &Base, |

989 | BoundNodesTreeBuilder *Builder) = 0; |

990 | |

991 | template <typename T> |

992 | bool matchesChildOf(const T &Node, |

993 | const DynTypedMatcher &Matcher, |

994 | BoundNodesTreeBuilder *Builder, |

995 | TraversalKind Traverse, |

996 | BindKind Bind) { |

997 | static_assert(std::is_base_of<Decl, T>::value || |

998 | std::is_base_of<Stmt, T>::value || |

999 | std::is_base_of<NestedNameSpecifier, T>::value || |

1000 | std::is_base_of<NestedNameSpecifierLoc, T>::value || |

1001 | std::is_base_of<TypeLoc, T>::value || |

1002 | std::is_base_of<QualType, T>::value, |

1003 | "unsupported type for recursive matching"); |

1004 | return matchesChildOf(ast_type_traits::DynTypedNode::create(Node), |

1005 | Matcher, Builder, Traverse, Bind); |

1006 | } |

1007 | |

1008 | template <typename T> |

1009 | bool matchesDescendantOf(const T &Node, |

1010 | const DynTypedMatcher &Matcher, |

1011 | BoundNodesTreeBuilder *Builder, |

1012 | BindKind Bind) { |

1013 | static_assert(std::is_base_of<Decl, T>::value || |

1014 | std::is_base_of<Stmt, T>::value || |

1015 | std::is_base_of<NestedNameSpecifier, T>::value || |

1016 | std::is_base_of<NestedNameSpecifierLoc, T>::value || |

1017 | std::is_base_of<TypeLoc, T>::value || |

1018 | std::is_base_of<QualType, T>::value, |

1019 | "unsupported type for recursive matching"); |

1020 | return matchesDescendantOf(ast_type_traits::DynTypedNode::create(Node), |

1021 | Matcher, Builder, Bind); |

1022 | } |

1023 | |

1024 | // FIXME: Implement support for BindKind. |

1025 | template <typename T> |

1026 | bool matchesAncestorOf(const T &Node, |

1027 | const DynTypedMatcher &Matcher, |

1028 | BoundNodesTreeBuilder *Builder, |

1029 | AncestorMatchMode MatchMode) { |

1030 | static_assert(std::is_base_of<Decl, T>::value || |

1031 | std::is_base_of<NestedNameSpecifierLoc, T>::value || |

1032 | std::is_base_of<Stmt, T>::value || |

1033 | std::is_base_of<TypeLoc, T>::value, |

1034 | "type not allowed for recursive matching"); |

1035 | return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node), |

1036 | Matcher, Builder, MatchMode); |

1037 | } |

1038 | |

1039 | virtual ASTContext &getASTContext() const = 0; |

1040 | |

1041 | protected: |

1042 | virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node, |

1043 | const DynTypedMatcher &Matcher, |

1044 | BoundNodesTreeBuilder *Builder, |

1045 | TraversalKind Traverse, |

1046 | BindKind Bind) = 0; |

1047 | |

1048 | virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node, |

1049 | const DynTypedMatcher &Matcher, |

1050 | BoundNodesTreeBuilder *Builder, |

1051 | BindKind Bind) = 0; |

1052 | |

1053 | virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node, |

1054 | const DynTypedMatcher &Matcher, |

1055 | BoundNodesTreeBuilder *Builder, |

1056 | AncestorMatchMode MatchMode) = 0; |

1057 | }; |

1058 | |

1059 | /// A type-list implementation. |

1060 | /// |

1061 | /// A "linked list" of types, accessible by using the ::head and ::tail |

1062 | /// typedefs. |

1063 | template <typename... Ts> struct TypeList {}; // Empty sentinel type list. |

1064 | |

1065 | template <typename T1, typename... Ts> struct TypeList<T1, Ts...> { |

1066 | /// The first type on the list. |

1067 | using head = T1; |

1068 | |

1069 | /// A sublist with the tail. ie everything but the head. |

1070 | /// |

1071 | /// This type is used to do recursion. TypeList<>/EmptyTypeList indicates the |

1072 | /// end of the list. |

1073 | using tail = TypeList<Ts...>; |

1074 | }; |

1075 | |

1076 | /// The empty type list. |

1077 | using EmptyTypeList = TypeList<>; |

1078 | |

1079 | /// Helper meta-function to determine if some type \c T is present or |

1080 | /// a parent type in the list. |

1081 | template <typename AnyTypeList, typename T> |

1082 | struct TypeListContainsSuperOf { |

1083 | static const bool value = |

1084 | std::is_base_of<typename AnyTypeList::head, T>::value || |

1085 | TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value; |

1086 | }; |

1087 | template <typename T> |

1088 | struct TypeListContainsSuperOf<EmptyTypeList, T> { |

1089 | static const bool value = false; |

1090 | }; |

1091 | |

1092 | /// A "type list" that contains all types. |

1093 | /// |

1094 | /// Useful for matchers like \c anything and \c unless. |

1095 | using AllNodeBaseTypes = |

1096 | TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, QualType, |

1097 | Type, TypeLoc, CXXCtorInitializer>; |

1098 | |

1099 | /// Helper meta-function to extract the argument out of a function of |

1100 | /// type void(Arg). |

1101 | /// |

1102 | /// See AST_POLYMORPHIC_SUPPORTED_TYPES for details. |

1103 | template <class T> struct ExtractFunctionArgMeta; |

1104 | template <class T> struct ExtractFunctionArgMeta<void(T)> { |

1105 | using type = T; |

1106 | }; |

1107 | |

1108 | /// Default type lists for ArgumentAdaptingMatcher matchers. |

1109 | using AdaptativeDefaultFromTypes = AllNodeBaseTypes; |

1110 | using AdaptativeDefaultToTypes = |

1111 | TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, TypeLoc, |

1112 | QualType>; |

1113 | |

1114 | /// All types that are supported by HasDeclarationMatcher above. |

1115 | using HasDeclarationSupportedTypes = |

1116 | TypeList<CallExpr, CXXConstructExpr, CXXNewExpr, DeclRefExpr, EnumType, |

1117 | ElaboratedType, InjectedClassNameType, LabelStmt, AddrLabelExpr, |

1118 | MemberExpr, QualType, RecordType, TagType, |

1119 | TemplateSpecializationType, TemplateTypeParmType, TypedefType, |

1120 | UnresolvedUsingType, ObjCIvarRefExpr>; |

1121 | |

1122 | /// Converts a \c Matcher<T> to a matcher of desired type \c To by |

1123 | /// "adapting" a \c To into a \c T. |

1124 | /// |

1125 | /// The \c ArgumentAdapterT argument specifies how the adaptation is done. |

1126 | /// |

1127 | /// For example: |

1128 | /// \c ArgumentAdaptingMatcher<HasMatcher, T>(InnerMatcher); |

1129 | /// Given that \c InnerMatcher is of type \c Matcher<T>, this returns a matcher |

1130 | /// that is convertible into any matcher of type \c To by constructing |

1131 | /// \c HasMatcher<To, T>(InnerMatcher). |

1132 | /// |

1133 | /// If a matcher does not need knowledge about the inner type, prefer to use |

1134 | /// PolymorphicMatcherWithParam1. |

1135 | template <template <typename ToArg, typename FromArg> class ArgumentAdapterT, |

1136 | typename FromTypes = AdaptativeDefaultFromTypes, |

1137 | typename ToTypes = AdaptativeDefaultToTypes> |

1138 | struct ArgumentAdaptingMatcherFunc { |

1139 | template <typename T> class Adaptor { |

1140 | public: |

1141 | explicit Adaptor(const Matcher<T> &InnerMatcher) |

1142 | : InnerMatcher(InnerMatcher) {} |

1143 | |

1144 | using ReturnTypes = ToTypes; |

1145 | |

1146 | template <typename To> operator Matcher<To>() const { |

1147 | return Matcher<To>(new ArgumentAdapterT<To, T>(InnerMatcher)); |

1148 | } |

1149 | |

1150 | private: |

1151 | const Matcher<T> InnerMatcher; |

1152 | }; |

1153 | |

1154 | template <typename T> |

1155 | static Adaptor<T> create(const Matcher<T> &InnerMatcher) { |

1156 | return Adaptor<T>(InnerMatcher); |

1157 | } |

1158 | |

1159 | template <typename T> |

1160 | Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const { |

1161 | return create(InnerMatcher); |

1162 | } |

1163 | }; |

1164 | |

1165 | /// A PolymorphicMatcherWithParamN<MatcherT, P1, ..., PN> object can be |

1166 | /// created from N parameters p1, ..., pN (of type P1, ..., PN) and |

1167 | /// used as a Matcher<T> where a MatcherT<T, P1, ..., PN>(p1, ..., pN) |

1168 | /// can be constructed. |

1169 | /// |

1170 | /// For example: |

1171 | /// - PolymorphicMatcherWithParam0<IsDefinitionMatcher>() |

1172 | /// creates an object that can be used as a Matcher<T> for any type T |

1173 | /// where an IsDefinitionMatcher<T>() can be constructed. |

1174 | /// - PolymorphicMatcherWithParam1<ValueEqualsMatcher, int>(42) |

1175 | /// creates an object that can be used as a Matcher<T> for any type T |

1176 | /// where a ValueEqualsMatcher<T, int>(42) can be constructed. |

1177 | template <template <typename T> class MatcherT, |

1178 | typename ReturnTypesF = void(AllNodeBaseTypes)> |

1179 | class PolymorphicMatcherWithParam0 { |

1180 | public: |

1181 | using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type; |

1182 | |

1183 | template <typename T> |

1184 | operator Matcher<T>() const { |

1185 | static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value, |

1186 | "right polymorphic conversion"); |

1187 | return Matcher<T>(new MatcherT<T>()); |

1188 | } |

1189 | }; |

1190 | |

1191 | template <template <typename T, typename P1> class MatcherT, |

1192 | typename P1, |

1193 | typename ReturnTypesF = void(AllNodeBaseTypes)> |

1194 | class PolymorphicMatcherWithParam1 { |

1195 | public: |

1196 | explicit PolymorphicMatcherWithParam1(const P1 &Param1) |

1197 | : Param1(Param1) {} |

1198 | |

1199 | using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type; |

1200 | |

1201 | template <typename T> |

1202 | operator Matcher<T>() const { |

1203 | static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value, |

1204 | "right polymorphic conversion"); |

1205 | return Matcher<T>(new MatcherT<T, P1>(Param1)); |

1206 | } |

1207 | |

1208 | private: |

1209 | const P1 Param1; |

1210 | }; |

1211 | |

1212 | template <template <typename T, typename P1, typename P2> class MatcherT, |

1213 | typename P1, typename P2, |

1214 | typename ReturnTypesF = void(AllNodeBaseTypes)> |

1215 | class PolymorphicMatcherWithParam2 { |

1216 | public: |

1217 | PolymorphicMatcherWithParam2(const P1 &Param1, const P2 &Param2) |

1218 | : Param1(Param1), Param2(Param2) {} |

1219 | |

1220 | using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type; |

1221 | |

1222 | template <typename T> |

1223 | operator Matcher<T>() const { |

1224 | static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value, |

1225 | "right polymorphic conversion"); |

1226 | return Matcher<T>(new MatcherT<T, P1, P2>(Param1, Param2)); |

1227 | } |

1228 | |

1229 | private: |

1230 | const P1 Param1; |

1231 | const P2 Param2; |

1232 | }; |

1233 | |

1234 | /// Matches any instance of the given NodeType. |

1235 | /// |

1236 | /// This is useful when a matcher syntactically requires a child matcher, |

1237 | /// but the context doesn't care. See for example: anything(). |

1238 | class TrueMatcher { |

1239 | public: |

1240 | using ReturnTypes = AllNodeBaseTypes; |

1241 | |

1242 | template <typename T> |

1243 | operator Matcher<T>() const { |

1244 | return DynTypedMatcher::trueMatcher( |

1245 | ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) |

1246 | .template unconditionalConvertTo<T>(); |

1247 | } |

1248 | }; |

1249 | |

1250 | /// A Matcher that allows binding the node it matches to an id. |

1251 | /// |

1252 | /// BindableMatcher provides a \a bind() method that allows binding the |

1253 | /// matched node to an id if the match was successful. |

1254 | template <typename T> |

1255 | class BindableMatcher : public Matcher<T> { |

1256 | public: |

1257 | explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {} |

1258 | explicit BindableMatcher(MatcherInterface<T> *Implementation) |

1259 | : Matcher<T>(Implementation) {} |

1260 | |

1261 | /// Returns a matcher that will bind the matched node on a match. |

1262 | /// |

1263 | /// The returned matcher is equivalent to this matcher, but will |

1264 | /// bind the matched node on a match. |

1265 | Matcher<T> bind(StringRef ID) const { |

1266 | return DynTypedMatcher(*this) |

1267 | .tryBind(ID) |

1268 | ->template unconditionalConvertTo<T>(); |

1269 | } |

1270 | |

1271 | /// Same as Matcher<T>'s conversion operator, but enables binding on |

1272 | /// the returned matcher. |

1273 | operator DynTypedMatcher() const { |

1274 | DynTypedMatcher Result = static_cast<const Matcher<T>&>(*this); |

1275 | Result.setAllowBind(true); |

1276 | return Result; |

1277 | } |

1278 | }; |

1279 | |

1280 | /// Matches nodes of type T that have child nodes of type ChildT for |

1281 | /// which a specified child matcher matches. |

1282 | /// |

1283 | /// ChildT must be an AST base type. |

1284 | template <typename T, typename ChildT> |

1285 | class HasMatcher : public WrapperMatcherInterface<T> { |

1286 | public: |

1287 | explicit HasMatcher(const Matcher<ChildT> &ChildMatcher) |

1288 | : HasMatcher::WrapperMatcherInterface(ChildMatcher) {} |

1289 | |

1290 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1291 | BoundNodesTreeBuilder *Builder) const override { |

1292 | return Finder->matchesChildOf(Node, this->InnerMatcher, Builder, |

1293 | ASTMatchFinder::TK_AsIs, |

1294 | ASTMatchFinder::BK_First); |

1295 | } |

1296 | }; |

1297 | |

1298 | /// Matches nodes of type T that have child nodes of type ChildT for |

1299 | /// which a specified child matcher matches. ChildT must be an AST base |

1300 | /// type. |

1301 | /// As opposed to the HasMatcher, the ForEachMatcher will produce a match |

1302 | /// for each child that matches. |

1303 | template <typename T, typename ChildT> |

1304 | class ForEachMatcher : public WrapperMatcherInterface<T> { |

1305 | static_assert(IsBaseType<ChildT>::value, |

1306 | "for each only accepts base type matcher"); |

1307 | |

1308 | public: |

1309 | explicit ForEachMatcher(const Matcher<ChildT> &ChildMatcher) |

1310 | : ForEachMatcher::WrapperMatcherInterface(ChildMatcher) {} |

1311 | |

1312 | bool matches(const T& Node, ASTMatchFinder* Finder, |

1313 | BoundNodesTreeBuilder* Builder) const override { |

1314 | return Finder->matchesChildOf( |

1315 | Node, this->InnerMatcher, Builder, |

1316 | ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses, |

1317 | ASTMatchFinder::BK_All); |

1318 | } |

1319 | }; |

1320 | |

1321 | /// VariadicOperatorMatcher related types. |

1322 | /// @{ |

1323 | |

1324 | /// Polymorphic matcher object that uses a \c |

1325 | /// DynTypedMatcher::VariadicOperator operator. |

1326 | /// |

1327 | /// Input matchers can have any type (including other polymorphic matcher |

1328 | /// types), and the actual Matcher<T> is generated on demand with an implicit |

1329 | /// coversion operator. |

1330 | template <typename... Ps> class VariadicOperatorMatcher { |

1331 | public: |

1332 | VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params) |

1333 | : Op(Op), Params(std::forward<Ps>(Params)...) {} |

1334 | |

1335 | template <typename T> operator Matcher<T>() const { |

1336 | return DynTypedMatcher::constructVariadic( |

1337 | Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(), |

1338 | getMatchers<T>(llvm::index_sequence_for<Ps...>())) |

1339 | .template unconditionalConvertTo<T>(); |

1340 | } |

1341 | |

1342 | private: |

1343 | // Helper method to unpack the tuple into a vector. |

1344 | template <typename T, std::size_t... Is> |

1345 | std::vector<DynTypedMatcher> getMatchers(llvm::index_sequence<Is...>) const { |

1346 | return {Matcher<T>(std::get<Is>(Params))...}; |

1347 | } |

1348 | |

1349 | const DynTypedMatcher::VariadicOperator Op; |

1350 | std::tuple<Ps...> Params; |

1351 | }; |

1352 | |

1353 | /// Overloaded function object to generate VariadicOperatorMatcher |

1354 | /// objects from arbitrary matchers. |

1355 | template <unsigned MinCount, unsigned MaxCount> |

1356 | struct VariadicOperatorMatcherFunc { |

1357 | DynTypedMatcher::VariadicOperator Op; |

1358 | |

1359 | template <typename... Ms> |

1360 | VariadicOperatorMatcher<Ms...> operator()(Ms &&... Ps) const { |

1361 | static_assert(MinCount <= sizeof...(Ms) && sizeof...(Ms) <= MaxCount, |

1362 | "invalid number of parameters for variadic matcher"); |

1363 | return VariadicOperatorMatcher<Ms...>(Op, std::forward<Ms>(Ps)...); |

1364 | } |

1365 | }; |

1366 | |

1367 | /// @} |

1368 | |

1369 | template <typename T> |

1370 | inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const { |

1371 | return Matcher<T>(*this); |

1372 | } |

1373 | |

1374 | /// Creates a Matcher<T> that matches if all inner matchers match. |

1375 | template<typename T> |

1376 | BindableMatcher<T> makeAllOfComposite( |

1377 | ArrayRef<const Matcher<T> *> InnerMatchers) { |

1378 | // For the size() == 0 case, we return a "true" matcher. |

1379 | if (InnerMatchers.empty()) { |

1380 | return BindableMatcher<T>(TrueMatcher()); |

1381 | } |

1382 | // For the size() == 1 case, we simply return that one matcher. |

1383 | // No need to wrap it in a variadic operation. |

1384 | if (InnerMatchers.size() == 1) { |

1385 | return BindableMatcher<T>(*InnerMatchers[0]); |

1386 | } |

1387 | |

1388 | using PI = llvm::pointee_iterator<const Matcher<T> *const *>; |

1389 | |

1390 | std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()), |

1391 | PI(InnerMatchers.end())); |

1392 | return BindableMatcher<T>( |

1393 | DynTypedMatcher::constructVariadic( |

1394 | DynTypedMatcher::VO_AllOf, |

1395 | ast_type_traits::ASTNodeKind::getFromNodeKind<T>(), |

1396 | std::move(DynMatchers)) |

1397 | .template unconditionalConvertTo<T>()); |

1398 | } |

1399 | |

1400 | /// Creates a Matcher<T> that matches if |

1401 | /// T is dyn_cast'able into InnerT and all inner matchers match. |

1402 | /// |

1403 | /// Returns BindableMatcher, as matchers that use dyn_cast have |

1404 | /// the same object both to match on and to run submatchers on, |

1405 | /// so there is no ambiguity with what gets bound. |

1406 | template<typename T, typename InnerT> |

1407 | BindableMatcher<T> makeDynCastAllOfComposite( |

1408 | ArrayRef<const Matcher<InnerT> *> InnerMatchers) { |

1409 | return BindableMatcher<T>( |

1410 | makeAllOfComposite(InnerMatchers).template dynCastTo<T>()); |

1411 | } |

1412 | |

1413 | /// Matches nodes of type T that have at least one descendant node of |

1414 | /// type DescendantT for which the given inner matcher matches. |

1415 | /// |

1416 | /// DescendantT must be an AST base type. |

1417 | template <typename T, typename DescendantT> |

1418 | class HasDescendantMatcher : public WrapperMatcherInterface<T> { |

1419 | static_assert(IsBaseType<DescendantT>::value, |

1420 | "has descendant only accepts base type matcher"); |

1421 | |

1422 | public: |

1423 | explicit HasDescendantMatcher(const Matcher<DescendantT> &DescendantMatcher) |

1424 | : HasDescendantMatcher::WrapperMatcherInterface(DescendantMatcher) {} |

1425 | |

1426 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1427 | BoundNodesTreeBuilder *Builder) const override { |

1428 | return Finder->matchesDescendantOf(Node, this->InnerMatcher, Builder, |

1429 | ASTMatchFinder::BK_First); |

1430 | } |

1431 | }; |

1432 | |

1433 | /// Matches nodes of type \c T that have a parent node of type \c ParentT |

1434 | /// for which the given inner matcher matches. |

1435 | /// |

1436 | /// \c ParentT must be an AST base type. |

1437 | template <typename T, typename ParentT> |

1438 | class HasParentMatcher : public WrapperMatcherInterface<T> { |

1439 | static_assert(IsBaseType<ParentT>::value, |

1440 | "has parent only accepts base type matcher"); |

1441 | |

1442 | public: |

1443 | explicit HasParentMatcher(const Matcher<ParentT> &ParentMatcher) |

1444 | : HasParentMatcher::WrapperMatcherInterface(ParentMatcher) {} |

1445 | |

1446 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1447 | BoundNodesTreeBuilder *Builder) const override { |

1448 | return Finder->matchesAncestorOf(Node, this->InnerMatcher, Builder, |

1449 | ASTMatchFinder::AMM_ParentOnly); |

1450 | } |

1451 | }; |

1452 | |

1453 | /// Matches nodes of type \c T that have at least one ancestor node of |

1454 | /// type \c AncestorT for which the given inner matcher matches. |

1455 | /// |

1456 | /// \c AncestorT must be an AST base type. |

1457 | template <typename T, typename AncestorT> |

1458 | class HasAncestorMatcher : public WrapperMatcherInterface<T> { |

1459 | static_assert(IsBaseType<AncestorT>::value, |

1460 | "has ancestor only accepts base type matcher"); |

1461 | |

1462 | public: |

1463 | explicit HasAncestorMatcher(const Matcher<AncestorT> &AncestorMatcher) |

1464 | : HasAncestorMatcher::WrapperMatcherInterface(AncestorMatcher) {} |

1465 | |

1466 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1467 | BoundNodesTreeBuilder *Builder) const override { |

1468 | return Finder->matchesAncestorOf(Node, this->InnerMatcher, Builder, |

1469 | ASTMatchFinder::AMM_All); |

1470 | } |

1471 | }; |

1472 | |

1473 | /// Matches nodes of type T that have at least one descendant node of |

1474 | /// type DescendantT for which the given inner matcher matches. |

1475 | /// |

1476 | /// DescendantT must be an AST base type. |

1477 | /// As opposed to HasDescendantMatcher, ForEachDescendantMatcher will match |

1478 | /// for each descendant node that matches instead of only for the first. |

1479 | template <typename T, typename DescendantT> |

1480 | class ForEachDescendantMatcher : public WrapperMatcherInterface<T> { |

1481 | static_assert(IsBaseType<DescendantT>::value, |

1482 | "for each descendant only accepts base type matcher"); |

1483 | |

1484 | public: |

1485 | explicit ForEachDescendantMatcher( |

1486 | const Matcher<DescendantT> &DescendantMatcher) |

1487 | : ForEachDescendantMatcher::WrapperMatcherInterface(DescendantMatcher) {} |

1488 | |

1489 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1490 | BoundNodesTreeBuilder *Builder) const override { |

1491 | return Finder->matchesDescendantOf(Node, this->InnerMatcher, Builder, |

1492 | ASTMatchFinder::BK_All); |

1493 | } |

1494 | }; |

1495 | |

1496 | /// Matches on nodes that have a getValue() method if getValue() equals |

1497 | /// the value the ValueEqualsMatcher was constructed with. |

1498 | template <typename T, typename ValueT> |

1499 | class ValueEqualsMatcher : public SingleNodeMatcherInterface<T> { |

1500 | static_assert(std::is_base_of<CharacterLiteral, T>::value || |

1501 | std::is_base_of<CXXBoolLiteralExpr, T>::value || |

1502 | std::is_base_of<FloatingLiteral, T>::value || |

1503 | std::is_base_of<IntegerLiteral, T>::value, |

1504 | "the node must have a getValue method"); |

1505 | |

1506 | public: |

1507 | explicit ValueEqualsMatcher(const ValueT &ExpectedValue) |

1508 | : ExpectedValue(ExpectedValue) {} |

1509 | |

1510 | bool matchesNode(const T &Node) const override { |

1511 | return Node.getValue() == ExpectedValue; |

1512 | } |

1513 | |

1514 | private: |

1515 | const ValueT ExpectedValue; |

1516 | }; |

1517 | |

1518 | /// Template specializations to easily write matchers for floating point |

1519 | /// literals. |

1520 | template <> |

1521 | inline bool ValueEqualsMatcher<FloatingLiteral, double>::matchesNode( |

1522 | const FloatingLiteral &Node) const { |

1523 | if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle()) |

1524 | return Node.getValue().convertToFloat() == ExpectedValue; |

1525 | if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble()) |

1526 | return Node.getValue().convertToDouble() == ExpectedValue; |

1527 | return false; |

1528 | } |

1529 | template <> |

1530 | inline bool ValueEqualsMatcher<FloatingLiteral, float>::matchesNode( |

1531 | const FloatingLiteral &Node) const { |

1532 | if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle()) |

1533 | return Node.getValue().convertToFloat() == ExpectedValue; |

1534 | if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble()) |

1535 | return Node.getValue().convertToDouble() == ExpectedValue; |

1536 | return false; |

1537 | } |

1538 | template <> |

1539 | inline bool ValueEqualsMatcher<FloatingLiteral, llvm::APFloat>::matchesNode( |

1540 | const FloatingLiteral &Node) const { |

1541 | return ExpectedValue.compare(Node.getValue()) == llvm::APFloat::cmpEqual; |

1542 | } |

1543 | |

1544 | /// A VariadicDynCastAllOfMatcher<SourceT, TargetT> object is a |

1545 | /// variadic functor that takes a number of Matcher<TargetT> and returns a |

1546 | /// Matcher<SourceT> that matches TargetT nodes that are matched by all of the |

1547 | /// given matchers, if SourceT can be dynamically casted into TargetT. |

1548 | /// |

1549 | /// For example: |

1550 | /// const VariadicDynCastAllOfMatcher< |

1551 | /// Decl, CXXRecordDecl> record; |

1552 | /// Creates a functor record(...) that creates a Matcher<Decl> given |

1553 | /// a variable number of arguments of type Matcher<CXXRecordDecl>. |

1554 | /// The returned matcher matches if the given Decl can by dynamically |

1555 | /// casted to CXXRecordDecl and all given matchers match. |

1556 | template <typename SourceT, typename TargetT> |

1557 | class VariadicDynCastAllOfMatcher |

1558 | : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>, |

1559 | makeDynCastAllOfComposite<SourceT, TargetT>> { |

1560 | public: |

1561 | VariadicDynCastAllOfMatcher() {} |

1562 | }; |

1563 | |

1564 | /// A \c VariadicAllOfMatcher<T> object is a variadic functor that takes |

1565 | /// a number of \c Matcher<T> and returns a \c Matcher<T> that matches \c T |

1566 | /// nodes that are matched by all of the given matchers. |

1567 | /// |

1568 | /// For example: |

1569 | /// const VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier; |

1570 | /// Creates a functor nestedNameSpecifier(...) that creates a |

1571 | /// \c Matcher<NestedNameSpecifier> given a variable number of arguments of type |

1572 | /// \c Matcher<NestedNameSpecifier>. |

1573 | /// The returned matcher matches if all given matchers match. |

1574 | template <typename T> |

1575 | class VariadicAllOfMatcher |

1576 | : public VariadicFunction<BindableMatcher<T>, Matcher<T>, |

1577 | makeAllOfComposite<T>> { |

1578 | public: |

1579 | VariadicAllOfMatcher() {} |

1580 | }; |

1581 | |

1582 | /// Matches nodes of type \c TLoc for which the inner |

1583 | /// \c Matcher<T> matches. |

1584 | template <typename TLoc, typename T> |

1585 | class LocMatcher : public WrapperMatcherInterface<TLoc> { |

1586 | public: |

1587 | explicit LocMatcher(const Matcher<T> &InnerMatcher) |

1588 | : LocMatcher::WrapperMatcherInterface(InnerMatcher) {} |

1589 | |

1590 | bool matches(const TLoc &Node, ASTMatchFinder *Finder, |

1591 | BoundNodesTreeBuilder *Builder) const override { |

1592 | if (!Node) |

1593 | return false; |

1594 | return this->InnerMatcher.matches(extract(Node), Finder, Builder); |

1595 | } |

1596 | |

1597 | private: |

1598 | static ast_type_traits::DynTypedNode |

1599 | extract(const NestedNameSpecifierLoc &Loc) { |

1600 | return ast_type_traits::DynTypedNode::create(*Loc.getNestedNameSpecifier()); |

1601 | } |

1602 | }; |

1603 | |

1604 | /// Matches \c TypeLocs based on an inner matcher matching a certain |

1605 | /// \c QualType. |

1606 | /// |

1607 | /// Used to implement the \c loc() matcher. |

1608 | class TypeLocTypeMatcher : public WrapperMatcherInterface<TypeLoc> { |

1609 | public: |

1610 | explicit TypeLocTypeMatcher(const Matcher<QualType> &InnerMatcher) |

1611 | : TypeLocTypeMatcher::WrapperMatcherInterface(InnerMatcher) {} |

1612 | |

1613 | bool matches(const TypeLoc &Node, ASTMatchFinder *Finder, |

1614 | BoundNodesTreeBuilder *Builder) const override { |

1615 | if (!Node) |

1616 | return false; |

1617 | return this->InnerMatcher.matches( |

1618 | ast_type_traits::DynTypedNode::create(Node.getType()), Finder, Builder); |

1619 | } |

1620 | }; |

1621 | |

1622 | /// Matches nodes of type \c T for which the inner matcher matches on a |

1623 | /// another node of type \c T that can be reached using a given traverse |

1624 | /// function. |

1625 | template <typename T> |

1626 | class TypeTraverseMatcher : public WrapperMatcherInterface<T> { |

1627 | public: |

1628 | explicit TypeTraverseMatcher(const Matcher<QualType> &InnerMatcher, |

1629 | QualType (T::*TraverseFunction)() const) |

1630 | : TypeTraverseMatcher::WrapperMatcherInterface(InnerMatcher), |

1631 | TraverseFunction(TraverseFunction) {} |

1632 | |

1633 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1634 | BoundNodesTreeBuilder *Builder) const override { |

1635 | QualType NextNode = (Node.*TraverseFunction)(); |

1636 | if (NextNode.isNull()) |

1637 | return false; |

1638 | return this->InnerMatcher.matches( |

1639 | ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder); |

1640 | } |

1641 | |

1642 | private: |

1643 | QualType (T::*TraverseFunction)() const; |

1644 | }; |

1645 | |

1646 | /// Matches nodes of type \c T in a ..Loc hierarchy, for which the inner |

1647 | /// matcher matches on a another node of type \c T that can be reached using a |

1648 | /// given traverse function. |

1649 | template <typename T> |

1650 | class TypeLocTraverseMatcher : public WrapperMatcherInterface<T> { |

1651 | public: |

1652 | explicit TypeLocTraverseMatcher(const Matcher<TypeLoc> &InnerMatcher, |

1653 | TypeLoc (T::*TraverseFunction)() const) |

1654 | : TypeLocTraverseMatcher::WrapperMatcherInterface(InnerMatcher), |

1655 | TraverseFunction(TraverseFunction) {} |

1656 | |

1657 | bool matches(const T &Node, ASTMatchFinder *Finder, |

1658 | BoundNodesTreeBuilder *Builder) const override { |

1659 | TypeLoc NextNode = (Node.*TraverseFunction)(); |

1660 | if (!NextNode) |

1661 | return false; |

1662 | return this->InnerMatcher.matches( |

1663 | ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder); |

1664 | } |

1665 | |

1666 | private: |

1667 | TypeLoc (T::*TraverseFunction)() const; |

1668 | }; |

1669 | |

1670 | /// Converts a \c Matcher<InnerT> to a \c Matcher<OuterT>, where |

1671 | /// \c OuterT is any type that is supported by \c Getter. |

1672 | /// |

1673 | /// \code Getter<OuterT>::value() \endcode returns a |

1674 | /// \code InnerTBase (OuterT::*)() \endcode, which is used to adapt a \c OuterT |

1675 | /// object into a \c InnerT |

1676 | template <typename InnerTBase, |

1677 | template <typename OuterT> class Getter, |

1678 | template <typename OuterT> class MatcherImpl, |

1679 | typename ReturnTypesF> |

1680 | class TypeTraversePolymorphicMatcher { |

1681 | private: |

1682 | using Self = TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, |

1683 | ReturnTypesF>; |

1684 | |

1685 | static Self create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers); |

1686 | |

1687 | public: |

1688 | using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type; |

1689 | |

1690 | explicit TypeTraversePolymorphicMatcher( |

1691 | ArrayRef<const Matcher<InnerTBase> *> InnerMatchers) |

1692 | : InnerMatcher(makeAllOfComposite(InnerMatchers)) {} |

1693 | |

1694 | template <typename OuterT> operator Matcher<OuterT>() const { |

1695 | return Matcher<OuterT>( |

1696 | new MatcherImpl<OuterT>(InnerMatcher, Getter<OuterT>::value())); |

1697 | } |

1698 | |

1699 | struct Func |

1700 | : public VariadicFunction<Self, Matcher<InnerTBase>, &Self::create> { |

1701 | Func() {} |

1702 | }; |

1703 | |

1704 | private: |

1705 | const Matcher<InnerTBase> InnerMatcher; |

1706 | }; |

1707 | |

1708 | /// A simple memoizer of T(*)() functions. |

1709 | /// |

1710 | /// It will call the passed 'Func' template parameter at most once. |

1711 | /// Used to support AST_MATCHER_FUNCTION() macro. |

1712 | template <typename Matcher, Matcher (*Func)()> class MemoizedMatcher { |

1713 | struct Wrapper { |

1714 | Wrapper() : M(Func()) {} |

1715 | |

1716 | Matcher M; |

1717 | }; |

1718 | |

1719 | public: |

1720 | static const Matcher &getInstance() { |

1721 | static llvm::ManagedStatic<Wrapper> Instance; |

1722 | return Instance->M; |

1723 | } |

1724 | }; |

1725 | |

1726 | // Define the create() method out of line to silence a GCC warning about |

1727 | // the struct "Func" having greater visibility than its base, which comes from |

1728 | // using the flag -fvisibility-inlines-hidden. |

1729 | template <typename InnerTBase, template <typename OuterT> class Getter, |

1730 | template <typename OuterT> class MatcherImpl, typename ReturnTypesF> |

1731 | TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, ReturnTypesF> |

1732 | TypeTraversePolymorphicMatcher< |

1733 | InnerTBase, Getter, MatcherImpl, |

1734 | ReturnTypesF>::create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers) { |

1735 | return Self(InnerMatchers); |

1736 | } |

1737 | |

1738 | // FIXME: unify ClassTemplateSpecializationDecl and TemplateSpecializationType's |

1739 | // APIs for accessing the template argument list. |

1740 | inline ArrayRef<TemplateArgument> |

1741 | getTemplateSpecializationArgs(const ClassTemplateSpecializationDecl &D) { |

1742 | return D.getTemplateArgs().asArray(); |

1743 | } |

1744 | |

1745 | inline ArrayRef<TemplateArgument> |

1746 | getTemplateSpecializationArgs(const TemplateSpecializationType &T) { |

1747 | return llvm::makeArrayRef(T.getArgs(), T.getNumArgs()); |

1748 | } |

1749 | |

1750 | inline ArrayRef<TemplateArgument> |

1751 | getTemplateSpecializationArgs(const FunctionDecl &FD) { |

1752 | if (const auto* TemplateArgs = FD.getTemplateSpecializationArgs()) |

1753 | return TemplateArgs->asArray(); |

1754 | return ArrayRef<TemplateArgument>(); |

1755 | } |

1756 | |

1757 | struct NotEqualsBoundNodePredicate { |

1758 | bool operator()(const internal::BoundNodesMap &Nodes) const { |

1759 | return Nodes.getNode(ID) != Node; |

1760 | } |

1761 | |

1762 | std::string ID; |

1763 | ast_type_traits::DynTypedNode Node; |

1764 | }; |

1765 | |

1766 | template <typename Ty> |

1767 | struct GetBodyMatcher { |

1768 | static const Stmt *get(const Ty &Node) { |

1769 | return Node.getBody(); |

1770 | } |

1771 | }; |

1772 | |

1773 | template <> |

1774 | inline const Stmt *GetBodyMatcher<FunctionDecl>::get(const FunctionDecl &Node) { |

1775 | return Node.doesThisDeclarationHaveABody() ? Node.getBody() : nullptr; |

1776 | } |

1777 | |

1778 | template <typename Ty> |

1779 | struct HasSizeMatcher { |

1780 | static bool hasSize(const Ty &Node, unsigned int N) { |

1781 | return Node.getSize() == N; |

1782 | } |

1783 | }; |

1784 | |

1785 | template <> |

1786 | inline bool HasSizeMatcher<StringLiteral>::hasSize( |

1787 | const StringLiteral &Node, unsigned int N) { |

1788 | return Node.getLength() == N; |

1789 | } |

1790 | |

1791 | template <typename Ty> |

1792 | struct GetSourceExpressionMatcher { |

1793 | static const Expr *get(const Ty &Node) { |

1794 | return Node.getSubExpr(); |

1795 | } |

1796 | }; |

1797 | |

1798 | template <> |

1799 | inline const Expr *GetSourceExpressionMatcher<OpaqueValueExpr>::get( |

1800 | const OpaqueValueExpr &Node) { |

1801 | return Node.getSourceExpr(); |

1802 | } |

1803 | |

1804 | template <typename Ty> |

1805 | struct CompoundStmtMatcher { |

1806 | static const CompoundStmt *get(const Ty &Node) { |

1807 | return &Node; |

1808 | } |

1809 | }; |

1810 | |

1811 | template <> |

1812 | inline const CompoundStmt * |

1813 | CompoundStmtMatcher<StmtExpr>::get(const StmtExpr &Node) { |

1814 | return Node.getSubStmt(); |

1815 | } |

1816 | |

1817 | } // namespace internal |

1818 | |

1819 | } // namespace ast_matchers |

1820 | |

1821 | } // namespace clang |

1822 | |

1823 | #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H |

1824 |