1 | //===- ASTMatchers.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 | // This file implements matchers to be used together with the MatchFinder to |

10 | // match AST nodes. |

11 | // |

12 | // Matchers are created by generator functions, which can be combined in |

13 | // a functional in-language DSL to express queries over the C++ AST. |

14 | // |

15 | // For example, to match a class with a certain name, one would call: |

16 | // cxxRecordDecl(hasName("MyClass")) |

17 | // which returns a matcher that can be used to find all AST nodes that declare |

18 | // a class named 'MyClass'. |

19 | // |

20 | // For more complicated match expressions we're often interested in accessing |

21 | // multiple parts of the matched AST nodes once a match is found. In that case, |

22 | // call `.bind("name")` on match expressions that match the nodes you want to |

23 | // access. |

24 | // |

25 | // For example, when we're interested in child classes of a certain class, we |

26 | // would write: |

27 | // cxxRecordDecl(hasName("MyClass"), has(recordDecl().bind("child"))) |

28 | // When the match is found via the MatchFinder, a user provided callback will |

29 | // be called with a BoundNodes instance that contains a mapping from the |

30 | // strings that we provided for the `.bind()` calls to the nodes that were |

31 | // matched. |

32 | // In the given example, each time our matcher finds a match we get a callback |

33 | // where "child" is bound to the RecordDecl node of the matching child |

34 | // class declaration. |

35 | // |

36 | // See ASTMatchersInternal.h for a more in-depth explanation of the |

37 | // implementation details of the matcher framework. |

38 | // |

39 | // See ASTMatchFinder.h for how to use the generated matchers to run over |

40 | // an AST. |

41 | // |

42 | //===----------------------------------------------------------------------===// |

43 | |

44 | #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H |

45 | #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H |

46 | |

47 | #include "clang/AST/ASTContext.h" |

48 | #include "clang/AST/ASTTypeTraits.h" |

49 | #include "clang/AST/Attr.h" |

50 | #include "clang/AST/CXXInheritance.h" |

51 | #include "clang/AST/Decl.h" |

52 | #include "clang/AST/DeclCXX.h" |

53 | #include "clang/AST/DeclFriend.h" |

54 | #include "clang/AST/DeclObjC.h" |

55 | #include "clang/AST/DeclTemplate.h" |

56 | #include "clang/AST/Expr.h" |

57 | #include "clang/AST/ExprCXX.h" |

58 | #include "clang/AST/ExprObjC.h" |

59 | #include "clang/AST/LambdaCapture.h" |

60 | #include "clang/AST/NestedNameSpecifier.h" |

61 | #include "clang/AST/OpenMPClause.h" |

62 | #include "clang/AST/OperationKinds.h" |

63 | #include "clang/AST/ParentMapContext.h" |

64 | #include "clang/AST/Stmt.h" |

65 | #include "clang/AST/StmtCXX.h" |

66 | #include "clang/AST/StmtObjC.h" |

67 | #include "clang/AST/StmtOpenMP.h" |

68 | #include "clang/AST/TemplateBase.h" |

69 | #include "clang/AST/TemplateName.h" |

70 | #include "clang/AST/Type.h" |

71 | #include "clang/AST/TypeLoc.h" |

72 | #include "clang/ASTMatchers/ASTMatchersInternal.h" |

73 | #include "clang/ASTMatchers/ASTMatchersMacros.h" |

74 | #include "clang/Basic/AttrKinds.h" |

75 | #include "clang/Basic/ExceptionSpecificationType.h" |

76 | #include "clang/Basic/FileManager.h" |

77 | #include "clang/Basic/IdentifierTable.h" |

78 | #include "clang/Basic/LLVM.h" |

79 | #include "clang/Basic/SourceManager.h" |

80 | #include "clang/Basic/Specifiers.h" |

81 | #include "clang/Basic/TypeTraits.h" |

82 | #include "llvm/ADT/ArrayRef.h" |

83 | #include "llvm/ADT/SmallVector.h" |

84 | #include "llvm/ADT/StringRef.h" |

85 | #include "llvm/Support/Casting.h" |

86 | #include "llvm/Support/Compiler.h" |

87 | #include "llvm/Support/ErrorHandling.h" |

88 | #include "llvm/Support/Regex.h" |

89 | #include <cassert> |

90 | #include <cstddef> |

91 | #include <iterator> |

92 | #include <limits> |

93 | #include <string> |

94 | #include <utility> |

95 | #include <vector> |

96 | |

97 | namespace clang { |

98 | namespace ast_matchers { |

99 | |

100 | /// Maps string IDs to AST nodes matched by parts of a matcher. |

101 | /// |

102 | /// The bound nodes are generated by calling \c bind("id") on the node matchers |

103 | /// of the nodes we want to access later. |

104 | /// |

105 | /// The instances of BoundNodes are created by \c MatchFinder when the user's |

106 | /// callbacks are executed every time a match is found. |

107 | class BoundNodes { |

108 | public: |

109 | /// Returns the AST node bound to \c ID. |

110 | /// |

111 | /// Returns NULL if there was no node bound to \c ID or if there is a node but |

112 | /// it cannot be converted to the specified type. |

113 | template <typename T> |

114 | const T *getNodeAs(StringRef ID) const { |

115 | return MyBoundNodes.getNodeAs<T>(ID); |

116 | } |

117 | |

118 | /// Type of mapping from binding identifiers to bound nodes. This type |

119 | /// is an associative container with a key type of \c std::string and a value |

120 | /// type of \c clang::DynTypedNode |

121 | using IDToNodeMap = internal::BoundNodesMap::IDToNodeMap; |

122 | |

123 | /// Retrieve mapping from binding identifiers to bound nodes. |

124 | const IDToNodeMap &getMap() const { |

125 | return MyBoundNodes.getMap(); |

126 | } |

127 | |

128 | private: |

129 | friend class internal::BoundNodesTreeBuilder; |

130 | |

131 | /// Create BoundNodes from a pre-filled map of bindings. |

132 | BoundNodes(internal::BoundNodesMap &MyBoundNodes) |

133 | : MyBoundNodes(MyBoundNodes) {} |

134 | |

135 | internal::BoundNodesMap MyBoundNodes; |

136 | }; |

137 | |

138 | /// Types of matchers for the top-level classes in the AST class |

139 | /// hierarchy. |

140 | /// @{ |

141 | using DeclarationMatcher = internal::Matcher<Decl>; |

142 | using StatementMatcher = internal::Matcher<Stmt>; |

143 | using TypeMatcher = internal::Matcher<QualType>; |

144 | using TypeLocMatcher = internal::Matcher<TypeLoc>; |

145 | using NestedNameSpecifierMatcher = internal::Matcher<NestedNameSpecifier>; |

146 | using NestedNameSpecifierLocMatcher = internal::Matcher<NestedNameSpecifierLoc>; |

147 | using CXXBaseSpecifierMatcher = internal::Matcher<CXXBaseSpecifier>; |

148 | using CXXCtorInitializerMatcher = internal::Matcher<CXXCtorInitializer>; |

149 | using TemplateArgumentMatcher = internal::Matcher<TemplateArgument>; |

150 | using TemplateArgumentLocMatcher = internal::Matcher<TemplateArgumentLoc>; |

151 | /// @} |

152 | |

153 | /// Matches any node. |

154 | /// |

155 | /// Useful when another matcher requires a child matcher, but there's no |

156 | /// additional constraint. This will often be used with an explicit conversion |

157 | /// to an \c internal::Matcher<> type such as \c TypeMatcher. |

158 | /// |

159 | /// Example: \c DeclarationMatcher(anything()) matches all declarations, e.g., |

160 | /// \code |

161 | /// "int* p" and "void f()" in |

162 | /// int* p; |

163 | /// void f(); |

164 | /// \endcode |

165 | /// |

166 | /// Usable as: Any Matcher |

167 | inline internal::TrueMatcher anything() { return internal::TrueMatcher(); } |

168 | |

169 | /// Matches the top declaration context. |

170 | /// |

171 | /// Given |

172 | /// \code |

173 | /// int X; |

174 | /// namespace NS { |

175 | /// int Y; |

176 | /// } // namespace NS |

177 | /// \endcode |

178 | /// decl(hasDeclContext(translationUnitDecl())) |

179 | /// matches "int X", but not "int Y". |

180 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl> |

181 | translationUnitDecl; |

182 | |

183 | /// Matches typedef declarations. |

184 | /// |

185 | /// Given |

186 | /// \code |

187 | /// typedef int X; |

188 | /// using Y = int; |

189 | /// \endcode |

190 | /// typedefDecl() |

191 | /// matches "typedef int X", but not "using Y = int" |

192 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> |

193 | typedefDecl; |

194 | |

195 | /// Matches typedef name declarations. |

196 | /// |

197 | /// Given |

198 | /// \code |

199 | /// typedef int X; |

200 | /// using Y = int; |

201 | /// \endcode |

202 | /// typedefNameDecl() |

203 | /// matches "typedef int X" and "using Y = int" |

204 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl> |

205 | typedefNameDecl; |

206 | |

207 | /// Matches type alias declarations. |

208 | /// |

209 | /// Given |

210 | /// \code |

211 | /// typedef int X; |

212 | /// using Y = int; |

213 | /// \endcode |

214 | /// typeAliasDecl() |

215 | /// matches "using Y = int", but not "typedef int X" |

216 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> |

217 | typeAliasDecl; |

218 | |

219 | /// Matches type alias template declarations. |

220 | /// |

221 | /// typeAliasTemplateDecl() matches |

222 | /// \code |

223 | /// template <typename T> |

224 | /// using Y = X<T>; |

225 | /// \endcode |

226 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl> |

227 | typeAliasTemplateDecl; |

228 | |

229 | /// Matches AST nodes that were expanded within the main-file. |

230 | /// |

231 | /// Example matches X but not Y |

232 | /// (matcher = cxxRecordDecl(isExpansionInMainFile()) |

233 | /// \code |

234 | /// #include <Y.h> |

235 | /// class X {}; |

236 | /// \endcode |

237 | /// Y.h: |

238 | /// \code |

239 | /// class Y {}; |

240 | /// \endcode |

241 | /// |

242 | /// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> |

243 | AST_POLYMORPHIC_MATCHER(isExpansionInMainFile, |

244 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc)) { |

245 | auto &SourceManager = Finder->getASTContext().getSourceManager(); |

246 | return SourceManager.isInMainFile( |

247 | SourceManager.getExpansionLoc(Node.getBeginLoc())); |

248 | } |

249 | |

250 | /// Matches AST nodes that were expanded within system-header-files. |

251 | /// |

252 | /// Example matches Y but not X |

253 | /// (matcher = cxxRecordDecl(isExpansionInSystemHeader()) |

254 | /// \code |

255 | /// #include <SystemHeader.h> |

256 | /// class X {}; |

257 | /// \endcode |

258 | /// SystemHeader.h: |

259 | /// \code |

260 | /// class Y {}; |

261 | /// \endcode |

262 | /// |

263 | /// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> |

264 | AST_POLYMORPHIC_MATCHER(isExpansionInSystemHeader, |

265 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc)) { |

266 | auto &SourceManager = Finder->getASTContext().getSourceManager(); |

267 | auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc()); |

268 | if (ExpansionLoc.isInvalid()) { |

269 | return false; |

270 | } |

271 | return SourceManager.isInSystemHeader(ExpansionLoc); |

272 | } |

273 | |

274 | /// Matches AST nodes that were expanded within files whose name is |

275 | /// partially matching a given regex. |

276 | /// |

277 | /// Example matches Y but not X |

278 | /// (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*")) |

279 | /// \code |

280 | /// #include "ASTMatcher.h" |

281 | /// class X {}; |

282 | /// \endcode |

283 | /// ASTMatcher.h: |

284 | /// \code |

285 | /// class Y {}; |

286 | /// \endcode |

287 | /// |

288 | /// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> |

289 | AST_POLYMORPHIC_MATCHER_REGEX(isExpansionInFileMatching, |

290 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, |

291 | TypeLoc), |

292 | RegExp) { |

293 | auto &SourceManager = Finder->getASTContext().getSourceManager(); |

294 | auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc()); |

295 | if (ExpansionLoc.isInvalid()) { |

296 | return false; |

297 | } |

298 | auto FileEntry = |

299 | SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc)); |

300 | if (!FileEntry) { |

301 | return false; |

302 | } |

303 | |

304 | auto Filename = FileEntry->getName(); |

305 | return RegExp->match(Filename); |

306 | } |

307 | |

308 | /// Matches statements that are (transitively) expanded from the named macro. |

309 | /// Does not match if only part of the statement is expanded from that macro or |

310 | /// if different parts of the the statement are expanded from different |

311 | /// appearances of the macro. |

312 | AST_POLYMORPHIC_MATCHER_P(isExpandedFromMacro, |

313 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc), |

314 | std::string, MacroName) { |

315 | // Verifies that the statement' beginning and ending are both expanded from |

316 | // the same instance of the given macro. |

317 | auto& Context = Finder->getASTContext(); |

318 | llvm::Optional<SourceLocation> B = |

319 | internal::getExpansionLocOfMacro(MacroName, Node.getBeginLoc(), Context); |

320 | if (!B) return false; |

321 | llvm::Optional<SourceLocation> E = |

322 | internal::getExpansionLocOfMacro(MacroName, Node.getEndLoc(), Context); |

323 | if (!E) return false; |

324 | return *B == *E; |

325 | } |

326 | |

327 | /// Matches declarations. |

328 | /// |

329 | /// Examples matches \c X, \c C, and the friend declaration inside \c C; |

330 | /// \code |

331 | /// void X(); |

332 | /// class C { |

333 | /// friend X; |

334 | /// }; |

335 | /// \endcode |

336 | extern const internal::VariadicAllOfMatcher<Decl> decl; |

337 | |

338 | /// Matches decomposition-declarations. |

339 | /// |

340 | /// Examples matches the declaration node with \c foo and \c bar, but not |

341 | /// \c number. |

342 | /// (matcher = declStmt(has(decompositionDecl()))) |

343 | /// |

344 | /// \code |

345 | /// int number = 42; |

346 | /// auto [foo, bar] = std::make_pair{42, 42}; |

347 | /// \endcode |

348 | extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl> |

349 | decompositionDecl; |

350 | |

351 | /// Matches binding declarations |

352 | /// Example matches \c foo and \c bar |

353 | /// (matcher = bindingDecl() |

354 | /// |

355 | /// \code |

356 | /// auto [foo, bar] = std::make_pair{42, 42}; |

357 | /// \endcode |

358 | extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl> |

359 | bindingDecl; |

360 | |

361 | /// Matches a declaration of a linkage specification. |

362 | /// |

363 | /// Given |

364 | /// \code |

365 | /// extern "C" {} |

366 | /// \endcode |

367 | /// linkageSpecDecl() |

368 | /// matches "extern "C" {}" |

369 | extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl> |

370 | linkageSpecDecl; |

371 | |

372 | /// Matches a declaration of anything that could have a name. |

373 | /// |

374 | /// Example matches \c X, \c S, the anonymous union type, \c i, and \c U; |

375 | /// \code |

376 | /// typedef int X; |

377 | /// struct S { |

378 | /// union { |

379 | /// int i; |

380 | /// } U; |

381 | /// }; |

382 | /// \endcode |

383 | extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl; |

384 | |

385 | /// Matches a declaration of label. |

386 | /// |

387 | /// Given |

388 | /// \code |

389 | /// goto FOO; |

390 | /// FOO: bar(); |

391 | /// \endcode |

392 | /// labelDecl() |

393 | /// matches 'FOO:' |

394 | extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl; |

395 | |

396 | /// Matches a declaration of a namespace. |

397 | /// |

398 | /// Given |

399 | /// \code |

400 | /// namespace {} |

401 | /// namespace test {} |

402 | /// \endcode |

403 | /// namespaceDecl() |

404 | /// matches "namespace {}" and "namespace test {}" |

405 | extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> |

406 | namespaceDecl; |

407 | |

408 | /// Matches a declaration of a namespace alias. |

409 | /// |

410 | /// Given |

411 | /// \code |

412 | /// namespace test {} |

413 | /// namespace alias = ::test; |

414 | /// \endcode |

415 | /// namespaceAliasDecl() |

416 | /// matches "namespace alias" but not "namespace test" |

417 | extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl> |

418 | namespaceAliasDecl; |

419 | |

420 | /// Matches class, struct, and union declarations. |

421 | /// |

422 | /// Example matches \c X, \c Z, \c U, and \c S |

423 | /// \code |

424 | /// class X; |

425 | /// template<class T> class Z {}; |

426 | /// struct S {}; |

427 | /// union U {}; |

428 | /// \endcode |

429 | extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl; |

430 | |

431 | /// Matches C++ class declarations. |

432 | /// |

433 | /// Example matches \c X, \c Z |

434 | /// \code |

435 | /// class X; |

436 | /// template<class T> class Z {}; |

437 | /// \endcode |

438 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> |

439 | cxxRecordDecl; |

440 | |

441 | /// Matches C++ class template declarations. |

442 | /// |

443 | /// Example matches \c Z |

444 | /// \code |

445 | /// template<class T> class Z {}; |

446 | /// \endcode |

447 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl> |

448 | classTemplateDecl; |

449 | |

450 | /// Matches C++ class template specializations. |

451 | /// |

452 | /// Given |

453 | /// \code |

454 | /// template<typename T> class A {}; |

455 | /// template<> class A<double> {}; |

456 | /// A<int> a; |

457 | /// \endcode |

458 | /// classTemplateSpecializationDecl() |

459 | /// matches the specializations \c A<int> and \c A<double> |

460 | extern const internal::VariadicDynCastAllOfMatcher< |

461 | Decl, ClassTemplateSpecializationDecl> |

462 | classTemplateSpecializationDecl; |

463 | |

464 | /// Matches C++ class template partial specializations. |

465 | /// |

466 | /// Given |

467 | /// \code |

468 | /// template<class T1, class T2, int I> |

469 | /// class A {}; |

470 | /// |

471 | /// template<class T, int I> |

472 | /// class A<T, T*, I> {}; |

473 | /// |

474 | /// template<> |

475 | /// class A<int, int, 1> {}; |

476 | /// \endcode |

477 | /// classTemplatePartialSpecializationDecl() |

478 | /// matches the specialization \c A<T,T*,I> but not \c A<int,int,1> |

479 | extern const internal::VariadicDynCastAllOfMatcher< |

480 | Decl, ClassTemplatePartialSpecializationDecl> |

481 | classTemplatePartialSpecializationDecl; |

482 | |

483 | /// Matches declarator declarations (field, variable, function |

484 | /// and non-type template parameter declarations). |

485 | /// |

486 | /// Given |

487 | /// \code |

488 | /// class X { int y; }; |

489 | /// \endcode |

490 | /// declaratorDecl() |

491 | /// matches \c int y. |

492 | extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl> |

493 | declaratorDecl; |

494 | |

495 | /// Matches parameter variable declarations. |

496 | /// |

497 | /// Given |

498 | /// \code |

499 | /// void f(int x); |

500 | /// \endcode |

501 | /// parmVarDecl() |

502 | /// matches \c int x. |

503 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> |

504 | parmVarDecl; |

505 | |

506 | /// Matches C++ access specifier declarations. |

507 | /// |

508 | /// Given |

509 | /// \code |

510 | /// class C { |

511 | /// public: |

512 | /// int a; |

513 | /// }; |

514 | /// \endcode |

515 | /// accessSpecDecl() |

516 | /// matches 'public:' |

517 | extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl> |

518 | accessSpecDecl; |

519 | |

520 | /// Matches class bases. |

521 | /// |

522 | /// Examples matches \c public virtual B. |

523 | /// \code |

524 | /// class B {}; |

525 | /// class C : public virtual B {}; |

526 | /// \endcode |

527 | extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier> cxxBaseSpecifier; |

528 | |

529 | /// Matches constructor initializers. |

530 | /// |

531 | /// Examples matches \c i(42). |

532 | /// \code |

533 | /// class C { |

534 | /// C() : i(42) {} |

535 | /// int i; |

536 | /// }; |

537 | /// \endcode |

538 | extern const internal::VariadicAllOfMatcher<CXXCtorInitializer> |

539 | cxxCtorInitializer; |

540 | |

541 | /// Matches template arguments. |

542 | /// |

543 | /// Given |

544 | /// \code |

545 | /// template <typename T> struct C {}; |

546 | /// C<int> c; |

547 | /// \endcode |

548 | /// templateArgument() |

549 | /// matches 'int' in C<int>. |

550 | extern const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument; |

551 | |

552 | /// Matches template arguments (with location info). |

553 | /// |

554 | /// Given |

555 | /// \code |

556 | /// template <typename T> struct C {}; |

557 | /// C<int> c; |

558 | /// \endcode |

559 | /// templateArgumentLoc() |

560 | /// matches 'int' in C<int>. |

561 | extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc> |

562 | templateArgumentLoc; |

563 | |

564 | /// Matches template name. |

565 | /// |

566 | /// Given |

567 | /// \code |

568 | /// template <typename T> class X { }; |

569 | /// X<int> xi; |

570 | /// \endcode |

571 | /// templateName() |

572 | /// matches 'X' in X<int>. |

573 | extern const internal::VariadicAllOfMatcher<TemplateName> templateName; |

574 | |

575 | /// Matches non-type template parameter declarations. |

576 | /// |

577 | /// Given |

578 | /// \code |

579 | /// template <typename T, int N> struct C {}; |

580 | /// \endcode |

581 | /// nonTypeTemplateParmDecl() |

582 | /// matches 'N', but not 'T'. |

583 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |

584 | NonTypeTemplateParmDecl> |

585 | nonTypeTemplateParmDecl; |

586 | |

587 | /// Matches template type parameter declarations. |

588 | /// |

589 | /// Given |

590 | /// \code |

591 | /// template <typename T, int N> struct C {}; |

592 | /// \endcode |

593 | /// templateTypeParmDecl() |

594 | /// matches 'T', but not 'N'. |

595 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl> |

596 | templateTypeParmDecl; |

597 | |

598 | /// Matches template template parameter declarations. |

599 | /// |

600 | /// Given |

601 | /// \code |

602 | /// template <template <typename> class Z, int N> struct C {}; |

603 | /// \endcode |

604 | /// templateTypeParmDecl() |

605 | /// matches 'Z', but not 'N'. |

606 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |

607 | TemplateTemplateParmDecl> |

608 | templateTemplateParmDecl; |

609 | |

610 | /// Matches public C++ declarations and C++ base specifers that specify public |

611 | /// inheritance. |

612 | /// |

613 | /// Examples: |

614 | /// \code |

615 | /// class C { |

616 | /// public: int a; // fieldDecl(isPublic()) matches 'a' |

617 | /// protected: int b; |

618 | /// private: int c; |

619 | /// }; |

620 | /// \endcode |

621 | /// |

622 | /// \code |

623 | /// class Base {}; |

624 | /// class Derived1 : public Base {}; // matches 'Base' |

625 | /// struct Derived2 : Base {}; // matches 'Base' |

626 | /// \endcode |

627 | AST_POLYMORPHIC_MATCHER(isPublic, |

628 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, |

629 | CXXBaseSpecifier)) { |

630 | return getAccessSpecifier(Node) == AS_public; |

631 | } |

632 | |

633 | /// Matches protected C++ declarations and C++ base specifers that specify |

634 | /// protected inheritance. |

635 | /// |

636 | /// Examples: |

637 | /// \code |

638 | /// class C { |

639 | /// public: int a; |

640 | /// protected: int b; // fieldDecl(isProtected()) matches 'b' |

641 | /// private: int c; |

642 | /// }; |

643 | /// \endcode |

644 | /// |

645 | /// \code |

646 | /// class Base {}; |

647 | /// class Derived : protected Base {}; // matches 'Base' |

648 | /// \endcode |

649 | AST_POLYMORPHIC_MATCHER(isProtected, |

650 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, |

651 | CXXBaseSpecifier)) { |

652 | return getAccessSpecifier(Node) == AS_protected; |

653 | } |

654 | |

655 | /// Matches private C++ declarations and C++ base specifers that specify private |

656 | /// inheritance. |

657 | /// |

658 | /// Examples: |

659 | /// \code |

660 | /// class C { |

661 | /// public: int a; |

662 | /// protected: int b; |

663 | /// private: int c; // fieldDecl(isPrivate()) matches 'c' |

664 | /// }; |

665 | /// \endcode |

666 | /// |

667 | /// \code |

668 | /// struct Base {}; |

669 | /// struct Derived1 : private Base {}; // matches 'Base' |

670 | /// class Derived2 : Base {}; // matches 'Base' |

671 | /// \endcode |

672 | AST_POLYMORPHIC_MATCHER(isPrivate, |

673 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, |

674 | CXXBaseSpecifier)) { |

675 | return getAccessSpecifier(Node) == AS_private; |

676 | } |

677 | |

678 | /// Matches non-static data members that are bit-fields. |

679 | /// |

680 | /// Given |

681 | /// \code |

682 | /// class C { |

683 | /// int a : 2; |

684 | /// int b; |

685 | /// }; |

686 | /// \endcode |

687 | /// fieldDecl(isBitField()) |

688 | /// matches 'int a;' but not 'int b;'. |

689 | AST_MATCHER(FieldDecl, isBitField) { |

690 | return Node.isBitField(); |

691 | } |

692 | |

693 | /// Matches non-static data members that are bit-fields of the specified |

694 | /// bit width. |

695 | /// |

696 | /// Given |

697 | /// \code |

698 | /// class C { |

699 | /// int a : 2; |

700 | /// int b : 4; |

701 | /// int c : 2; |

702 | /// }; |

703 | /// \endcode |

704 | /// fieldDecl(hasBitWidth(2)) |

705 | /// matches 'int a;' and 'int c;' but not 'int b;'. |

706 | AST_MATCHER_P(FieldDecl, hasBitWidth, unsigned, Width) { |

707 | return Node.isBitField() && |

708 | Node.getBitWidthValue(Finder->getASTContext()) == Width; |

709 | } |

710 | |

711 | /// Matches non-static data members that have an in-class initializer. |

712 | /// |

713 | /// Given |

714 | /// \code |

715 | /// class C { |

716 | /// int a = 2; |

717 | /// int b = 3; |

718 | /// int c; |

719 | /// }; |

720 | /// \endcode |

721 | /// fieldDecl(hasInClassInitializer(integerLiteral(equals(2)))) |

722 | /// matches 'int a;' but not 'int b;'. |

723 | /// fieldDecl(hasInClassInitializer(anything())) |

724 | /// matches 'int a;' and 'int b;' but not 'int c;'. |

725 | AST_MATCHER_P(FieldDecl, hasInClassInitializer, internal::Matcher<Expr>, |

726 | InnerMatcher) { |

727 | const Expr *Initializer = Node.getInClassInitializer(); |

728 | return (Initializer != nullptr && |

729 | InnerMatcher.matches(*Initializer, Finder, Builder)); |

730 | } |

731 | |

732 | /// Determines whether the function is "main", which is the entry point |

733 | /// into an executable program. |

734 | AST_MATCHER(FunctionDecl, isMain) { |

735 | return Node.isMain(); |

736 | } |

737 | |

738 | /// Matches the specialized template of a specialization declaration. |

739 | /// |

740 | /// Given |

741 | /// \code |

742 | /// template<typename T> class A {}; #1 |

743 | /// template<> class A<int> {}; #2 |

744 | /// \endcode |

745 | /// classTemplateSpecializationDecl(hasSpecializedTemplate(classTemplateDecl())) |

746 | /// matches '#2' with classTemplateDecl() matching the class template |

747 | /// declaration of 'A' at #1. |

748 | AST_MATCHER_P(ClassTemplateSpecializationDecl, hasSpecializedTemplate, |

749 | internal::Matcher<ClassTemplateDecl>, InnerMatcher) { |

750 | const ClassTemplateDecl* Decl = Node.getSpecializedTemplate(); |

751 | return (Decl != nullptr && |

752 | InnerMatcher.matches(*Decl, Finder, Builder)); |

753 | } |

754 | |

755 | /// Matches a declaration that has been implicitly added |

756 | /// by the compiler (eg. implicit default/copy constructors). |

757 | AST_MATCHER(Decl, isImplicit) { |

758 | return Node.isImplicit(); |

759 | } |

760 | |

761 | /// Matches classTemplateSpecializations, templateSpecializationType and |

762 | /// functionDecl that have at least one TemplateArgument matching the given |

763 | /// InnerMatcher. |

764 | /// |

765 | /// Given |

766 | /// \code |

767 | /// template<typename T> class A {}; |

768 | /// template<> class A<double> {}; |

769 | /// A<int> a; |

770 | /// |

771 | /// template<typename T> f() {}; |

772 | /// void func() { f<int>(); }; |

773 | /// \endcode |

774 | /// |

775 | /// \endcode |

776 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |

777 | /// refersToType(asString("int")))) |

778 | /// matches the specialization \c A<int> |

779 | /// |

780 | /// functionDecl(hasAnyTemplateArgument(refersToType(asString("int")))) |

781 | /// matches the specialization \c f<int> |

782 | AST_POLYMORPHIC_MATCHER_P( |

783 | hasAnyTemplateArgument, |

784 | AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl, |

785 | TemplateSpecializationType, |

786 | FunctionDecl), |

787 | internal::Matcher<TemplateArgument>, InnerMatcher) { |

788 | ArrayRef<TemplateArgument> List = |

789 | internal::getTemplateSpecializationArgs(Node); |

790 | return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder, |

791 | Builder) != List.end(); |

792 | } |

793 | |

794 | /// Causes all nested matchers to be matched with the specified traversal kind. |

795 | /// |

796 | /// Given |

797 | /// \code |

798 | /// void foo() |

799 | /// { |

800 | /// int i = 3.0; |

801 | /// } |

802 | /// \endcode |

803 | /// The matcher |

804 | /// \code |

805 | /// traverse(TK_IgnoreUnlessSpelledInSource, |

806 | /// varDecl(hasInitializer(floatLiteral().bind("init"))) |

807 | /// ) |

808 | /// \endcode |

809 | /// matches the variable declaration with "init" bound to the "3.0". |

810 | template <typename T> |

811 | internal::Matcher<T> traverse(TraversalKind TK, |

812 | const internal::Matcher<T> &InnerMatcher) { |

813 | return internal::DynTypedMatcher::constructRestrictedWrapper( |

814 | new internal::TraversalMatcher<T>(TK, InnerMatcher), |

815 | InnerMatcher.getID().first) |

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

817 | } |

818 | |

819 | template <typename T> |

820 | internal::BindableMatcher<T> |

821 | traverse(TraversalKind TK, const internal::BindableMatcher<T> &InnerMatcher) { |

822 | return internal::BindableMatcher<T>( |

823 | internal::DynTypedMatcher::constructRestrictedWrapper( |

824 | new internal::TraversalMatcher<T>(TK, InnerMatcher), |

825 | InnerMatcher.getID().first) |

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

827 | } |

828 | |

829 | template <typename... T> |

830 | internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>> |

831 | traverse(TraversalKind TK, |

832 | const internal::VariadicOperatorMatcher<T...> &InnerMatcher) { |

833 | return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>( |

834 | TK, InnerMatcher); |

835 | } |

836 | |

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

838 | typename T, typename ToTypes> |

839 | internal::TraversalWrapper< |

840 | internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>> |

841 | traverse(TraversalKind TK, const internal::ArgumentAdaptingMatcherFuncAdaptor< |

842 | ArgumentAdapterT, T, ToTypes> &InnerMatcher) { |

843 | return internal::TraversalWrapper< |

844 | internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, |

845 | ToTypes>>(TK, InnerMatcher); |

846 | } |

847 | |

848 | template <template <typename T, typename... P> class MatcherT, typename... P, |

849 | typename ReturnTypesF> |

850 | internal::TraversalWrapper< |

851 | internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>> |

852 | traverse(TraversalKind TK, |

853 | const internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...> |

854 | &InnerMatcher) { |

855 | return internal::TraversalWrapper< |

856 | internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>>(TK, |

857 | InnerMatcher); |

858 | } |

859 | |

860 | template <typename... T> |

861 | internal::Matcher<typename internal::GetClade<T...>::Type> |

862 | traverse(TraversalKind TK, const internal::MapAnyOfHelper<T...> &InnerMatcher) { |

863 | return traverse(TK, InnerMatcher.with()); |

864 | } |

865 | |

866 | /// Matches expressions that match InnerMatcher after any implicit AST |

867 | /// nodes are stripped off. |

868 | /// |

869 | /// Parentheses and explicit casts are not discarded. |

870 | /// Given |

871 | /// \code |

872 | /// class C {}; |

873 | /// C a = C(); |

874 | /// C b; |

875 | /// C c = b; |

876 | /// \endcode |

877 | /// The matchers |

878 | /// \code |

879 | /// varDecl(hasInitializer(ignoringImplicit(cxxConstructExpr()))) |

880 | /// \endcode |

881 | /// would match the declarations for a, b, and c. |

882 | /// While |

883 | /// \code |

884 | /// varDecl(hasInitializer(cxxConstructExpr())) |

885 | /// \endcode |

886 | /// only match the declarations for b and c. |

887 | AST_MATCHER_P(Expr, ignoringImplicit, internal::Matcher<Expr>, |

888 | InnerMatcher) { |

889 | return InnerMatcher.matches(*Node.IgnoreImplicit(), Finder, Builder); |

890 | } |

891 | |

892 | /// Matches expressions that match InnerMatcher after any implicit casts |

893 | /// are stripped off. |

894 | /// |

895 | /// Parentheses and explicit casts are not discarded. |

896 | /// Given |

897 | /// \code |

898 | /// int arr[5]; |

899 | /// int a = 0; |

900 | /// char b = 0; |

901 | /// const int c = a; |

902 | /// int *d = arr; |

903 | /// long e = (long) 0l; |

904 | /// \endcode |

905 | /// The matchers |

906 | /// \code |

907 | /// varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))) |

908 | /// varDecl(hasInitializer(ignoringImpCasts(declRefExpr()))) |

909 | /// \endcode |

910 | /// would match the declarations for a, b, c, and d, but not e. |

911 | /// While |

912 | /// \code |

913 | /// varDecl(hasInitializer(integerLiteral())) |

914 | /// varDecl(hasInitializer(declRefExpr())) |

915 | /// \endcode |

916 | /// only match the declarations for b, c, and d. |

917 | AST_MATCHER_P(Expr, ignoringImpCasts, |

918 | internal::Matcher<Expr>, InnerMatcher) { |

919 | return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder); |

920 | } |

921 | |

922 | /// Matches expressions that match InnerMatcher after parentheses and |

923 | /// casts are stripped off. |

924 | /// |

925 | /// Implicit and non-C Style casts are also discarded. |

926 | /// Given |

927 | /// \code |

928 | /// int a = 0; |

929 | /// char b = (0); |

930 | /// void* c = reinterpret_cast<char*>(0); |

931 | /// char d = char(0); |

932 | /// \endcode |

933 | /// The matcher |

934 | /// varDecl(hasInitializer(ignoringParenCasts(integerLiteral()))) |

935 | /// would match the declarations for a, b, c, and d. |

936 | /// while |

937 | /// varDecl(hasInitializer(integerLiteral())) |

938 | /// only match the declaration for a. |

939 | AST_MATCHER_P(Expr, ignoringParenCasts, internal::Matcher<Expr>, InnerMatcher) { |

940 | return InnerMatcher.matches(*Node.IgnoreParenCasts(), Finder, Builder); |

941 | } |

942 | |

943 | /// Matches expressions that match InnerMatcher after implicit casts and |

944 | /// parentheses are stripped off. |

945 | /// |

946 | /// Explicit casts are not discarded. |

947 | /// Given |

948 | /// \code |

949 | /// int arr[5]; |

950 | /// int a = 0; |

951 | /// char b = (0); |

952 | /// const int c = a; |

953 | /// int *d = (arr); |

954 | /// long e = ((long) 0l); |

955 | /// \endcode |

956 | /// The matchers |

957 | /// varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral()))) |

958 | /// varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr()))) |

959 | /// would match the declarations for a, b, c, and d, but not e. |

960 | /// while |

961 | /// varDecl(hasInitializer(integerLiteral())) |

962 | /// varDecl(hasInitializer(declRefExpr())) |

963 | /// would only match the declaration for a. |

964 | AST_MATCHER_P(Expr, ignoringParenImpCasts, |

965 | internal::Matcher<Expr>, InnerMatcher) { |

966 | return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder); |

967 | } |

968 | |

969 | /// Matches types that match InnerMatcher after any parens are stripped. |

970 | /// |

971 | /// Given |

972 | /// \code |

973 | /// void (*fp)(void); |

974 | /// \endcode |

975 | /// The matcher |

976 | /// \code |

977 | /// varDecl(hasType(pointerType(pointee(ignoringParens(functionType()))))) |

978 | /// \endcode |

979 | /// would match the declaration for fp. |

980 | AST_MATCHER_P_OVERLOAD(QualType, ignoringParens, internal::Matcher<QualType>, |

981 | InnerMatcher, 0) { |

982 | return InnerMatcher.matches(Node.IgnoreParens(), Finder, Builder); |

983 | } |

984 | |

985 | /// Overload \c ignoringParens for \c Expr. |

986 | /// |

987 | /// Given |

988 | /// \code |

989 | /// const char* str = ("my-string"); |

990 | /// \endcode |

991 | /// The matcher |

992 | /// \code |

993 | /// implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral()))) |

994 | /// \endcode |

995 | /// would match the implicit cast resulting from the assignment. |

996 | AST_MATCHER_P_OVERLOAD(Expr, ignoringParens, internal::Matcher<Expr>, |

997 | InnerMatcher, 1) { |

998 | const Expr *E = Node.IgnoreParens(); |

999 | return InnerMatcher.matches(*E, Finder, Builder); |

1000 | } |

1001 | |

1002 | /// Matches expressions that are instantiation-dependent even if it is |

1003 | /// neither type- nor value-dependent. |

1004 | /// |

1005 | /// In the following example, the expression sizeof(sizeof(T() + T())) |

1006 | /// is instantiation-dependent (since it involves a template parameter T), |

1007 | /// but is neither type- nor value-dependent, since the type of the inner |

1008 | /// sizeof is known (std::size_t) and therefore the size of the outer |

1009 | /// sizeof is known. |

1010 | /// \code |

1011 | /// template<typename T> |

1012 | /// void f(T x, T y) { sizeof(sizeof(T() + T()); } |

1013 | /// \endcode |

1014 | /// expr(isInstantiationDependent()) matches sizeof(sizeof(T() + T()) |

1015 | AST_MATCHER(Expr, isInstantiationDependent) { |

1016 | return Node.isInstantiationDependent(); |

1017 | } |

1018 | |

1019 | /// Matches expressions that are type-dependent because the template type |

1020 | /// is not yet instantiated. |

1021 | /// |

1022 | /// For example, the expressions "x" and "x + y" are type-dependent in |

1023 | /// the following code, but "y" is not type-dependent: |

1024 | /// \code |

1025 | /// template<typename T> |

1026 | /// void add(T x, int y) { |

1027 | /// x + y; |

1028 | /// } |

1029 | /// \endcode |

1030 | /// expr(isTypeDependent()) matches x + y |

1031 | AST_MATCHER(Expr, isTypeDependent) { return Node.isTypeDependent(); } |

1032 | |

1033 | /// Matches expression that are value-dependent because they contain a |

1034 | /// non-type template parameter. |

1035 | /// |

1036 | /// For example, the array bound of "Chars" in the following example is |

1037 | /// value-dependent. |

1038 | /// \code |

1039 | /// template<int Size> int f() { return Size; } |

1040 | /// \endcode |

1041 | /// expr(isValueDependent()) matches return Size |

1042 | AST_MATCHER(Expr, isValueDependent) { return Node.isValueDependent(); } |

1043 | |

1044 | /// Matches classTemplateSpecializations, templateSpecializationType and |

1045 | /// functionDecl where the n'th TemplateArgument matches the given InnerMatcher. |

1046 | /// |

1047 | /// Given |

1048 | /// \code |

1049 | /// template<typename T, typename U> class A {}; |

1050 | /// A<bool, int> b; |

1051 | /// A<int, bool> c; |

1052 | /// |

1053 | /// template<typename T> void f() {} |

1054 | /// void func() { f<int>(); }; |

1055 | /// \endcode |

1056 | /// classTemplateSpecializationDecl(hasTemplateArgument( |

1057 | /// 1, refersToType(asString("int")))) |

1058 | /// matches the specialization \c A<bool, int> |

1059 | /// |

1060 | /// functionDecl(hasTemplateArgument(0, refersToType(asString("int")))) |

1061 | /// matches the specialization \c f<int> |

1062 | AST_POLYMORPHIC_MATCHER_P2( |

1063 | hasTemplateArgument, |

1064 | AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl, |

1065 | TemplateSpecializationType, |

1066 | FunctionDecl), |

1067 | unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher) { |

1068 | ArrayRef<TemplateArgument> List = |

1069 | internal::getTemplateSpecializationArgs(Node); |

1070 | if (List.size() <= N) |

1071 | return false; |

1072 | return InnerMatcher.matches(List[N], Finder, Builder); |

1073 | } |

1074 | |

1075 | /// Matches if the number of template arguments equals \p N. |

1076 | /// |

1077 | /// Given |

1078 | /// \code |

1079 | /// template<typename T> struct C {}; |

1080 | /// C<int> c; |

1081 | /// \endcode |

1082 | /// classTemplateSpecializationDecl(templateArgumentCountIs(1)) |

1083 | /// matches C<int>. |

1084 | AST_POLYMORPHIC_MATCHER_P( |

1085 | templateArgumentCountIs, |

1086 | AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl, |

1087 | TemplateSpecializationType), |

1088 | unsigned, N) { |

1089 | return internal::getTemplateSpecializationArgs(Node).size() == N; |

1090 | } |

1091 | |

1092 | /// Matches a TemplateArgument that refers to a certain type. |

1093 | /// |

1094 | /// Given |

1095 | /// \code |

1096 | /// struct X {}; |

1097 | /// template<typename T> struct A {}; |

1098 | /// A<X> a; |

1099 | /// \endcode |

1100 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |

1101 | /// refersToType(class(hasName("X"))))) |

1102 | /// matches the specialization \c A<X> |

1103 | AST_MATCHER_P(TemplateArgument, refersToType, |

1104 | internal::Matcher<QualType>, InnerMatcher) { |

1105 | if (Node.getKind() != TemplateArgument::Type) |

1106 | return false; |

1107 | return InnerMatcher.matches(Node.getAsType(), Finder, Builder); |

1108 | } |

1109 | |

1110 | /// Matches a TemplateArgument that refers to a certain template. |

1111 | /// |

1112 | /// Given |

1113 | /// \code |

1114 | /// template<template <typename> class S> class X {}; |

1115 | /// template<typename T> class Y {}; |

1116 | /// X<Y> xi; |

1117 | /// \endcode |

1118 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |

1119 | /// refersToTemplate(templateName()))) |

1120 | /// matches the specialization \c X<Y> |

1121 | AST_MATCHER_P(TemplateArgument, refersToTemplate, |

1122 | internal::Matcher<TemplateName>, InnerMatcher) { |

1123 | if (Node.getKind() != TemplateArgument::Template) |

1124 | return false; |

1125 | return InnerMatcher.matches(Node.getAsTemplate(), Finder, Builder); |

1126 | } |

1127 | |

1128 | /// Matches a canonical TemplateArgument that refers to a certain |

1129 | /// declaration. |

1130 | /// |

1131 | /// Given |

1132 | /// \code |

1133 | /// struct B { int next; }; |

1134 | /// template<int(B::*next_ptr)> struct A {}; |

1135 | /// A<&B::next> a; |

1136 | /// \endcode |

1137 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |

1138 | /// refersToDeclaration(fieldDecl(hasName("next"))))) |

1139 | /// matches the specialization \c A<&B::next> with \c fieldDecl(...) matching |

1140 | /// \c B::next |

1141 | AST_MATCHER_P(TemplateArgument, refersToDeclaration, |

1142 | internal::Matcher<Decl>, InnerMatcher) { |

1143 | if (Node.getKind() == TemplateArgument::Declaration) |

1144 | return InnerMatcher.matches(*Node.getAsDecl(), Finder, Builder); |

1145 | return false; |

1146 | } |

1147 | |

1148 | /// Matches a sugar TemplateArgument that refers to a certain expression. |

1149 | /// |

1150 | /// Given |

1151 | /// \code |

1152 | /// struct B { int next; }; |

1153 | /// template<int(B::*next_ptr)> struct A {}; |

1154 | /// A<&B::next> a; |

1155 | /// \endcode |

1156 | /// templateSpecializationType(hasAnyTemplateArgument( |

1157 | /// isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next")))))))) |

1158 | /// matches the specialization \c A<&B::next> with \c fieldDecl(...) matching |

1159 | /// \c B::next |

1160 | AST_MATCHER_P(TemplateArgument, isExpr, internal::Matcher<Expr>, InnerMatcher) { |

1161 | if (Node.getKind() == TemplateArgument::Expression) |

1162 | return InnerMatcher.matches(*Node.getAsExpr(), Finder, Builder); |

1163 | return false; |

1164 | } |

1165 | |

1166 | /// Matches a TemplateArgument that is an integral value. |

1167 | /// |

1168 | /// Given |

1169 | /// \code |

1170 | /// template<int T> struct C {}; |

1171 | /// C<42> c; |

1172 | /// \endcode |

1173 | /// classTemplateSpecializationDecl( |

1174 | /// hasAnyTemplateArgument(isIntegral())) |

1175 | /// matches the implicit instantiation of C in C<42> |

1176 | /// with isIntegral() matching 42. |

1177 | AST_MATCHER(TemplateArgument, isIntegral) { |

1178 | return Node.getKind() == TemplateArgument::Integral; |

1179 | } |

1180 | |

1181 | /// Matches a TemplateArgument that refers to an integral type. |

1182 | /// |

1183 | /// Given |

1184 | /// \code |

1185 | /// template<int T> struct C {}; |

1186 | /// C<42> c; |

1187 | /// \endcode |

1188 | /// classTemplateSpecializationDecl( |

1189 | /// hasAnyTemplateArgument(refersToIntegralType(asString("int")))) |

1190 | /// matches the implicit instantiation of C in C<42>. |

1191 | AST_MATCHER_P(TemplateArgument, refersToIntegralType, |

1192 | internal::Matcher<QualType>, InnerMatcher) { |

1193 | if (Node.getKind() != TemplateArgument::Integral) |

1194 | return false; |

1195 | return InnerMatcher.matches(Node.getIntegralType(), Finder, Builder); |

1196 | } |

1197 | |

1198 | /// Matches a TemplateArgument of integral type with a given value. |

1199 | /// |

1200 | /// Note that 'Value' is a string as the template argument's value is |

1201 | /// an arbitrary precision integer. 'Value' must be euqal to the canonical |

1202 | /// representation of that integral value in base 10. |

1203 | /// |

1204 | /// Given |

1205 | /// \code |

1206 | /// template<int T> struct C {}; |

1207 | /// C<42> c; |

1208 | /// \endcode |

1209 | /// classTemplateSpecializationDecl( |

1210 | /// hasAnyTemplateArgument(equalsIntegralValue("42"))) |

1211 | /// matches the implicit instantiation of C in C<42>. |

1212 | AST_MATCHER_P(TemplateArgument, equalsIntegralValue, |

1213 | std::string, Value) { |

1214 | if (Node.getKind() != TemplateArgument::Integral) |

1215 | return false; |

1216 | return Node.getAsIntegral().toString(10) == Value; |

1217 | } |

1218 | |

1219 | /// Matches an Objective-C autorelease pool statement. |

1220 | /// |

1221 | /// Given |

1222 | /// \code |

1223 | /// @autoreleasepool { |

1224 | /// int x = 0; |

1225 | /// } |

1226 | /// \endcode |

1227 | /// autoreleasePoolStmt(stmt()) matches the declaration of "x" |

1228 | /// inside the autorelease pool. |

1229 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

1230 | ObjCAutoreleasePoolStmt> autoreleasePoolStmt; |

1231 | |

1232 | /// Matches any value declaration. |

1233 | /// |

1234 | /// Example matches A, B, C and F |

1235 | /// \code |

1236 | /// enum X { A, B, C }; |

1237 | /// void F(); |

1238 | /// \endcode |

1239 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl; |

1240 | |

1241 | /// Matches C++ constructor declarations. |

1242 | /// |

1243 | /// Example matches Foo::Foo() and Foo::Foo(int) |

1244 | /// \code |

1245 | /// class Foo { |

1246 | /// public: |

1247 | /// Foo(); |

1248 | /// Foo(int); |

1249 | /// int DoSomething(); |

1250 | /// }; |

1251 | /// \endcode |

1252 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl> |

1253 | cxxConstructorDecl; |

1254 | |

1255 | /// Matches explicit C++ destructor declarations. |

1256 | /// |

1257 | /// Example matches Foo::~Foo() |

1258 | /// \code |

1259 | /// class Foo { |

1260 | /// public: |

1261 | /// virtual ~Foo(); |

1262 | /// }; |

1263 | /// \endcode |

1264 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl> |

1265 | cxxDestructorDecl; |

1266 | |

1267 | /// Matches enum declarations. |

1268 | /// |

1269 | /// Example matches X |

1270 | /// \code |

1271 | /// enum X { |

1272 | /// A, B, C |

1273 | /// }; |

1274 | /// \endcode |

1275 | extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl; |

1276 | |

1277 | /// Matches enum constants. |

1278 | /// |

1279 | /// Example matches A, B, C |

1280 | /// \code |

1281 | /// enum X { |

1282 | /// A, B, C |

1283 | /// }; |

1284 | /// \endcode |

1285 | extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl> |

1286 | enumConstantDecl; |

1287 | |

1288 | /// Matches tag declarations. |

1289 | /// |

1290 | /// Example matches X, Z, U, S, E |

1291 | /// \code |

1292 | /// class X; |

1293 | /// template<class T> class Z {}; |

1294 | /// struct S {}; |

1295 | /// union U {}; |

1296 | /// enum E { |

1297 | /// A, B, C |

1298 | /// }; |

1299 | /// \endcode |

1300 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl; |

1301 | |

1302 | /// Matches method declarations. |

1303 | /// |

1304 | /// Example matches y |

1305 | /// \code |

1306 | /// class X { void y(); }; |

1307 | /// \endcode |

1308 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> |

1309 | cxxMethodDecl; |

1310 | |

1311 | /// Matches conversion operator declarations. |

1312 | /// |

1313 | /// Example matches the operator. |

1314 | /// \code |

1315 | /// class X { operator int() const; }; |

1316 | /// \endcode |

1317 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl> |

1318 | cxxConversionDecl; |

1319 | |

1320 | /// Matches user-defined and implicitly generated deduction guide. |

1321 | /// |

1322 | /// Example matches the deduction guide. |

1323 | /// \code |

1324 | /// template<typename T> |

1325 | /// class X { X(int) }; |

1326 | /// X(int) -> X<int>; |

1327 | /// \endcode |

1328 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl> |

1329 | cxxDeductionGuideDecl; |

1330 | |

1331 | /// Matches variable declarations. |

1332 | /// |

1333 | /// Note: this does not match declarations of member variables, which are |

1334 | /// "field" declarations in Clang parlance. |

1335 | /// |

1336 | /// Example matches a |

1337 | /// \code |

1338 | /// int a; |

1339 | /// \endcode |

1340 | extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl; |

1341 | |

1342 | /// Matches field declarations. |

1343 | /// |

1344 | /// Given |

1345 | /// \code |

1346 | /// class X { int m; }; |

1347 | /// \endcode |

1348 | /// fieldDecl() |

1349 | /// matches 'm'. |

1350 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl; |

1351 | |

1352 | /// Matches indirect field declarations. |

1353 | /// |

1354 | /// Given |

1355 | /// \code |

1356 | /// struct X { struct { int a; }; }; |

1357 | /// \endcode |

1358 | /// indirectFieldDecl() |

1359 | /// matches 'a'. |

1360 | extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl> |

1361 | indirectFieldDecl; |

1362 | |

1363 | /// Matches function declarations. |

1364 | /// |

1365 | /// Example matches f |

1366 | /// \code |

1367 | /// void f(); |

1368 | /// \endcode |

1369 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> |

1370 | functionDecl; |

1371 | |

1372 | /// Matches C++ function template declarations. |

1373 | /// |

1374 | /// Example matches f |

1375 | /// \code |

1376 | /// template<class T> void f(T t) {} |

1377 | /// \endcode |

1378 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl> |

1379 | functionTemplateDecl; |

1380 | |

1381 | /// Matches friend declarations. |

1382 | /// |

1383 | /// Given |

1384 | /// \code |

1385 | /// class X { friend void foo(); }; |

1386 | /// \endcode |

1387 | /// friendDecl() |

1388 | /// matches 'friend void foo()'. |

1389 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl; |

1390 | |

1391 | /// Matches statements. |

1392 | /// |

1393 | /// Given |

1394 | /// \code |

1395 | /// { ++a; } |

1396 | /// \endcode |

1397 | /// stmt() |

1398 | /// matches both the compound statement '{ ++a; }' and '++a'. |

1399 | extern const internal::VariadicAllOfMatcher<Stmt> stmt; |

1400 | |

1401 | /// Matches declaration statements. |

1402 | /// |

1403 | /// Given |

1404 | /// \code |

1405 | /// int a; |

1406 | /// \endcode |

1407 | /// declStmt() |

1408 | /// matches 'int a'. |

1409 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt; |

1410 | |

1411 | /// Matches member expressions. |

1412 | /// |

1413 | /// Given |

1414 | /// \code |

1415 | /// class Y { |

1416 | /// void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; } |

1417 | /// int a; static int b; |

1418 | /// }; |

1419 | /// \endcode |

1420 | /// memberExpr() |

1421 | /// matches this->x, x, y.x, a, this->b |

1422 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr; |

1423 | |

1424 | /// Matches unresolved member expressions. |

1425 | /// |

1426 | /// Given |

1427 | /// \code |

1428 | /// struct X { |

1429 | /// template <class T> void f(); |

1430 | /// void g(); |

1431 | /// }; |

1432 | /// template <class T> void h() { X x; x.f<T>(); x.g(); } |

1433 | /// \endcode |

1434 | /// unresolvedMemberExpr() |

1435 | /// matches x.f<T> |

1436 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr> |

1437 | unresolvedMemberExpr; |

1438 | |

1439 | /// Matches member expressions where the actual member referenced could not be |

1440 | /// resolved because the base expression or the member name was dependent. |

1441 | /// |

1442 | /// Given |

1443 | /// \code |

1444 | /// template <class T> void f() { T t; t.g(); } |

1445 | /// \endcode |

1446 | /// cxxDependentScopeMemberExpr() |

1447 | /// matches t.g |

1448 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

1449 | CXXDependentScopeMemberExpr> |

1450 | cxxDependentScopeMemberExpr; |

1451 | |

1452 | /// Matches call expressions. |

1453 | /// |

1454 | /// Example matches x.y() and y() |

1455 | /// \code |

1456 | /// X x; |

1457 | /// x.y(); |

1458 | /// y(); |

1459 | /// \endcode |

1460 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr; |

1461 | |

1462 | /// Matches call expressions which were resolved using ADL. |

1463 | /// |

1464 | /// Example matches y(x) but not y(42) or NS::y(x). |

1465 | /// \code |

1466 | /// namespace NS { |

1467 | /// struct X {}; |

1468 | /// void y(X); |

1469 | /// } |

1470 | /// |

1471 | /// void y(...); |

1472 | /// |

1473 | /// void test() { |

1474 | /// NS::X x; |

1475 | /// y(x); // Matches |

1476 | /// NS::y(x); // Doesn't match |

1477 | /// y(42); // Doesn't match |

1478 | /// using NS::y; |

1479 | /// y(x); // Found by both unqualified lookup and ADL, doesn't match |

1480 | // } |

1481 | /// \endcode |

1482 | AST_MATCHER(CallExpr, usesADL) { return Node.usesADL(); } |

1483 | |

1484 | /// Matches lambda expressions. |

1485 | /// |

1486 | /// Example matches [&](){return 5;} |

1487 | /// \code |

1488 | /// [&](){return 5;} |

1489 | /// \endcode |

1490 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr; |

1491 | |

1492 | /// Matches member call expressions. |

1493 | /// |

1494 | /// Example matches x.y() |

1495 | /// \code |

1496 | /// X x; |

1497 | /// x.y(); |

1498 | /// \endcode |

1499 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr> |

1500 | cxxMemberCallExpr; |

1501 | |

1502 | /// Matches ObjectiveC Message invocation expressions. |

1503 | /// |

1504 | /// The innermost message send invokes the "alloc" class method on the |

1505 | /// NSString class, while the outermost message send invokes the |

1506 | /// "initWithString" instance method on the object returned from |

1507 | /// NSString's "alloc". This matcher should match both message sends. |

1508 | /// \code |

1509 | /// [[NSString alloc] initWithString:@"Hello"] |

1510 | /// \endcode |

1511 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr> |

1512 | objcMessageExpr; |

1513 | |

1514 | /// Matches Objective-C interface declarations. |

1515 | /// |

1516 | /// Example matches Foo |

1517 | /// \code |

1518 | /// @interface Foo |

1519 | /// @end |

1520 | /// \endcode |

1521 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl> |

1522 | objcInterfaceDecl; |

1523 | |

1524 | /// Matches Objective-C implementation declarations. |

1525 | /// |

1526 | /// Example matches Foo |

1527 | /// \code |

1528 | /// @implementation Foo |

1529 | /// @end |

1530 | /// \endcode |

1531 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl> |

1532 | objcImplementationDecl; |

1533 | |

1534 | /// Matches Objective-C protocol declarations. |

1535 | /// |

1536 | /// Example matches FooDelegate |

1537 | /// \code |

1538 | /// @protocol FooDelegate |

1539 | /// @end |

1540 | /// \endcode |

1541 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl> |

1542 | objcProtocolDecl; |

1543 | |

1544 | /// Matches Objective-C category declarations. |

1545 | /// |

1546 | /// Example matches Foo (Additions) |

1547 | /// \code |

1548 | /// @interface Foo (Additions) |

1549 | /// @end |

1550 | /// \endcode |

1551 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl> |

1552 | objcCategoryDecl; |

1553 | |

1554 | /// Matches Objective-C category definitions. |

1555 | /// |

1556 | /// Example matches Foo (Additions) |

1557 | /// \code |

1558 | /// @implementation Foo (Additions) |

1559 | /// @end |

1560 | /// \endcode |

1561 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl> |

1562 | objcCategoryImplDecl; |

1563 | |

1564 | /// Matches Objective-C method declarations. |

1565 | /// |

1566 | /// Example matches both declaration and definition of -[Foo method] |

1567 | /// \code |

1568 | /// @interface Foo |

1569 | /// - (void)method; |

1570 | /// @end |

1571 | /// |

1572 | /// @implementation Foo |

1573 | /// - (void)method {} |

1574 | /// @end |

1575 | /// \endcode |

1576 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl> |

1577 | objcMethodDecl; |

1578 | |

1579 | /// Matches block declarations. |

1580 | /// |

1581 | /// Example matches the declaration of the nameless block printing an input |

1582 | /// integer. |

1583 | /// |

1584 | /// \code |

1585 | /// myFunc(^(int p) { |

1586 | /// printf("%d", p); |

1587 | /// }) |

1588 | /// \endcode |

1589 | extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl> |

1590 | blockDecl; |

1591 | |

1592 | /// Matches Objective-C instance variable declarations. |

1593 | /// |

1594 | /// Example matches _enabled |

1595 | /// \code |

1596 | /// @implementation Foo { |

1597 | /// BOOL _enabled; |

1598 | /// } |

1599 | /// @end |

1600 | /// \endcode |

1601 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> |

1602 | objcIvarDecl; |

1603 | |

1604 | /// Matches Objective-C property declarations. |

1605 | /// |

1606 | /// Example matches enabled |

1607 | /// \code |

1608 | /// @interface Foo |

1609 | /// @property BOOL enabled; |

1610 | /// @end |

1611 | /// \endcode |

1612 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl> |

1613 | objcPropertyDecl; |

1614 | |

1615 | /// Matches Objective-C \@throw statements. |

1616 | /// |

1617 | /// Example matches \@throw |

1618 | /// \code |

1619 | /// @throw obj; |

1620 | /// \endcode |

1621 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt> |

1622 | objcThrowStmt; |

1623 | |

1624 | /// Matches Objective-C @try statements. |

1625 | /// |

1626 | /// Example matches @try |

1627 | /// \code |

1628 | /// @try {} |

1629 | /// @catch (...) {} |

1630 | /// \endcode |

1631 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> |

1632 | objcTryStmt; |

1633 | |

1634 | /// Matches Objective-C @catch statements. |

1635 | /// |

1636 | /// Example matches @catch |

1637 | /// \code |

1638 | /// @try {} |

1639 | /// @catch (...) {} |

1640 | /// \endcode |

1641 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt> |

1642 | objcCatchStmt; |

1643 | |

1644 | /// Matches Objective-C @finally statements. |

1645 | /// |

1646 | /// Example matches @finally |

1647 | /// \code |

1648 | /// @try {} |

1649 | /// @finally {} |

1650 | /// \endcode |

1651 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt> |

1652 | objcFinallyStmt; |

1653 | |

1654 | /// Matches expressions that introduce cleanups to be run at the end |

1655 | /// of the sub-expression's evaluation. |

1656 | /// |

1657 | /// Example matches std::string() |

1658 | /// \code |

1659 | /// const std::string str = std::string(); |

1660 | /// \endcode |

1661 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups> |

1662 | exprWithCleanups; |

1663 | |

1664 | /// Matches init list expressions. |

1665 | /// |

1666 | /// Given |

1667 | /// \code |

1668 | /// int a[] = { 1, 2 }; |

1669 | /// struct B { int x, y; }; |

1670 | /// B b = { 5, 6 }; |

1671 | /// \endcode |

1672 | /// initListExpr() |

1673 | /// matches "{ 1, 2 }" and "{ 5, 6 }" |

1674 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> |

1675 | initListExpr; |

1676 | |

1677 | /// Matches the syntactic form of init list expressions |

1678 | /// (if expression have it). |

1679 | AST_MATCHER_P(InitListExpr, hasSyntacticForm, |

1680 | internal::Matcher<Expr>, InnerMatcher) { |

1681 | const Expr *SyntForm = Node.getSyntacticForm(); |

1682 | return (SyntForm != nullptr && |

1683 | InnerMatcher.matches(*SyntForm, Finder, Builder)); |

1684 | } |

1685 | |

1686 | /// Matches C++ initializer list expressions. |

1687 | /// |

1688 | /// Given |

1689 | /// \code |

1690 | /// std::vector<int> a({ 1, 2, 3 }); |

1691 | /// std::vector<int> b = { 4, 5 }; |

1692 | /// int c[] = { 6, 7 }; |

1693 | /// std::pair<int, int> d = { 8, 9 }; |

1694 | /// \endcode |

1695 | /// cxxStdInitializerListExpr() |

1696 | /// matches "{ 1, 2, 3 }" and "{ 4, 5 }" |

1697 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

1698 | CXXStdInitializerListExpr> |

1699 | cxxStdInitializerListExpr; |

1700 | |

1701 | /// Matches implicit initializers of init list expressions. |

1702 | /// |

1703 | /// Given |

1704 | /// \code |

1705 | /// point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; |

1706 | /// \endcode |

1707 | /// implicitValueInitExpr() |

1708 | /// matches "[0].y" (implicitly) |

1709 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr> |

1710 | implicitValueInitExpr; |

1711 | |

1712 | /// Matches paren list expressions. |

1713 | /// ParenListExprs don't have a predefined type and are used for late parsing. |

1714 | /// In the final AST, they can be met in template declarations. |

1715 | /// |

1716 | /// Given |

1717 | /// \code |

1718 | /// template<typename T> class X { |

1719 | /// void f() { |

1720 | /// X x(*this); |

1721 | /// int a = 0, b = 1; int i = (a, b); |

1722 | /// } |

1723 | /// }; |

1724 | /// \endcode |

1725 | /// parenListExpr() matches "*this" but NOT matches (a, b) because (a, b) |

1726 | /// has a predefined type and is a ParenExpr, not a ParenListExpr. |

1727 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> |

1728 | parenListExpr; |

1729 | |

1730 | /// Matches substitutions of non-type template parameters. |

1731 | /// |

1732 | /// Given |

1733 | /// \code |

1734 | /// template <int N> |

1735 | /// struct A { static const int n = N; }; |

1736 | /// struct B : public A<42> {}; |

1737 | /// \endcode |

1738 | /// substNonTypeTemplateParmExpr() |

1739 | /// matches "N" in the right-hand side of "static const int n = N;" |

1740 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

1741 | SubstNonTypeTemplateParmExpr> |

1742 | substNonTypeTemplateParmExpr; |

1743 | |

1744 | /// Matches using declarations. |

1745 | /// |

1746 | /// Given |

1747 | /// \code |

1748 | /// namespace X { int x; } |

1749 | /// using X::x; |

1750 | /// \endcode |

1751 | /// usingDecl() |

1752 | /// matches \code using X::x \endcode |

1753 | extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl; |

1754 | |

1755 | /// Matches using namespace declarations. |

1756 | /// |

1757 | /// Given |

1758 | /// \code |

1759 | /// namespace X { int x; } |

1760 | /// using namespace X; |

1761 | /// \endcode |

1762 | /// usingDirectiveDecl() |

1763 | /// matches \code using namespace X \endcode |

1764 | extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl> |

1765 | usingDirectiveDecl; |

1766 | |

1767 | /// Matches reference to a name that can be looked up during parsing |

1768 | /// but could not be resolved to a specific declaration. |

1769 | /// |

1770 | /// Given |

1771 | /// \code |

1772 | /// template<typename T> |

1773 | /// T foo() { T a; return a; } |

1774 | /// template<typename T> |

1775 | /// void bar() { |

1776 | /// foo<T>(); |

1777 | /// } |

1778 | /// \endcode |

1779 | /// unresolvedLookupExpr() |

1780 | /// matches \code foo<T>() \endcode |

1781 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr> |

1782 | unresolvedLookupExpr; |

1783 | |

1784 | /// Matches unresolved using value declarations. |

1785 | /// |

1786 | /// Given |

1787 | /// \code |

1788 | /// template<typename X> |

1789 | /// class C : private X { |

1790 | /// using X::x; |

1791 | /// }; |

1792 | /// \endcode |

1793 | /// unresolvedUsingValueDecl() |

1794 | /// matches \code using X::x \endcode |

1795 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |

1796 | UnresolvedUsingValueDecl> |

1797 | unresolvedUsingValueDecl; |

1798 | |

1799 | /// Matches unresolved using value declarations that involve the |

1800 | /// typename. |

1801 | /// |

1802 | /// Given |

1803 | /// \code |

1804 | /// template <typename T> |

1805 | /// struct Base { typedef T Foo; }; |

1806 | /// |

1807 | /// template<typename T> |

1808 | /// struct S : private Base<T> { |

1809 | /// using typename Base<T>::Foo; |

1810 | /// }; |

1811 | /// \endcode |

1812 | /// unresolvedUsingTypenameDecl() |

1813 | /// matches \code using Base<T>::Foo \endcode |

1814 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |

1815 | UnresolvedUsingTypenameDecl> |

1816 | unresolvedUsingTypenameDecl; |

1817 | |

1818 | /// Matches a constant expression wrapper. |

1819 | /// |

1820 | /// Example matches the constant in the case statement: |

1821 | /// (matcher = constantExpr()) |

1822 | /// \code |

1823 | /// switch (a) { |

1824 | /// case 37: break; |

1825 | /// } |

1826 | /// \endcode |

1827 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> |

1828 | constantExpr; |

1829 | |

1830 | /// Matches parentheses used in expressions. |

1831 | /// |

1832 | /// Example matches (foo() + 1) |

1833 | /// \code |

1834 | /// int foo() { return 1; } |

1835 | /// int a = (foo() + 1); |

1836 | /// \endcode |

1837 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr; |

1838 | |

1839 | /// Matches constructor call expressions (including implicit ones). |

1840 | /// |

1841 | /// Example matches string(ptr, n) and ptr within arguments of f |

1842 | /// (matcher = cxxConstructExpr()) |

1843 | /// \code |

1844 | /// void f(const string &a, const string &b); |

1845 | /// char *ptr; |

1846 | /// int n; |

1847 | /// f(string(ptr, n), ptr); |

1848 | /// \endcode |

1849 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr> |

1850 | cxxConstructExpr; |

1851 | |

1852 | /// Matches unresolved constructor call expressions. |

1853 | /// |

1854 | /// Example matches T(t) in return statement of f |

1855 | /// (matcher = cxxUnresolvedConstructExpr()) |

1856 | /// \code |

1857 | /// template <typename T> |

1858 | /// void f(const T& t) { return T(t); } |

1859 | /// \endcode |

1860 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

1861 | CXXUnresolvedConstructExpr> |

1862 | cxxUnresolvedConstructExpr; |

1863 | |

1864 | /// Matches implicit and explicit this expressions. |

1865 | /// |

1866 | /// Example matches the implicit this expression in "return i". |

1867 | /// (matcher = cxxThisExpr()) |

1868 | /// \code |

1869 | /// struct foo { |

1870 | /// int i; |

1871 | /// int f() { return i; } |

1872 | /// }; |

1873 | /// \endcode |

1874 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> |

1875 | cxxThisExpr; |

1876 | |

1877 | /// Matches nodes where temporaries are created. |

1878 | /// |

1879 | /// Example matches FunctionTakesString(GetStringByValue()) |

1880 | /// (matcher = cxxBindTemporaryExpr()) |

1881 | /// \code |

1882 | /// FunctionTakesString(GetStringByValue()); |

1883 | /// FunctionTakesStringByPointer(GetStringPointer()); |

1884 | /// \endcode |

1885 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr> |

1886 | cxxBindTemporaryExpr; |

1887 | |

1888 | /// Matches nodes where temporaries are materialized. |

1889 | /// |

1890 | /// Example: Given |

1891 | /// \code |

1892 | /// struct T {void func();}; |

1893 | /// T f(); |

1894 | /// void g(T); |

1895 | /// \endcode |

1896 | /// materializeTemporaryExpr() matches 'f()' in these statements |

1897 | /// \code |

1898 | /// T u(f()); |

1899 | /// g(f()); |

1900 | /// f().func(); |

1901 | /// \endcode |

1902 | /// but does not match |

1903 | /// \code |

1904 | /// f(); |

1905 | /// \endcode |

1906 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

1907 | MaterializeTemporaryExpr> |

1908 | materializeTemporaryExpr; |

1909 | |

1910 | /// Matches new expressions. |

1911 | /// |

1912 | /// Given |

1913 | /// \code |

1914 | /// new X; |

1915 | /// \endcode |

1916 | /// cxxNewExpr() |

1917 | /// matches 'new X'. |

1918 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr; |

1919 | |

1920 | /// Matches delete expressions. |

1921 | /// |

1922 | /// Given |

1923 | /// \code |

1924 | /// delete X; |

1925 | /// \endcode |

1926 | /// cxxDeleteExpr() |

1927 | /// matches 'delete X'. |

1928 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> |

1929 | cxxDeleteExpr; |

1930 | |

1931 | /// Matches noexcept expressions. |

1932 | /// |

1933 | /// Given |

1934 | /// \code |

1935 | /// bool a() noexcept; |

1936 | /// bool b() noexcept(true); |

1937 | /// bool c() noexcept(false); |

1938 | /// bool d() noexcept(noexcept(a())); |

1939 | /// bool e = noexcept(b()) || noexcept(c()); |

1940 | /// \endcode |

1941 | /// cxxNoexceptExpr() |

1942 | /// matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`. |

1943 | /// doesn't match the noexcept specifier in the declarations a, b, c or d. |

1944 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr> |

1945 | cxxNoexceptExpr; |

1946 | |

1947 | /// Matches array subscript expressions. |

1948 | /// |

1949 | /// Given |

1950 | /// \code |

1951 | /// int i = a[1]; |

1952 | /// \endcode |

1953 | /// arraySubscriptExpr() |

1954 | /// matches "a[1]" |

1955 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr> |

1956 | arraySubscriptExpr; |

1957 | |

1958 | /// Matches the value of a default argument at the call site. |

1959 | /// |

1960 | /// Example matches the CXXDefaultArgExpr placeholder inserted for the |

1961 | /// default value of the second parameter in the call expression f(42) |

1962 | /// (matcher = cxxDefaultArgExpr()) |

1963 | /// \code |

1964 | /// void f(int x, int y = 0); |

1965 | /// f(42); |

1966 | /// \endcode |

1967 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr> |

1968 | cxxDefaultArgExpr; |

1969 | |

1970 | /// Matches overloaded operator calls. |

1971 | /// |

1972 | /// Note that if an operator isn't overloaded, it won't match. Instead, use |

1973 | /// binaryOperator matcher. |

1974 | /// Currently it does not match operators such as new delete. |

1975 | /// FIXME: figure out why these do not match? |

1976 | /// |

1977 | /// Example matches both operator<<((o << b), c) and operator<<(o, b) |

1978 | /// (matcher = cxxOperatorCallExpr()) |

1979 | /// \code |

1980 | /// ostream &operator<< (ostream &out, int i) { }; |

1981 | /// ostream &o; int b = 1, c = 1; |

1982 | /// o << b << c; |

1983 | /// \endcode |

1984 | /// See also the binaryOperation() matcher for more-general matching of binary |

1985 | /// uses of this AST node. |

1986 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr> |

1987 | cxxOperatorCallExpr; |

1988 | |

1989 | /// Matches rewritten binary operators |

1990 | /// |

1991 | /// Example matches use of "<": |

1992 | /// \code |

1993 | /// #include <compare> |

1994 | /// struct HasSpaceshipMem { |

1995 | /// int a; |

1996 | /// constexpr auto operator<=>(const HasSpaceshipMem&) const = default; |

1997 | /// }; |

1998 | /// void compare() { |

1999 | /// HasSpaceshipMem hs1, hs2; |

2000 | /// if (hs1 < hs2) |

2001 | /// return; |

2002 | /// } |

2003 | /// \endcode |

2004 | /// See also the binaryOperation() matcher for more-general matching |

2005 | /// of this AST node. |

2006 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

2007 | CXXRewrittenBinaryOperator> |

2008 | cxxRewrittenBinaryOperator; |

2009 | |

2010 | /// Matches expressions. |

2011 | /// |

2012 | /// Example matches x() |

2013 | /// \code |

2014 | /// void f() { x(); } |

2015 | /// \endcode |

2016 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr; |

2017 | |

2018 | /// Matches expressions that refer to declarations. |

2019 | /// |

2020 | /// Example matches x in if (x) |

2021 | /// \code |

2022 | /// bool x; |

2023 | /// if (x) {} |

2024 | /// \endcode |

2025 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> |

2026 | declRefExpr; |

2027 | |

2028 | /// Matches a reference to an ObjCIvar. |

2029 | /// |

2030 | /// Example: matches "a" in "init" method: |

2031 | /// \code |

2032 | /// @implementation A { |

2033 | /// NSString *a; |

2034 | /// } |

2035 | /// - (void) init { |

2036 | /// a = @"hello"; |

2037 | /// } |

2038 | /// \endcode |

2039 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> |

2040 | objcIvarRefExpr; |

2041 | |

2042 | /// Matches a reference to a block. |

2043 | /// |

2044 | /// Example: matches "^{}": |

2045 | /// \code |

2046 | /// void f() { ^{}(); } |

2047 | /// \endcode |

2048 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr; |

2049 | |

2050 | /// Matches if statements. |

2051 | /// |

2052 | /// Example matches 'if (x) {}' |

2053 | /// \code |

2054 | /// if (x) {} |

2055 | /// \endcode |

2056 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt; |

2057 | |

2058 | /// Matches for statements. |

2059 | /// |

2060 | /// Example matches 'for (;;) {}' |

2061 | /// \code |

2062 | /// for (;;) {} |

2063 | /// int i[] = {1, 2, 3}; for (auto a : i); |

2064 | /// \endcode |

2065 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt; |

2066 | |

2067 | /// Matches the increment statement of a for loop. |

2068 | /// |

2069 | /// Example: |

2070 | /// forStmt(hasIncrement(unaryOperator(hasOperatorName("++")))) |

2071 | /// matches '++x' in |

2072 | /// \code |

2073 | /// for (x; x < N; ++x) { } |

2074 | /// \endcode |

2075 | AST_MATCHER_P(ForStmt, hasIncrement, internal::Matcher<Stmt>, |

2076 | InnerMatcher) { |

2077 | const Stmt *const Increment = Node.getInc(); |

2078 | return (Increment != nullptr && |

2079 | InnerMatcher.matches(*Increment, Finder, Builder)); |

2080 | } |

2081 | |

2082 | /// Matches the initialization statement of a for loop. |

2083 | /// |

2084 | /// Example: |

2085 | /// forStmt(hasLoopInit(declStmt())) |

2086 | /// matches 'int x = 0' in |

2087 | /// \code |

2088 | /// for (int x = 0; x < N; ++x) { } |

2089 | /// \endcode |

2090 | AST_MATCHER_P(ForStmt, hasLoopInit, internal::Matcher<Stmt>, |

2091 | InnerMatcher) { |

2092 | const Stmt *const Init = Node.getInit(); |

2093 | return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder)); |

2094 | } |

2095 | |

2096 | /// Matches range-based for statements. |

2097 | /// |

2098 | /// cxxForRangeStmt() matches 'for (auto a : i)' |

2099 | /// \code |

2100 | /// int i[] = {1, 2, 3}; for (auto a : i); |

2101 | /// for(int j = 0; j < 5; ++j); |

2102 | /// \endcode |

2103 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt> |

2104 | cxxForRangeStmt; |

2105 | |

2106 | /// Matches the initialization statement of a for loop. |

2107 | /// |

2108 | /// Example: |

2109 | /// forStmt(hasLoopVariable(anything())) |

2110 | /// matches 'int x' in |

2111 | /// \code |

2112 | /// for (int x : a) { } |

2113 | /// \endcode |

2114 | AST_MATCHER_P(CXXForRangeStmt, hasLoopVariable, internal::Matcher<VarDecl>, |

2115 | InnerMatcher) { |

2116 | const VarDecl *const Var = Node.getLoopVariable(); |

2117 | return (Var != nullptr && InnerMatcher.matches(*Var, Finder, Builder)); |

2118 | } |

2119 | |

2120 | /// Matches the range initialization statement of a for loop. |

2121 | /// |

2122 | /// Example: |

2123 | /// forStmt(hasRangeInit(anything())) |

2124 | /// matches 'a' in |

2125 | /// \code |

2126 | /// for (int x : a) { } |

2127 | /// \endcode |

2128 | AST_MATCHER_P(CXXForRangeStmt, hasRangeInit, internal::Matcher<Expr>, |

2129 | InnerMatcher) { |

2130 | const Expr *const Init = Node.getRangeInit(); |

2131 | return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder)); |

2132 | } |

2133 | |

2134 | /// Matches while statements. |

2135 | /// |

2136 | /// Given |

2137 | /// \code |

2138 | /// while (true) {} |

2139 | /// \endcode |

2140 | /// whileStmt() |

2141 | /// matches 'while (true) {}'. |

2142 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt; |

2143 | |

2144 | /// Matches do statements. |

2145 | /// |

2146 | /// Given |

2147 | /// \code |

2148 | /// do {} while (true); |

2149 | /// \endcode |

2150 | /// doStmt() |

2151 | /// matches 'do {} while(true)' |

2152 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt; |

2153 | |

2154 | /// Matches break statements. |

2155 | /// |

2156 | /// Given |

2157 | /// \code |

2158 | /// while (true) { break; } |

2159 | /// \endcode |

2160 | /// breakStmt() |

2161 | /// matches 'break' |

2162 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt; |

2163 | |

2164 | /// Matches continue statements. |

2165 | /// |

2166 | /// Given |

2167 | /// \code |

2168 | /// while (true) { continue; } |

2169 | /// \endcode |

2170 | /// continueStmt() |

2171 | /// matches 'continue' |

2172 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> |

2173 | continueStmt; |

2174 | |

2175 | /// Matches co_return statements. |

2176 | /// |

2177 | /// Given |

2178 | /// \code |

2179 | /// while (true) { co_return; } |

2180 | /// \endcode |

2181 | /// coreturnStmt() |

2182 | /// matches 'co_return' |

2183 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt> |

2184 | coreturnStmt; |

2185 | |

2186 | /// Matches return statements. |

2187 | /// |

2188 | /// Given |

2189 | /// \code |

2190 | /// return 1; |

2191 | /// \endcode |

2192 | /// returnStmt() |

2193 | /// matches 'return 1' |

2194 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt; |

2195 | |

2196 | /// Matches goto statements. |

2197 | /// |

2198 | /// Given |

2199 | /// \code |

2200 | /// goto FOO; |

2201 | /// FOO: bar(); |

2202 | /// \endcode |

2203 | /// gotoStmt() |

2204 | /// matches 'goto FOO' |

2205 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt; |

2206 | |

2207 | /// Matches label statements. |

2208 | /// |

2209 | /// Given |

2210 | /// \code |

2211 | /// goto FOO; |

2212 | /// FOO: bar(); |

2213 | /// \endcode |

2214 | /// labelStmt() |

2215 | /// matches 'FOO:' |

2216 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt; |

2217 | |

2218 | /// Matches address of label statements (GNU extension). |

2219 | /// |

2220 | /// Given |

2221 | /// \code |

2222 | /// FOO: bar(); |

2223 | /// void *ptr = &&FOO; |

2224 | /// goto *bar; |

2225 | /// \endcode |

2226 | /// addrLabelExpr() |

2227 | /// matches '&&FOO' |

2228 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> |

2229 | addrLabelExpr; |

2230 | |

2231 | /// Matches switch statements. |

2232 | /// |

2233 | /// Given |

2234 | /// \code |

2235 | /// switch(a) { case 42: break; default: break; } |

2236 | /// \endcode |

2237 | /// switchStmt() |

2238 | /// matches 'switch(a)'. |

2239 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt; |

2240 | |

2241 | /// Matches case and default statements inside switch statements. |

2242 | /// |

2243 | /// Given |

2244 | /// \code |

2245 | /// switch(a) { case 42: break; default: break; } |

2246 | /// \endcode |

2247 | /// switchCase() |

2248 | /// matches 'case 42:' and 'default:'. |

2249 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase; |

2250 | |

2251 | /// Matches case statements inside switch statements. |

2252 | /// |

2253 | /// Given |

2254 | /// \code |

2255 | /// switch(a) { case 42: break; default: break; } |

2256 | /// \endcode |

2257 | /// caseStmt() |

2258 | /// matches 'case 42:'. |

2259 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt; |

2260 | |

2261 | /// Matches default statements inside switch statements. |

2262 | /// |

2263 | /// Given |

2264 | /// \code |

2265 | /// switch(a) { case 42: break; default: break; } |

2266 | /// \endcode |

2267 | /// defaultStmt() |

2268 | /// matches 'default:'. |

2269 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> |

2270 | defaultStmt; |

2271 | |

2272 | /// Matches compound statements. |

2273 | /// |

2274 | /// Example matches '{}' and '{{}}' in 'for (;;) {{}}' |

2275 | /// \code |

2276 | /// for (;;) {{}} |

2277 | /// \endcode |

2278 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> |

2279 | compoundStmt; |

2280 | |

2281 | /// Matches catch statements. |

2282 | /// |

2283 | /// \code |

2284 | /// try {} catch(int i) {} |

2285 | /// \endcode |

2286 | /// cxxCatchStmt() |

2287 | /// matches 'catch(int i)' |

2288 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> |

2289 | cxxCatchStmt; |

2290 | |

2291 | /// Matches try statements. |

2292 | /// |

2293 | /// \code |

2294 | /// try {} catch(int i) {} |

2295 | /// \endcode |

2296 | /// cxxTryStmt() |

2297 | /// matches 'try {}' |

2298 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt; |

2299 | |

2300 | /// Matches throw expressions. |

2301 | /// |

2302 | /// \code |

2303 | /// try { throw 5; } catch(int i) {} |

2304 | /// \endcode |

2305 | /// cxxThrowExpr() |

2306 | /// matches 'throw 5' |

2307 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> |

2308 | cxxThrowExpr; |

2309 | |

2310 | /// Matches null statements. |

2311 | /// |

2312 | /// \code |

2313 | /// foo();; |

2314 | /// \endcode |

2315 | /// nullStmt() |

2316 | /// matches the second ';' |

2317 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt; |

2318 | |

2319 | /// Matches asm statements. |

2320 | /// |

2321 | /// \code |

2322 | /// int i = 100; |

2323 | /// __asm("mov al, 2"); |

2324 | /// \endcode |

2325 | /// asmStmt() |

2326 | /// matches '__asm("mov al, 2")' |

2327 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt; |

2328 | |

2329 | /// Matches bool literals. |

2330 | /// |

2331 | /// Example matches true |

2332 | /// \code |

2333 | /// true |

2334 | /// \endcode |

2335 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr> |

2336 | cxxBoolLiteral; |

2337 | |

2338 | /// Matches string literals (also matches wide string literals). |

2339 | /// |

2340 | /// Example matches "abcd", L"abcd" |

2341 | /// \code |

2342 | /// char *s = "abcd"; |

2343 | /// wchar_t *ws = L"abcd"; |

2344 | /// \endcode |

2345 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> |

2346 | stringLiteral; |

2347 | |

2348 | /// Matches character literals (also matches wchar_t). |

2349 | /// |

2350 | /// Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral), |

2351 | /// though. |

2352 | /// |

2353 | /// Example matches 'a', L'a' |

2354 | /// \code |

2355 | /// char ch = 'a'; |

2356 | /// wchar_t chw = L'a'; |

2357 | /// \endcode |

2358 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral> |

2359 | characterLiteral; |

2360 | |

2361 | /// Matches integer literals of all sizes / encodings, e.g. |

2362 | /// 1, 1L, 0x1 and 1U. |

2363 | /// |

2364 | /// Does not match character-encoded integers such as L'a'. |

2365 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral> |

2366 | integerLiteral; |

2367 | |

2368 | /// Matches float literals of all sizes / encodings, e.g. |

2369 | /// 1.0, 1.0f, 1.0L and 1e10. |

2370 | /// |

2371 | /// Does not match implicit conversions such as |

2372 | /// \code |

2373 | /// float a = 10; |

2374 | /// \endcode |

2375 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> |

2376 | floatLiteral; |

2377 | |

2378 | /// Matches imaginary literals, which are based on integer and floating |

2379 | /// point literals e.g.: 1i, 1.0i |

2380 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> |

2381 | imaginaryLiteral; |

2382 | |

2383 | /// Matches fixed point literals |

2384 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral> |

2385 | fixedPointLiteral; |

2386 | |

2387 | /// Matches user defined literal operator call. |

2388 | /// |

2389 | /// Example match: "foo"_suffix |

2390 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral> |

2391 | userDefinedLiteral; |

2392 | |

2393 | /// Matches compound (i.e. non-scalar) literals |

2394 | /// |

2395 | /// Example match: {1}, (1, 2) |

2396 | /// \code |

2397 | /// int array[4] = {1}; |

2398 | /// vector int myvec = (vector int)(1, 2); |

2399 | /// \endcode |

2400 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr> |

2401 | compoundLiteralExpr; |

2402 | |

2403 | /// Matches co_await expressions. |

2404 | /// |

2405 | /// Given |

2406 | /// \code |

2407 | /// co_await 1; |

2408 | /// \endcode |

2409 | /// coawaitExpr() |

2410 | /// matches 'co_await 1' |

2411 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr> |

2412 | coawaitExpr; |

2413 | /// Matches co_await expressions where the type of the promise is dependent |

2414 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr> |

2415 | dependentCoawaitExpr; |

2416 | /// Matches co_yield expressions. |

2417 | /// |

2418 | /// Given |

2419 | /// \code |

2420 | /// co_yield 1; |

2421 | /// \endcode |

2422 | /// coyieldExpr() |

2423 | /// matches 'co_yield 1' |

2424 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr> |

2425 | coyieldExpr; |

2426 | |

2427 | /// Matches nullptr literal. |

2428 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr> |

2429 | cxxNullPtrLiteralExpr; |

2430 | |

2431 | /// Matches GNU __builtin_choose_expr. |

2432 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> |

2433 | chooseExpr; |

2434 | |

2435 | /// Matches GNU __null expression. |

2436 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> |

2437 | gnuNullExpr; |

2438 | |

2439 | /// Matches C11 _Generic expression. |

2440 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr> |

2441 | genericSelectionExpr; |

2442 | |

2443 | /// Matches atomic builtins. |

2444 | /// Example matches __atomic_load_n(ptr, 1) |

2445 | /// \code |

2446 | /// void foo() { int *ptr; __atomic_load_n(ptr, 1); } |

2447 | /// \endcode |

2448 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr; |

2449 | |

2450 | /// Matches statement expression (GNU extension). |

2451 | /// |

2452 | /// Example match: ({ int X = 4; X; }) |

2453 | /// \code |

2454 | /// int C = ({ int X = 4; X; }); |

2455 | /// \endcode |

2456 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr; |

2457 | |

2458 | /// Matches binary operator expressions. |

2459 | /// |

2460 | /// Example matches a || b |

2461 | /// \code |

2462 | /// !(a || b) |

2463 | /// \endcode |

2464 | /// See also the binaryOperation() matcher for more-general matching. |

2465 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator> |

2466 | binaryOperator; |

2467 | |

2468 | /// Matches unary operator expressions. |

2469 | /// |

2470 | /// Example matches !a |

2471 | /// \code |

2472 | /// !a || b |

2473 | /// \endcode |

2474 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> |

2475 | unaryOperator; |

2476 | |

2477 | /// Matches conditional operator expressions. |

2478 | /// |

2479 | /// Example matches a ? b : c |

2480 | /// \code |

2481 | /// (a ? b : c) + 42 |

2482 | /// \endcode |

2483 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator> |

2484 | conditionalOperator; |

2485 | |

2486 | /// Matches binary conditional operator expressions (GNU extension). |

2487 | /// |

2488 | /// Example matches a ?: b |

2489 | /// \code |

2490 | /// (a ?: b) + 42; |

2491 | /// \endcode |

2492 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

2493 | BinaryConditionalOperator> |

2494 | binaryConditionalOperator; |

2495 | |

2496 | /// Matches opaque value expressions. They are used as helpers |

2497 | /// to reference another expressions and can be met |

2498 | /// in BinaryConditionalOperators, for example. |

2499 | /// |

2500 | /// Example matches 'a' |

2501 | /// \code |

2502 | /// (a ?: c) + 42; |

2503 | /// \endcode |

2504 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr> |

2505 | opaqueValueExpr; |

2506 | |

2507 | /// Matches a C++ static_assert declaration. |

2508 | /// |

2509 | /// Example: |

2510 | /// staticAssertExpr() |

2511 | /// matches |

2512 | /// static_assert(sizeof(S) == sizeof(int)) |

2513 | /// in |

2514 | /// \code |

2515 | /// struct S { |

2516 | /// int x; |

2517 | /// }; |

2518 | /// static_assert(sizeof(S) == sizeof(int)); |

2519 | /// \endcode |

2520 | extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl> |

2521 | staticAssertDecl; |

2522 | |

2523 | /// Matches a reinterpret_cast expression. |

2524 | /// |

2525 | /// Either the source expression or the destination type can be matched |

2526 | /// using has(), but hasDestinationType() is more specific and can be |

2527 | /// more readable. |

2528 | /// |

2529 | /// Example matches reinterpret_cast<char*>(&p) in |

2530 | /// \code |

2531 | /// void* p = reinterpret_cast<char*>(&p); |

2532 | /// \endcode |

2533 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr> |

2534 | cxxReinterpretCastExpr; |

2535 | |

2536 | /// Matches a C++ static_cast expression. |

2537 | /// |

2538 | /// \see hasDestinationType |

2539 | /// \see reinterpretCast |

2540 | /// |

2541 | /// Example: |

2542 | /// cxxStaticCastExpr() |

2543 | /// matches |

2544 | /// static_cast<long>(8) |

2545 | /// in |

2546 | /// \code |

2547 | /// long eight(static_cast<long>(8)); |

2548 | /// \endcode |

2549 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr> |

2550 | cxxStaticCastExpr; |

2551 | |

2552 | /// Matches a dynamic_cast expression. |

2553 | /// |

2554 | /// Example: |

2555 | /// cxxDynamicCastExpr() |

2556 | /// matches |

2557 | /// dynamic_cast<D*>(&b); |

2558 | /// in |

2559 | /// \code |

2560 | /// struct B { virtual ~B() {} }; struct D : B {}; |

2561 | /// B b; |

2562 | /// D* p = dynamic_cast<D*>(&b); |

2563 | /// \endcode |

2564 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr> |

2565 | cxxDynamicCastExpr; |

2566 | |

2567 | /// Matches a const_cast expression. |

2568 | /// |

2569 | /// Example: Matches const_cast<int*>(&r) in |

2570 | /// \code |

2571 | /// int n = 42; |

2572 | /// const int &r(n); |

2573 | /// int* p = const_cast<int*>(&r); |

2574 | /// \endcode |

2575 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr> |

2576 | cxxConstCastExpr; |

2577 | |

2578 | /// Matches a C-style cast expression. |

2579 | /// |

2580 | /// Example: Matches (int) 2.2f in |

2581 | /// \code |

2582 | /// int i = (int) 2.2f; |

2583 | /// \endcode |

2584 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr> |

2585 | cStyleCastExpr; |

2586 | |

2587 | /// Matches explicit cast expressions. |

2588 | /// |

2589 | /// Matches any cast expression written in user code, whether it be a |

2590 | /// C-style cast, a functional-style cast, or a keyword cast. |

2591 | /// |

2592 | /// Does not match implicit conversions. |

2593 | /// |

2594 | /// Note: the name "explicitCast" is chosen to match Clang's terminology, as |

2595 | /// Clang uses the term "cast" to apply to implicit conversions as well as to |

2596 | /// actual cast expressions. |

2597 | /// |

2598 | /// \see hasDestinationType. |

2599 | /// |

2600 | /// Example: matches all five of the casts in |

2601 | /// \code |

2602 | /// int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42))))) |

2603 | /// \endcode |

2604 | /// but does not match the implicit conversion in |

2605 | /// \code |

2606 | /// long ell = 42; |

2607 | /// \endcode |

2608 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr> |

2609 | explicitCastExpr; |

2610 | |

2611 | /// Matches the implicit cast nodes of Clang's AST. |

2612 | /// |

2613 | /// This matches many different places, including function call return value |

2614 | /// eliding, as well as any type conversions. |

2615 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr> |

2616 | implicitCastExpr; |

2617 | |

2618 | /// Matches any cast nodes of Clang's AST. |

2619 | /// |

2620 | /// Example: castExpr() matches each of the following: |

2621 | /// \code |

2622 | /// (int) 3; |

2623 | /// const_cast<Expr *>(SubExpr); |

2624 | /// char c = 0; |

2625 | /// \endcode |

2626 | /// but does not match |

2627 | /// \code |

2628 | /// int i = (0); |

2629 | /// int k = 0; |

2630 | /// \endcode |

2631 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr; |

2632 | |

2633 | /// Matches functional cast expressions |

2634 | /// |

2635 | /// Example: Matches Foo(bar); |

2636 | /// \code |

2637 | /// Foo f = bar; |

2638 | /// Foo g = (Foo) bar; |

2639 | /// Foo h = Foo(bar); |

2640 | /// \endcode |

2641 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr> |

2642 | cxxFunctionalCastExpr; |

2643 | |

2644 | /// Matches functional cast expressions having N != 1 arguments |

2645 | /// |

2646 | /// Example: Matches Foo(bar, bar) |

2647 | /// \code |

2648 | /// Foo h = Foo(bar, bar); |

2649 | /// \endcode |

2650 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr> |

2651 | cxxTemporaryObjectExpr; |

2652 | |

2653 | /// Matches predefined identifier expressions [C99 6.4.2.2]. |

2654 | /// |

2655 | /// Example: Matches __func__ |

2656 | /// \code |

2657 | /// printf("%s", __func__); |

2658 | /// \endcode |

2659 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr> |

2660 | predefinedExpr; |

2661 | |

2662 | /// Matches C99 designated initializer expressions [C99 6.7.8]. |

2663 | /// |

2664 | /// Example: Matches { [2].y = 1.0, [0].x = 1.0 } |

2665 | /// \code |

2666 | /// point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 }; |

2667 | /// \endcode |

2668 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr> |

2669 | designatedInitExpr; |

2670 | |

2671 | /// Matches designated initializer expressions that contain |

2672 | /// a specific number of designators. |

2673 | /// |

2674 | /// Example: Given |

2675 | /// \code |

2676 | /// point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 }; |

2677 | /// point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }; |

2678 | /// \endcode |

2679 | /// designatorCountIs(2) |

2680 | /// matches '{ [2].y = 1.0, [0].x = 1.0 }', |

2681 | /// but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'. |

2682 | AST_MATCHER_P(DesignatedInitExpr, designatorCountIs, unsigned, N) { |

2683 | return Node.size() == N; |

2684 | } |

2685 | |

2686 | /// Matches \c QualTypes in the clang AST. |

2687 | extern const internal::VariadicAllOfMatcher<QualType> qualType; |

2688 | |

2689 | /// Matches \c Types in the clang AST. |

2690 | extern const internal::VariadicAllOfMatcher<Type> type; |

2691 | |

2692 | /// Matches \c TypeLocs in the clang AST. |

2693 | extern const internal::VariadicAllOfMatcher<TypeLoc> typeLoc; |

2694 | |

2695 | /// Matches if any of the given matchers matches. |

2696 | /// |

2697 | /// Unlike \c anyOf, \c eachOf will generate a match result for each |

2698 | /// matching submatcher. |

2699 | /// |

2700 | /// For example, in: |

2701 | /// \code |

2702 | /// class A { int a; int b; }; |

2703 | /// \endcode |

2704 | /// The matcher: |

2705 | /// \code |

2706 | /// cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")), |

2707 | /// has(fieldDecl(hasName("b")).bind("v")))) |

2708 | /// \endcode |

2709 | /// will generate two results binding "v", the first of which binds |

2710 | /// the field declaration of \c a, the second the field declaration of |

2711 | /// \c b. |

2712 | /// |

2713 | /// Usable as: Any Matcher |

2714 | extern const internal::VariadicOperatorMatcherFunc< |

2715 | 2, std::numeric_limits<unsigned>::max()> |

2716 | eachOf; |

2717 | |

2718 | /// Matches if any of the given matchers matches. |

2719 | /// |

2720 | /// Usable as: Any Matcher |

2721 | extern const internal::VariadicOperatorMatcherFunc< |

2722 | 2, std::numeric_limits<unsigned>::max()> |

2723 | anyOf; |

2724 | |

2725 | /// Matches if all given matchers match. |

2726 | /// |

2727 | /// Usable as: Any Matcher |

2728 | extern const internal::VariadicOperatorMatcherFunc< |

2729 | 2, std::numeric_limits<unsigned>::max()> |

2730 | allOf; |

2731 | |

2732 | /// Matches any node regardless of the submatcher. |

2733 | /// |

2734 | /// However, \c optionally will retain any bindings generated by the submatcher. |

2735 | /// Useful when additional information which may or may not present about a main |

2736 | /// matching node is desired. |

2737 | /// |

2738 | /// For example, in: |

2739 | /// \code |

2740 | /// class Foo { |

2741 | /// int bar; |

2742 | /// } |

2743 | /// \endcode |

2744 | /// The matcher: |

2745 | /// \code |

2746 | /// cxxRecordDecl( |

2747 | /// optionally(has( |

2748 | /// fieldDecl(hasName("bar")).bind("var") |

2749 | /// ))).bind("record") |

2750 | /// \endcode |

2751 | /// will produce a result binding for both "record" and "var". |

2752 | /// The matcher will produce a "record" binding for even if there is no data |

2753 | /// member named "bar" in that class. |

2754 | /// |

2755 | /// Usable as: Any Matcher |

2756 | extern const internal::VariadicOperatorMatcherFunc<1, 1> optionally; |

2757 | |

2758 | /// Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL) |

2759 | /// |

2760 | /// Given |

2761 | /// \code |

2762 | /// Foo x = bar; |

2763 | /// int y = sizeof(x) + alignof(x); |

2764 | /// \endcode |

2765 | /// unaryExprOrTypeTraitExpr() |

2766 | /// matches \c sizeof(x) and \c alignof(x) |

2767 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |

2768 | UnaryExprOrTypeTraitExpr> |

2769 | unaryExprOrTypeTraitExpr; |

2770 | |

2771 | /// Matches any of the \p NodeMatchers with InnerMatchers nested within |

2772 | /// |

2773 | /// Given |

2774 | /// \code |

2775 | /// if (true); |

2776 | /// for (; true; ); |

2777 | /// \endcode |

2778 | /// with the matcher |

2779 | /// \code |

2780 | /// mapAnyOf(ifStmt, forStmt).with( |

2781 | /// hasCondition(cxxBoolLiteralExpr(equals(true))) |

2782 | /// ).bind("trueCond") |

2783 | /// \endcode |

2784 | /// matches the \c if and the \c for. It is equivalent to: |

2785 | /// \code |

2786 | /// auto trueCond = hasCondition(cxxBoolLiteralExpr(equals(true))); |

2787 | /// anyOf( |

2788 | /// ifStmt(trueCond).bind("trueCond"), |

2789 | /// forStmt(trueCond).bind("trueCond") |

2790 | /// ); |

2791 | /// \endcode |

2792 | /// |

2793 | /// The with() chain-call accepts zero or more matchers which are combined |

2794 | /// as-if with allOf() in each of the node matchers. |

2795 | /// Usable as: Any Matcher |

2796 | template <typename T, typename... U> |

2797 | auto mapAnyOf(internal::VariadicDynCastAllOfMatcher<T, U> const &...) { |

2798 | return internal::MapAnyOfHelper<U...>(); |

2799 | } |

2800 | |

2801 | /// Matches nodes which can be used with binary operators. |

2802 | /// |

2803 | /// The code |

2804 | /// \code |

2805 | /// var1 != var2; |

2806 | /// \endcode |

2807 | /// might be represented in the clang AST as a binaryOperator, a |

2808 | /// cxxOperatorCallExpr or a cxxRewrittenBinaryOperator, depending on |

2809 | /// |

2810 | /// * whether the types of var1 and var2 are fundamental (binaryOperator) or at |

2811 | /// least one is a class type (cxxOperatorCallExpr) |

2812 | /// * whether the code appears in a template declaration, if at least one of the |

2813 | /// vars is a dependent-type (binaryOperator) |

2814 | /// * whether the code relies on a rewritten binary operator, such as a |

2815 | /// spaceship operator or an inverted equality operator |

2816 | /// (cxxRewrittenBinaryOperator) |

2817 | /// |

2818 | /// This matcher elides details in places where the matchers for the nodes are |

2819 | /// compatible. |

2820 | /// |

2821 | /// Given |

2822 | /// \code |

2823 | /// binaryOperation( |

2824 | /// hasOperatorName("!="), |

2825 | /// hasLHS(expr().bind("lhs")), |

2826 | /// hasRHS(expr().bind("rhs")) |

2827 | /// ) |

2828 | /// \endcode |

2829 | /// matches each use of "!=" in: |

2830 | /// \code |

2831 | /// struct S{ |

2832 | /// bool operator!=(const S&) const; |

2833 | /// }; |

2834 | /// |

2835 | /// void foo() |

2836 | /// { |

2837 | /// 1 != 2; |

2838 | /// S() != S(); |

2839 | /// } |

2840 | /// |

2841 | /// template<typename T> |

2842 | /// void templ() |

2843 | /// { |

2844 | /// 1 != 2; |

2845 | /// T() != S(); |

2846 | /// } |

2847 | /// struct HasOpEq |

2848 | /// { |

2849 | /// bool operator==(const HasOpEq &) const; |

2850 | /// }; |

2851 | /// |

2852 | /// void inverse() |

2853 | /// { |

2854 | /// HasOpEq s1; |

2855 | /// HasOpEq s2; |

2856 | /// if (s1 != s2) |

2857 | /// return; |

2858 | /// } |

2859 | /// |

2860 | /// struct HasSpaceship |

2861 | /// { |

2862 | /// bool operator<=>(const HasOpEq &) const; |

2863 | /// }; |

2864 | /// |

2865 | /// void use_spaceship() |

2866 | /// { |

2867 | /// HasSpaceship s1; |

2868 | /// HasSpaceship s2; |

2869 | /// if (s1 != s2) |

2870 | /// return; |

2871 | /// } |

2872 | /// \endcode |

2873 | extern const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr, |

2874 | CXXRewrittenBinaryOperator> |

2875 | binaryOperation; |

2876 | |

2877 | /// Matches function calls and constructor calls |

2878 | /// |

2879 | /// Because CallExpr and CXXConstructExpr do not share a common |

2880 | /// base class with API accessing arguments etc, AST Matchers for code |

2881 | /// which should match both are typically duplicated. This matcher |

2882 | /// removes the need for duplication. |

2883 | /// |

2884 | /// Given code |

2885 | /// \code |

2886 | /// struct ConstructorTakesInt |

2887 | /// { |

2888 | /// ConstructorTakesInt(int i) {} |

2889 | /// }; |

2890 | /// |

2891 | /// void callTakesInt(int i) |

2892 | /// { |

2893 | /// } |

2894 | /// |

2895 | /// void doCall() |

2896 | /// { |

2897 | /// callTakesInt(42); |

2898 | /// } |

2899 | /// |

2900 | /// void doConstruct() |

2901 | /// { |

2902 | /// ConstructorTakesInt cti(42); |

2903 | /// } |

2904 | /// \endcode |

2905 | /// |

2906 | /// The matcher |

2907 | /// \code |

2908 | /// invocation(hasArgument(0, integerLiteral(equals(42)))) |

2909 | /// \endcode |

2910 | /// matches the expression in both doCall and doConstruct |

2911 | extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation; |

2912 | |

2913 | /// Matches unary expressions that have a specific type of argument. |

2914 | /// |

2915 | /// Given |

2916 | /// \code |

2917 | /// int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c); |

2918 | /// \endcode |

2919 | /// unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int")) |

2920 | /// matches \c sizeof(a) and \c alignof(c) |

2921 | AST_MATCHER_P(UnaryExprOrTypeTraitExpr, hasArgumentOfType, |

2922 | internal::Matcher<QualType>, InnerMatcher) { |

2923 | const QualType ArgumentType = Node.getTypeOfArgument(); |

2924 | return InnerMatcher.matches(ArgumentType, Finder, Builder); |

2925 | } |

2926 | |

2927 | /// Matches unary expressions of a certain kind. |

2928 | /// |

2929 | /// Given |

2930 | /// \code |

2931 | /// int x; |

2932 | /// int s = sizeof(x) + alignof(x) |

2933 | /// \endcode |

2934 | /// unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf)) |

2935 | /// matches \c sizeof(x) |

2936 | /// |

2937 | /// If the matcher is use from clang-query, UnaryExprOrTypeTrait parameter |

2938 | /// should be passed as a quoted string. e.g., ofKind("UETT_SizeOf"). |

2939 | AST_MATCHER_P(UnaryExprOrTypeTraitExpr, ofKind, UnaryExprOrTypeTrait, Kind) { |

2940 | return Node.getKind() == Kind; |

2941 | } |

2942 | |

2943 | /// Same as unaryExprOrTypeTraitExpr, but only matching |

2944 | /// alignof. |

2945 | inline internal::BindableMatcher<Stmt> alignOfExpr( |

2946 | const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) { |

2947 | return stmt(unaryExprOrTypeTraitExpr( |

2948 | allOf(anyOf(ofKind(UETT_AlignOf), ofKind(UETT_PreferredAlignOf)), |

2949 | InnerMatcher))); |

2950 | } |

2951 | |

2952 | /// Same as unaryExprOrTypeTraitExpr, but only matching |

2953 | /// sizeof. |

2954 | inline internal::BindableMatcher<Stmt> sizeOfExpr( |

2955 | const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) { |

2956 | return stmt(unaryExprOrTypeTraitExpr( |

2957 | allOf(ofKind(UETT_SizeOf), InnerMatcher))); |

2958 | } |

2959 | |

2960 | /// Matches NamedDecl nodes that have the specified name. |

2961 | /// |

2962 | /// Supports specifying enclosing namespaces or classes by prefixing the name |

2963 | /// with '<enclosing>::'. |

2964 | /// Does not match typedefs of an underlying type with the given name. |

2965 | /// |

2966 | /// Example matches X (Name == "X") |

2967 | /// \code |

2968 | /// class X; |

2969 | /// \endcode |

2970 | /// |

2971 | /// Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X") |

2972 | /// \code |

2973 | /// namespace a { namespace b { class X; } } |

2974 | /// \endcode |

2975 | inline internal::Matcher<NamedDecl> hasName(StringRef Name) { |

2976 | return internal::Matcher<NamedDecl>( |

2977 | new internal::HasNameMatcher({std::string(Name)})); |

2978 | } |

2979 | |

2980 | /// Matches NamedDecl nodes that have any of the specified names. |

2981 | /// |

2982 | /// This matcher is only provided as a performance optimization of hasName. |

2983 | /// \code |

2984 | /// hasAnyName(a, b, c) |

2985 | /// \endcode |

2986 | /// is equivalent to, but faster than |

2987 | /// \code |

2988 | /// anyOf(hasName(a), hasName(b), hasName(c)) |

2989 | /// \endcode |

2990 | extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef, |

2991 | internal::hasAnyNameFunc> |

2992 | hasAnyName; |

2993 | |

2994 | /// Matches NamedDecl nodes whose fully qualified names contain |

2995 | /// a substring matched by the given RegExp. |

2996 | /// |

2997 | /// Supports specifying enclosing namespaces or classes by |

2998 | /// prefixing the name with '<enclosing>::'. Does not match typedefs |

2999 | /// of an underlying type with the given name. |

3000 | /// |

3001 | /// Example matches X (regexp == "::X") |

3002 | /// \code |

3003 | /// class X; |

3004 | /// \endcode |

3005 | /// |

3006 | /// Example matches X (regexp is one of "::X", "^foo::.*X", among others) |

3007 | /// \code |

3008 | /// namespace foo { namespace bar { class X; } } |

3009 | /// \endcode |

3010 | AST_MATCHER_REGEX(NamedDecl, matchesName, RegExp) { |

3011 | std::string FullNameString = "::"+ Node.getQualifiedNameAsString(); |

3012 | return RegExp->match(FullNameString); |

3013 | } |

3014 | |

3015 | /// Matches overloaded operator names. |

3016 | /// |

3017 | /// Matches overloaded operator names specified in strings without the |

3018 | /// "operator" prefix: e.g. "<<". |

3019 | /// |

3020 | /// Given: |

3021 | /// \code |

3022 | /// class A { int operator*(); }; |

3023 | /// const A &operator<<(const A &a, const A &b); |

3024 | /// A a; |

3025 | /// a << a; // <-- This matches |

3026 | /// \endcode |

3027 | /// |

3028 | /// \c cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the |

3029 | /// specified line and |

3030 | /// \c cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*"))) |

3031 | /// matches the declaration of \c A. |

3032 | /// |

3033 | /// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl> |

3034 | inline internal::PolymorphicMatcher< |

3035 | internal::HasOverloadedOperatorNameMatcher, |

3036 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), |

3037 | std::vector<std::string>> |

3038 | hasOverloadedOperatorName(StringRef Name) { |

3039 | return internal::PolymorphicMatcher< |

3040 | internal::HasOverloadedOperatorNameMatcher, |

3041 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), |

3042 | std::vector<std::string>>({std::string(Name)}); |

3043 | } |

3044 | |

3045 | /// Matches overloaded operator names. |

3046 | /// |

3047 | /// Matches overloaded operator names specified in strings without the |

3048 | /// "operator" prefix: e.g. "<<". |

3049 | /// |

3050 | /// hasAnyOverloadedOperatorName("+", "-") |

3051 | /// Is equivalent to |

3052 | /// anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-")) |

3053 | extern const internal::VariadicFunction< |

3054 | internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher, |

3055 | AST_POLYMORPHIC_SUPPORTED_TYPES( |

3056 | CXXOperatorCallExpr, FunctionDecl), |

3057 | std::vector<std::string>>, |

3058 | StringRef, internal::hasAnyOverloadedOperatorNameFunc> |

3059 | hasAnyOverloadedOperatorName; |

3060 | |

3061 | /// Matches template-dependent, but known, member names. |

3062 | /// |

3063 | /// In template declarations, dependent members are not resolved and so can |

3064 | /// not be matched to particular named declarations. |

3065 | /// |

3066 | /// This matcher allows to match on the known name of members. |

3067 | /// |

3068 | /// Given |

3069 | /// \code |

3070 | /// template <typename T> |

3071 | /// struct S { |

3072 | /// void mem(); |

3073 | /// }; |

3074 | /// template <typename T> |

3075 | /// void x() { |

3076 | /// S<T> s; |

3077 | /// s.mem(); |

3078 | /// } |

3079 | /// \endcode |

3080 | /// \c cxxDependentScopeMemberExpr(hasMemberName("mem")) matches `s.mem()` |

3081 | AST_MATCHER_P(CXXDependentScopeMemberExpr, hasMemberName, std::string, N) { |

3082 | return Node.getMember().getAsString() == N; |

3083 | } |

3084 | |

3085 | /// Matches template-dependent, but known, member names against an already-bound |

3086 | /// node |

3087 | /// |

3088 | /// In template declarations, dependent members are not resolved and so can |

3089 | /// not be matched to particular named declarations. |

3090 | /// |

3091 | /// This matcher allows to match on the name of already-bound VarDecl, FieldDecl |

3092 | /// and CXXMethodDecl nodes. |

3093 | /// |

3094 | /// Given |

3095 | /// \code |

3096 | /// template <typename T> |

3097 | /// struct S { |

3098 | /// void mem(); |

3099 | /// }; |

3100 | /// template <typename T> |

3101 | /// void x() { |

3102 | /// S<T> s; |

3103 | /// s.mem(); |

3104 | /// } |

3105 | /// \endcode |

3106 | /// The matcher |

3107 | /// @code |

3108 | /// \c cxxDependentScopeMemberExpr( |

3109 | /// hasObjectExpression(declRefExpr(hasType(templateSpecializationType( |

3110 | /// hasDeclaration(classTemplateDecl(has(cxxRecordDecl(has( |

3111 | /// cxxMethodDecl(hasName("mem")).bind("templMem") |

3112 | /// ))))) |

3113 | /// )))), |

3114 | /// memberHasSameNameAsBoundNode("templMem") |

3115 | /// ) |

3116 | /// @endcode |

3117 | /// first matches and binds the @c mem member of the @c S template, then |

3118 | /// compares its name to the usage in @c s.mem() in the @c x function template |

3119 | AST_MATCHER_P(CXXDependentScopeMemberExpr, memberHasSameNameAsBoundNode, |

3120 | std::string, BindingID) { |

3121 | auto MemberName = Node.getMember().getAsString(); |

3122 | |

3123 | return Builder->removeBindings( |

3124 | [this, MemberName](const BoundNodesMap &Nodes) { |

3125 | const auto &BN = Nodes.getNode(this->BindingID); |

3126 | if (const auto *ND = BN.get<NamedDecl>()) { |

3127 | if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(ND)) |

3128 | return true; |

3129 | return ND->getName() != MemberName; |

3130 | } |

3131 | return true; |

3132 | }); |

3133 | } |

3134 | |

3135 | /// Matches C++ classes that are directly or indirectly derived from a class |

3136 | /// matching \c Base, or Objective-C classes that directly or indirectly |

3137 | /// subclass a class matching \c Base. |

3138 | /// |

3139 | /// Note that a class is not considered to be derived from itself. |

3140 | /// |

3141 | /// Example matches Y, Z, C (Base == hasName("X")) |

3142 | /// \code |

3143 | /// class X; |

3144 | /// class Y : public X {}; // directly derived |

3145 | /// class Z : public Y {}; // indirectly derived |

3146 | /// typedef X A; |

3147 | /// typedef A B; |

3148 | /// class C : public B {}; // derived from a typedef of X |

3149 | /// \endcode |

3150 | /// |

3151 | /// In the following example, Bar matches isDerivedFrom(hasName("X")): |

3152 | /// \code |

3153 | /// class Foo; |

3154 | /// typedef Foo X; |

3155 | /// class Bar : public Foo {}; // derived from a type that X is a typedef of |

3156 | /// \endcode |

3157 | /// |

3158 | /// In the following example, Bar matches isDerivedFrom(hasName("NSObject")) |

3159 | /// \code |

3160 | /// @interface NSObject @end |

3161 | /// @interface Bar : NSObject @end |

3162 | /// \endcode |

3163 | /// |

3164 | /// Usable as: Matcher<CXXRecordDecl>, Matcher<ObjCInterfaceDecl> |

3165 | AST_POLYMORPHIC_MATCHER_P( |

3166 | isDerivedFrom, |

3167 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl), |

3168 | internal::Matcher<NamedDecl>, Base) { |

3169 | // Check if the node is a C++ struct/union/class. |

3170 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |

3171 | return Finder->classIsDerivedFrom(RD, Base, Builder, /*Directly=*/false); |

3172 | |

3173 | // The node must be an Objective-C class. |

3174 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |

3175 | return Finder->objcClassIsDerivedFrom(InterfaceDecl, Base, Builder, |

3176 | /*Directly=*/false); |

3177 | } |

3178 | |

3179 | /// Overloaded method as shortcut for \c isDerivedFrom(hasName(...)). |

3180 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3181 | isDerivedFrom, |

3182 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl), |

3183 | std::string, BaseName, 1) { |

3184 | if (BaseName.empty()) |

3185 | return false; |

3186 | |

3187 | const auto M = isDerivedFrom(hasName(BaseName)); |

3188 | |

3189 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |

3190 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |

3191 | |

3192 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |

3193 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |

3194 | } |

3195 | |

3196 | /// Matches C++ classes that have a direct or indirect base matching \p |

3197 | /// BaseSpecMatcher. |

3198 | /// |

3199 | /// Example: |

3200 | /// matcher hasAnyBase(hasType(cxxRecordDecl(hasName("SpecialBase")))) |

3201 | /// \code |

3202 | /// class Foo; |

3203 | /// class Bar : Foo {}; |

3204 | /// class Baz : Bar {}; |

3205 | /// class SpecialBase; |

3206 | /// class Proxy : SpecialBase {}; // matches Proxy |

3207 | /// class IndirectlyDerived : Proxy {}; //matches IndirectlyDerived |

3208 | /// \endcode |

3209 | /// |

3210 | // FIXME: Refactor this and isDerivedFrom to reuse implementation. |

3211 | AST_MATCHER_P(CXXRecordDecl, hasAnyBase, internal::Matcher<CXXBaseSpecifier>, |

3212 | BaseSpecMatcher) { |

3213 | return internal::matchesAnyBase(Node, BaseSpecMatcher, Finder, Builder); |

3214 | } |

3215 | |

3216 | /// Matches C++ classes that have a direct base matching \p BaseSpecMatcher. |

3217 | /// |

3218 | /// Example: |

3219 | /// matcher hasDirectBase(hasType(cxxRecordDecl(hasName("SpecialBase")))) |

3220 | /// \code |

3221 | /// class Foo; |

3222 | /// class Bar : Foo {}; |

3223 | /// class Baz : Bar {}; |

3224 | /// class SpecialBase; |

3225 | /// class Proxy : SpecialBase {}; // matches Proxy |

3226 | /// class IndirectlyDerived : Proxy {}; // doesn't match |

3227 | /// \endcode |

3228 | AST_MATCHER_P(CXXRecordDecl, hasDirectBase, internal::Matcher<CXXBaseSpecifier>, |

3229 | BaseSpecMatcher) { |

3230 | return Node.hasDefinition() && |

3231 | llvm::any_of(Node.bases(), [&](const CXXBaseSpecifier &Base) { |

3232 | return BaseSpecMatcher.matches(Base, Finder, Builder); |

3233 | }); |

3234 | } |

3235 | |

3236 | /// Similar to \c isDerivedFrom(), but also matches classes that directly |

3237 | /// match \c Base. |

3238 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3239 | isSameOrDerivedFrom, |

3240 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl), |

3241 | internal::Matcher<NamedDecl>, Base, 0) { |

3242 | const auto M = anyOf(Base, isDerivedFrom(Base)); |

3243 | |

3244 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |

3245 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |

3246 | |

3247 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |

3248 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |

3249 | } |

3250 | |

3251 | /// Overloaded method as shortcut for |

3252 | /// \c isSameOrDerivedFrom(hasName(...)). |

3253 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3254 | isSameOrDerivedFrom, |

3255 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl), |

3256 | std::string, BaseName, 1) { |

3257 | if (BaseName.empty()) |

3258 | return false; |

3259 | |

3260 | const auto M = isSameOrDerivedFrom(hasName(BaseName)); |

3261 | |

3262 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |

3263 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |

3264 | |

3265 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |

3266 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |

3267 | } |

3268 | |

3269 | /// Matches C++ or Objective-C classes that are directly derived from a class |

3270 | /// matching \c Base. |

3271 | /// |

3272 | /// Note that a class is not considered to be derived from itself. |

3273 | /// |

3274 | /// Example matches Y, C (Base == hasName("X")) |

3275 | /// \code |

3276 | /// class X; |

3277 | /// class Y : public X {}; // directly derived |

3278 | /// class Z : public Y {}; // indirectly derived |

3279 | /// typedef X A; |

3280 | /// typedef A B; |

3281 | /// class C : public B {}; // derived from a typedef of X |

3282 | /// \endcode |

3283 | /// |

3284 | /// In the following example, Bar matches isDerivedFrom(hasName("X")): |

3285 | /// \code |

3286 | /// class Foo; |

3287 | /// typedef Foo X; |

3288 | /// class Bar : public Foo {}; // derived from a type that X is a typedef of |

3289 | /// \endcode |

3290 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3291 | isDirectlyDerivedFrom, |

3292 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl), |

3293 | internal::Matcher<NamedDecl>, Base, 0) { |

3294 | // Check if the node is a C++ struct/union/class. |

3295 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |

3296 | return Finder->classIsDerivedFrom(RD, Base, Builder, /*Directly=*/true); |

3297 | |

3298 | // The node must be an Objective-C class. |

3299 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |

3300 | return Finder->objcClassIsDerivedFrom(InterfaceDecl, Base, Builder, |

3301 | /*Directly=*/true); |

3302 | } |

3303 | |

3304 | /// Overloaded method as shortcut for \c isDirectlyDerivedFrom(hasName(...)). |

3305 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3306 | isDirectlyDerivedFrom, |

3307 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl), |

3308 | std::string, BaseName, 1) { |

3309 | if (BaseName.empty()) |

3310 | return false; |

3311 | const auto M = isDirectlyDerivedFrom(hasName(BaseName)); |

3312 | |

3313 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |

3314 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |

3315 | |

3316 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |

3317 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |

3318 | } |

3319 | /// Matches the first method of a class or struct that satisfies \c |

3320 | /// InnerMatcher. |

3321 | /// |

3322 | /// Given: |

3323 | /// \code |

3324 | /// class A { void func(); }; |

3325 | /// class B { void member(); }; |

3326 | /// \endcode |

3327 | /// |

3328 | /// \c cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of |

3329 | /// \c A but not \c B. |

3330 | AST_MATCHER_P(CXXRecordDecl, hasMethod, internal::Matcher<CXXMethodDecl>, |

3331 | InnerMatcher) { |

3332 | BoundNodesTreeBuilder Result(*Builder); |

3333 | auto MatchIt = matchesFirstInPointerRange(InnerMatcher, Node.method_begin(), |

3334 | Node.method_end(), Finder, &Result); |

3335 | if (MatchIt == Node.method_end()) |

3336 | return false; |

3337 | |

3338 | if (Finder->isTraversalIgnoringImplicitNodes() && (*MatchIt)->isImplicit()) |

3339 | return false; |

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

3341 | return true; |

3342 | } |

3343 | |

3344 | /// Matches the generated class of lambda expressions. |

3345 | /// |

3346 | /// Given: |

3347 | /// \code |

3348 | /// auto x = []{}; |

3349 | /// \endcode |

3350 | /// |

3351 | /// \c cxxRecordDecl(isLambda()) matches the implicit class declaration of |

3352 | /// \c decltype(x) |

3353 | AST_MATCHER(CXXRecordDecl, isLambda) { |

3354 | return Node.isLambda(); |

3355 | } |

3356 | |

3357 | /// Matches AST nodes that have child AST nodes that match the |

3358 | /// provided matcher. |

3359 | /// |

3360 | /// Example matches X, Y |

3361 | /// (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X"))) |

3362 | /// \code |

3363 | /// class X {}; // Matches X, because X::X is a class of name X inside X. |

3364 | /// class Y { class X {}; }; |

3365 | /// class Z { class Y { class X {}; }; }; // Does not match Z. |

3366 | /// \endcode |

3367 | /// |

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

3369 | /// |

3370 | /// Usable as: Any Matcher |

3371 | /// Note that has is direct matcher, so it also matches things like implicit |

3372 | /// casts and paren casts. If you are matching with expr then you should |

3373 | /// probably consider using ignoringParenImpCasts like: |

3374 | /// has(ignoringParenImpCasts(expr())). |

3375 | extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has; |

3376 | |

3377 | /// Matches AST nodes that have descendant AST nodes that match the |

3378 | /// provided matcher. |

3379 | /// |

3380 | /// Example matches X, Y, Z |

3381 | /// (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X"))))) |

3382 | /// \code |

3383 | /// class X {}; // Matches X, because X::X is a class of name X inside X. |

3384 | /// class Y { class X {}; }; |

3385 | /// class Z { class Y { class X {}; }; }; |

3386 | /// \endcode |

3387 | /// |

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

3389 | /// |

3390 | /// Usable as: Any Matcher |

3391 | extern const internal::ArgumentAdaptingMatcherFunc< |

3392 | internal::HasDescendantMatcher> |

3393 | hasDescendant; |

3394 | |

3395 | /// Matches AST nodes that have child AST nodes that match the |

3396 | /// provided matcher. |

3397 | /// |

3398 | /// Example matches X, Y, Y::X, Z::Y, Z::Y::X |

3399 | /// (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X"))) |

3400 | /// \code |

3401 | /// class X {}; |

3402 | /// class Y { class X {}; }; // Matches Y, because Y::X is a class of name X |

3403 | /// // inside Y. |

3404 | /// class Z { class Y { class X {}; }; }; // Does not match Z. |

3405 | /// \endcode |

3406 | /// |

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

3408 | /// |

3409 | /// As opposed to 'has', 'forEach' will cause a match for each result that |

3410 | /// matches instead of only on the first one. |

3411 | /// |

3412 | /// Usable as: Any Matcher |

3413 | extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> |

3414 | forEach; |

3415 | |

3416 | /// Matches AST nodes that have descendant AST nodes that match the |

3417 | /// provided matcher. |

3418 | /// |

3419 | /// Example matches X, A, A::X, B, B::C, B::C::X |

3420 | /// (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X"))))) |

3421 | /// \code |

3422 | /// class X {}; |

3423 | /// class A { class X {}; }; // Matches A, because A::X is a class of name |

3424 | /// // X inside A. |

3425 | /// class B { class C { class X {}; }; }; |

3426 | /// \endcode |

3427 | /// |

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

3429 | /// |

3430 | /// As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for |

3431 | /// each result that matches instead of only on the first one. |

3432 | /// |

3433 | /// Note: Recursively combined ForEachDescendant can cause many matches: |

3434 | /// cxxRecordDecl(forEachDescendant(cxxRecordDecl( |

3435 | /// forEachDescendant(cxxRecordDecl()) |

3436 | /// ))) |

3437 | /// will match 10 times (plus injected class name matches) on: |

3438 | /// \code |

3439 | /// class A { class B { class C { class D { class E {}; }; }; }; }; |

3440 | /// \endcode |

3441 | /// |

3442 | /// Usable as: Any Matcher |

3443 | extern const internal::ArgumentAdaptingMatcherFunc< |

3444 | internal::ForEachDescendantMatcher> |

3445 | forEachDescendant; |

3446 | |

3447 | /// Matches if the node or any descendant matches. |

3448 | /// |

3449 | /// Generates results for each match. |

3450 | /// |

3451 | /// For example, in: |

3452 | /// \code |

3453 | /// class A { class B {}; class C {}; }; |

3454 | /// \endcode |

3455 | /// The matcher: |

3456 | /// \code |

3457 | /// cxxRecordDecl(hasName("::A"), |

3458 | /// findAll(cxxRecordDecl(isDefinition()).bind("m"))) |

3459 | /// \endcode |

3460 | /// will generate results for \c A, \c B and \c C. |

3461 | /// |

3462 | /// Usable as: Any Matcher |

3463 | template <typename T> |

3464 | internal::Matcher<T> findAll(const internal::Matcher<T> &Matcher) { |

3465 | return eachOf(Matcher, forEachDescendant(Matcher)); |

3466 | } |

3467 | |

3468 | /// Matches AST nodes that have a parent that matches the provided |

3469 | /// matcher. |

3470 | /// |

3471 | /// Given |

3472 | /// \code |

3473 | /// void f() { for (;;) { int x = 42; if (true) { int x = 43; } } } |

3474 | /// \endcode |

3475 | /// \c compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }". |

3476 | /// |

3477 | /// Usable as: Any Matcher |

3478 | extern const internal::ArgumentAdaptingMatcherFunc< |

3479 | internal::HasParentMatcher, |

3480 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>, |

3481 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>> |

3482 | hasParent; |

3483 | |

3484 | /// Matches AST nodes that have an ancestor that matches the provided |

3485 | /// matcher. |

3486 | /// |

3487 | /// Given |

3488 | /// \code |

3489 | /// void f() { if (true) { int x = 42; } } |

3490 | /// void g() { for (;;) { int x = 43; } } |

3491 | /// \endcode |

3492 | /// \c expr(integerLiteral(hasAncestor(ifStmt()))) matches \c 42, but not 43. |

3493 | /// |

3494 | /// Usable as: Any Matcher |

3495 | extern const internal::ArgumentAdaptingMatcherFunc< |

3496 | internal::HasAncestorMatcher, |

3497 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>, |

3498 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>> |

3499 | hasAncestor; |

3500 | |

3501 | /// Matches if the provided matcher does not match. |

3502 | /// |

3503 | /// Example matches Y (matcher = cxxRecordDecl(unless(hasName("X")))) |

3504 | /// \code |

3505 | /// class X {}; |

3506 | /// class Y {}; |

3507 | /// \endcode |

3508 | /// |

3509 | /// Usable as: Any Matcher |

3510 | extern const internal::VariadicOperatorMatcherFunc<1, 1> unless; |

3511 | |

3512 | /// Matches a node if the declaration associated with that node |

3513 | /// matches the given matcher. |

3514 | /// |

3515 | /// The associated declaration is: |

3516 | /// - for type nodes, the declaration of the underlying type |

3517 | /// - for CallExpr, the declaration of the callee |

3518 | /// - for MemberExpr, the declaration of the referenced member |

3519 | /// - for CXXConstructExpr, the declaration of the constructor |

3520 | /// - for CXXNewExpr, the declaration of the operator new |

3521 | /// - for ObjCIvarExpr, the declaration of the ivar |

3522 | /// |

3523 | /// For type nodes, hasDeclaration will generally match the declaration of the |

3524 | /// sugared type. Given |

3525 | /// \code |

3526 | /// class X {}; |

3527 | /// typedef X Y; |

3528 | /// Y y; |

3529 | /// \endcode |

3530 | /// in varDecl(hasType(hasDeclaration(decl()))) the decl will match the |

3531 | /// typedefDecl. A common use case is to match the underlying, desugared type. |

3532 | /// This can be achieved by using the hasUnqualifiedDesugaredType matcher: |

3533 | /// \code |

3534 | /// varDecl(hasType(hasUnqualifiedDesugaredType( |

3535 | /// recordType(hasDeclaration(decl()))))) |

3536 | /// \endcode |

3537 | /// In this matcher, the decl will match the CXXRecordDecl of class X. |

3538 | /// |

3539 | /// Usable as: Matcher<AddrLabelExpr>, Matcher<CallExpr>, |

3540 | /// Matcher<CXXConstructExpr>, Matcher<CXXNewExpr>, Matcher<DeclRefExpr>, |

3541 | /// Matcher<EnumType>, Matcher<InjectedClassNameType>, Matcher<LabelStmt>, |

3542 | /// Matcher<MemberExpr>, Matcher<QualType>, Matcher<RecordType>, |

3543 | /// Matcher<TagType>, Matcher<TemplateSpecializationType>, |

3544 | /// Matcher<TemplateTypeParmType>, Matcher<TypedefType>, |

3545 | /// Matcher<UnresolvedUsingType> |

3546 | inline internal::PolymorphicMatcher< |

3547 | internal::HasDeclarationMatcher, |

3548 | void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>> |

3549 | hasDeclaration(const internal::Matcher<Decl> &InnerMatcher) { |

3550 | return internal::PolymorphicMatcher< |

3551 | internal::HasDeclarationMatcher, |

3552 | void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>( |

3553 | InnerMatcher); |

3554 | } |

3555 | |

3556 | /// Matches a \c NamedDecl whose underlying declaration matches the given |

3557 | /// matcher. |

3558 | /// |

3559 | /// Given |

3560 | /// \code |

3561 | /// namespace N { template<class T> void f(T t); } |

3562 | /// template <class T> void g() { using N::f; f(T()); } |

3563 | /// \endcode |

3564 | /// \c unresolvedLookupExpr(hasAnyDeclaration( |

3565 | /// namedDecl(hasUnderlyingDecl(hasName("::N::f"))))) |

3566 | /// matches the use of \c f in \c g() . |

3567 | AST_MATCHER_P(NamedDecl, hasUnderlyingDecl, internal::Matcher<NamedDecl>, |

3568 | InnerMatcher) { |

3569 | const NamedDecl *UnderlyingDecl = Node.getUnderlyingDecl(); |

3570 | |

3571 | return UnderlyingDecl != nullptr && |

3572 | InnerMatcher.matches(*UnderlyingDecl, Finder, Builder); |

3573 | } |

3574 | |

3575 | /// Matches on the implicit object argument of a member call expression, after |

3576 | /// stripping off any parentheses or implicit casts. |

3577 | /// |

3578 | /// Given |

3579 | /// \code |

3580 | /// class Y { public: void m(); }; |

3581 | /// Y g(); |

3582 | /// class X : public Y {}; |

3583 | /// void z(Y y, X x) { y.m(); (g()).m(); x.m(); } |

3584 | /// \endcode |

3585 | /// cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y"))))) |

3586 | /// matches `y.m()` and `(g()).m()`. |

3587 | /// cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("X"))))) |

3588 | /// matches `x.m()`. |

3589 | /// cxxMemberCallExpr(on(callExpr())) |

3590 | /// matches `(g()).m()`. |

3591 | /// |

3592 | /// FIXME: Overload to allow directly matching types? |

3593 | AST_MATCHER_P(CXXMemberCallExpr, on, internal::Matcher<Expr>, |

3594 | InnerMatcher) { |

3595 | const Expr *ExprNode = Node.getImplicitObjectArgument() |

3596 | ->IgnoreParenImpCasts(); |

3597 | return (ExprNode != nullptr && |

3598 | InnerMatcher.matches(*ExprNode, Finder, Builder)); |

3599 | } |

3600 | |

3601 | |

3602 | /// Matches on the receiver of an ObjectiveC Message expression. |

3603 | /// |

3604 | /// Example |

3605 | /// matcher = objCMessageExpr(hasReceiverType(asString("UIWebView *"))); |

3606 | /// matches the [webView ...] message invocation. |

3607 | /// \code |

3608 | /// NSString *webViewJavaScript = ... |

3609 | /// UIWebView *webView = ... |

3610 | /// [webView stringByEvaluatingJavaScriptFromString:webViewJavascript]; |

3611 | /// \endcode |

3612 | AST_MATCHER_P(ObjCMessageExpr, hasReceiverType, internal::Matcher<QualType>, |

3613 | InnerMatcher) { |

3614 | const QualType TypeDecl = Node.getReceiverType(); |

3615 | return InnerMatcher.matches(TypeDecl, Finder, Builder); |

3616 | } |

3617 | |

3618 | /// Returns true when the Objective-C method declaration is a class method. |

3619 | /// |

3620 | /// Example |

3621 | /// matcher = objcMethodDecl(isClassMethod()) |

3622 | /// matches |

3623 | /// \code |

3624 | /// @interface I + (void)foo; @end |

3625 | /// \endcode |

3626 | /// but not |

3627 | /// \code |

3628 | /// @interface I - (void)bar; @end |

3629 | /// \endcode |

3630 | AST_MATCHER(ObjCMethodDecl, isClassMethod) { |

3631 | return Node.isClassMethod(); |

3632 | } |

3633 | |

3634 | /// Returns true when the Objective-C method declaration is an instance method. |

3635 | /// |

3636 | /// Example |

3637 | /// matcher = objcMethodDecl(isInstanceMethod()) |

3638 | /// matches |

3639 | /// \code |

3640 | /// @interface I - (void)bar; @end |

3641 | /// \endcode |

3642 | /// but not |

3643 | /// \code |

3644 | /// @interface I + (void)foo; @end |

3645 | /// \endcode |

3646 | AST_MATCHER(ObjCMethodDecl, isInstanceMethod) { |

3647 | return Node.isInstanceMethod(); |

3648 | } |

3649 | |

3650 | /// Returns true when the Objective-C message is sent to a class. |

3651 | /// |

3652 | /// Example |

3653 | /// matcher = objcMessageExpr(isClassMessage()) |

3654 | /// matches |

3655 | /// \code |

3656 | /// [NSString stringWithFormat:@"format"]; |

3657 | /// \endcode |

3658 | /// but not |

3659 | /// \code |

3660 | /// NSString *x = @"hello"; |

3661 | /// [x containsString:@"h"]; |

3662 | /// \endcode |

3663 | AST_MATCHER(ObjCMessageExpr, isClassMessage) { |

3664 | return Node.isClassMessage(); |

3665 | } |

3666 | |

3667 | /// Returns true when the Objective-C message is sent to an instance. |

3668 | /// |

3669 | /// Example |

3670 | /// matcher = objcMessageExpr(isInstanceMessage()) |

3671 | /// matches |

3672 | /// \code |

3673 | /// NSString *x = @"hello"; |

3674 | /// [x containsString:@"h"]; |

3675 | /// \endcode |

3676 | /// but not |

3677 | /// \code |

3678 | /// [NSString stringWithFormat:@"format"]; |

3679 | /// \endcode |

3680 | AST_MATCHER(ObjCMessageExpr, isInstanceMessage) { |

3681 | return Node.isInstanceMessage(); |

3682 | } |

3683 | |

3684 | /// Matches if the Objective-C message is sent to an instance, |

3685 | /// and the inner matcher matches on that instance. |

3686 | /// |

3687 | /// For example the method call in |

3688 | /// \code |

3689 | /// NSString *x = @"hello"; |

3690 | /// [x containsString:@"h"]; |

3691 | /// \endcode |

3692 | /// is matched by |

3693 | /// objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x")))))) |

3694 | AST_MATCHER_P(ObjCMessageExpr, hasReceiver, internal::Matcher<Expr>, |

3695 | InnerMatcher) { |

3696 | const Expr *ReceiverNode = Node.getInstanceReceiver(); |

3697 | return (ReceiverNode != nullptr && |

3698 | InnerMatcher.matches(*ReceiverNode->IgnoreParenImpCasts(), Finder, |

3699 | Builder)); |

3700 | } |

3701 | |

3702 | /// Matches when BaseName == Selector.getAsString() |

3703 | /// |

3704 | /// matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:")); |

3705 | /// matches the outer message expr in the code below, but NOT the message |

3706 | /// invocation for self.bodyView. |

3707 | /// \code |

3708 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |

3709 | /// \endcode |

3710 | AST_MATCHER_P(ObjCMessageExpr, hasSelector, std::string, BaseName) { |

3711 | Selector Sel = Node.getSelector(); |

3712 | return BaseName.compare(Sel.getAsString()) == 0; |

3713 | } |

3714 | |

3715 | |

3716 | /// Matches when at least one of the supplied string equals to the |

3717 | /// Selector.getAsString() |

3718 | /// |

3719 | /// matcher = objCMessageExpr(hasSelector("methodA:", "methodB:")); |

3720 | /// matches both of the expressions below: |

3721 | /// \code |

3722 | /// [myObj methodA:argA]; |

3723 | /// [myObj methodB:argB]; |

3724 | /// \endcode |

3725 | extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>, |

3726 | StringRef, |

3727 | internal::hasAnySelectorFunc> |

3728 | hasAnySelector; |

3729 | |

3730 | /// Matches ObjC selectors whose name contains |

3731 | /// a substring matched by the given RegExp. |

3732 | /// matcher = objCMessageExpr(matchesSelector("loadHTMLString\:baseURL?")); |

3733 | /// matches the outer message expr in the code below, but NOT the message |

3734 | /// invocation for self.bodyView. |

3735 | /// \code |

3736 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |

3737 | /// \endcode |

3738 | AST_MATCHER_REGEX(ObjCMessageExpr, matchesSelector, RegExp) { |

3739 | std::string SelectorString = Node.getSelector().getAsString(); |

3740 | return RegExp->match(SelectorString); |

3741 | } |

3742 | |

3743 | /// Matches when the selector is the empty selector |

3744 | /// |

3745 | /// Matches only when the selector of the objCMessageExpr is NULL. This may |

3746 | /// represent an error condition in the tree! |

3747 | AST_MATCHER(ObjCMessageExpr, hasNullSelector) { |

3748 | return Node.getSelector().isNull(); |

3749 | } |

3750 | |

3751 | /// Matches when the selector is a Unary Selector |

3752 | /// |

3753 | /// matcher = objCMessageExpr(matchesSelector(hasUnarySelector()); |

3754 | /// matches self.bodyView in the code below, but NOT the outer message |

3755 | /// invocation of "loadHTMLString:baseURL:". |

3756 | /// \code |

3757 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |

3758 | /// \endcode |

3759 | AST_MATCHER(ObjCMessageExpr, hasUnarySelector) { |

3760 | return Node.getSelector().isUnarySelector(); |

3761 | } |

3762 | |

3763 | /// Matches when the selector is a keyword selector |

3764 | /// |

3765 | /// objCMessageExpr(hasKeywordSelector()) matches the generated setFrame |

3766 | /// message expression in |

3767 | /// |

3768 | /// \code |

3769 | /// UIWebView *webView = ...; |

3770 | /// CGRect bodyFrame = webView.frame; |

3771 | /// bodyFrame.size.height = self.bodyContentHeight; |

3772 | /// webView.frame = bodyFrame; |

3773 | /// // ^---- matches here |

3774 | /// \endcode |

3775 | AST_MATCHER(ObjCMessageExpr, hasKeywordSelector) { |

3776 | return Node.getSelector().isKeywordSelector(); |

3777 | } |

3778 | |

3779 | /// Matches when the selector has the specified number of arguments |

3780 | /// |

3781 | /// matcher = objCMessageExpr(numSelectorArgs(0)); |

3782 | /// matches self.bodyView in the code below |

3783 | /// |

3784 | /// matcher = objCMessageExpr(numSelectorArgs(2)); |

3785 | /// matches the invocation of "loadHTMLString:baseURL:" but not that |

3786 | /// of self.bodyView |

3787 | /// \code |

3788 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |

3789 | /// \endcode |

3790 | AST_MATCHER_P(ObjCMessageExpr, numSelectorArgs, unsigned, N) { |

3791 | return Node.getSelector().getNumArgs() == N; |

3792 | } |

3793 | |

3794 | /// Matches if the call expression's callee expression matches. |

3795 | /// |

3796 | /// Given |

3797 | /// \code |

3798 | /// class Y { void x() { this->x(); x(); Y y; y.x(); } }; |

3799 | /// void f() { f(); } |

3800 | /// \endcode |

3801 | /// callExpr(callee(expr())) |

3802 | /// matches this->x(), x(), y.x(), f() |

3803 | /// with callee(...) |

3804 | /// matching this->x, x, y.x, f respectively |

3805 | /// |

3806 | /// Note: Callee cannot take the more general internal::Matcher<Expr> |

3807 | /// because this introduces ambiguous overloads with calls to Callee taking a |

3808 | /// internal::Matcher<Decl>, as the matcher hierarchy is purely |

3809 | /// implemented in terms of implicit casts. |

3810 | AST_MATCHER_P(CallExpr, callee, internal::Matcher<Stmt>, |

3811 | InnerMatcher) { |

3812 | const Expr *ExprNode = Node.getCallee(); |

3813 | return (ExprNode != nullptr && |

3814 | InnerMatcher.matches(*ExprNode, Finder, Builder)); |

3815 | } |

3816 | |

3817 | /// Matches if the call expression's callee's declaration matches the |

3818 | /// given matcher. |

3819 | /// |

3820 | /// Example matches y.x() (matcher = callExpr(callee( |

3821 | /// cxxMethodDecl(hasName("x"))))) |

3822 | /// \code |

3823 | /// class Y { public: void x(); }; |

3824 | /// void z() { Y y; y.x(); } |

3825 | /// \endcode |

3826 | AST_MATCHER_P_OVERLOAD(CallExpr, callee, internal::Matcher<Decl>, InnerMatcher, |

3827 | 1) { |

3828 | return callExpr(hasDeclaration(InnerMatcher)).matches(Node, Finder, Builder); |

3829 | } |

3830 | |

3831 | /// Matches if the expression's or declaration's type matches a type |

3832 | /// matcher. |

3833 | /// |

3834 | /// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X"))))) |

3835 | /// and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X"))))) |

3836 | /// and U (matcher = typedefDecl(hasType(asString("int"))) |

3837 | /// and friend class X (matcher = friendDecl(hasType("X")) |

3838 | /// and public virtual X (matcher = cxxBaseSpecifier(hasType( |

3839 | /// asString("class X"))) |

3840 | /// \code |

3841 | /// class X {}; |

3842 | /// void y(X &x) { x; X z; } |

3843 | /// typedef int U; |

3844 | /// class Y { friend class X; }; |

3845 | /// class Z : public virtual X {}; |

3846 | /// \endcode |

3847 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3848 | hasType, |

3849 | AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, FriendDecl, TypedefNameDecl, |

3850 | ValueDecl, CXXBaseSpecifier), |

3851 | internal::Matcher<QualType>, InnerMatcher, 0) { |

3852 | QualType QT = internal::getUnderlyingType(Node); |

3853 | if (!QT.isNull()) |

3854 | return InnerMatcher.matches(QT, Finder, Builder); |

3855 | return false; |

3856 | } |

3857 | |

3858 | /// Overloaded to match the declaration of the expression's or value |

3859 | /// declaration's type. |

3860 | /// |

3861 | /// In case of a value declaration (for example a variable declaration), |

3862 | /// this resolves one layer of indirection. For example, in the value |

3863 | /// declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of |

3864 | /// X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the |

3865 | /// declaration of x. |

3866 | /// |

3867 | /// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X"))))) |

3868 | /// and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X"))))) |

3869 | /// and friend class X (matcher = friendDecl(hasType("X")) |

3870 | /// and public virtual X (matcher = cxxBaseSpecifier(hasType( |

3871 | /// cxxRecordDecl(hasName("X")))) |

3872 | /// \code |

3873 | /// class X {}; |

3874 | /// void y(X &x) { x; X z; } |

3875 | /// class Y { friend class X; }; |

3876 | /// class Z : public virtual X {}; |

3877 | /// \endcode |

3878 | /// |

3879 | /// Example matches class Derived |

3880 | /// (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base")))))) |

3881 | /// \code |

3882 | /// class Base {}; |

3883 | /// class Derived : Base {}; |

3884 | /// \endcode |

3885 | /// |

3886 | /// Usable as: Matcher<Expr>, Matcher<FriendDecl>, Matcher<ValueDecl>, |

3887 | /// Matcher<CXXBaseSpecifier> |

3888 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD( |

3889 | hasType, |

3890 | AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, FriendDecl, ValueDecl, |

3891 | CXXBaseSpecifier), |

3892 | internal::Matcher<Decl>, InnerMatcher, 1) { |

3893 | QualType QT = internal::getUnderlyingType(Node); |

3894 | if (!QT.isNull()) |

3895 | return qualType(hasDeclaration(InnerMatcher)).matches(QT, Finder, Builder); |

3896 | return false; |

3897 | } |

3898 | |

3899 | /// Matches if the type location of the declarator decl's type matches |

3900 | /// the inner matcher. |

3901 | /// |

3902 | /// Given |

3903 | /// \code |

3904 | /// int x; |

3905 | /// \endcode |

3906 | /// declaratorDecl(hasTypeLoc(loc(asString("int")))) |

3907 | /// matches int x |

3908 | AST_MATCHER_P(DeclaratorDecl, hasTypeLoc, internal::Matcher<TypeLoc>, Inner) { |

3909 | if (!Node.getTypeSourceInfo()) |

3910 | // This happens for example for implicit destructors. |

3911 | return false; |

3912 | return Inner.matches(Node.getTypeSourceInfo()->getTypeLoc(), Finder, Builder); |

3913 | } |

3914 | |

3915 | /// Matches if the matched type is represented by the given string. |

3916 | /// |

3917 | /// Given |

3918 | /// \code |

3919 | /// class Y { public: void x(); }; |

3920 | /// void z() { Y* y; y->x(); } |

3921 | /// \endcode |

3922 | /// cxxMemberCallExpr(on(hasType(asString("class Y *")))) |

3923 | /// matches y->x() |

3924 | AST_MATCHER_P(QualType, asString, std::string, Name) { |

3925 | return Name == Node.getAsString(); |

3926 | } |

3927 | |

3928 | /// Matches if the matched type is a pointer type and the pointee type |

3929 | /// matches the specified matcher. |

3930 | /// |

3931 | /// Example matches y->x() |

3932 | /// (matcher = cxxMemberCallExpr(on(hasType(pointsTo |

3933 | /// cxxRecordDecl(hasName("Y"))))))) |

3934 | /// \code |

3935 | /// class Y { public: void x(); }; |

3936 | /// void z() { Y *y; y->x(); } |

3937 | /// \endcode |

3938 | AST_MATCHER_P( |

3939 | QualType, pointsTo, internal::Matcher<QualType>, |

3940 | InnerMatcher) { |

3941 | return (!Node.isNull() && Node->isAnyPointerType() && |

3942 | InnerMatcher.matches(Node->getPointeeType(), Finder, Builder)); |

3943 | } |

3944 | |

3945 | /// Overloaded to match the pointee type's declaration. |

3946 | AST_MATCHER_P_OVERLOAD(QualType, pointsTo, internal::Matcher<Decl>, |

3947 | InnerMatcher, 1) { |

3948 | return pointsTo(qualType(hasDeclaration(InnerMatcher))) |

3949 | .matches(Node, Finder, Builder); |

3950 | } |

3951 | |

3952 | /// Matches if the matched type matches the unqualified desugared |

3953 | /// type of the matched node. |

3954 | /// |

3955 | /// For example, in: |

3956 | /// \code |

3957 | /// class A {}; |

3958 | /// using B = A; |

3959 | /// \endcode |

3960 | /// The matcher type(hasUnqualifiedDesugaredType(recordType())) matches |

3961 | /// both B and A. |

3962 | AST_MATCHER_P(Type, hasUnqualifiedDesugaredType, internal::Matcher<Type>, |

3963 | InnerMatcher) { |

3964 | return InnerMatcher.matches(*Node.getUnqualifiedDesugaredType(), Finder, |

3965 | Builder); |

3966 | } |

3967 | |

3968 | /// Matches if the matched type is a reference type and the referenced |

3969 | /// type matches the specified matcher. |

3970 | /// |

3971 | /// Example matches X &x and const X &y |

3972 | /// (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X")))))) |

3973 | /// \code |

3974 | /// class X { |

3975 | /// void a(X b) { |

3976 | /// X &x = b; |

3977 | /// const X &y = b; |

3978 | /// } |

3979 | /// }; |

3980 | /// \endcode |

3981 | AST_MATCHER_P(QualType, references, internal::Matcher<QualType>, |

3982 | InnerMatcher) { |

3983 | return (!Node.isNull() && Node->isReferenceType() && |

3984 | InnerMatcher.matches(Node->getPointeeType(), Finder, Builder)); |

3985 | } |

3986 | |

3987 | /// Matches QualTypes whose canonical type matches InnerMatcher. |

3988 | /// |

3989 | /// Given: |

3990 | /// \code |

3991 | /// typedef int &int_ref; |

3992 | /// int a; |

3993 | /// int_ref b = a; |

3994 | /// \endcode |

3995 | /// |

3996 | /// \c varDecl(hasType(qualType(referenceType()))))) will not match the |

3997 | /// declaration of b but \c |

3998 | /// varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does. |

3999 | AST_MATCHER_P(QualType, hasCanonicalType, internal::Matcher<QualType>, |

4000 | InnerMatcher) { |

4001 | if (Node.isNull()) |

4002 | return false; |

4003 | return InnerMatcher.matches(Node.getCanonicalType(), Finder, Builder); |

4004 | } |

4005 | |

4006 | /// Overloaded to match the referenced type's declaration. |

4007 | AST_MATCHER_P_OVERLOAD(QualType, references, internal::Matcher<Decl>, |

4008 | InnerMatcher, 1) { |

4009 | return references(qualType(hasDeclaration(InnerMatcher))) |

4010 | .matches(Node, Finder, Builder); |

4011 | } |

4012 | |

4013 | /// Matches on the implicit object argument of a member call expression. Unlike |

4014 | /// `on`, matches the argument directly without stripping away anything. |

4015 | /// |

4016 | /// Given |

4017 | /// \code |

4018 | /// class Y { public: void m(); }; |

4019 | /// Y g(); |

4020 | /// class X : public Y { void g(); }; |

4021 | /// void z(Y y, X x) { y.m(); x.m(); x.g(); (g()).m(); } |

4022 | /// \endcode |

4023 | /// cxxMemberCallExpr(onImplicitObjectArgument(hasType( |

4024 | /// cxxRecordDecl(hasName("Y"))))) |

4025 | /// matches `y.m()`, `x.m()` and (g()).m(), but not `x.g()`. |

4026 | /// cxxMemberCallExpr(on(callExpr())) |

4027 | /// does not match `(g()).m()`, because the parens are not ignored. |

4028 | /// |

4029 | /// FIXME: Overload to allow directly matching types? |

4030 | AST_MATCHER_P(CXXMemberCallExpr, onImplicitObjectArgument, |

4031 | internal::Matcher<Expr>, InnerMatcher) { |

4032 | const Expr *ExprNode = Node.getImplicitObjectArgument(); |

4033 | return (ExprNode != nullptr && |

4034 | InnerMatcher.matches(*ExprNode, Finder, Builder)); |

4035 | } |

4036 | |

4037 | /// Matches if the type of the expression's implicit object argument either |

4038 | /// matches the InnerMatcher, or is a pointer to a type that matches the |

4039 | /// InnerMatcher. |

4040 | /// |

4041 | /// Given |

4042 | /// \code |

4043 | /// class Y { public: void m(); }; |

4044 | /// class X : public Y { void g(); }; |

4045 | /// void z() { Y y; y.m(); Y *p; p->m(); X x; x.m(); x.g(); } |

4046 | /// \endcode |

4047 | /// cxxMemberCallExpr(thisPointerType(hasDeclaration( |

4048 | /// cxxRecordDecl(hasName("Y"))))) |

4049 | /// matches `y.m()`, `p->m()` and `x.m()`. |

4050 | /// cxxMemberCallExpr(thisPointerType(hasDeclaration( |

4051 | /// cxxRecordDecl(hasName("X"))))) |

4052 | /// matches `x.g()`. |

4053 | AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType, |

4054 | internal::Matcher<QualType>, InnerMatcher, 0) { |

4055 | return onImplicitObjectArgument( |

4056 | anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher)))) |

4057 | .matches(Node, Finder, Builder); |

4058 | } |

4059 | |

4060 | /// Overloaded to match the type's declaration. |

4061 | AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType, |

4062 | internal::Matcher<Decl>, InnerMatcher, 1) { |

4063 | return onImplicitObjectArgument( |

4064 | anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher)))) |

4065 | .matches(Node, Finder, Builder); |

4066 | } |

4067 | |

4068 | /// Matches a DeclRefExpr that refers to a declaration that matches the |

4069 | /// specified matcher. |

4070 | /// |

4071 | /// Example matches x in if(x) |

4072 | /// (matcher = declRefExpr(to(varDecl(hasName("x"))))) |

4073 | /// \code |

4074 | /// bool x; |

4075 | /// if (x) {} |

4076 | /// \endcode |

4077 | AST_MATCHER_P(DeclRefExpr, to, internal::Matcher<Decl>, |

4078 | InnerMatcher) { |

4079 | const Decl *DeclNode = Node.getDecl(); |

4080 | return ( |