| File: | build/source/clang-tools-extra/clang-tidy/bugprone/StandaloneEmptyCheck.cpp |
| Warning: | line 210, column 12 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===--- StandaloneEmptyCheck.cpp - clang-tidy ----------------------------===// | ||||||||
| 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 | #include "StandaloneEmptyCheck.h" | ||||||||
| 10 | #include "clang/AST/ASTContext.h" | ||||||||
| 11 | #include "clang/AST/Decl.h" | ||||||||
| 12 | #include "clang/AST/DeclBase.h" | ||||||||
| 13 | #include "clang/AST/DeclCXX.h" | ||||||||
| 14 | #include "clang/AST/Expr.h" | ||||||||
| 15 | #include "clang/AST/ExprCXX.h" | ||||||||
| 16 | #include "clang/AST/Stmt.h" | ||||||||
| 17 | #include "clang/AST/Type.h" | ||||||||
| 18 | #include "clang/ASTMatchers/ASTMatchFinder.h" | ||||||||
| 19 | #include "clang/ASTMatchers/ASTMatchers.h" | ||||||||
| 20 | #include "clang/Basic/Diagnostic.h" | ||||||||
| 21 | #include "clang/Basic/SourceLocation.h" | ||||||||
| 22 | #include "clang/Lex/Lexer.h" | ||||||||
| 23 | #include "llvm/ADT/STLExtras.h" | ||||||||
| 24 | #include "llvm/ADT/SmallVector.h" | ||||||||
| 25 | #include "llvm/Support/Casting.h" | ||||||||
| 26 | |||||||||
| 27 | namespace clang::tidy::bugprone { | ||||||||
| 28 | |||||||||
| 29 | using ast_matchers::BoundNodes; | ||||||||
| 30 | using ast_matchers::callee; | ||||||||
| 31 | using ast_matchers::callExpr; | ||||||||
| 32 | using ast_matchers::classTemplateDecl; | ||||||||
| 33 | using ast_matchers::cxxMemberCallExpr; | ||||||||
| 34 | using ast_matchers::cxxMethodDecl; | ||||||||
| 35 | using ast_matchers::expr; | ||||||||
| 36 | using ast_matchers::functionDecl; | ||||||||
| 37 | using ast_matchers::hasAncestor; | ||||||||
| 38 | using ast_matchers::hasName; | ||||||||
| 39 | using ast_matchers::hasParent; | ||||||||
| 40 | using ast_matchers::ignoringImplicit; | ||||||||
| 41 | using ast_matchers::ignoringParenImpCasts; | ||||||||
| 42 | using ast_matchers::MatchFinder; | ||||||||
| 43 | using ast_matchers::optionally; | ||||||||
| 44 | using ast_matchers::returns; | ||||||||
| 45 | using ast_matchers::stmt; | ||||||||
| 46 | using ast_matchers::stmtExpr; | ||||||||
| 47 | using ast_matchers::unless; | ||||||||
| 48 | using ast_matchers::voidType; | ||||||||
| 49 | |||||||||
| 50 | const Expr *getCondition(const BoundNodes &Nodes, const StringRef NodeId) { | ||||||||
| 51 | const auto *If = Nodes.getNodeAs<IfStmt>(NodeId); | ||||||||
| 52 | if (If != nullptr) | ||||||||
| 53 | return If->getCond(); | ||||||||
| 54 | |||||||||
| 55 | const auto *For = Nodes.getNodeAs<ForStmt>(NodeId); | ||||||||
| 56 | if (For != nullptr) | ||||||||
| 57 | return For->getCond(); | ||||||||
| 58 | |||||||||
| 59 | const auto *While = Nodes.getNodeAs<WhileStmt>(NodeId); | ||||||||
| 60 | if (While != nullptr) | ||||||||
| 61 | return While->getCond(); | ||||||||
| 62 | |||||||||
| 63 | const auto *Do = Nodes.getNodeAs<DoStmt>(NodeId); | ||||||||
| 64 | if (Do != nullptr) | ||||||||
| 65 | return Do->getCond(); | ||||||||
| 66 | |||||||||
| 67 | const auto *Switch = Nodes.getNodeAs<SwitchStmt>(NodeId); | ||||||||
| 68 | if (Switch != nullptr) | ||||||||
| 69 | return Switch->getCond(); | ||||||||
| 70 | |||||||||
| 71 | return nullptr; | ||||||||
| 72 | } | ||||||||
| 73 | |||||||||
| 74 | void StandaloneEmptyCheck::registerMatchers(ast_matchers::MatchFinder *Finder) { | ||||||||
| 75 | // Ignore empty calls in a template definition which fall under callExpr | ||||||||
| 76 | // non-member matcher even if they are methods. | ||||||||
| 77 | const auto NonMemberMatcher = expr(ignoringImplicit(ignoringParenImpCasts( | ||||||||
| 78 | callExpr( | ||||||||
| 79 | hasParent(stmt(optionally(hasParent(stmtExpr().bind("stexpr")))) | ||||||||
| 80 | .bind("parent")), | ||||||||
| 81 | unless(hasAncestor(classTemplateDecl())), | ||||||||
| 82 | callee(functionDecl(hasName("empty"), unless(returns(voidType()))))) | ||||||||
| 83 | .bind("empty")))); | ||||||||
| 84 | const auto MemberMatcher = | ||||||||
| 85 | expr(ignoringImplicit(ignoringParenImpCasts(cxxMemberCallExpr( | ||||||||
| 86 | hasParent(stmt(optionally(hasParent(stmtExpr().bind("stexpr")))) | ||||||||
| 87 | .bind("parent")), | ||||||||
| 88 | callee(cxxMethodDecl(hasName("empty"), | ||||||||
| 89 | unless(returns(voidType())))))))) | ||||||||
| 90 | .bind("empty"); | ||||||||
| 91 | |||||||||
| 92 | Finder->addMatcher(MemberMatcher, this); | ||||||||
| 93 | Finder->addMatcher(NonMemberMatcher, this); | ||||||||
| 94 | } | ||||||||
| 95 | |||||||||
| 96 | void StandaloneEmptyCheck::check(const MatchFinder::MatchResult &Result) { | ||||||||
| 97 | // Skip if the parent node is Expr. | ||||||||
| 98 | if (Result.Nodes.getNodeAs<Expr>("parent")) | ||||||||
| |||||||||
| 99 | return; | ||||||||
| 100 | |||||||||
| 101 | const auto PParentStmtExpr = Result.Nodes.getNodeAs<Expr>("stexpr"); | ||||||||
| 102 | const auto ParentCompStmt = Result.Nodes.getNodeAs<CompoundStmt>("parent"); | ||||||||
| 103 | const auto *ParentCond = getCondition(Result.Nodes, "parent"); | ||||||||
| 104 | const auto *ParentReturnStmt = Result.Nodes.getNodeAs<ReturnStmt>("parent"); | ||||||||
| 105 | |||||||||
| 106 | if (const auto *MemberCall
| ||||||||
| 107 | Result.Nodes.getNodeAs<CXXMemberCallExpr>("empty")) { | ||||||||
| 108 | // Skip if it's a condition of the parent statement. | ||||||||
| 109 | if (ParentCond == MemberCall->getExprStmt()) | ||||||||
| 110 | return; | ||||||||
| 111 | // Skip if it's the last statement in the GNU extension | ||||||||
| 112 | // statement expression. | ||||||||
| 113 | if (PParentStmtExpr && ParentCompStmt && | ||||||||
| 114 | ParentCompStmt->body_back() == MemberCall->getExprStmt()) | ||||||||
| 115 | return; | ||||||||
| 116 | // Skip if it's a return statement | ||||||||
| 117 | if (ParentReturnStmt) | ||||||||
| 118 | return; | ||||||||
| 119 | |||||||||
| 120 | SourceLocation MemberLoc = MemberCall->getBeginLoc(); | ||||||||
| 121 | SourceLocation ReplacementLoc = MemberCall->getExprLoc(); | ||||||||
| 122 | SourceRange ReplacementRange = SourceRange(ReplacementLoc, ReplacementLoc); | ||||||||
| 123 | |||||||||
| 124 | ASTContext &Context = MemberCall->getRecordDecl()->getASTContext(); | ||||||||
| 125 | DeclarationName Name = | ||||||||
| 126 | Context.DeclarationNames.getIdentifier(&Context.Idents.get("clear")); | ||||||||
| 127 | |||||||||
| 128 | auto Candidates = MemberCall->getRecordDecl()->lookupDependentName( | ||||||||
| 129 | Name, [](const NamedDecl *ND) { | ||||||||
| 130 | return isa<CXXMethodDecl>(ND) && | ||||||||
| 131 | llvm::cast<CXXMethodDecl>(ND)->getMinRequiredArguments() == | ||||||||
| 132 | 0 && | ||||||||
| 133 | !llvm::cast<CXXMethodDecl>(ND)->isConst(); | ||||||||
| 134 | }); | ||||||||
| 135 | |||||||||
| 136 | bool HasClear = !Candidates.empty(); | ||||||||
| 137 | if (HasClear) { | ||||||||
| 138 | const CXXMethodDecl *Clear = llvm::cast<CXXMethodDecl>(Candidates.at(0)); | ||||||||
| 139 | QualType RangeType = MemberCall->getImplicitObjectArgument()->getType(); | ||||||||
| 140 | bool QualifierIncompatible = | ||||||||
| 141 | (!Clear->isVolatile() && RangeType.isVolatileQualified()) || | ||||||||
| 142 | RangeType.isConstQualified(); | ||||||||
| 143 | if (!QualifierIncompatible) { | ||||||||
| 144 | diag(MemberLoc, | ||||||||
| 145 | "ignoring the result of 'empty()'; did you mean 'clear()'? ") | ||||||||
| 146 | << FixItHint::CreateReplacement(ReplacementRange, "clear"); | ||||||||
| 147 | return; | ||||||||
| 148 | } | ||||||||
| 149 | } | ||||||||
| 150 | |||||||||
| 151 | diag(MemberLoc, "ignoring the result of 'empty()'"); | ||||||||
| 152 | |||||||||
| 153 | } else if (const auto *NonMemberCall
| ||||||||
| 154 | Result.Nodes.getNodeAs<CallExpr>("empty")) { | ||||||||
| 155 | if (ParentCond == NonMemberCall->getExprStmt()) | ||||||||
| 156 | return; | ||||||||
| 157 | if (PParentStmtExpr
| ||||||||
| 158 | ParentCompStmt->body_back() == NonMemberCall->getExprStmt()) | ||||||||
| 159 | return; | ||||||||
| 160 | if (ParentReturnStmt
| ||||||||
| 161 | return; | ||||||||
| 162 | if (NonMemberCall->getNumArgs() != 1) | ||||||||
| 163 | return; | ||||||||
| 164 | |||||||||
| 165 | SourceLocation NonMemberLoc = NonMemberCall->getExprLoc(); | ||||||||
| 166 | SourceLocation NonMemberEndLoc = NonMemberCall->getEndLoc(); | ||||||||
| 167 | |||||||||
| 168 | const Expr *Arg = NonMemberCall->getArg(0); | ||||||||
| 169 | CXXRecordDecl *ArgRecordDecl = Arg->getType()->getAsCXXRecordDecl(); | ||||||||
| 170 | if (ArgRecordDecl == nullptr) | ||||||||
| 171 | return; | ||||||||
| 172 | |||||||||
| 173 | ASTContext &Context = ArgRecordDecl->getASTContext(); | ||||||||
| 174 | DeclarationName Name = | ||||||||
| 175 | Context.DeclarationNames.getIdentifier(&Context.Idents.get("clear")); | ||||||||
| 176 | |||||||||
| 177 | auto Candidates = | ||||||||
| 178 | ArgRecordDecl->lookupDependentName(Name, [](const NamedDecl *ND) { | ||||||||
| 179 | return isa<CXXMethodDecl>(ND) && | ||||||||
| 180 | llvm::cast<CXXMethodDecl>(ND)->getMinRequiredArguments() == | ||||||||
| 181 | 0 && | ||||||||
| 182 | !llvm::cast<CXXMethodDecl>(ND)->isConst(); | ||||||||
| 183 | }); | ||||||||
| 184 | |||||||||
| 185 | bool HasClear = !Candidates.empty(); | ||||||||
| 186 | |||||||||
| 187 | if (HasClear
| ||||||||
| 188 | const CXXMethodDecl *Clear = llvm::cast<CXXMethodDecl>(Candidates.at(0)); | ||||||||
| 189 | bool QualifierIncompatible = | ||||||||
| 190 | (!Clear->isVolatile() && Arg->getType().isVolatileQualified()) || | ||||||||
| 191 | Arg->getType().isConstQualified(); | ||||||||
| 192 | if (!QualifierIncompatible) { | ||||||||
| 193 | std::string ReplacementText = | ||||||||
| 194 | std::string(Lexer::getSourceText( | ||||||||
| 195 | CharSourceRange::getTokenRange(Arg->getSourceRange()), | ||||||||
| 196 | *Result.SourceManager, getLangOpts())) + | ||||||||
| 197 | ".clear()"; | ||||||||
| 198 | SourceRange ReplacementRange = | ||||||||
| 199 | SourceRange(NonMemberLoc, NonMemberEndLoc); | ||||||||
| 200 | diag(NonMemberLoc, | ||||||||
| 201 | "ignoring the result of '%0'; did you mean 'clear()'?") | ||||||||
| 202 | << llvm::dyn_cast<NamedDecl>(NonMemberCall->getCalleeDecl()) | ||||||||
| 203 | ->getQualifiedNameAsString() | ||||||||
| 204 | << FixItHint::CreateReplacement(ReplacementRange, ReplacementText); | ||||||||
| 205 | return; | ||||||||
| 206 | } | ||||||||
| 207 | } | ||||||||
| 208 | |||||||||
| 209 | diag(NonMemberLoc, "ignoring the result of '%0'") | ||||||||
| 210 | << llvm::dyn_cast<NamedDecl>(NonMemberCall->getCalleeDecl()) | ||||||||
| |||||||||
| 211 | ->getQualifiedNameAsString(); | ||||||||
| 212 | } | ||||||||
| 213 | } | ||||||||
| 214 | |||||||||
| 215 | } // namespace clang::tidy::bugprone |
| 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 <optional> |
| 94 | #include <string> |
| 95 | #include <utility> |
| 96 | #include <vector> |
| 97 | |
| 98 | namespace clang { |
| 99 | namespace ast_matchers { |
| 100 | |
| 101 | /// Maps string IDs to AST nodes matched by parts of a matcher. |
| 102 | /// |
| 103 | /// The bound nodes are generated by calling \c bind("id") on the node matchers |
| 104 | /// of the nodes we want to access later. |
| 105 | /// |
| 106 | /// The instances of BoundNodes are created by \c MatchFinder when the user's |
| 107 | /// callbacks are executed every time a match is found. |
| 108 | class BoundNodes { |
| 109 | public: |
| 110 | /// Returns the AST node bound to \c ID. |
| 111 | /// |
| 112 | /// Returns NULL if there was no node bound to \c ID or if there is a node but |
| 113 | /// it cannot be converted to the specified type. |
| 114 | template <typename T> |
| 115 | const T *getNodeAs(StringRef ID) const { |
| 116 | return MyBoundNodes.getNodeAs<T>(ID); |
| 117 | } |
| 118 | |
| 119 | /// Type of mapping from binding identifiers to bound nodes. This type |
| 120 | /// is an associative container with a key type of \c std::string and a value |
| 121 | /// type of \c clang::DynTypedNode |
| 122 | using IDToNodeMap = internal::BoundNodesMap::IDToNodeMap; |
| 123 | |
| 124 | /// Retrieve mapping from binding identifiers to bound nodes. |
| 125 | const IDToNodeMap &getMap() const { |
| 126 | return MyBoundNodes.getMap(); |
| 127 | } |
| 128 | |
| 129 | private: |
| 130 | friend class internal::BoundNodesTreeBuilder; |
| 131 | |
| 132 | /// Create BoundNodes from a pre-filled map of bindings. |
| 133 | BoundNodes(internal::BoundNodesMap &MyBoundNodes) |
| 134 | : MyBoundNodes(MyBoundNodes) {} |
| 135 | |
| 136 | internal::BoundNodesMap MyBoundNodes; |
| 137 | }; |
| 138 | |
| 139 | /// Types of matchers for the top-level classes in the AST class |
| 140 | /// hierarchy. |
| 141 | /// @{ |
| 142 | using DeclarationMatcher = internal::Matcher<Decl>; |
| 143 | using StatementMatcher = internal::Matcher<Stmt>; |
| 144 | using TypeMatcher = internal::Matcher<QualType>; |
| 145 | using TypeLocMatcher = internal::Matcher<TypeLoc>; |
| 146 | using NestedNameSpecifierMatcher = internal::Matcher<NestedNameSpecifier>; |
| 147 | using NestedNameSpecifierLocMatcher = internal::Matcher<NestedNameSpecifierLoc>; |
| 148 | using CXXBaseSpecifierMatcher = internal::Matcher<CXXBaseSpecifier>; |
| 149 | using CXXCtorInitializerMatcher = internal::Matcher<CXXCtorInitializer>; |
| 150 | using TemplateArgumentMatcher = internal::Matcher<TemplateArgument>; |
| 151 | using TemplateArgumentLocMatcher = internal::Matcher<TemplateArgumentLoc>; |
| 152 | using LambdaCaptureMatcher = internal::Matcher<LambdaCapture>; |
| 153 | using AttrMatcher = internal::Matcher<Attr>; |
| 154 | /// @} |
| 155 | |
| 156 | /// Matches any node. |
| 157 | /// |
| 158 | /// Useful when another matcher requires a child matcher, but there's no |
| 159 | /// additional constraint. This will often be used with an explicit conversion |
| 160 | /// to an \c internal::Matcher<> type such as \c TypeMatcher. |
| 161 | /// |
| 162 | /// Example: \c DeclarationMatcher(anything()) matches all declarations, e.g., |
| 163 | /// \code |
| 164 | /// "int* p" and "void f()" in |
| 165 | /// int* p; |
| 166 | /// void f(); |
| 167 | /// \endcode |
| 168 | /// |
| 169 | /// Usable as: Any Matcher |
| 170 | inline internal::TrueMatcher anything() { return internal::TrueMatcher(); } |
| 171 | |
| 172 | /// Matches the top declaration context. |
| 173 | /// |
| 174 | /// Given |
| 175 | /// \code |
| 176 | /// int X; |
| 177 | /// namespace NS { |
| 178 | /// int Y; |
| 179 | /// } // namespace NS |
| 180 | /// \endcode |
| 181 | /// decl(hasDeclContext(translationUnitDecl())) |
| 182 | /// matches "int X", but not "int Y". |
| 183 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl> |
| 184 | translationUnitDecl; |
| 185 | |
| 186 | /// Matches typedef declarations. |
| 187 | /// |
| 188 | /// Given |
| 189 | /// \code |
| 190 | /// typedef int X; |
| 191 | /// using Y = int; |
| 192 | /// \endcode |
| 193 | /// typedefDecl() |
| 194 | /// matches "typedef int X", but not "using Y = int" |
| 195 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> |
| 196 | typedefDecl; |
| 197 | |
| 198 | /// Matches typedef name declarations. |
| 199 | /// |
| 200 | /// Given |
| 201 | /// \code |
| 202 | /// typedef int X; |
| 203 | /// using Y = int; |
| 204 | /// \endcode |
| 205 | /// typedefNameDecl() |
| 206 | /// matches "typedef int X" and "using Y = int" |
| 207 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl> |
| 208 | typedefNameDecl; |
| 209 | |
| 210 | /// Matches type alias declarations. |
| 211 | /// |
| 212 | /// Given |
| 213 | /// \code |
| 214 | /// typedef int X; |
| 215 | /// using Y = int; |
| 216 | /// \endcode |
| 217 | /// typeAliasDecl() |
| 218 | /// matches "using Y = int", but not "typedef int X" |
| 219 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> |
| 220 | typeAliasDecl; |
| 221 | |
| 222 | /// Matches type alias template declarations. |
| 223 | /// |
| 224 | /// typeAliasTemplateDecl() matches |
| 225 | /// \code |
| 226 | /// template <typename T> |
| 227 | /// using Y = X<T>; |
| 228 | /// \endcode |
| 229 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl> |
| 230 | typeAliasTemplateDecl; |
| 231 | |
| 232 | /// Matches AST nodes that were expanded within the main-file. |
| 233 | /// |
| 234 | /// Example matches X but not Y |
| 235 | /// (matcher = cxxRecordDecl(isExpansionInMainFile()) |
| 236 | /// \code |
| 237 | /// #include <Y.h> |
| 238 | /// class X {}; |
| 239 | /// \endcode |
| 240 | /// Y.h: |
| 241 | /// \code |
| 242 | /// class Y {}; |
| 243 | /// \endcode |
| 244 | /// |
| 245 | /// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> |
| 246 | AST_POLYMORPHIC_MATCHER(isExpansionInMainFile,namespace internal { template <typename NodeType> class matcher_isExpansionInMainFileMatcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isExpansionInMainFileMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)> isExpansionInMainFile() { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInMainFileMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)>(); } template <typename NodeType> bool internal::matcher_isExpansionInMainFileMatcher<NodeType> ::matches( const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 247 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc))namespace internal { template <typename NodeType> class matcher_isExpansionInMainFileMatcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isExpansionInMainFileMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)> isExpansionInMainFile() { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInMainFileMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)>(); } template <typename NodeType> bool internal::matcher_isExpansionInMainFileMatcher<NodeType> ::matches( const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 248 | auto &SourceManager = Finder->getASTContext().getSourceManager(); |
| 249 | return SourceManager.isInMainFile( |
| 250 | SourceManager.getExpansionLoc(Node.getBeginLoc())); |
| 251 | } |
| 252 | |
| 253 | /// Matches AST nodes that were expanded within system-header-files. |
| 254 | /// |
| 255 | /// Example matches Y but not X |
| 256 | /// (matcher = cxxRecordDecl(isExpansionInSystemHeader()) |
| 257 | /// \code |
| 258 | /// #include <SystemHeader.h> |
| 259 | /// class X {}; |
| 260 | /// \endcode |
| 261 | /// SystemHeader.h: |
| 262 | /// \code |
| 263 | /// class Y {}; |
| 264 | /// \endcode |
| 265 | /// |
| 266 | /// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> |
| 267 | AST_POLYMORPHIC_MATCHER(isExpansionInSystemHeader,namespace internal { template <typename NodeType> class matcher_isExpansionInSystemHeaderMatcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isExpansionInSystemHeaderMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)> isExpansionInSystemHeader() { return ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInSystemHeaderMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)>(); } template <typename NodeType> bool internal::matcher_isExpansionInSystemHeaderMatcher<NodeType >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 268 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc))namespace internal { template <typename NodeType> class matcher_isExpansionInSystemHeaderMatcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isExpansionInSystemHeaderMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)> isExpansionInSystemHeader() { return ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInSystemHeaderMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>)>(); } template <typename NodeType> bool internal::matcher_isExpansionInSystemHeaderMatcher<NodeType >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 269 | auto &SourceManager = Finder->getASTContext().getSourceManager(); |
| 270 | auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc()); |
| 271 | if (ExpansionLoc.isInvalid()) { |
| 272 | return false; |
| 273 | } |
| 274 | return SourceManager.isInSystemHeader(ExpansionLoc); |
| 275 | } |
| 276 | |
| 277 | /// Matches AST nodes that were expanded within files whose name is |
| 278 | /// partially matching a given regex. |
| 279 | /// |
| 280 | /// Example matches Y but not X |
| 281 | /// (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*")) |
| 282 | /// \code |
| 283 | /// #include "ASTMatcher.h" |
| 284 | /// class X {}; |
| 285 | /// \endcode |
| 286 | /// ASTMatcher.h: |
| 287 | /// \code |
| 288 | /// class Y {}; |
| 289 | /// \endcode |
| 290 | /// |
| 291 | /// Usable as: Matcher<Decl>, Matcher<Stmt>, Matcher<TypeLoc> |
| 292 | AST_POLYMORPHIC_MATCHER_REGEX(isExpansionInFileMatching,namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpansionInFileMatching0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: explicit matcher_isExpansionInFileMatching0Matcher ( std::shared_ptr<llvm::Regex> RE) : RegExp(std::move(RE )) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: std ::shared_ptr<llvm::Regex> RegExp; }; } inline ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp, llvm::Regex::RegexFlags RegexFlags) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher, void(:: clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>>( ::clang::ast_matchers ::internal::createAndVerifyRegex( RegExp, RegexFlags, "isExpansionInFileMatching" )); } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpansionInFileMatching0Matcher, void (::clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp) { return isExpansionInFileMatching(RegExp , llvm::Regex::NoFlags); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> ( & isExpansionInFileMatching_Type0Flags)( llvm::StringRef RegExp , llvm::Regex::RegexFlags RegexFlags); typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> (& isExpansionInFileMatching_Type0)( llvm::StringRef RegExp); template <typename NodeType, typename ParamT> bool internal:: matcher_isExpansionInFileMatching0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 293 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt,namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpansionInFileMatching0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: explicit matcher_isExpansionInFileMatching0Matcher ( std::shared_ptr<llvm::Regex> RE) : RegExp(std::move(RE )) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: std ::shared_ptr<llvm::Regex> RegExp; }; } inline ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp, llvm::Regex::RegexFlags RegexFlags) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher, void(:: clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>>( ::clang::ast_matchers ::internal::createAndVerifyRegex( RegExp, RegexFlags, "isExpansionInFileMatching" )); } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpansionInFileMatching0Matcher, void (::clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp) { return isExpansionInFileMatching(RegExp , llvm::Regex::NoFlags); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> ( & isExpansionInFileMatching_Type0Flags)( llvm::StringRef RegExp , llvm::Regex::RegexFlags RegexFlags); typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> (& isExpansionInFileMatching_Type0)( llvm::StringRef RegExp); template <typename NodeType, typename ParamT> bool internal:: matcher_isExpansionInFileMatching0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 294 | TypeLoc),namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpansionInFileMatching0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: explicit matcher_isExpansionInFileMatching0Matcher ( std::shared_ptr<llvm::Regex> RE) : RegExp(std::move(RE )) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: std ::shared_ptr<llvm::Regex> RegExp; }; } inline ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp, llvm::Regex::RegexFlags RegexFlags) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher, void(:: clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>>( ::clang::ast_matchers ::internal::createAndVerifyRegex( RegExp, RegexFlags, "isExpansionInFileMatching" )); } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpansionInFileMatching0Matcher, void (::clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp) { return isExpansionInFileMatching(RegExp , llvm::Regex::NoFlags); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> ( & isExpansionInFileMatching_Type0Flags)( llvm::StringRef RegExp , llvm::Regex::RegexFlags RegexFlags); typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> (& isExpansionInFileMatching_Type0)( llvm::StringRef RegExp); template <typename NodeType, typename ParamT> bool internal:: matcher_isExpansionInFileMatching0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 295 | RegExp)namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpansionInFileMatching0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: explicit matcher_isExpansionInFileMatching0Matcher ( std::shared_ptr<llvm::Regex> RE) : RegExp(std::move(RE )) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: std ::shared_ptr<llvm::Regex> RegExp; }; } inline ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp, llvm::Regex::RegexFlags RegexFlags) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher, void(:: clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>>( ::clang::ast_matchers ::internal::createAndVerifyRegex( RegExp, RegexFlags, "isExpansionInFileMatching" )); } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpansionInFileMatching0Matcher, void (::clang::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc >), std::shared_ptr<llvm::Regex>> isExpansionInFileMatching (llvm::StringRef RegExp) { return isExpansionInFileMatching(RegExp , llvm::Regex::NoFlags); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> ( & isExpansionInFileMatching_Type0Flags)( llvm::StringRef RegExp , llvm::Regex::RegexFlags RegexFlags); typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpansionInFileMatching0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::shared_ptr<llvm::Regex>> (& isExpansionInFileMatching_Type0)( llvm::StringRef RegExp); template <typename NodeType, typename ParamT> bool internal:: matcher_isExpansionInFileMatching0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 296 | auto &SourceManager = Finder->getASTContext().getSourceManager(); |
| 297 | auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc()); |
| 298 | if (ExpansionLoc.isInvalid()) { |
| 299 | return false; |
| 300 | } |
| 301 | auto FileEntry = |
| 302 | SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc)); |
| 303 | if (!FileEntry) { |
| 304 | return false; |
| 305 | } |
| 306 | |
| 307 | auto Filename = FileEntry->getName(); |
| 308 | return RegExp->match(Filename); |
| 309 | } |
| 310 | |
| 311 | /// Matches statements that are (transitively) expanded from the named macro. |
| 312 | /// Does not match if only part of the statement is expanded from that macro or |
| 313 | /// if different parts of the statement are expanded from different |
| 314 | /// appearances of the macro. |
| 315 | AST_POLYMORPHIC_MATCHER_P(isExpandedFromMacro,namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpandedFromMacro0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isExpandedFromMacro0Matcher( std ::string const &AMacroName) : MacroName(AMacroName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string MacroName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpandedFromMacro0Matcher, void(::clang ::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc> ), std::string> isExpandedFromMacro(std::string const & MacroName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpandedFromMacro0Matcher, void(::clang ::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc> ), std::string>(MacroName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpandedFromMacro0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::string> (&isExpandedFromMacro_Type0 )(std::string const &MacroName); template <typename NodeType , typename ParamT> bool internal:: matcher_isExpandedFromMacro0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 316 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc),namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpandedFromMacro0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isExpandedFromMacro0Matcher( std ::string const &AMacroName) : MacroName(AMacroName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string MacroName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpandedFromMacro0Matcher, void(::clang ::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc> ), std::string> isExpandedFromMacro(std::string const & MacroName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpandedFromMacro0Matcher, void(::clang ::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc> ), std::string>(MacroName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpandedFromMacro0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::string> (&isExpandedFromMacro_Type0 )(std::string const &MacroName); template <typename NodeType , typename ParamT> bool internal:: matcher_isExpandedFromMacro0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 317 | std::string, MacroName)namespace internal { template <typename NodeType, typename ParamT> class matcher_isExpandedFromMacro0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isExpandedFromMacro0Matcher( std ::string const &AMacroName) : MacroName(AMacroName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string MacroName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpandedFromMacro0Matcher, void(::clang ::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc> ), std::string> isExpandedFromMacro(std::string const & MacroName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isExpandedFromMacro0Matcher, void(::clang ::ast_matchers::internal::TypeList<Decl, Stmt, TypeLoc> ), std::string>(MacroName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isExpandedFromMacro0Matcher , void(::clang::ast_matchers::internal::TypeList<Decl, Stmt , TypeLoc>), std::string> (&isExpandedFromMacro_Type0 )(std::string const &MacroName); template <typename NodeType , typename ParamT> bool internal:: matcher_isExpandedFromMacro0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 318 | // Verifies that the statement' beginning and ending are both expanded from |
| 319 | // the same instance of the given macro. |
| 320 | auto& Context = Finder->getASTContext(); |
| 321 | std::optional<SourceLocation> B = |
| 322 | internal::getExpansionLocOfMacro(MacroName, Node.getBeginLoc(), Context); |
| 323 | if (!B) return false; |
| 324 | std::optional<SourceLocation> E = |
| 325 | internal::getExpansionLocOfMacro(MacroName, Node.getEndLoc(), Context); |
| 326 | if (!E) return false; |
| 327 | return *B == *E; |
| 328 | } |
| 329 | |
| 330 | /// Matches declarations. |
| 331 | /// |
| 332 | /// Examples matches \c X, \c C, and the friend declaration inside \c C; |
| 333 | /// \code |
| 334 | /// void X(); |
| 335 | /// class C { |
| 336 | /// friend X; |
| 337 | /// }; |
| 338 | /// \endcode |
| 339 | extern const internal::VariadicAllOfMatcher<Decl> decl; |
| 340 | |
| 341 | /// Matches decomposition-declarations. |
| 342 | /// |
| 343 | /// Examples matches the declaration node with \c foo and \c bar, but not |
| 344 | /// \c number. |
| 345 | /// (matcher = declStmt(has(decompositionDecl()))) |
| 346 | /// |
| 347 | /// \code |
| 348 | /// int number = 42; |
| 349 | /// auto [foo, bar] = std::make_pair{42, 42}; |
| 350 | /// \endcode |
| 351 | extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl> |
| 352 | decompositionDecl; |
| 353 | |
| 354 | /// Matches binding declarations |
| 355 | /// Example matches \c foo and \c bar |
| 356 | /// (matcher = bindingDecl() |
| 357 | /// |
| 358 | /// \code |
| 359 | /// auto [foo, bar] = std::make_pair{42, 42}; |
| 360 | /// \endcode |
| 361 | extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl> |
| 362 | bindingDecl; |
| 363 | |
| 364 | /// Matches a declaration of a linkage specification. |
| 365 | /// |
| 366 | /// Given |
| 367 | /// \code |
| 368 | /// extern "C" {} |
| 369 | /// \endcode |
| 370 | /// linkageSpecDecl() |
| 371 | /// matches "extern "C" {}" |
| 372 | extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl> |
| 373 | linkageSpecDecl; |
| 374 | |
| 375 | /// Matches a declaration of anything that could have a name. |
| 376 | /// |
| 377 | /// Example matches \c X, \c S, the anonymous union type, \c i, and \c U; |
| 378 | /// \code |
| 379 | /// typedef int X; |
| 380 | /// struct S { |
| 381 | /// union { |
| 382 | /// int i; |
| 383 | /// } U; |
| 384 | /// }; |
| 385 | /// \endcode |
| 386 | extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl; |
| 387 | |
| 388 | /// Matches a declaration of label. |
| 389 | /// |
| 390 | /// Given |
| 391 | /// \code |
| 392 | /// goto FOO; |
| 393 | /// FOO: bar(); |
| 394 | /// \endcode |
| 395 | /// labelDecl() |
| 396 | /// matches 'FOO:' |
| 397 | extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl; |
| 398 | |
| 399 | /// Matches a declaration of a namespace. |
| 400 | /// |
| 401 | /// Given |
| 402 | /// \code |
| 403 | /// namespace {} |
| 404 | /// namespace test {} |
| 405 | /// \endcode |
| 406 | /// namespaceDecl() |
| 407 | /// matches "namespace {}" and "namespace test {}" |
| 408 | extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> |
| 409 | namespaceDecl; |
| 410 | |
| 411 | /// Matches a declaration of a namespace alias. |
| 412 | /// |
| 413 | /// Given |
| 414 | /// \code |
| 415 | /// namespace test {} |
| 416 | /// namespace alias = ::test; |
| 417 | /// \endcode |
| 418 | /// namespaceAliasDecl() |
| 419 | /// matches "namespace alias" but not "namespace test" |
| 420 | extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl> |
| 421 | namespaceAliasDecl; |
| 422 | |
| 423 | /// Matches class, struct, and union declarations. |
| 424 | /// |
| 425 | /// Example matches \c X, \c Z, \c U, and \c S |
| 426 | /// \code |
| 427 | /// class X; |
| 428 | /// template<class T> class Z {}; |
| 429 | /// struct S {}; |
| 430 | /// union U {}; |
| 431 | /// \endcode |
| 432 | extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl; |
| 433 | |
| 434 | /// Matches C++ class declarations. |
| 435 | /// |
| 436 | /// Example matches \c X, \c Z |
| 437 | /// \code |
| 438 | /// class X; |
| 439 | /// template<class T> class Z {}; |
| 440 | /// \endcode |
| 441 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl> |
| 442 | cxxRecordDecl; |
| 443 | |
| 444 | /// Matches C++ class template declarations. |
| 445 | /// |
| 446 | /// Example matches \c Z |
| 447 | /// \code |
| 448 | /// template<class T> class Z {}; |
| 449 | /// \endcode |
| 450 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl> |
| 451 | classTemplateDecl; |
| 452 | |
| 453 | /// Matches C++ class template specializations. |
| 454 | /// |
| 455 | /// Given |
| 456 | /// \code |
| 457 | /// template<typename T> class A {}; |
| 458 | /// template<> class A<double> {}; |
| 459 | /// A<int> a; |
| 460 | /// \endcode |
| 461 | /// classTemplateSpecializationDecl() |
| 462 | /// matches the specializations \c A<int> and \c A<double> |
| 463 | extern const internal::VariadicDynCastAllOfMatcher< |
| 464 | Decl, ClassTemplateSpecializationDecl> |
| 465 | classTemplateSpecializationDecl; |
| 466 | |
| 467 | /// Matches C++ class template partial specializations. |
| 468 | /// |
| 469 | /// Given |
| 470 | /// \code |
| 471 | /// template<class T1, class T2, int I> |
| 472 | /// class A {}; |
| 473 | /// |
| 474 | /// template<class T, int I> |
| 475 | /// class A<T, T*, I> {}; |
| 476 | /// |
| 477 | /// template<> |
| 478 | /// class A<int, int, 1> {}; |
| 479 | /// \endcode |
| 480 | /// classTemplatePartialSpecializationDecl() |
| 481 | /// matches the specialization \c A<T,T*,I> but not \c A<int,int,1> |
| 482 | extern const internal::VariadicDynCastAllOfMatcher< |
| 483 | Decl, ClassTemplatePartialSpecializationDecl> |
| 484 | classTemplatePartialSpecializationDecl; |
| 485 | |
| 486 | /// Matches declarator declarations (field, variable, function |
| 487 | /// and non-type template parameter declarations). |
| 488 | /// |
| 489 | /// Given |
| 490 | /// \code |
| 491 | /// class X { int y; }; |
| 492 | /// \endcode |
| 493 | /// declaratorDecl() |
| 494 | /// matches \c int y. |
| 495 | extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl> |
| 496 | declaratorDecl; |
| 497 | |
| 498 | /// Matches parameter variable declarations. |
| 499 | /// |
| 500 | /// Given |
| 501 | /// \code |
| 502 | /// void f(int x); |
| 503 | /// \endcode |
| 504 | /// parmVarDecl() |
| 505 | /// matches \c int x. |
| 506 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> |
| 507 | parmVarDecl; |
| 508 | |
| 509 | /// Matches C++ access specifier declarations. |
| 510 | /// |
| 511 | /// Given |
| 512 | /// \code |
| 513 | /// class C { |
| 514 | /// public: |
| 515 | /// int a; |
| 516 | /// }; |
| 517 | /// \endcode |
| 518 | /// accessSpecDecl() |
| 519 | /// matches 'public:' |
| 520 | extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl> |
| 521 | accessSpecDecl; |
| 522 | |
| 523 | /// Matches class bases. |
| 524 | /// |
| 525 | /// Examples matches \c public virtual B. |
| 526 | /// \code |
| 527 | /// class B {}; |
| 528 | /// class C : public virtual B {}; |
| 529 | /// \endcode |
| 530 | extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier> cxxBaseSpecifier; |
| 531 | |
| 532 | /// Matches constructor initializers. |
| 533 | /// |
| 534 | /// Examples matches \c i(42). |
| 535 | /// \code |
| 536 | /// class C { |
| 537 | /// C() : i(42) {} |
| 538 | /// int i; |
| 539 | /// }; |
| 540 | /// \endcode |
| 541 | extern const internal::VariadicAllOfMatcher<CXXCtorInitializer> |
| 542 | cxxCtorInitializer; |
| 543 | |
| 544 | /// Matches template arguments. |
| 545 | /// |
| 546 | /// Given |
| 547 | /// \code |
| 548 | /// template <typename T> struct C {}; |
| 549 | /// C<int> c; |
| 550 | /// \endcode |
| 551 | /// templateArgument() |
| 552 | /// matches 'int' in C<int>. |
| 553 | extern const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument; |
| 554 | |
| 555 | /// Matches template arguments (with location info). |
| 556 | /// |
| 557 | /// Given |
| 558 | /// \code |
| 559 | /// template <typename T> struct C {}; |
| 560 | /// C<int> c; |
| 561 | /// \endcode |
| 562 | /// templateArgumentLoc() |
| 563 | /// matches 'int' in C<int>. |
| 564 | extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc> |
| 565 | templateArgumentLoc; |
| 566 | |
| 567 | /// Matches template name. |
| 568 | /// |
| 569 | /// Given |
| 570 | /// \code |
| 571 | /// template <typename T> class X { }; |
| 572 | /// X<int> xi; |
| 573 | /// \endcode |
| 574 | /// templateName() |
| 575 | /// matches 'X' in X<int>. |
| 576 | extern const internal::VariadicAllOfMatcher<TemplateName> templateName; |
| 577 | |
| 578 | /// Matches non-type template parameter declarations. |
| 579 | /// |
| 580 | /// Given |
| 581 | /// \code |
| 582 | /// template <typename T, int N> struct C {}; |
| 583 | /// \endcode |
| 584 | /// nonTypeTemplateParmDecl() |
| 585 | /// matches 'N', but not 'T'. |
| 586 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |
| 587 | NonTypeTemplateParmDecl> |
| 588 | nonTypeTemplateParmDecl; |
| 589 | |
| 590 | /// Matches template type parameter declarations. |
| 591 | /// |
| 592 | /// Given |
| 593 | /// \code |
| 594 | /// template <typename T, int N> struct C {}; |
| 595 | /// \endcode |
| 596 | /// templateTypeParmDecl() |
| 597 | /// matches 'T', but not 'N'. |
| 598 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl> |
| 599 | templateTypeParmDecl; |
| 600 | |
| 601 | /// Matches template template parameter declarations. |
| 602 | /// |
| 603 | /// Given |
| 604 | /// \code |
| 605 | /// template <template <typename> class Z, int N> struct C {}; |
| 606 | /// \endcode |
| 607 | /// templateTypeParmDecl() |
| 608 | /// matches 'Z', but not 'N'. |
| 609 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |
| 610 | TemplateTemplateParmDecl> |
| 611 | templateTemplateParmDecl; |
| 612 | |
| 613 | /// Matches public C++ declarations and C++ base specifers that specify public |
| 614 | /// inheritance. |
| 615 | /// |
| 616 | /// Examples: |
| 617 | /// \code |
| 618 | /// class C { |
| 619 | /// public: int a; // fieldDecl(isPublic()) matches 'a' |
| 620 | /// protected: int b; |
| 621 | /// private: int c; |
| 622 | /// }; |
| 623 | /// \endcode |
| 624 | /// |
| 625 | /// \code |
| 626 | /// class Base {}; |
| 627 | /// class Derived1 : public Base {}; // matches 'Base' |
| 628 | /// struct Derived2 : Base {}; // matches 'Base' |
| 629 | /// \endcode |
| 630 | AST_POLYMORPHIC_MATCHER(isPublic,namespace internal { template <typename NodeType> class matcher_isPublicMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isPublicMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isPublic() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isPublicMatcher, void (::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isPublicMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 631 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl,namespace internal { template <typename NodeType> class matcher_isPublicMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isPublicMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isPublic() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isPublicMatcher, void (::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isPublicMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 632 | CXXBaseSpecifier))namespace internal { template <typename NodeType> class matcher_isPublicMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isPublicMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isPublic() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isPublicMatcher, void (::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isPublicMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 633 | return getAccessSpecifier(Node) == AS_public; |
| 634 | } |
| 635 | |
| 636 | /// Matches protected C++ declarations and C++ base specifers that specify |
| 637 | /// protected inheritance. |
| 638 | /// |
| 639 | /// Examples: |
| 640 | /// \code |
| 641 | /// class C { |
| 642 | /// public: int a; |
| 643 | /// protected: int b; // fieldDecl(isProtected()) matches 'b' |
| 644 | /// private: int c; |
| 645 | /// }; |
| 646 | /// \endcode |
| 647 | /// |
| 648 | /// \code |
| 649 | /// class Base {}; |
| 650 | /// class Derived : protected Base {}; // matches 'Base' |
| 651 | /// \endcode |
| 652 | AST_POLYMORPHIC_MATCHER(isProtected,namespace internal { template <typename NodeType> class matcher_isProtectedMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isProtectedMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isProtected() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isProtectedMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isProtectedMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 653 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl,namespace internal { template <typename NodeType> class matcher_isProtectedMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isProtectedMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isProtected() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isProtectedMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isProtectedMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 654 | CXXBaseSpecifier))namespace internal { template <typename NodeType> class matcher_isProtectedMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isProtectedMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isProtected() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isProtectedMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isProtectedMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 655 | return getAccessSpecifier(Node) == AS_protected; |
| 656 | } |
| 657 | |
| 658 | /// Matches private C++ declarations and C++ base specifers that specify private |
| 659 | /// inheritance. |
| 660 | /// |
| 661 | /// Examples: |
| 662 | /// \code |
| 663 | /// class C { |
| 664 | /// public: int a; |
| 665 | /// protected: int b; |
| 666 | /// private: int c; // fieldDecl(isPrivate()) matches 'c' |
| 667 | /// }; |
| 668 | /// \endcode |
| 669 | /// |
| 670 | /// \code |
| 671 | /// struct Base {}; |
| 672 | /// struct Derived1 : private Base {}; // matches 'Base' |
| 673 | /// class Derived2 : Base {}; // matches 'Base' |
| 674 | /// \endcode |
| 675 | AST_POLYMORPHIC_MATCHER(isPrivate,namespace internal { template <typename NodeType> class matcher_isPrivateMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isPrivateMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isPrivate() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isPrivateMatcher, void (::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isPrivateMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 676 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl,namespace internal { template <typename NodeType> class matcher_isPrivateMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isPrivateMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isPrivate() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isPrivateMatcher, void (::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isPrivateMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 677 | CXXBaseSpecifier))namespace internal { template <typename NodeType> class matcher_isPrivateMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isPrivateMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)> isPrivate() { return ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_isPrivateMatcher, void (::clang::ast_matchers::internal::TypeList<Decl, CXXBaseSpecifier >)>(); } template <typename NodeType> bool internal ::matcher_isPrivateMatcher<NodeType>::matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 678 | return getAccessSpecifier(Node) == AS_private; |
| 679 | } |
| 680 | |
| 681 | /// Matches non-static data members that are bit-fields. |
| 682 | /// |
| 683 | /// Given |
| 684 | /// \code |
| 685 | /// class C { |
| 686 | /// int a : 2; |
| 687 | /// int b; |
| 688 | /// }; |
| 689 | /// \endcode |
| 690 | /// fieldDecl(isBitField()) |
| 691 | /// matches 'int a;' but not 'int b;'. |
| 692 | AST_MATCHER(FieldDecl, isBitField)namespace internal { class matcher_isBitFieldMatcher : public ::clang::ast_matchers::internal::MatcherInterface<FieldDecl > { public: explicit matcher_isBitFieldMatcher() = default ; bool matches(const FieldDecl &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<FieldDecl> isBitField () { return ::clang::ast_matchers::internal::makeMatcher( new internal::matcher_isBitFieldMatcher()); } inline bool internal ::matcher_isBitFieldMatcher::matches( const FieldDecl &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const { |
| 693 | return Node.isBitField(); |
| 694 | } |
| 695 | |
| 696 | /// Matches non-static data members that are bit-fields of the specified |
| 697 | /// bit width. |
| 698 | /// |
| 699 | /// Given |
| 700 | /// \code |
| 701 | /// class C { |
| 702 | /// int a : 2; |
| 703 | /// int b : 4; |
| 704 | /// int c : 2; |
| 705 | /// }; |
| 706 | /// \endcode |
| 707 | /// fieldDecl(hasBitWidth(2)) |
| 708 | /// matches 'int a;' and 'int c;' but not 'int b;'. |
| 709 | AST_MATCHER_P(FieldDecl, hasBitWidth, unsigned, Width)namespace internal { class matcher_hasBitWidth0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<FieldDecl > { public: explicit matcher_hasBitWidth0Matcher( unsigned const &AWidth) : Width(AWidth) {} bool matches(const FieldDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned Width; }; } inline ::clang::ast_matchers::internal::Matcher<FieldDecl> hasBitWidth ( unsigned const &Width) { return ::clang::ast_matchers:: internal::makeMatcher( new internal::matcher_hasBitWidth0Matcher (Width)); } typedef ::clang::ast_matchers::internal::Matcher< FieldDecl> ( &hasBitWidth_Type0)(unsigned const &Width ); inline bool internal::matcher_hasBitWidth0Matcher::matches ( const FieldDecl &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 710 | return Node.isBitField() && |
| 711 | Node.getBitWidthValue(Finder->getASTContext()) == Width; |
| 712 | } |
| 713 | |
| 714 | /// Matches non-static data members that have an in-class initializer. |
| 715 | /// |
| 716 | /// Given |
| 717 | /// \code |
| 718 | /// class C { |
| 719 | /// int a = 2; |
| 720 | /// int b = 3; |
| 721 | /// int c; |
| 722 | /// }; |
| 723 | /// \endcode |
| 724 | /// fieldDecl(hasInClassInitializer(integerLiteral(equals(2)))) |
| 725 | /// matches 'int a;' but not 'int b;'. |
| 726 | /// fieldDecl(hasInClassInitializer(anything())) |
| 727 | /// matches 'int a;' and 'int b;' but not 'int c;'. |
| 728 | AST_MATCHER_P(FieldDecl, hasInClassInitializer, internal::Matcher<Expr>,namespace internal { class matcher_hasInClassInitializer0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< FieldDecl> { public: explicit matcher_hasInClassInitializer0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const FieldDecl &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<FieldDecl > hasInClassInitializer( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_hasInClassInitializer0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <FieldDecl> ( &hasInClassInitializer_Type0)(internal ::Matcher<Expr> const &InnerMatcher); inline bool internal ::matcher_hasInClassInitializer0Matcher::matches( const FieldDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 729 | InnerMatcher)namespace internal { class matcher_hasInClassInitializer0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< FieldDecl> { public: explicit matcher_hasInClassInitializer0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const FieldDecl &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<FieldDecl > hasInClassInitializer( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_hasInClassInitializer0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <FieldDecl> ( &hasInClassInitializer_Type0)(internal ::Matcher<Expr> const &InnerMatcher); inline bool internal ::matcher_hasInClassInitializer0Matcher::matches( const FieldDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 730 | const Expr *Initializer = Node.getInClassInitializer(); |
| 731 | return (Initializer != nullptr && |
| 732 | InnerMatcher.matches(*Initializer, Finder, Builder)); |
| 733 | } |
| 734 | |
| 735 | /// Determines whether the function is "main", which is the entry point |
| 736 | /// into an executable program. |
| 737 | AST_MATCHER(FunctionDecl, isMain)namespace internal { class matcher_isMainMatcher : public ::clang ::ast_matchers::internal::MatcherInterface<FunctionDecl> { public: explicit matcher_isMainMatcher() = default; bool matches (const FunctionDecl &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::Matcher<FunctionDecl> isMain() { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_isMainMatcher ()); } inline bool internal::matcher_isMainMatcher::matches( const FunctionDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 738 | return Node.isMain(); |
| 739 | } |
| 740 | |
| 741 | /// Matches the specialized template of a specialization declaration. |
| 742 | /// |
| 743 | /// Given |
| 744 | /// \code |
| 745 | /// template<typename T> class A {}; #1 |
| 746 | /// template<> class A<int> {}; #2 |
| 747 | /// \endcode |
| 748 | /// classTemplateSpecializationDecl(hasSpecializedTemplate(classTemplateDecl())) |
| 749 | /// matches '#2' with classTemplateDecl() matching the class template |
| 750 | /// declaration of 'A' at #1. |
| 751 | AST_MATCHER_P(ClassTemplateSpecializationDecl, hasSpecializedTemplate,namespace internal { class matcher_hasSpecializedTemplate0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< ClassTemplateSpecializationDecl> { public: explicit matcher_hasSpecializedTemplate0Matcher ( internal::Matcher<ClassTemplateDecl> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const ClassTemplateSpecializationDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<ClassTemplateDecl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<ClassTemplateSpecializationDecl> hasSpecializedTemplate ( internal::Matcher<ClassTemplateDecl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_hasSpecializedTemplate0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<ClassTemplateSpecializationDecl > ( &hasSpecializedTemplate_Type0)(internal::Matcher< ClassTemplateDecl> const &InnerMatcher); inline bool internal ::matcher_hasSpecializedTemplate0Matcher::matches( const ClassTemplateSpecializationDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 752 | internal::Matcher<ClassTemplateDecl>, InnerMatcher)namespace internal { class matcher_hasSpecializedTemplate0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< ClassTemplateSpecializationDecl> { public: explicit matcher_hasSpecializedTemplate0Matcher ( internal::Matcher<ClassTemplateDecl> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const ClassTemplateSpecializationDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<ClassTemplateDecl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<ClassTemplateSpecializationDecl> hasSpecializedTemplate ( internal::Matcher<ClassTemplateDecl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_hasSpecializedTemplate0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<ClassTemplateSpecializationDecl > ( &hasSpecializedTemplate_Type0)(internal::Matcher< ClassTemplateDecl> const &InnerMatcher); inline bool internal ::matcher_hasSpecializedTemplate0Matcher::matches( const ClassTemplateSpecializationDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 753 | const ClassTemplateDecl* Decl = Node.getSpecializedTemplate(); |
| 754 | return (Decl != nullptr && |
| 755 | InnerMatcher.matches(*Decl, Finder, Builder)); |
| 756 | } |
| 757 | |
| 758 | /// Matches an entity that has been implicitly added by the compiler (e.g. |
| 759 | /// implicit default/copy constructors). |
| 760 | AST_POLYMORPHIC_MATCHER(isImplicit,namespace internal { template <typename NodeType> class matcher_isImplicitMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isImplicitMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Attr , LambdaCapture>)> isImplicit() { return ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isImplicitMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Attr , LambdaCapture>)>(); } template <typename NodeType> bool internal::matcher_isImplicitMatcher<NodeType>::matches ( const NodeType &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 761 | AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Attr,namespace internal { template <typename NodeType> class matcher_isImplicitMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isImplicitMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Attr , LambdaCapture>)> isImplicit() { return ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isImplicitMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Attr , LambdaCapture>)>(); } template <typename NodeType> bool internal::matcher_isImplicitMatcher<NodeType>::matches ( const NodeType &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 762 | LambdaCapture))namespace internal { template <typename NodeType> class matcher_isImplicitMatcher : public ::clang::ast_matchers::internal ::MatcherInterface<NodeType> { public: bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isImplicitMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Attr , LambdaCapture>)> isImplicit() { return ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isImplicitMatcher , void(::clang::ast_matchers::internal::TypeList<Decl, Attr , LambdaCapture>)>(); } template <typename NodeType> bool internal::matcher_isImplicitMatcher<NodeType>::matches ( const NodeType &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 763 | return Node.isImplicit(); |
| 764 | } |
| 765 | |
| 766 | /// Matches classTemplateSpecializations, templateSpecializationType and |
| 767 | /// functionDecl that have at least one TemplateArgument matching the given |
| 768 | /// InnerMatcher. |
| 769 | /// |
| 770 | /// Given |
| 771 | /// \code |
| 772 | /// template<typename T> class A {}; |
| 773 | /// template<> class A<double> {}; |
| 774 | /// A<int> a; |
| 775 | /// |
| 776 | /// template<typename T> f() {}; |
| 777 | /// void func() { f<int>(); }; |
| 778 | /// \endcode |
| 779 | /// |
| 780 | /// \endcode |
| 781 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |
| 782 | /// refersToType(asString("int")))) |
| 783 | /// matches the specialization \c A<int> |
| 784 | /// |
| 785 | /// functionDecl(hasAnyTemplateArgument(refersToType(asString("int")))) |
| 786 | /// matches the specialization \c f<int> |
| 787 | AST_POLYMORPHIC_MATCHER_P(namespace internal { template <typename NodeType, typename ParamT> class matcher_hasAnyTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_hasAnyTemplateArgument0Matcher ( internal::Matcher<TemplateArgument> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateArgument > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > hasAnyTemplateArgument(internal ::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasAnyTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), internal::Matcher<TemplateArgument> >(InnerMatcher); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > (&hasAnyTemplateArgument_Type0 )(internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT> bool internal :: matcher_hasAnyTemplateArgument0Matcher<NodeType, ParamT >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 788 | hasAnyTemplateArgument,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasAnyTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_hasAnyTemplateArgument0Matcher ( internal::Matcher<TemplateArgument> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateArgument > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > hasAnyTemplateArgument(internal ::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasAnyTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), internal::Matcher<TemplateArgument> >(InnerMatcher); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > (&hasAnyTemplateArgument_Type0 )(internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT> bool internal :: matcher_hasAnyTemplateArgument0Matcher<NodeType, ParamT >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 789 | AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasAnyTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_hasAnyTemplateArgument0Matcher ( internal::Matcher<TemplateArgument> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateArgument > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > hasAnyTemplateArgument(internal ::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasAnyTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), internal::Matcher<TemplateArgument> >(InnerMatcher); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > (&hasAnyTemplateArgument_Type0 )(internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT> bool internal :: matcher_hasAnyTemplateArgument0Matcher<NodeType, ParamT >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 790 | TemplateSpecializationType,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasAnyTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_hasAnyTemplateArgument0Matcher ( internal::Matcher<TemplateArgument> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateArgument > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > hasAnyTemplateArgument(internal ::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasAnyTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), internal::Matcher<TemplateArgument> >(InnerMatcher); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > (&hasAnyTemplateArgument_Type0 )(internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT> bool internal :: matcher_hasAnyTemplateArgument0Matcher<NodeType, ParamT >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 791 | FunctionDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_hasAnyTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_hasAnyTemplateArgument0Matcher ( internal::Matcher<TemplateArgument> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateArgument > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > hasAnyTemplateArgument(internal ::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasAnyTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), internal::Matcher<TemplateArgument> >(InnerMatcher); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > (&hasAnyTemplateArgument_Type0 )(internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT> bool internal :: matcher_hasAnyTemplateArgument0Matcher<NodeType, ParamT >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 792 | internal::Matcher<TemplateArgument>, InnerMatcher)namespace internal { template <typename NodeType, typename ParamT> class matcher_hasAnyTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_hasAnyTemplateArgument0Matcher ( internal::Matcher<TemplateArgument> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateArgument > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > hasAnyTemplateArgument(internal ::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasAnyTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), internal::Matcher<TemplateArgument> >(InnerMatcher); } typedef ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasAnyTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), internal::Matcher <TemplateArgument> > (&hasAnyTemplateArgument_Type0 )(internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT> bool internal :: matcher_hasAnyTemplateArgument0Matcher<NodeType, ParamT >::matches( const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 793 | ArrayRef<TemplateArgument> List = |
| 794 | internal::getTemplateSpecializationArgs(Node); |
| 795 | return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder, |
| 796 | Builder) != List.end(); |
| 797 | } |
| 798 | |
| 799 | /// Causes all nested matchers to be matched with the specified traversal kind. |
| 800 | /// |
| 801 | /// Given |
| 802 | /// \code |
| 803 | /// void foo() |
| 804 | /// { |
| 805 | /// int i = 3.0; |
| 806 | /// } |
| 807 | /// \endcode |
| 808 | /// The matcher |
| 809 | /// \code |
| 810 | /// traverse(TK_IgnoreUnlessSpelledInSource, |
| 811 | /// varDecl(hasInitializer(floatLiteral().bind("init"))) |
| 812 | /// ) |
| 813 | /// \endcode |
| 814 | /// matches the variable declaration with "init" bound to the "3.0". |
| 815 | template <typename T> |
| 816 | internal::Matcher<T> traverse(TraversalKind TK, |
| 817 | const internal::Matcher<T> &InnerMatcher) { |
| 818 | return internal::DynTypedMatcher::constructRestrictedWrapper( |
| 819 | new internal::TraversalMatcher<T>(TK, InnerMatcher), |
| 820 | InnerMatcher.getID().first) |
| 821 | .template unconditionalConvertTo<T>(); |
| 822 | } |
| 823 | |
| 824 | template <typename T> |
| 825 | internal::BindableMatcher<T> |
| 826 | traverse(TraversalKind TK, const internal::BindableMatcher<T> &InnerMatcher) { |
| 827 | return internal::BindableMatcher<T>( |
| 828 | internal::DynTypedMatcher::constructRestrictedWrapper( |
| 829 | new internal::TraversalMatcher<T>(TK, InnerMatcher), |
| 830 | InnerMatcher.getID().first) |
| 831 | .template unconditionalConvertTo<T>()); |
| 832 | } |
| 833 | |
| 834 | template <typename... T> |
| 835 | internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>> |
| 836 | traverse(TraversalKind TK, |
| 837 | const internal::VariadicOperatorMatcher<T...> &InnerMatcher) { |
| 838 | return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>( |
| 839 | TK, InnerMatcher); |
| 840 | } |
| 841 | |
| 842 | template <template <typename ToArg, typename FromArg> class ArgumentAdapterT, |
| 843 | typename T, typename ToTypes> |
| 844 | internal::TraversalWrapper< |
| 845 | internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>> |
| 846 | traverse(TraversalKind TK, const internal::ArgumentAdaptingMatcherFuncAdaptor< |
| 847 | ArgumentAdapterT, T, ToTypes> &InnerMatcher) { |
| 848 | return internal::TraversalWrapper< |
| 849 | internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, |
| 850 | ToTypes>>(TK, InnerMatcher); |
| 851 | } |
| 852 | |
| 853 | template <template <typename T, typename... P> class MatcherT, typename... P, |
| 854 | typename ReturnTypesF> |
| 855 | internal::TraversalWrapper< |
| 856 | internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>> |
| 857 | traverse(TraversalKind TK, |
| 858 | const internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...> |
| 859 | &InnerMatcher) { |
| 860 | return internal::TraversalWrapper< |
| 861 | internal::PolymorphicMatcher<MatcherT, ReturnTypesF, P...>>(TK, |
| 862 | InnerMatcher); |
| 863 | } |
| 864 | |
| 865 | template <typename... T> |
| 866 | internal::Matcher<typename internal::GetClade<T...>::Type> |
| 867 | traverse(TraversalKind TK, const internal::MapAnyOfHelper<T...> &InnerMatcher) { |
| 868 | return traverse(TK, InnerMatcher.with()); |
| 869 | } |
| 870 | |
| 871 | /// Matches expressions that match InnerMatcher after any implicit AST |
| 872 | /// nodes are stripped off. |
| 873 | /// |
| 874 | /// Parentheses and explicit casts are not discarded. |
| 875 | /// Given |
| 876 | /// \code |
| 877 | /// class C {}; |
| 878 | /// C a = C(); |
| 879 | /// C b; |
| 880 | /// C c = b; |
| 881 | /// \endcode |
| 882 | /// The matchers |
| 883 | /// \code |
| 884 | /// varDecl(hasInitializer(ignoringImplicit(cxxConstructExpr()))) |
| 885 | /// \endcode |
| 886 | /// would match the declarations for a, b, and c. |
| 887 | /// While |
| 888 | /// \code |
| 889 | /// varDecl(hasInitializer(cxxConstructExpr())) |
| 890 | /// \endcode |
| 891 | /// only match the declarations for b and c. |
| 892 | AST_MATCHER_P(Expr, ignoringImplicit, internal::Matcher<Expr>,namespace internal { class matcher_ignoringImplicit0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringImplicit0Matcher( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringImplicit ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringImplicit0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<Expr> ( &ignoringImplicit_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringImplicit0Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 893 | InnerMatcher)namespace internal { class matcher_ignoringImplicit0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringImplicit0Matcher( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringImplicit ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringImplicit0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<Expr> ( &ignoringImplicit_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringImplicit0Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 894 | return InnerMatcher.matches(*Node.IgnoreImplicit(), Finder, Builder); |
| 895 | } |
| 896 | |
| 897 | /// Matches expressions that match InnerMatcher after any implicit casts |
| 898 | /// are stripped off. |
| 899 | /// |
| 900 | /// Parentheses and explicit casts are not discarded. |
| 901 | /// Given |
| 902 | /// \code |
| 903 | /// int arr[5]; |
| 904 | /// int a = 0; |
| 905 | /// char b = 0; |
| 906 | /// const int c = a; |
| 907 | /// int *d = arr; |
| 908 | /// long e = (long) 0l; |
| 909 | /// \endcode |
| 910 | /// The matchers |
| 911 | /// \code |
| 912 | /// varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))) |
| 913 | /// varDecl(hasInitializer(ignoringImpCasts(declRefExpr()))) |
| 914 | /// \endcode |
| 915 | /// would match the declarations for a, b, c, and d, but not e. |
| 916 | /// While |
| 917 | /// \code |
| 918 | /// varDecl(hasInitializer(integerLiteral())) |
| 919 | /// varDecl(hasInitializer(declRefExpr())) |
| 920 | /// \endcode |
| 921 | /// only match the declarations for a. |
| 922 | AST_MATCHER_P(Expr, ignoringImpCasts,namespace internal { class matcher_ignoringImpCasts0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringImpCasts0Matcher( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringImpCasts ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringImpCasts0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<Expr> ( &ignoringImpCasts_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringImpCasts0Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 923 | internal::Matcher<Expr>, InnerMatcher)namespace internal { class matcher_ignoringImpCasts0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringImpCasts0Matcher( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringImpCasts ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringImpCasts0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<Expr> ( &ignoringImpCasts_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringImpCasts0Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 924 | return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder); |
| 925 | } |
| 926 | |
| 927 | /// Matches expressions that match InnerMatcher after parentheses and |
| 928 | /// casts are stripped off. |
| 929 | /// |
| 930 | /// Implicit and non-C Style casts are also discarded. |
| 931 | /// Given |
| 932 | /// \code |
| 933 | /// int a = 0; |
| 934 | /// char b = (0); |
| 935 | /// void* c = reinterpret_cast<char*>(0); |
| 936 | /// char d = char(0); |
| 937 | /// \endcode |
| 938 | /// The matcher |
| 939 | /// varDecl(hasInitializer(ignoringParenCasts(integerLiteral()))) |
| 940 | /// would match the declarations for a, b, c, and d. |
| 941 | /// while |
| 942 | /// varDecl(hasInitializer(integerLiteral())) |
| 943 | /// only match the declaration for a. |
| 944 | AST_MATCHER_P(Expr, ignoringParenCasts, internal::Matcher<Expr>, InnerMatcher)namespace internal { class matcher_ignoringParenCasts0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringParenCasts0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringParenCasts ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringParenCasts0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<Expr> ( &ignoringParenCasts_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringParenCasts0Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 945 | return InnerMatcher.matches(*Node.IgnoreParenCasts(), Finder, Builder); |
| 946 | } |
| 947 | |
| 948 | /// Matches expressions that match InnerMatcher after implicit casts and |
| 949 | /// parentheses are stripped off. |
| 950 | /// |
| 951 | /// Explicit casts are not discarded. |
| 952 | /// Given |
| 953 | /// \code |
| 954 | /// int arr[5]; |
| 955 | /// int a = 0; |
| 956 | /// char b = (0); |
| 957 | /// const int c = a; |
| 958 | /// int *d = (arr); |
| 959 | /// long e = ((long) 0l); |
| 960 | /// \endcode |
| 961 | /// The matchers |
| 962 | /// varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral()))) |
| 963 | /// varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr()))) |
| 964 | /// would match the declarations for a, b, c, and d, but not e. |
| 965 | /// while |
| 966 | /// varDecl(hasInitializer(integerLiteral())) |
| 967 | /// varDecl(hasInitializer(declRefExpr())) |
| 968 | /// would only match the declaration for a. |
| 969 | AST_MATCHER_P(Expr, ignoringParenImpCasts,namespace internal { class matcher_ignoringParenImpCasts0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringParenImpCasts0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringParenImpCasts ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringParenImpCasts0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<Expr> ( & ignoringParenImpCasts_Type0)(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringParenImpCasts0Matcher ::matches( const Expr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 970 | internal::Matcher<Expr>, InnerMatcher)namespace internal { class matcher_ignoringParenImpCasts0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_ignoringParenImpCasts0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Expr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringParenImpCasts ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringParenImpCasts0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<Expr> ( & ignoringParenImpCasts_Type0)(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringParenImpCasts0Matcher ::matches( const Expr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 971 | return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder); |
| 972 | } |
| 973 | |
| 974 | /// Matches types that match InnerMatcher after any parens are stripped. |
| 975 | /// |
| 976 | /// Given |
| 977 | /// \code |
| 978 | /// void (*fp)(void); |
| 979 | /// \endcode |
| 980 | /// The matcher |
| 981 | /// \code |
| 982 | /// varDecl(hasType(pointerType(pointee(ignoringParens(functionType()))))) |
| 983 | /// \endcode |
| 984 | /// would match the declaration for fp. |
| 985 | AST_MATCHER_P_OVERLOAD(QualType, ignoringParens, internal::Matcher<QualType>,namespace internal { class matcher_ignoringParens0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<QualType > { public: explicit matcher_ignoringParens0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const QualType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<QualType> InnerMatcher; }; } inline ::clang::ast_matchers::internal::Matcher<QualType> ignoringParens ( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_ignoringParens0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<QualType> ( & ignoringParens_Type0)(internal::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_ignoringParens0Matcher ::matches( const QualType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 986 | InnerMatcher, 0)namespace internal { class matcher_ignoringParens0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<QualType > { public: explicit matcher_ignoringParens0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const QualType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<QualType> InnerMatcher; }; } inline ::clang::ast_matchers::internal::Matcher<QualType> ignoringParens ( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_ignoringParens0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<QualType> ( & ignoringParens_Type0)(internal::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_ignoringParens0Matcher ::matches( const QualType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 987 | return InnerMatcher.matches(Node.IgnoreParens(), Finder, Builder); |
| 988 | } |
| 989 | |
| 990 | /// Overload \c ignoringParens for \c Expr. |
| 991 | /// |
| 992 | /// Given |
| 993 | /// \code |
| 994 | /// const char* str = ("my-string"); |
| 995 | /// \endcode |
| 996 | /// The matcher |
| 997 | /// \code |
| 998 | /// implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral()))) |
| 999 | /// \endcode |
| 1000 | /// would match the implicit cast resulting from the assignment. |
| 1001 | AST_MATCHER_P_OVERLOAD(Expr, ignoringParens, internal::Matcher<Expr>,namespace internal { class matcher_ignoringParens1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<Expr> { public: explicit matcher_ignoringParens1Matcher( internal:: Matcher<Expr> const &AInnerMatcher) : InnerMatcher( AInnerMatcher) {} bool matches(const Expr &Node, ::clang:: ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringParens( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringParens1Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<Expr> ( &ignoringParens_Type1 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringParens1Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 1002 | InnerMatcher, 1)namespace internal { class matcher_ignoringParens1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<Expr> { public: explicit matcher_ignoringParens1Matcher( internal:: Matcher<Expr> const &AInnerMatcher) : InnerMatcher( AInnerMatcher) {} bool matches(const Expr &Node, ::clang:: ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Expr> ignoringParens( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_ignoringParens1Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<Expr> ( &ignoringParens_Type1 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_ignoringParens1Matcher::matches( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 1003 | const Expr *E = Node.IgnoreParens(); |
| 1004 | return InnerMatcher.matches(*E, Finder, Builder); |
| 1005 | } |
| 1006 | |
| 1007 | /// Matches expressions that are instantiation-dependent even if it is |
| 1008 | /// neither type- nor value-dependent. |
| 1009 | /// |
| 1010 | /// In the following example, the expression sizeof(sizeof(T() + T())) |
| 1011 | /// is instantiation-dependent (since it involves a template parameter T), |
| 1012 | /// but is neither type- nor value-dependent, since the type of the inner |
| 1013 | /// sizeof is known (std::size_t) and therefore the size of the outer |
| 1014 | /// sizeof is known. |
| 1015 | /// \code |
| 1016 | /// template<typename T> |
| 1017 | /// void f(T x, T y) { sizeof(sizeof(T() + T()); } |
| 1018 | /// \endcode |
| 1019 | /// expr(isInstantiationDependent()) matches sizeof(sizeof(T() + T()) |
| 1020 | AST_MATCHER(Expr, isInstantiationDependent)namespace internal { class matcher_isInstantiationDependentMatcher : public ::clang::ast_matchers::internal::MatcherInterface< Expr> { public: explicit matcher_isInstantiationDependentMatcher () = default; bool matches(const Expr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<Expr> isInstantiationDependent () { return ::clang::ast_matchers::internal::makeMatcher( new internal::matcher_isInstantiationDependentMatcher()); } inline bool internal::matcher_isInstantiationDependentMatcher::matches ( const Expr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 1021 | return Node.isInstantiationDependent(); |
| 1022 | } |
| 1023 | |
| 1024 | /// Matches expressions that are type-dependent because the template type |
| 1025 | /// is not yet instantiated. |
| 1026 | /// |
| 1027 | /// For example, the expressions "x" and "x + y" are type-dependent in |
| 1028 | /// the following code, but "y" is not type-dependent: |
| 1029 | /// \code |
| 1030 | /// template<typename T> |
| 1031 | /// void add(T x, int y) { |
| 1032 | /// x + y; |
| 1033 | /// } |
| 1034 | /// \endcode |
| 1035 | /// expr(isTypeDependent()) matches x + y |
| 1036 | AST_MATCHER(Expr, isTypeDependent)namespace internal { class matcher_isTypeDependentMatcher : public ::clang::ast_matchers::internal::MatcherInterface<Expr> { public: explicit matcher_isTypeDependentMatcher() = default ; bool matches(const Expr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::Matcher<Expr> isTypeDependent() { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_isTypeDependentMatcher ()); } inline bool internal::matcher_isTypeDependentMatcher:: matches( const Expr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { return Node.isTypeDependent(); } |
| 1037 | |
| 1038 | /// Matches expression that are value-dependent because they contain a |
| 1039 | /// non-type template parameter. |
| 1040 | /// |
| 1041 | /// For example, the array bound of "Chars" in the following example is |
| 1042 | /// value-dependent. |
| 1043 | /// \code |
| 1044 | /// template<int Size> int f() { return Size; } |
| 1045 | /// \endcode |
| 1046 | /// expr(isValueDependent()) matches return Size |
| 1047 | AST_MATCHER(Expr, isValueDependent)namespace internal { class matcher_isValueDependentMatcher : public ::clang::ast_matchers::internal::MatcherInterface<Expr> { public: explicit matcher_isValueDependentMatcher() = default ; bool matches(const Expr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::Matcher<Expr> isValueDependent() { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_isValueDependentMatcher ()); } inline bool internal::matcher_isValueDependentMatcher:: matches( const Expr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { return Node.isValueDependent(); } |
| 1048 | |
| 1049 | /// Matches classTemplateSpecializations, templateSpecializationType and |
| 1050 | /// functionDecl where the n'th TemplateArgument matches the given InnerMatcher. |
| 1051 | /// |
| 1052 | /// Given |
| 1053 | /// \code |
| 1054 | /// template<typename T, typename U> class A {}; |
| 1055 | /// A<bool, int> b; |
| 1056 | /// A<int, bool> c; |
| 1057 | /// |
| 1058 | /// template<typename T> void f() {} |
| 1059 | /// void func() { f<int>(); }; |
| 1060 | /// \endcode |
| 1061 | /// classTemplateSpecializationDecl(hasTemplateArgument( |
| 1062 | /// 1, refersToType(asString("int")))) |
| 1063 | /// matches the specialization \c A<bool, int> |
| 1064 | /// |
| 1065 | /// functionDecl(hasTemplateArgument(0, refersToType(asString("int")))) |
| 1066 | /// matches the specialization \c f<int> |
| 1067 | AST_POLYMORPHIC_MATCHER_P2(namespace internal { template <typename NodeType, typename ParamT1, typename ParamT2> class matcher_hasTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: matcher_hasTemplateArgument0Matcher(unsigned const &AN, internal::Matcher<TemplateArgument> const &AInnerMatcher) : N(AN), InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; internal::Matcher <TemplateArgument> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> > hasTemplateArgument(unsigned const &N, internal::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal:: PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> >(N, InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), unsigned, internal::Matcher<TemplateArgument > > (&hasTemplateArgument_Type0)( unsigned const & N, internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT1, typename ParamT2> bool internal::matcher_hasTemplateArgument0Matcher < NodeType, ParamT1, ParamT2>:: matches(const NodeType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 1068 | hasTemplateArgument,namespace internal { template <typename NodeType, typename ParamT1, typename ParamT2> class matcher_hasTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: matcher_hasTemplateArgument0Matcher(unsigned const &AN, internal::Matcher<TemplateArgument> const &AInnerMatcher) : N(AN), InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; internal::Matcher <TemplateArgument> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> > hasTemplateArgument(unsigned const &N, internal::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal:: PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> >(N, InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), unsigned, internal::Matcher<TemplateArgument > > (&hasTemplateArgument_Type0)( unsigned const & N, internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT1, typename ParamT2> bool internal::matcher_hasTemplateArgument0Matcher < NodeType, ParamT1, ParamT2>:: matches(const NodeType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 1069 | AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl,namespace internal { template <typename NodeType, typename ParamT1, typename ParamT2> class matcher_hasTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: matcher_hasTemplateArgument0Matcher(unsigned const &AN, internal::Matcher<TemplateArgument> const &AInnerMatcher) : N(AN), InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; internal::Matcher <TemplateArgument> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> > hasTemplateArgument(unsigned const &N, internal::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal:: PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> >(N, InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), unsigned, internal::Matcher<TemplateArgument > > (&hasTemplateArgument_Type0)( unsigned const & N, internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT1, typename ParamT2> bool internal::matcher_hasTemplateArgument0Matcher < NodeType, ParamT1, ParamT2>:: matches(const NodeType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 1070 | TemplateSpecializationType,namespace internal { template <typename NodeType, typename ParamT1, typename ParamT2> class matcher_hasTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: matcher_hasTemplateArgument0Matcher(unsigned const &AN, internal::Matcher<TemplateArgument> const &AInnerMatcher) : N(AN), InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; internal::Matcher <TemplateArgument> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> > hasTemplateArgument(unsigned const &N, internal::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal:: PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> >(N, InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), unsigned, internal::Matcher<TemplateArgument > > (&hasTemplateArgument_Type0)( unsigned const & N, internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT1, typename ParamT2> bool internal::matcher_hasTemplateArgument0Matcher < NodeType, ParamT1, ParamT2>:: matches(const NodeType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 1071 | FunctionDecl),namespace internal { template <typename NodeType, typename ParamT1, typename ParamT2> class matcher_hasTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: matcher_hasTemplateArgument0Matcher(unsigned const &AN, internal::Matcher<TemplateArgument> const &AInnerMatcher) : N(AN), InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; internal::Matcher <TemplateArgument> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> > hasTemplateArgument(unsigned const &N, internal::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal:: PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> >(N, InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), unsigned, internal::Matcher<TemplateArgument > > (&hasTemplateArgument_Type0)( unsigned const & N, internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT1, typename ParamT2> bool internal::matcher_hasTemplateArgument0Matcher < NodeType, ParamT1, ParamT2>:: matches(const NodeType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 1072 | unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher)namespace internal { template <typename NodeType, typename ParamT1, typename ParamT2> class matcher_hasTemplateArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NodeType> { public: matcher_hasTemplateArgument0Matcher(unsigned const &AN, internal::Matcher<TemplateArgument> const &AInnerMatcher) : N(AN), InnerMatcher(AInnerMatcher) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; internal::Matcher <TemplateArgument> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> > hasTemplateArgument(unsigned const &N, internal::Matcher<TemplateArgument> const &InnerMatcher) { return ::clang::ast_matchers::internal:: PolymorphicMatcher< internal::matcher_hasTemplateArgument0Matcher , void(::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType, FunctionDecl>), unsigned, internal ::Matcher<TemplateArgument> >(N, InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTemplateArgument0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType , FunctionDecl>), unsigned, internal::Matcher<TemplateArgument > > (&hasTemplateArgument_Type0)( unsigned const & N, internal::Matcher<TemplateArgument> const &InnerMatcher ); template <typename NodeType, typename ParamT1, typename ParamT2> bool internal::matcher_hasTemplateArgument0Matcher < NodeType, ParamT1, ParamT2>:: matches(const NodeType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const { |
| 1073 | ArrayRef<TemplateArgument> List = |
| 1074 | internal::getTemplateSpecializationArgs(Node); |
| 1075 | if (List.size() <= N) |
| 1076 | return false; |
| 1077 | return InnerMatcher.matches(List[N], Finder, Builder); |
| 1078 | } |
| 1079 | |
| 1080 | /// Matches if the number of template arguments equals \p N. |
| 1081 | /// |
| 1082 | /// Given |
| 1083 | /// \code |
| 1084 | /// template<typename T> struct C {}; |
| 1085 | /// C<int> c; |
| 1086 | /// \endcode |
| 1087 | /// classTemplateSpecializationDecl(templateArgumentCountIs(1)) |
| 1088 | /// matches C<int>. |
| 1089 | AST_POLYMORPHIC_MATCHER_P(namespace internal { template <typename NodeType, typename ParamT> class matcher_templateArgumentCountIs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_templateArgumentCountIs0Matcher ( unsigned const &AN) : N(AN) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> templateArgumentCountIs(unsigned const & N) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_templateArgumentCountIs0Matcher, void( ::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType>), unsigned>(N); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> (&templateArgumentCountIs_Type0)(unsigned const &N); template <typename NodeType, typename ParamT > bool internal:: matcher_templateArgumentCountIs0Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 1090 | templateArgumentCountIs,namespace internal { template <typename NodeType, typename ParamT> class matcher_templateArgumentCountIs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_templateArgumentCountIs0Matcher ( unsigned const &AN) : N(AN) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> templateArgumentCountIs(unsigned const & N) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_templateArgumentCountIs0Matcher, void( ::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType>), unsigned>(N); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> (&templateArgumentCountIs_Type0)(unsigned const &N); template <typename NodeType, typename ParamT > bool internal:: matcher_templateArgumentCountIs0Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 1091 | AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl,namespace internal { template <typename NodeType, typename ParamT> class matcher_templateArgumentCountIs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_templateArgumentCountIs0Matcher ( unsigned const &AN) : N(AN) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> templateArgumentCountIs(unsigned const & N) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_templateArgumentCountIs0Matcher, void( ::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType>), unsigned>(N); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> (&templateArgumentCountIs_Type0)(unsigned const &N); template <typename NodeType, typename ParamT > bool internal:: matcher_templateArgumentCountIs0Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 1092 | TemplateSpecializationType),namespace internal { template <typename NodeType, typename ParamT> class matcher_templateArgumentCountIs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_templateArgumentCountIs0Matcher ( unsigned const &AN) : N(AN) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> templateArgumentCountIs(unsigned const & N) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_templateArgumentCountIs0Matcher, void( ::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType>), unsigned>(N); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> (&templateArgumentCountIs_Type0)(unsigned const &N); template <typename NodeType, typename ParamT > bool internal:: matcher_templateArgumentCountIs0Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 1093 | unsigned, N)namespace internal { template <typename NodeType, typename ParamT> class matcher_templateArgumentCountIs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_templateArgumentCountIs0Matcher ( unsigned const &AN) : N(AN) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> templateArgumentCountIs(unsigned const & N) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_templateArgumentCountIs0Matcher, void( ::clang::ast_matchers::internal::TypeList<ClassTemplateSpecializationDecl , TemplateSpecializationType>), unsigned>(N); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_templateArgumentCountIs0Matcher, void(::clang::ast_matchers ::internal::TypeList<ClassTemplateSpecializationDecl, TemplateSpecializationType >), unsigned> (&templateArgumentCountIs_Type0)(unsigned const &N); template <typename NodeType, typename ParamT > bool internal:: matcher_templateArgumentCountIs0Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const { |
| 1094 | return internal::getTemplateSpecializationArgs(Node).size() == N; |
| 1095 | } |
| 1096 | |
| 1097 | /// Matches a TemplateArgument that refers to a certain type. |
| 1098 | /// |
| 1099 | /// Given |
| 1100 | /// \code |
| 1101 | /// struct X {}; |
| 1102 | /// template<typename T> struct A {}; |
| 1103 | /// A<X> a; |
| 1104 | /// \endcode |
| 1105 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType( |
| 1106 | /// recordType(hasDeclaration(recordDecl(hasName("X"))))))) |
| 1107 | /// matches the specialization of \c struct A generated by \c A<X>. |
| 1108 | AST_MATCHER_P(TemplateArgument, refersToType,namespace internal { class matcher_refersToType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<TemplateArgument > { public: explicit matcher_refersToType0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const TemplateArgument &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<QualType> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > refersToType( internal::Matcher<QualType> const & InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_refersToType0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<TemplateArgument > ( &refersToType_Type0)(internal::Matcher<QualType > const &InnerMatcher); inline bool internal::matcher_refersToType0Matcher ::matches( const TemplateArgument &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 1109 | internal::Matcher<QualType>, InnerMatcher)namespace internal { class matcher_refersToType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<TemplateArgument > { public: explicit matcher_refersToType0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const TemplateArgument &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<QualType> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > refersToType( internal::Matcher<QualType> const & InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_refersToType0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<TemplateArgument > ( &refersToType_Type0)(internal::Matcher<QualType > const &InnerMatcher); inline bool internal::matcher_refersToType0Matcher ::matches( const TemplateArgument &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 1110 | if (Node.getKind() != TemplateArgument::Type) |
| 1111 | return false; |
| 1112 | return InnerMatcher.matches(Node.getAsType(), Finder, Builder); |
| 1113 | } |
| 1114 | |
| 1115 | /// Matches a TemplateArgument that refers to a certain template. |
| 1116 | /// |
| 1117 | /// Given |
| 1118 | /// \code |
| 1119 | /// template<template <typename> class S> class X {}; |
| 1120 | /// template<typename T> class Y {}; |
| 1121 | /// X<Y> xi; |
| 1122 | /// \endcode |
| 1123 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |
| 1124 | /// refersToTemplate(templateName()))) |
| 1125 | /// matches the specialization \c X<Y> |
| 1126 | AST_MATCHER_P(TemplateArgument, refersToTemplate,namespace internal { class matcher_refersToTemplate0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_refersToTemplate0Matcher ( internal::Matcher<TemplateName> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateName > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<TemplateArgument> refersToTemplate( internal:: Matcher<TemplateName> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_refersToTemplate0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<TemplateArgument> ( &refersToTemplate_Type0)(internal::Matcher<TemplateName > const &InnerMatcher); inline bool internal::matcher_refersToTemplate0Matcher ::matches( const TemplateArgument &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 1127 | internal::Matcher<TemplateName>, InnerMatcher)namespace internal { class matcher_refersToTemplate0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_refersToTemplate0Matcher ( internal::Matcher<TemplateName> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TemplateName > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<TemplateArgument> refersToTemplate( internal:: Matcher<TemplateName> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_refersToTemplate0Matcher(InnerMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<TemplateArgument> ( &refersToTemplate_Type0)(internal::Matcher<TemplateName > const &InnerMatcher); inline bool internal::matcher_refersToTemplate0Matcher ::matches( const TemplateArgument &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 1128 | if (Node.getKind() != TemplateArgument::Template) |
| 1129 | return false; |
| 1130 | return InnerMatcher.matches(Node.getAsTemplate(), Finder, Builder); |
| 1131 | } |
| 1132 | |
| 1133 | /// Matches a canonical TemplateArgument that refers to a certain |
| 1134 | /// declaration. |
| 1135 | /// |
| 1136 | /// Given |
| 1137 | /// \code |
| 1138 | /// struct B { int next; }; |
| 1139 | /// template<int(B::*next_ptr)> struct A {}; |
| 1140 | /// A<&B::next> a; |
| 1141 | /// \endcode |
| 1142 | /// classTemplateSpecializationDecl(hasAnyTemplateArgument( |
| 1143 | /// refersToDeclaration(fieldDecl(hasName("next"))))) |
| 1144 | /// matches the specialization \c A<&B::next> with \c fieldDecl(...) matching |
| 1145 | /// \c B::next |
| 1146 | AST_MATCHER_P(TemplateArgument, refersToDeclaration,namespace internal { class matcher_refersToDeclaration0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_refersToDeclaration0Matcher ( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const TemplateArgument &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Decl> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > refersToDeclaration( internal::Matcher<Decl> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_refersToDeclaration0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <TemplateArgument> ( &refersToDeclaration_Type0)(internal ::Matcher<Decl> const &InnerMatcher); inline bool internal ::matcher_refersToDeclaration0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 1147 | internal::Matcher<Decl>, InnerMatcher)namespace internal { class matcher_refersToDeclaration0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_refersToDeclaration0Matcher ( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const TemplateArgument &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Decl> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > refersToDeclaration( internal::Matcher<Decl> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_refersToDeclaration0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <TemplateArgument> ( &refersToDeclaration_Type0)(internal ::Matcher<Decl> const &InnerMatcher); inline bool internal ::matcher_refersToDeclaration0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 1148 | if (Node.getKind() == TemplateArgument::Declaration) |
| 1149 | return InnerMatcher.matches(*Node.getAsDecl(), Finder, Builder); |
| 1150 | return false; |
| 1151 | } |
| 1152 | |
| 1153 | /// Matches a sugar TemplateArgument that refers to a certain expression. |
| 1154 | /// |
| 1155 | /// Given |
| 1156 | /// \code |
| 1157 | /// struct B { int next; }; |
| 1158 | /// template<int(B::*next_ptr)> struct A {}; |
| 1159 | /// A<&B::next> a; |
| 1160 | /// \endcode |
| 1161 | /// templateSpecializationType(hasAnyTemplateArgument( |
| 1162 | /// isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next")))))))) |
| 1163 | /// matches the specialization \c A<&B::next> with \c fieldDecl(...) matching |
| 1164 | /// \c B::next |
| 1165 | AST_MATCHER_P(TemplateArgument, isExpr, internal::Matcher<Expr>, InnerMatcher)namespace internal { class matcher_isExpr0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<TemplateArgument > { public: explicit matcher_isExpr0Matcher( internal::Matcher <Expr> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const TemplateArgument &Node, ::clang:: ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<TemplateArgument> isExpr ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_isExpr0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers ::internal::Matcher<TemplateArgument> ( &isExpr_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_isExpr0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 1166 | if (Node.getKind() == TemplateArgument::Expression) |
| 1167 | return InnerMatcher.matches(*Node.getAsExpr(), Finder, Builder); |
| 1168 | return false; |
| 1169 | } |
| 1170 | |
| 1171 | /// Matches a TemplateArgument that is an integral value. |
| 1172 | /// |
| 1173 | /// Given |
| 1174 | /// \code |
| 1175 | /// template<int T> struct C {}; |
| 1176 | /// C<42> c; |
| 1177 | /// \endcode |
| 1178 | /// classTemplateSpecializationDecl( |
| 1179 | /// hasAnyTemplateArgument(isIntegral())) |
| 1180 | /// matches the implicit instantiation of C in C<42> |
| 1181 | /// with isIntegral() matching 42. |
| 1182 | AST_MATCHER(TemplateArgument, isIntegral)namespace internal { class matcher_isIntegralMatcher : public ::clang::ast_matchers::internal::MatcherInterface<TemplateArgument > { public: explicit matcher_isIntegralMatcher() = default ; bool matches(const TemplateArgument &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > isIntegral() { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_isIntegralMatcher()); } inline bool internal ::matcher_isIntegralMatcher::matches( const TemplateArgument & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const { |
| 1183 | return Node.getKind() == TemplateArgument::Integral; |
| 1184 | } |
| 1185 | |
| 1186 | /// Matches a TemplateArgument that refers to an integral type. |
| 1187 | /// |
| 1188 | /// Given |
| 1189 | /// \code |
| 1190 | /// template<int T> struct C {}; |
| 1191 | /// C<42> c; |
| 1192 | /// \endcode |
| 1193 | /// classTemplateSpecializationDecl( |
| 1194 | /// hasAnyTemplateArgument(refersToIntegralType(asString("int")))) |
| 1195 | /// matches the implicit instantiation of C in C<42>. |
| 1196 | AST_MATCHER_P(TemplateArgument, refersToIntegralType,namespace internal { class matcher_refersToIntegralType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_refersToIntegralType0Matcher ( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches(const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<TemplateArgument> refersToIntegralType( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_refersToIntegralType0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <TemplateArgument> ( &refersToIntegralType_Type0)(internal ::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_refersToIntegralType0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 1197 | internal::Matcher<QualType>, InnerMatcher)namespace internal { class matcher_refersToIntegralType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_refersToIntegralType0Matcher ( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches(const TemplateArgument &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<TemplateArgument> refersToIntegralType( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_refersToIntegralType0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <TemplateArgument> ( &refersToIntegralType_Type0)(internal ::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_refersToIntegralType0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 1198 | if (Node.getKind() != TemplateArgument::Integral) |
| 1199 | return false; |
| 1200 | return InnerMatcher.matches(Node.getIntegralType(), Finder, Builder); |
| 1201 | } |
| 1202 | |
| 1203 | /// Matches a TemplateArgument of integral type with a given value. |
| 1204 | /// |
| 1205 | /// Note that 'Value' is a string as the template argument's value is |
| 1206 | /// an arbitrary precision integer. 'Value' must be euqal to the canonical |
| 1207 | /// representation of that integral value in base 10. |
| 1208 | /// |
| 1209 | /// Given |
| 1210 | /// \code |
| 1211 | /// template<int T> struct C {}; |
| 1212 | /// C<42> c; |
| 1213 | /// \endcode |
| 1214 | /// classTemplateSpecializationDecl( |
| 1215 | /// hasAnyTemplateArgument(equalsIntegralValue("42"))) |
| 1216 | /// matches the implicit instantiation of C in C<42>. |
| 1217 | AST_MATCHER_P(TemplateArgument, equalsIntegralValue,namespace internal { class matcher_equalsIntegralValue0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_equalsIntegralValue0Matcher ( std::string const &AValue) : Value(AValue) {} bool matches (const TemplateArgument &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string Value; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > equalsIntegralValue( std::string const &Value) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_equalsIntegralValue0Matcher(Value)); } typedef ::clang ::ast_matchers::internal::Matcher<TemplateArgument> ( & equalsIntegralValue_Type0)(std::string const &Value); inline bool internal::matcher_equalsIntegralValue0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 1218 | std::string, Value)namespace internal { class matcher_equalsIntegralValue0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< TemplateArgument> { public: explicit matcher_equalsIntegralValue0Matcher ( std::string const &AValue) : Value(AValue) {} bool matches (const TemplateArgument &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string Value; }; } inline ::clang::ast_matchers::internal::Matcher<TemplateArgument > equalsIntegralValue( std::string const &Value) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_equalsIntegralValue0Matcher(Value)); } typedef ::clang ::ast_matchers::internal::Matcher<TemplateArgument> ( & equalsIntegralValue_Type0)(std::string const &Value); inline bool internal::matcher_equalsIntegralValue0Matcher::matches( const TemplateArgument &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 1219 | if (Node.getKind() != TemplateArgument::Integral) |
| 1220 | return false; |
| 1221 | return toString(Node.getAsIntegral(), 10) == Value; |
| 1222 | } |
| 1223 | |
| 1224 | /// Matches an Objective-C autorelease pool statement. |
| 1225 | /// |
| 1226 | /// Given |
| 1227 | /// \code |
| 1228 | /// @autoreleasepool { |
| 1229 | /// int x = 0; |
| 1230 | /// } |
| 1231 | /// \endcode |
| 1232 | /// autoreleasePoolStmt(stmt()) matches the declaration of "x" |
| 1233 | /// inside the autorelease pool. |
| 1234 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 1235 | ObjCAutoreleasePoolStmt> autoreleasePoolStmt; |
| 1236 | |
| 1237 | /// Matches any value declaration. |
| 1238 | /// |
| 1239 | /// Example matches A, B, C and F |
| 1240 | /// \code |
| 1241 | /// enum X { A, B, C }; |
| 1242 | /// void F(); |
| 1243 | /// \endcode |
| 1244 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl; |
| 1245 | |
| 1246 | /// Matches C++ constructor declarations. |
| 1247 | /// |
| 1248 | /// Example matches Foo::Foo() and Foo::Foo(int) |
| 1249 | /// \code |
| 1250 | /// class Foo { |
| 1251 | /// public: |
| 1252 | /// Foo(); |
| 1253 | /// Foo(int); |
| 1254 | /// int DoSomething(); |
| 1255 | /// }; |
| 1256 | /// \endcode |
| 1257 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl> |
| 1258 | cxxConstructorDecl; |
| 1259 | |
| 1260 | /// Matches explicit C++ destructor declarations. |
| 1261 | /// |
| 1262 | /// Example matches Foo::~Foo() |
| 1263 | /// \code |
| 1264 | /// class Foo { |
| 1265 | /// public: |
| 1266 | /// virtual ~Foo(); |
| 1267 | /// }; |
| 1268 | /// \endcode |
| 1269 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl> |
| 1270 | cxxDestructorDecl; |
| 1271 | |
| 1272 | /// Matches enum declarations. |
| 1273 | /// |
| 1274 | /// Example matches X |
| 1275 | /// \code |
| 1276 | /// enum X { |
| 1277 | /// A, B, C |
| 1278 | /// }; |
| 1279 | /// \endcode |
| 1280 | extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl; |
| 1281 | |
| 1282 | /// Matches enum constants. |
| 1283 | /// |
| 1284 | /// Example matches A, B, C |
| 1285 | /// \code |
| 1286 | /// enum X { |
| 1287 | /// A, B, C |
| 1288 | /// }; |
| 1289 | /// \endcode |
| 1290 | extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl> |
| 1291 | enumConstantDecl; |
| 1292 | |
| 1293 | /// Matches tag declarations. |
| 1294 | /// |
| 1295 | /// Example matches X, Z, U, S, E |
| 1296 | /// \code |
| 1297 | /// class X; |
| 1298 | /// template<class T> class Z {}; |
| 1299 | /// struct S {}; |
| 1300 | /// union U {}; |
| 1301 | /// enum E { |
| 1302 | /// A, B, C |
| 1303 | /// }; |
| 1304 | /// \endcode |
| 1305 | extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl; |
| 1306 | |
| 1307 | /// Matches method declarations. |
| 1308 | /// |
| 1309 | /// Example matches y |
| 1310 | /// \code |
| 1311 | /// class X { void y(); }; |
| 1312 | /// \endcode |
| 1313 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> |
| 1314 | cxxMethodDecl; |
| 1315 | |
| 1316 | /// Matches conversion operator declarations. |
| 1317 | /// |
| 1318 | /// Example matches the operator. |
| 1319 | /// \code |
| 1320 | /// class X { operator int() const; }; |
| 1321 | /// \endcode |
| 1322 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl> |
| 1323 | cxxConversionDecl; |
| 1324 | |
| 1325 | /// Matches user-defined and implicitly generated deduction guide. |
| 1326 | /// |
| 1327 | /// Example matches the deduction guide. |
| 1328 | /// \code |
| 1329 | /// template<typename T> |
| 1330 | /// class X { X(int) }; |
| 1331 | /// X(int) -> X<int>; |
| 1332 | /// \endcode |
| 1333 | extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl> |
| 1334 | cxxDeductionGuideDecl; |
| 1335 | |
| 1336 | /// Matches variable declarations. |
| 1337 | /// |
| 1338 | /// Note: this does not match declarations of member variables, which are |
| 1339 | /// "field" declarations in Clang parlance. |
| 1340 | /// |
| 1341 | /// Example matches a |
| 1342 | /// \code |
| 1343 | /// int a; |
| 1344 | /// \endcode |
| 1345 | extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl; |
| 1346 | |
| 1347 | /// Matches field declarations. |
| 1348 | /// |
| 1349 | /// Given |
| 1350 | /// \code |
| 1351 | /// class X { int m; }; |
| 1352 | /// \endcode |
| 1353 | /// fieldDecl() |
| 1354 | /// matches 'm'. |
| 1355 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl; |
| 1356 | |
| 1357 | /// Matches indirect field declarations. |
| 1358 | /// |
| 1359 | /// Given |
| 1360 | /// \code |
| 1361 | /// struct X { struct { int a; }; }; |
| 1362 | /// \endcode |
| 1363 | /// indirectFieldDecl() |
| 1364 | /// matches 'a'. |
| 1365 | extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl> |
| 1366 | indirectFieldDecl; |
| 1367 | |
| 1368 | /// Matches function declarations. |
| 1369 | /// |
| 1370 | /// Example matches f |
| 1371 | /// \code |
| 1372 | /// void f(); |
| 1373 | /// \endcode |
| 1374 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> |
| 1375 | functionDecl; |
| 1376 | |
| 1377 | /// Matches C++ function template declarations. |
| 1378 | /// |
| 1379 | /// Example matches f |
| 1380 | /// \code |
| 1381 | /// template<class T> void f(T t) {} |
| 1382 | /// \endcode |
| 1383 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl> |
| 1384 | functionTemplateDecl; |
| 1385 | |
| 1386 | /// Matches friend declarations. |
| 1387 | /// |
| 1388 | /// Given |
| 1389 | /// \code |
| 1390 | /// class X { friend void foo(); }; |
| 1391 | /// \endcode |
| 1392 | /// friendDecl() |
| 1393 | /// matches 'friend void foo()'. |
| 1394 | extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl; |
| 1395 | |
| 1396 | /// Matches statements. |
| 1397 | /// |
| 1398 | /// Given |
| 1399 | /// \code |
| 1400 | /// { ++a; } |
| 1401 | /// \endcode |
| 1402 | /// stmt() |
| 1403 | /// matches both the compound statement '{ ++a; }' and '++a'. |
| 1404 | extern const internal::VariadicAllOfMatcher<Stmt> stmt; |
| 1405 | |
| 1406 | /// Matches declaration statements. |
| 1407 | /// |
| 1408 | /// Given |
| 1409 | /// \code |
| 1410 | /// int a; |
| 1411 | /// \endcode |
| 1412 | /// declStmt() |
| 1413 | /// matches 'int a'. |
| 1414 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt; |
| 1415 | |
| 1416 | /// Matches member expressions. |
| 1417 | /// |
| 1418 | /// Given |
| 1419 | /// \code |
| 1420 | /// class Y { |
| 1421 | /// void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; } |
| 1422 | /// int a; static int b; |
| 1423 | /// }; |
| 1424 | /// \endcode |
| 1425 | /// memberExpr() |
| 1426 | /// matches this->x, x, y.x, a, this->b |
| 1427 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr; |
| 1428 | |
| 1429 | /// Matches unresolved member expressions. |
| 1430 | /// |
| 1431 | /// Given |
| 1432 | /// \code |
| 1433 | /// struct X { |
| 1434 | /// template <class T> void f(); |
| 1435 | /// void g(); |
| 1436 | /// }; |
| 1437 | /// template <class T> void h() { X x; x.f<T>(); x.g(); } |
| 1438 | /// \endcode |
| 1439 | /// unresolvedMemberExpr() |
| 1440 | /// matches x.f<T> |
| 1441 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr> |
| 1442 | unresolvedMemberExpr; |
| 1443 | |
| 1444 | /// Matches member expressions where the actual member referenced could not be |
| 1445 | /// resolved because the base expression or the member name was dependent. |
| 1446 | /// |
| 1447 | /// Given |
| 1448 | /// \code |
| 1449 | /// template <class T> void f() { T t; t.g(); } |
| 1450 | /// \endcode |
| 1451 | /// cxxDependentScopeMemberExpr() |
| 1452 | /// matches t.g |
| 1453 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 1454 | CXXDependentScopeMemberExpr> |
| 1455 | cxxDependentScopeMemberExpr; |
| 1456 | |
| 1457 | /// Matches call expressions. |
| 1458 | /// |
| 1459 | /// Example matches x.y() and y() |
| 1460 | /// \code |
| 1461 | /// X x; |
| 1462 | /// x.y(); |
| 1463 | /// y(); |
| 1464 | /// \endcode |
| 1465 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr; |
| 1466 | |
| 1467 | /// Matches call expressions which were resolved using ADL. |
| 1468 | /// |
| 1469 | /// Example matches y(x) but not y(42) or NS::y(x). |
| 1470 | /// \code |
| 1471 | /// namespace NS { |
| 1472 | /// struct X {}; |
| 1473 | /// void y(X); |
| 1474 | /// } |
| 1475 | /// |
| 1476 | /// void y(...); |
| 1477 | /// |
| 1478 | /// void test() { |
| 1479 | /// NS::X x; |
| 1480 | /// y(x); // Matches |
| 1481 | /// NS::y(x); // Doesn't match |
| 1482 | /// y(42); // Doesn't match |
| 1483 | /// using NS::y; |
| 1484 | /// y(x); // Found by both unqualified lookup and ADL, doesn't match |
| 1485 | // } |
| 1486 | /// \endcode |
| 1487 | AST_MATCHER(CallExpr, usesADL)namespace internal { class matcher_usesADLMatcher : public :: clang::ast_matchers::internal::MatcherInterface<CallExpr> { public: explicit matcher_usesADLMatcher() = default; bool matches (const CallExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers:: internal::Matcher<CallExpr> usesADL() { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_usesADLMatcher ()); } inline bool internal::matcher_usesADLMatcher::matches( const CallExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { return Node.usesADL(); } |
| 1488 | |
| 1489 | /// Matches lambda expressions. |
| 1490 | /// |
| 1491 | /// Example matches [&](){return 5;} |
| 1492 | /// \code |
| 1493 | /// [&](){return 5;} |
| 1494 | /// \endcode |
| 1495 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr; |
| 1496 | |
| 1497 | /// Matches member call expressions. |
| 1498 | /// |
| 1499 | /// Example matches x.y() |
| 1500 | /// \code |
| 1501 | /// X x; |
| 1502 | /// x.y(); |
| 1503 | /// \endcode |
| 1504 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr> |
| 1505 | cxxMemberCallExpr; |
| 1506 | |
| 1507 | /// Matches ObjectiveC Message invocation expressions. |
| 1508 | /// |
| 1509 | /// The innermost message send invokes the "alloc" class method on the |
| 1510 | /// NSString class, while the outermost message send invokes the |
| 1511 | /// "initWithString" instance method on the object returned from |
| 1512 | /// NSString's "alloc". This matcher should match both message sends. |
| 1513 | /// \code |
| 1514 | /// [[NSString alloc] initWithString:@"Hello"] |
| 1515 | /// \endcode |
| 1516 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr> |
| 1517 | objcMessageExpr; |
| 1518 | |
| 1519 | /// Matches ObjectiveC String literal expressions. |
| 1520 | /// |
| 1521 | /// Example matches @"abcd" |
| 1522 | /// \code |
| 1523 | /// NSString *s = @"abcd"; |
| 1524 | /// \endcode |
| 1525 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral> |
| 1526 | objcStringLiteral; |
| 1527 | |
| 1528 | /// Matches Objective-C interface declarations. |
| 1529 | /// |
| 1530 | /// Example matches Foo |
| 1531 | /// \code |
| 1532 | /// @interface Foo |
| 1533 | /// @end |
| 1534 | /// \endcode |
| 1535 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl> |
| 1536 | objcInterfaceDecl; |
| 1537 | |
| 1538 | /// Matches Objective-C implementation declarations. |
| 1539 | /// |
| 1540 | /// Example matches Foo |
| 1541 | /// \code |
| 1542 | /// @implementation Foo |
| 1543 | /// @end |
| 1544 | /// \endcode |
| 1545 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl> |
| 1546 | objcImplementationDecl; |
| 1547 | |
| 1548 | /// Matches Objective-C protocol declarations. |
| 1549 | /// |
| 1550 | /// Example matches FooDelegate |
| 1551 | /// \code |
| 1552 | /// @protocol FooDelegate |
| 1553 | /// @end |
| 1554 | /// \endcode |
| 1555 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl> |
| 1556 | objcProtocolDecl; |
| 1557 | |
| 1558 | /// Matches Objective-C category declarations. |
| 1559 | /// |
| 1560 | /// Example matches Foo (Additions) |
| 1561 | /// \code |
| 1562 | /// @interface Foo (Additions) |
| 1563 | /// @end |
| 1564 | /// \endcode |
| 1565 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl> |
| 1566 | objcCategoryDecl; |
| 1567 | |
| 1568 | /// Matches Objective-C category definitions. |
| 1569 | /// |
| 1570 | /// Example matches Foo (Additions) |
| 1571 | /// \code |
| 1572 | /// @implementation Foo (Additions) |
| 1573 | /// @end |
| 1574 | /// \endcode |
| 1575 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl> |
| 1576 | objcCategoryImplDecl; |
| 1577 | |
| 1578 | /// Matches Objective-C method declarations. |
| 1579 | /// |
| 1580 | /// Example matches both declaration and definition of -[Foo method] |
| 1581 | /// \code |
| 1582 | /// @interface Foo |
| 1583 | /// - (void)method; |
| 1584 | /// @end |
| 1585 | /// |
| 1586 | /// @implementation Foo |
| 1587 | /// - (void)method {} |
| 1588 | /// @end |
| 1589 | /// \endcode |
| 1590 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl> |
| 1591 | objcMethodDecl; |
| 1592 | |
| 1593 | /// Matches block declarations. |
| 1594 | /// |
| 1595 | /// Example matches the declaration of the nameless block printing an input |
| 1596 | /// integer. |
| 1597 | /// |
| 1598 | /// \code |
| 1599 | /// myFunc(^(int p) { |
| 1600 | /// printf("%d", p); |
| 1601 | /// }) |
| 1602 | /// \endcode |
| 1603 | extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl> |
| 1604 | blockDecl; |
| 1605 | |
| 1606 | /// Matches Objective-C instance variable declarations. |
| 1607 | /// |
| 1608 | /// Example matches _enabled |
| 1609 | /// \code |
| 1610 | /// @implementation Foo { |
| 1611 | /// BOOL _enabled; |
| 1612 | /// } |
| 1613 | /// @end |
| 1614 | /// \endcode |
| 1615 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> |
| 1616 | objcIvarDecl; |
| 1617 | |
| 1618 | /// Matches Objective-C property declarations. |
| 1619 | /// |
| 1620 | /// Example matches enabled |
| 1621 | /// \code |
| 1622 | /// @interface Foo |
| 1623 | /// @property BOOL enabled; |
| 1624 | /// @end |
| 1625 | /// \endcode |
| 1626 | extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl> |
| 1627 | objcPropertyDecl; |
| 1628 | |
| 1629 | /// Matches Objective-C \@throw statements. |
| 1630 | /// |
| 1631 | /// Example matches \@throw |
| 1632 | /// \code |
| 1633 | /// @throw obj; |
| 1634 | /// \endcode |
| 1635 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt> |
| 1636 | objcThrowStmt; |
| 1637 | |
| 1638 | /// Matches Objective-C @try statements. |
| 1639 | /// |
| 1640 | /// Example matches @try |
| 1641 | /// \code |
| 1642 | /// @try {} |
| 1643 | /// @catch (...) {} |
| 1644 | /// \endcode |
| 1645 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> |
| 1646 | objcTryStmt; |
| 1647 | |
| 1648 | /// Matches Objective-C @catch statements. |
| 1649 | /// |
| 1650 | /// Example matches @catch |
| 1651 | /// \code |
| 1652 | /// @try {} |
| 1653 | /// @catch (...) {} |
| 1654 | /// \endcode |
| 1655 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt> |
| 1656 | objcCatchStmt; |
| 1657 | |
| 1658 | /// Matches Objective-C @finally statements. |
| 1659 | /// |
| 1660 | /// Example matches @finally |
| 1661 | /// \code |
| 1662 | /// @try {} |
| 1663 | /// @finally {} |
| 1664 | /// \endcode |
| 1665 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt> |
| 1666 | objcFinallyStmt; |
| 1667 | |
| 1668 | /// Matches expressions that introduce cleanups to be run at the end |
| 1669 | /// of the sub-expression's evaluation. |
| 1670 | /// |
| 1671 | /// Example matches std::string() |
| 1672 | /// \code |
| 1673 | /// const std::string str = std::string(); |
| 1674 | /// \endcode |
| 1675 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups> |
| 1676 | exprWithCleanups; |
| 1677 | |
| 1678 | /// Matches init list expressions. |
| 1679 | /// |
| 1680 | /// Given |
| 1681 | /// \code |
| 1682 | /// int a[] = { 1, 2 }; |
| 1683 | /// struct B { int x, y; }; |
| 1684 | /// B b = { 5, 6 }; |
| 1685 | /// \endcode |
| 1686 | /// initListExpr() |
| 1687 | /// matches "{ 1, 2 }" and "{ 5, 6 }" |
| 1688 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> |
| 1689 | initListExpr; |
| 1690 | |
| 1691 | /// Matches the syntactic form of init list expressions |
| 1692 | /// (if expression have it). |
| 1693 | AST_MATCHER_P(InitListExpr, hasSyntacticForm,namespace internal { class matcher_hasSyntacticForm0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< InitListExpr> { public: explicit matcher_hasSyntacticForm0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const InitListExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<InitListExpr > hasSyntacticForm( internal::Matcher<Expr> const & InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_hasSyntacticForm0Matcher(InnerMatcher )); } typedef ::clang::ast_matchers::internal::Matcher<InitListExpr > ( &hasSyntacticForm_Type0)(internal::Matcher<Expr > const &InnerMatcher); inline bool internal::matcher_hasSyntacticForm0Matcher ::matches( const InitListExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 1694 | internal::Matcher<Expr>, InnerMatcher)namespace internal { class matcher_hasSyntacticForm0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< InitListExpr> { public: explicit matcher_hasSyntacticForm0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const InitListExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<InitListExpr > hasSyntacticForm( internal::Matcher<Expr> const & InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_hasSyntacticForm0Matcher(InnerMatcher )); } typedef ::clang::ast_matchers::internal::Matcher<InitListExpr > ( &hasSyntacticForm_Type0)(internal::Matcher<Expr > const &InnerMatcher); inline bool internal::matcher_hasSyntacticForm0Matcher ::matches( const InitListExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 1695 | const Expr *SyntForm = Node.getSyntacticForm(); |
| 1696 | return (SyntForm != nullptr && |
| 1697 | InnerMatcher.matches(*SyntForm, Finder, Builder)); |
| 1698 | } |
| 1699 | |
| 1700 | /// Matches C++ initializer list expressions. |
| 1701 | /// |
| 1702 | /// Given |
| 1703 | /// \code |
| 1704 | /// std::vector<int> a({ 1, 2, 3 }); |
| 1705 | /// std::vector<int> b = { 4, 5 }; |
| 1706 | /// int c[] = { 6, 7 }; |
| 1707 | /// std::pair<int, int> d = { 8, 9 }; |
| 1708 | /// \endcode |
| 1709 | /// cxxStdInitializerListExpr() |
| 1710 | /// matches "{ 1, 2, 3 }" and "{ 4, 5 }" |
| 1711 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 1712 | CXXStdInitializerListExpr> |
| 1713 | cxxStdInitializerListExpr; |
| 1714 | |
| 1715 | /// Matches implicit initializers of init list expressions. |
| 1716 | /// |
| 1717 | /// Given |
| 1718 | /// \code |
| 1719 | /// point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; |
| 1720 | /// \endcode |
| 1721 | /// implicitValueInitExpr() |
| 1722 | /// matches "[0].y" (implicitly) |
| 1723 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr> |
| 1724 | implicitValueInitExpr; |
| 1725 | |
| 1726 | /// Matches paren list expressions. |
| 1727 | /// ParenListExprs don't have a predefined type and are used for late parsing. |
| 1728 | /// In the final AST, they can be met in template declarations. |
| 1729 | /// |
| 1730 | /// Given |
| 1731 | /// \code |
| 1732 | /// template<typename T> class X { |
| 1733 | /// void f() { |
| 1734 | /// X x(*this); |
| 1735 | /// int a = 0, b = 1; int i = (a, b); |
| 1736 | /// } |
| 1737 | /// }; |
| 1738 | /// \endcode |
| 1739 | /// parenListExpr() matches "*this" but NOT matches (a, b) because (a, b) |
| 1740 | /// has a predefined type and is a ParenExpr, not a ParenListExpr. |
| 1741 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> |
| 1742 | parenListExpr; |
| 1743 | |
| 1744 | /// Matches substitutions of non-type template parameters. |
| 1745 | /// |
| 1746 | /// Given |
| 1747 | /// \code |
| 1748 | /// template <int N> |
| 1749 | /// struct A { static const int n = N; }; |
| 1750 | /// struct B : public A<42> {}; |
| 1751 | /// \endcode |
| 1752 | /// substNonTypeTemplateParmExpr() |
| 1753 | /// matches "N" in the right-hand side of "static const int n = N;" |
| 1754 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 1755 | SubstNonTypeTemplateParmExpr> |
| 1756 | substNonTypeTemplateParmExpr; |
| 1757 | |
| 1758 | /// Matches using declarations. |
| 1759 | /// |
| 1760 | /// Given |
| 1761 | /// \code |
| 1762 | /// namespace X { int x; } |
| 1763 | /// using X::x; |
| 1764 | /// \endcode |
| 1765 | /// usingDecl() |
| 1766 | /// matches \code using X::x \endcode |
| 1767 | extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl; |
| 1768 | |
| 1769 | /// Matches using-enum declarations. |
| 1770 | /// |
| 1771 | /// Given |
| 1772 | /// \code |
| 1773 | /// namespace X { enum x {...}; } |
| 1774 | /// using enum X::x; |
| 1775 | /// \endcode |
| 1776 | /// usingEnumDecl() |
| 1777 | /// matches \code using enum X::x \endcode |
| 1778 | extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl> |
| 1779 | usingEnumDecl; |
| 1780 | |
| 1781 | /// Matches using namespace declarations. |
| 1782 | /// |
| 1783 | /// Given |
| 1784 | /// \code |
| 1785 | /// namespace X { int x; } |
| 1786 | /// using namespace X; |
| 1787 | /// \endcode |
| 1788 | /// usingDirectiveDecl() |
| 1789 | /// matches \code using namespace X \endcode |
| 1790 | extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl> |
| 1791 | usingDirectiveDecl; |
| 1792 | |
| 1793 | /// Matches reference to a name that can be looked up during parsing |
| 1794 | /// but could not be resolved to a specific declaration. |
| 1795 | /// |
| 1796 | /// Given |
| 1797 | /// \code |
| 1798 | /// template<typename T> |
| 1799 | /// T foo() { T a; return a; } |
| 1800 | /// template<typename T> |
| 1801 | /// void bar() { |
| 1802 | /// foo<T>(); |
| 1803 | /// } |
| 1804 | /// \endcode |
| 1805 | /// unresolvedLookupExpr() |
| 1806 | /// matches \code foo<T>() \endcode |
| 1807 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr> |
| 1808 | unresolvedLookupExpr; |
| 1809 | |
| 1810 | /// Matches unresolved using value declarations. |
| 1811 | /// |
| 1812 | /// Given |
| 1813 | /// \code |
| 1814 | /// template<typename X> |
| 1815 | /// class C : private X { |
| 1816 | /// using X::x; |
| 1817 | /// }; |
| 1818 | /// \endcode |
| 1819 | /// unresolvedUsingValueDecl() |
| 1820 | /// matches \code using X::x \endcode |
| 1821 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |
| 1822 | UnresolvedUsingValueDecl> |
| 1823 | unresolvedUsingValueDecl; |
| 1824 | |
| 1825 | /// Matches unresolved using value declarations that involve the |
| 1826 | /// typename. |
| 1827 | /// |
| 1828 | /// Given |
| 1829 | /// \code |
| 1830 | /// template <typename T> |
| 1831 | /// struct Base { typedef T Foo; }; |
| 1832 | /// |
| 1833 | /// template<typename T> |
| 1834 | /// struct S : private Base<T> { |
| 1835 | /// using typename Base<T>::Foo; |
| 1836 | /// }; |
| 1837 | /// \endcode |
| 1838 | /// unresolvedUsingTypenameDecl() |
| 1839 | /// matches \code using Base<T>::Foo \endcode |
| 1840 | extern const internal::VariadicDynCastAllOfMatcher<Decl, |
| 1841 | UnresolvedUsingTypenameDecl> |
| 1842 | unresolvedUsingTypenameDecl; |
| 1843 | |
| 1844 | /// Matches a constant expression wrapper. |
| 1845 | /// |
| 1846 | /// Example matches the constant in the case statement: |
| 1847 | /// (matcher = constantExpr()) |
| 1848 | /// \code |
| 1849 | /// switch (a) { |
| 1850 | /// case 37: break; |
| 1851 | /// } |
| 1852 | /// \endcode |
| 1853 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> |
| 1854 | constantExpr; |
| 1855 | |
| 1856 | /// Matches parentheses used in expressions. |
| 1857 | /// |
| 1858 | /// Example matches (foo() + 1) |
| 1859 | /// \code |
| 1860 | /// int foo() { return 1; } |
| 1861 | /// int a = (foo() + 1); |
| 1862 | /// \endcode |
| 1863 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr; |
| 1864 | |
| 1865 | /// Matches constructor call expressions (including implicit ones). |
| 1866 | /// |
| 1867 | /// Example matches string(ptr, n) and ptr within arguments of f |
| 1868 | /// (matcher = cxxConstructExpr()) |
| 1869 | /// \code |
| 1870 | /// void f(const string &a, const string &b); |
| 1871 | /// char *ptr; |
| 1872 | /// int n; |
| 1873 | /// f(string(ptr, n), ptr); |
| 1874 | /// \endcode |
| 1875 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr> |
| 1876 | cxxConstructExpr; |
| 1877 | |
| 1878 | /// Matches unresolved constructor call expressions. |
| 1879 | /// |
| 1880 | /// Example matches T(t) in return statement of f |
| 1881 | /// (matcher = cxxUnresolvedConstructExpr()) |
| 1882 | /// \code |
| 1883 | /// template <typename T> |
| 1884 | /// void f(const T& t) { return T(t); } |
| 1885 | /// \endcode |
| 1886 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 1887 | CXXUnresolvedConstructExpr> |
| 1888 | cxxUnresolvedConstructExpr; |
| 1889 | |
| 1890 | /// Matches implicit and explicit this expressions. |
| 1891 | /// |
| 1892 | /// Example matches the implicit this expression in "return i". |
| 1893 | /// (matcher = cxxThisExpr()) |
| 1894 | /// \code |
| 1895 | /// struct foo { |
| 1896 | /// int i; |
| 1897 | /// int f() { return i; } |
| 1898 | /// }; |
| 1899 | /// \endcode |
| 1900 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> |
| 1901 | cxxThisExpr; |
| 1902 | |
| 1903 | /// Matches nodes where temporaries are created. |
| 1904 | /// |
| 1905 | /// Example matches FunctionTakesString(GetStringByValue()) |
| 1906 | /// (matcher = cxxBindTemporaryExpr()) |
| 1907 | /// \code |
| 1908 | /// FunctionTakesString(GetStringByValue()); |
| 1909 | /// FunctionTakesStringByPointer(GetStringPointer()); |
| 1910 | /// \endcode |
| 1911 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr> |
| 1912 | cxxBindTemporaryExpr; |
| 1913 | |
| 1914 | /// Matches nodes where temporaries are materialized. |
| 1915 | /// |
| 1916 | /// Example: Given |
| 1917 | /// \code |
| 1918 | /// struct T {void func();}; |
| 1919 | /// T f(); |
| 1920 | /// void g(T); |
| 1921 | /// \endcode |
| 1922 | /// materializeTemporaryExpr() matches 'f()' in these statements |
| 1923 | /// \code |
| 1924 | /// T u(f()); |
| 1925 | /// g(f()); |
| 1926 | /// f().func(); |
| 1927 | /// \endcode |
| 1928 | /// but does not match |
| 1929 | /// \code |
| 1930 | /// f(); |
| 1931 | /// \endcode |
| 1932 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 1933 | MaterializeTemporaryExpr> |
| 1934 | materializeTemporaryExpr; |
| 1935 | |
| 1936 | /// Matches new expressions. |
| 1937 | /// |
| 1938 | /// Given |
| 1939 | /// \code |
| 1940 | /// new X; |
| 1941 | /// \endcode |
| 1942 | /// cxxNewExpr() |
| 1943 | /// matches 'new X'. |
| 1944 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr; |
| 1945 | |
| 1946 | /// Matches delete expressions. |
| 1947 | /// |
| 1948 | /// Given |
| 1949 | /// \code |
| 1950 | /// delete X; |
| 1951 | /// \endcode |
| 1952 | /// cxxDeleteExpr() |
| 1953 | /// matches 'delete X'. |
| 1954 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> |
| 1955 | cxxDeleteExpr; |
| 1956 | |
| 1957 | /// Matches noexcept expressions. |
| 1958 | /// |
| 1959 | /// Given |
| 1960 | /// \code |
| 1961 | /// bool a() noexcept; |
| 1962 | /// bool b() noexcept(true); |
| 1963 | /// bool c() noexcept(false); |
| 1964 | /// bool d() noexcept(noexcept(a())); |
| 1965 | /// bool e = noexcept(b()) || noexcept(c()); |
| 1966 | /// \endcode |
| 1967 | /// cxxNoexceptExpr() |
| 1968 | /// matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`. |
| 1969 | /// doesn't match the noexcept specifier in the declarations a, b, c or d. |
| 1970 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr> |
| 1971 | cxxNoexceptExpr; |
| 1972 | |
| 1973 | /// Matches array subscript expressions. |
| 1974 | /// |
| 1975 | /// Given |
| 1976 | /// \code |
| 1977 | /// int i = a[1]; |
| 1978 | /// \endcode |
| 1979 | /// arraySubscriptExpr() |
| 1980 | /// matches "a[1]" |
| 1981 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr> |
| 1982 | arraySubscriptExpr; |
| 1983 | |
| 1984 | /// Matches the value of a default argument at the call site. |
| 1985 | /// |
| 1986 | /// Example matches the CXXDefaultArgExpr placeholder inserted for the |
| 1987 | /// default value of the second parameter in the call expression f(42) |
| 1988 | /// (matcher = cxxDefaultArgExpr()) |
| 1989 | /// \code |
| 1990 | /// void f(int x, int y = 0); |
| 1991 | /// f(42); |
| 1992 | /// \endcode |
| 1993 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr> |
| 1994 | cxxDefaultArgExpr; |
| 1995 | |
| 1996 | /// Matches overloaded operator calls. |
| 1997 | /// |
| 1998 | /// Note that if an operator isn't overloaded, it won't match. Instead, use |
| 1999 | /// binaryOperator matcher. |
| 2000 | /// Currently it does not match operators such as new delete. |
| 2001 | /// FIXME: figure out why these do not match? |
| 2002 | /// |
| 2003 | /// Example matches both operator<<((o << b), c) and operator<<(o, b) |
| 2004 | /// (matcher = cxxOperatorCallExpr()) |
| 2005 | /// \code |
| 2006 | /// ostream &operator<< (ostream &out, int i) { }; |
| 2007 | /// ostream &o; int b = 1, c = 1; |
| 2008 | /// o << b << c; |
| 2009 | /// \endcode |
| 2010 | /// See also the binaryOperation() matcher for more-general matching of binary |
| 2011 | /// uses of this AST node. |
| 2012 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr> |
| 2013 | cxxOperatorCallExpr; |
| 2014 | |
| 2015 | /// Matches rewritten binary operators |
| 2016 | /// |
| 2017 | /// Example matches use of "<": |
| 2018 | /// \code |
| 2019 | /// #include <compare> |
| 2020 | /// struct HasSpaceshipMem { |
| 2021 | /// int a; |
| 2022 | /// constexpr auto operator<=>(const HasSpaceshipMem&) const = default; |
| 2023 | /// }; |
| 2024 | /// void compare() { |
| 2025 | /// HasSpaceshipMem hs1, hs2; |
| 2026 | /// if (hs1 < hs2) |
| 2027 | /// return; |
| 2028 | /// } |
| 2029 | /// \endcode |
| 2030 | /// See also the binaryOperation() matcher for more-general matching |
| 2031 | /// of this AST node. |
| 2032 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 2033 | CXXRewrittenBinaryOperator> |
| 2034 | cxxRewrittenBinaryOperator; |
| 2035 | |
| 2036 | /// Matches expressions. |
| 2037 | /// |
| 2038 | /// Example matches x() |
| 2039 | /// \code |
| 2040 | /// void f() { x(); } |
| 2041 | /// \endcode |
| 2042 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr; |
| 2043 | |
| 2044 | /// Matches expressions that refer to declarations. |
| 2045 | /// |
| 2046 | /// Example matches x in if (x) |
| 2047 | /// \code |
| 2048 | /// bool x; |
| 2049 | /// if (x) {} |
| 2050 | /// \endcode |
| 2051 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> |
| 2052 | declRefExpr; |
| 2053 | |
| 2054 | /// Matches a reference to an ObjCIvar. |
| 2055 | /// |
| 2056 | /// Example: matches "a" in "init" method: |
| 2057 | /// \code |
| 2058 | /// @implementation A { |
| 2059 | /// NSString *a; |
| 2060 | /// } |
| 2061 | /// - (void) init { |
| 2062 | /// a = @"hello"; |
| 2063 | /// } |
| 2064 | /// \endcode |
| 2065 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> |
| 2066 | objcIvarRefExpr; |
| 2067 | |
| 2068 | /// Matches a reference to a block. |
| 2069 | /// |
| 2070 | /// Example: matches "^{}": |
| 2071 | /// \code |
| 2072 | /// void f() { ^{}(); } |
| 2073 | /// \endcode |
| 2074 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr; |
| 2075 | |
| 2076 | /// Matches if statements. |
| 2077 | /// |
| 2078 | /// Example matches 'if (x) {}' |
| 2079 | /// \code |
| 2080 | /// if (x) {} |
| 2081 | /// \endcode |
| 2082 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt; |
| 2083 | |
| 2084 | /// Matches for statements. |
| 2085 | /// |
| 2086 | /// Example matches 'for (;;) {}' |
| 2087 | /// \code |
| 2088 | /// for (;;) {} |
| 2089 | /// int i[] = {1, 2, 3}; for (auto a : i); |
| 2090 | /// \endcode |
| 2091 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt; |
| 2092 | |
| 2093 | /// Matches the increment statement of a for loop. |
| 2094 | /// |
| 2095 | /// Example: |
| 2096 | /// forStmt(hasIncrement(unaryOperator(hasOperatorName("++")))) |
| 2097 | /// matches '++x' in |
| 2098 | /// \code |
| 2099 | /// for (x; x < N; ++x) { } |
| 2100 | /// \endcode |
| 2101 | AST_MATCHER_P(ForStmt, hasIncrement, internal::Matcher<Stmt>,namespace internal { class matcher_hasIncrement0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ForStmt > { public: explicit matcher_hasIncrement0Matcher( internal ::Matcher<Stmt> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ForStmt &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Stmt> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<ForStmt> hasIncrement ( internal::Matcher<Stmt> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasIncrement0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<ForStmt> ( &hasIncrement_Type0 )(internal::Matcher<Stmt> const &InnerMatcher); inline bool internal::matcher_hasIncrement0Matcher::matches( const ForStmt &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 2102 | InnerMatcher)namespace internal { class matcher_hasIncrement0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ForStmt > { public: explicit matcher_hasIncrement0Matcher( internal ::Matcher<Stmt> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ForStmt &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Stmt> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<ForStmt> hasIncrement ( internal::Matcher<Stmt> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasIncrement0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<ForStmt> ( &hasIncrement_Type0 )(internal::Matcher<Stmt> const &InnerMatcher); inline bool internal::matcher_hasIncrement0Matcher::matches( const ForStmt &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 2103 | const Stmt *const Increment = Node.getInc(); |
| 2104 | return (Increment != nullptr && |
| 2105 | InnerMatcher.matches(*Increment, Finder, Builder)); |
| 2106 | } |
| 2107 | |
| 2108 | /// Matches the initialization statement of a for loop. |
| 2109 | /// |
| 2110 | /// Example: |
| 2111 | /// forStmt(hasLoopInit(declStmt())) |
| 2112 | /// matches 'int x = 0' in |
| 2113 | /// \code |
| 2114 | /// for (int x = 0; x < N; ++x) { } |
| 2115 | /// \endcode |
| 2116 | AST_MATCHER_P(ForStmt, hasLoopInit, internal::Matcher<Stmt>,namespace internal { class matcher_hasLoopInit0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ForStmt > { public: explicit matcher_hasLoopInit0Matcher( internal ::Matcher<Stmt> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ForStmt &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Stmt> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<ForStmt> hasLoopInit( internal::Matcher<Stmt> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasLoopInit0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<ForStmt> ( &hasLoopInit_Type0 )(internal::Matcher<Stmt> const &InnerMatcher); inline bool internal::matcher_hasLoopInit0Matcher::matches( const ForStmt &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 2117 | InnerMatcher)namespace internal { class matcher_hasLoopInit0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ForStmt > { public: explicit matcher_hasLoopInit0Matcher( internal ::Matcher<Stmt> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ForStmt &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Stmt> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<ForStmt> hasLoopInit( internal::Matcher<Stmt> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasLoopInit0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<ForStmt> ( &hasLoopInit_Type0 )(internal::Matcher<Stmt> const &InnerMatcher); inline bool internal::matcher_hasLoopInit0Matcher::matches( const ForStmt &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 2118 | const Stmt *const Init = Node.getInit(); |
| 2119 | return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder)); |
| 2120 | } |
| 2121 | |
| 2122 | /// Matches range-based for statements. |
| 2123 | /// |
| 2124 | /// cxxForRangeStmt() matches 'for (auto a : i)' |
| 2125 | /// \code |
| 2126 | /// int i[] = {1, 2, 3}; for (auto a : i); |
| 2127 | /// for(int j = 0; j < 5; ++j); |
| 2128 | /// \endcode |
| 2129 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt> |
| 2130 | cxxForRangeStmt; |
| 2131 | |
| 2132 | /// Matches the initialization statement of a for loop. |
| 2133 | /// |
| 2134 | /// Example: |
| 2135 | /// forStmt(hasLoopVariable(anything())) |
| 2136 | /// matches 'int x' in |
| 2137 | /// \code |
| 2138 | /// for (int x : a) { } |
| 2139 | /// \endcode |
| 2140 | AST_MATCHER_P(CXXForRangeStmt, hasLoopVariable, internal::Matcher<VarDecl>,namespace internal { class matcher_hasLoopVariable0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXForRangeStmt > { public: explicit matcher_hasLoopVariable0Matcher( internal ::Matcher<VarDecl> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXForRangeStmt &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<VarDecl> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXForRangeStmt > hasLoopVariable( internal::Matcher<VarDecl> const & InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_hasLoopVariable0Matcher(InnerMatcher) ); } typedef ::clang::ast_matchers::internal::Matcher<CXXForRangeStmt > ( &hasLoopVariable_Type0)(internal::Matcher<VarDecl > const &InnerMatcher); inline bool internal::matcher_hasLoopVariable0Matcher ::matches( const CXXForRangeStmt &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 2141 | InnerMatcher)namespace internal { class matcher_hasLoopVariable0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXForRangeStmt > { public: explicit matcher_hasLoopVariable0Matcher( internal ::Matcher<VarDecl> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXForRangeStmt &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<VarDecl> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXForRangeStmt > hasLoopVariable( internal::Matcher<VarDecl> const & InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_hasLoopVariable0Matcher(InnerMatcher) ); } typedef ::clang::ast_matchers::internal::Matcher<CXXForRangeStmt > ( &hasLoopVariable_Type0)(internal::Matcher<VarDecl > const &InnerMatcher); inline bool internal::matcher_hasLoopVariable0Matcher ::matches( const CXXForRangeStmt &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 2142 | const VarDecl *const Var = Node.getLoopVariable(); |
| 2143 | return (Var != nullptr && InnerMatcher.matches(*Var, Finder, Builder)); |
| 2144 | } |
| 2145 | |
| 2146 | /// Matches the range initialization statement of a for loop. |
| 2147 | /// |
| 2148 | /// Example: |
| 2149 | /// forStmt(hasRangeInit(anything())) |
| 2150 | /// matches 'a' in |
| 2151 | /// \code |
| 2152 | /// for (int x : a) { } |
| 2153 | /// \endcode |
| 2154 | AST_MATCHER_P(CXXForRangeStmt, hasRangeInit, internal::Matcher<Expr>,namespace internal { class matcher_hasRangeInit0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXForRangeStmt > { public: explicit matcher_hasRangeInit0Matcher( internal ::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXForRangeStmt &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXForRangeStmt > hasRangeInit( internal::Matcher<Expr> const &InnerMatcher ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_hasRangeInit0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<CXXForRangeStmt> ( & hasRangeInit_Type0)(internal::Matcher<Expr> const & InnerMatcher); inline bool internal::matcher_hasRangeInit0Matcher ::matches( const CXXForRangeStmt &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 2155 | InnerMatcher)namespace internal { class matcher_hasRangeInit0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXForRangeStmt > { public: explicit matcher_hasRangeInit0Matcher( internal ::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXForRangeStmt &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXForRangeStmt > hasRangeInit( internal::Matcher<Expr> const &InnerMatcher ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_hasRangeInit0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<CXXForRangeStmt> ( & hasRangeInit_Type0)(internal::Matcher<Expr> const & InnerMatcher); inline bool internal::matcher_hasRangeInit0Matcher ::matches( const CXXForRangeStmt &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 2156 | const Expr *const Init = Node.getRangeInit(); |
| 2157 | return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder)); |
| 2158 | } |
| 2159 | |
| 2160 | /// Matches while statements. |
| 2161 | /// |
| 2162 | /// Given |
| 2163 | /// \code |
| 2164 | /// while (true) {} |
| 2165 | /// \endcode |
| 2166 | /// whileStmt() |
| 2167 | /// matches 'while (true) {}'. |
| 2168 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt; |
| 2169 | |
| 2170 | /// Matches do statements. |
| 2171 | /// |
| 2172 | /// Given |
| 2173 | /// \code |
| 2174 | /// do {} while (true); |
| 2175 | /// \endcode |
| 2176 | /// doStmt() |
| 2177 | /// matches 'do {} while(true)' |
| 2178 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt; |
| 2179 | |
| 2180 | /// Matches break statements. |
| 2181 | /// |
| 2182 | /// Given |
| 2183 | /// \code |
| 2184 | /// while (true) { break; } |
| 2185 | /// \endcode |
| 2186 | /// breakStmt() |
| 2187 | /// matches 'break' |
| 2188 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt; |
| 2189 | |
| 2190 | /// Matches continue statements. |
| 2191 | /// |
| 2192 | /// Given |
| 2193 | /// \code |
| 2194 | /// while (true) { continue; } |
| 2195 | /// \endcode |
| 2196 | /// continueStmt() |
| 2197 | /// matches 'continue' |
| 2198 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> |
| 2199 | continueStmt; |
| 2200 | |
| 2201 | /// Matches co_return statements. |
| 2202 | /// |
| 2203 | /// Given |
| 2204 | /// \code |
| 2205 | /// while (true) { co_return; } |
| 2206 | /// \endcode |
| 2207 | /// coreturnStmt() |
| 2208 | /// matches 'co_return' |
| 2209 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt> |
| 2210 | coreturnStmt; |
| 2211 | |
| 2212 | /// Matches return statements. |
| 2213 | /// |
| 2214 | /// Given |
| 2215 | /// \code |
| 2216 | /// return 1; |
| 2217 | /// \endcode |
| 2218 | /// returnStmt() |
| 2219 | /// matches 'return 1' |
| 2220 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt; |
| 2221 | |
| 2222 | /// Matches goto statements. |
| 2223 | /// |
| 2224 | /// Given |
| 2225 | /// \code |
| 2226 | /// goto FOO; |
| 2227 | /// FOO: bar(); |
| 2228 | /// \endcode |
| 2229 | /// gotoStmt() |
| 2230 | /// matches 'goto FOO' |
| 2231 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt; |
| 2232 | |
| 2233 | /// Matches label statements. |
| 2234 | /// |
| 2235 | /// Given |
| 2236 | /// \code |
| 2237 | /// goto FOO; |
| 2238 | /// FOO: bar(); |
| 2239 | /// \endcode |
| 2240 | /// labelStmt() |
| 2241 | /// matches 'FOO:' |
| 2242 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt; |
| 2243 | |
| 2244 | /// Matches address of label statements (GNU extension). |
| 2245 | /// |
| 2246 | /// Given |
| 2247 | /// \code |
| 2248 | /// FOO: bar(); |
| 2249 | /// void *ptr = &&FOO; |
| 2250 | /// goto *bar; |
| 2251 | /// \endcode |
| 2252 | /// addrLabelExpr() |
| 2253 | /// matches '&&FOO' |
| 2254 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> |
| 2255 | addrLabelExpr; |
| 2256 | |
| 2257 | /// Matches switch statements. |
| 2258 | /// |
| 2259 | /// Given |
| 2260 | /// \code |
| 2261 | /// switch(a) { case 42: break; default: break; } |
| 2262 | /// \endcode |
| 2263 | /// switchStmt() |
| 2264 | /// matches 'switch(a)'. |
| 2265 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt; |
| 2266 | |
| 2267 | /// Matches case and default statements inside switch statements. |
| 2268 | /// |
| 2269 | /// Given |
| 2270 | /// \code |
| 2271 | /// switch(a) { case 42: break; default: break; } |
| 2272 | /// \endcode |
| 2273 | /// switchCase() |
| 2274 | /// matches 'case 42:' and 'default:'. |
| 2275 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase; |
| 2276 | |
| 2277 | /// Matches case statements inside switch statements. |
| 2278 | /// |
| 2279 | /// Given |
| 2280 | /// \code |
| 2281 | /// switch(a) { case 42: break; default: break; } |
| 2282 | /// \endcode |
| 2283 | /// caseStmt() |
| 2284 | /// matches 'case 42:'. |
| 2285 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt; |
| 2286 | |
| 2287 | /// Matches default statements inside switch statements. |
| 2288 | /// |
| 2289 | /// Given |
| 2290 | /// \code |
| 2291 | /// switch(a) { case 42: break; default: break; } |
| 2292 | /// \endcode |
| 2293 | /// defaultStmt() |
| 2294 | /// matches 'default:'. |
| 2295 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> |
| 2296 | defaultStmt; |
| 2297 | |
| 2298 | /// Matches compound statements. |
| 2299 | /// |
| 2300 | /// Example matches '{}' and '{{}}' in 'for (;;) {{}}' |
| 2301 | /// \code |
| 2302 | /// for (;;) {{}} |
| 2303 | /// \endcode |
| 2304 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> |
| 2305 | compoundStmt; |
| 2306 | |
| 2307 | /// Matches catch statements. |
| 2308 | /// |
| 2309 | /// \code |
| 2310 | /// try {} catch(int i) {} |
| 2311 | /// \endcode |
| 2312 | /// cxxCatchStmt() |
| 2313 | /// matches 'catch(int i)' |
| 2314 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> |
| 2315 | cxxCatchStmt; |
| 2316 | |
| 2317 | /// Matches try statements. |
| 2318 | /// |
| 2319 | /// \code |
| 2320 | /// try {} catch(int i) {} |
| 2321 | /// \endcode |
| 2322 | /// cxxTryStmt() |
| 2323 | /// matches 'try {}' |
| 2324 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt; |
| 2325 | |
| 2326 | /// Matches throw expressions. |
| 2327 | /// |
| 2328 | /// \code |
| 2329 | /// try { throw 5; } catch(int i) {} |
| 2330 | /// \endcode |
| 2331 | /// cxxThrowExpr() |
| 2332 | /// matches 'throw 5' |
| 2333 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> |
| 2334 | cxxThrowExpr; |
| 2335 | |
| 2336 | /// Matches null statements. |
| 2337 | /// |
| 2338 | /// \code |
| 2339 | /// foo();; |
| 2340 | /// \endcode |
| 2341 | /// nullStmt() |
| 2342 | /// matches the second ';' |
| 2343 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt; |
| 2344 | |
| 2345 | /// Matches asm statements. |
| 2346 | /// |
| 2347 | /// \code |
| 2348 | /// int i = 100; |
| 2349 | /// __asm("mov al, 2"); |
| 2350 | /// \endcode |
| 2351 | /// asmStmt() |
| 2352 | /// matches '__asm("mov al, 2")' |
| 2353 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt; |
| 2354 | |
| 2355 | /// Matches bool literals. |
| 2356 | /// |
| 2357 | /// Example matches true |
| 2358 | /// \code |
| 2359 | /// true |
| 2360 | /// \endcode |
| 2361 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr> |
| 2362 | cxxBoolLiteral; |
| 2363 | |
| 2364 | /// Matches string literals (also matches wide string literals). |
| 2365 | /// |
| 2366 | /// Example matches "abcd", L"abcd" |
| 2367 | /// \code |
| 2368 | /// char *s = "abcd"; |
| 2369 | /// wchar_t *ws = L"abcd"; |
| 2370 | /// \endcode |
| 2371 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> |
| 2372 | stringLiteral; |
| 2373 | |
| 2374 | /// Matches character literals (also matches wchar_t). |
| 2375 | /// |
| 2376 | /// Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral), |
| 2377 | /// though. |
| 2378 | /// |
| 2379 | /// Example matches 'a', L'a' |
| 2380 | /// \code |
| 2381 | /// char ch = 'a'; |
| 2382 | /// wchar_t chw = L'a'; |
| 2383 | /// \endcode |
| 2384 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral> |
| 2385 | characterLiteral; |
| 2386 | |
| 2387 | /// Matches integer literals of all sizes / encodings, e.g. |
| 2388 | /// 1, 1L, 0x1 and 1U. |
| 2389 | /// |
| 2390 | /// Does not match character-encoded integers such as L'a'. |
| 2391 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral> |
| 2392 | integerLiteral; |
| 2393 | |
| 2394 | /// Matches float literals of all sizes / encodings, e.g. |
| 2395 | /// 1.0, 1.0f, 1.0L and 1e10. |
| 2396 | /// |
| 2397 | /// Does not match implicit conversions such as |
| 2398 | /// \code |
| 2399 | /// float a = 10; |
| 2400 | /// \endcode |
| 2401 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> |
| 2402 | floatLiteral; |
| 2403 | |
| 2404 | /// Matches imaginary literals, which are based on integer and floating |
| 2405 | /// point literals e.g.: 1i, 1.0i |
| 2406 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> |
| 2407 | imaginaryLiteral; |
| 2408 | |
| 2409 | /// Matches fixed point literals |
| 2410 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral> |
| 2411 | fixedPointLiteral; |
| 2412 | |
| 2413 | /// Matches user defined literal operator call. |
| 2414 | /// |
| 2415 | /// Example match: "foo"_suffix |
| 2416 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral> |
| 2417 | userDefinedLiteral; |
| 2418 | |
| 2419 | /// Matches compound (i.e. non-scalar) literals |
| 2420 | /// |
| 2421 | /// Example match: {1}, (1, 2) |
| 2422 | /// \code |
| 2423 | /// int array[4] = {1}; |
| 2424 | /// vector int myvec = (vector int)(1, 2); |
| 2425 | /// \endcode |
| 2426 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr> |
| 2427 | compoundLiteralExpr; |
| 2428 | |
| 2429 | /// Matches co_await expressions. |
| 2430 | /// |
| 2431 | /// Given |
| 2432 | /// \code |
| 2433 | /// co_await 1; |
| 2434 | /// \endcode |
| 2435 | /// coawaitExpr() |
| 2436 | /// matches 'co_await 1' |
| 2437 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr> |
| 2438 | coawaitExpr; |
| 2439 | /// Matches co_await expressions where the type of the promise is dependent |
| 2440 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr> |
| 2441 | dependentCoawaitExpr; |
| 2442 | /// Matches co_yield expressions. |
| 2443 | /// |
| 2444 | /// Given |
| 2445 | /// \code |
| 2446 | /// co_yield 1; |
| 2447 | /// \endcode |
| 2448 | /// coyieldExpr() |
| 2449 | /// matches 'co_yield 1' |
| 2450 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr> |
| 2451 | coyieldExpr; |
| 2452 | |
| 2453 | /// Matches coroutine body statements. |
| 2454 | /// |
| 2455 | /// coroutineBodyStmt() matches the coroutine below |
| 2456 | /// \code |
| 2457 | /// generator<int> gen() { |
| 2458 | /// co_return; |
| 2459 | /// } |
| 2460 | /// \endcode |
| 2461 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt> |
| 2462 | coroutineBodyStmt; |
| 2463 | |
| 2464 | /// Matches nullptr literal. |
| 2465 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr> |
| 2466 | cxxNullPtrLiteralExpr; |
| 2467 | |
| 2468 | /// Matches GNU __builtin_choose_expr. |
| 2469 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> |
| 2470 | chooseExpr; |
| 2471 | |
| 2472 | /// Matches GNU __null expression. |
| 2473 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> |
| 2474 | gnuNullExpr; |
| 2475 | |
| 2476 | /// Matches C11 _Generic expression. |
| 2477 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr> |
| 2478 | genericSelectionExpr; |
| 2479 | |
| 2480 | /// Matches atomic builtins. |
| 2481 | /// Example matches __atomic_load_n(ptr, 1) |
| 2482 | /// \code |
| 2483 | /// void foo() { int *ptr; __atomic_load_n(ptr, 1); } |
| 2484 | /// \endcode |
| 2485 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr; |
| 2486 | |
| 2487 | /// Matches statement expression (GNU extension). |
| 2488 | /// |
| 2489 | /// Example match: ({ int X = 4; X; }) |
| 2490 | /// \code |
| 2491 | /// int C = ({ int X = 4; X; }); |
| 2492 | /// \endcode |
| 2493 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr; |
| 2494 | |
| 2495 | /// Matches binary operator expressions. |
| 2496 | /// |
| 2497 | /// Example matches a || b |
| 2498 | /// \code |
| 2499 | /// !(a || b) |
| 2500 | /// \endcode |
| 2501 | /// See also the binaryOperation() matcher for more-general matching. |
| 2502 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator> |
| 2503 | binaryOperator; |
| 2504 | |
| 2505 | /// Matches unary operator expressions. |
| 2506 | /// |
| 2507 | /// Example matches !a |
| 2508 | /// \code |
| 2509 | /// !a || b |
| 2510 | /// \endcode |
| 2511 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> |
| 2512 | unaryOperator; |
| 2513 | |
| 2514 | /// Matches conditional operator expressions. |
| 2515 | /// |
| 2516 | /// Example matches a ? b : c |
| 2517 | /// \code |
| 2518 | /// (a ? b : c) + 42 |
| 2519 | /// \endcode |
| 2520 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator> |
| 2521 | conditionalOperator; |
| 2522 | |
| 2523 | /// Matches binary conditional operator expressions (GNU extension). |
| 2524 | /// |
| 2525 | /// Example matches a ?: b |
| 2526 | /// \code |
| 2527 | /// (a ?: b) + 42; |
| 2528 | /// \endcode |
| 2529 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 2530 | BinaryConditionalOperator> |
| 2531 | binaryConditionalOperator; |
| 2532 | |
| 2533 | /// Matches opaque value expressions. They are used as helpers |
| 2534 | /// to reference another expressions and can be met |
| 2535 | /// in BinaryConditionalOperators, for example. |
| 2536 | /// |
| 2537 | /// Example matches 'a' |
| 2538 | /// \code |
| 2539 | /// (a ?: c) + 42; |
| 2540 | /// \endcode |
| 2541 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr> |
| 2542 | opaqueValueExpr; |
| 2543 | |
| 2544 | /// Matches a C++ static_assert declaration. |
| 2545 | /// |
| 2546 | /// Example: |
| 2547 | /// staticAssertDecl() |
| 2548 | /// matches |
| 2549 | /// static_assert(sizeof(S) == sizeof(int)) |
| 2550 | /// in |
| 2551 | /// \code |
| 2552 | /// struct S { |
| 2553 | /// int x; |
| 2554 | /// }; |
| 2555 | /// static_assert(sizeof(S) == sizeof(int)); |
| 2556 | /// \endcode |
| 2557 | extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl> |
| 2558 | staticAssertDecl; |
| 2559 | |
| 2560 | /// Matches a reinterpret_cast expression. |
| 2561 | /// |
| 2562 | /// Either the source expression or the destination type can be matched |
| 2563 | /// using has(), but hasDestinationType() is more specific and can be |
| 2564 | /// more readable. |
| 2565 | /// |
| 2566 | /// Example matches reinterpret_cast<char*>(&p) in |
| 2567 | /// \code |
| 2568 | /// void* p = reinterpret_cast<char*>(&p); |
| 2569 | /// \endcode |
| 2570 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr> |
| 2571 | cxxReinterpretCastExpr; |
| 2572 | |
| 2573 | /// Matches a C++ static_cast expression. |
| 2574 | /// |
| 2575 | /// \see hasDestinationType |
| 2576 | /// \see reinterpretCast |
| 2577 | /// |
| 2578 | /// Example: |
| 2579 | /// cxxStaticCastExpr() |
| 2580 | /// matches |
| 2581 | /// static_cast<long>(8) |
| 2582 | /// in |
| 2583 | /// \code |
| 2584 | /// long eight(static_cast<long>(8)); |
| 2585 | /// \endcode |
| 2586 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr> |
| 2587 | cxxStaticCastExpr; |
| 2588 | |
| 2589 | /// Matches a dynamic_cast expression. |
| 2590 | /// |
| 2591 | /// Example: |
| 2592 | /// cxxDynamicCastExpr() |
| 2593 | /// matches |
| 2594 | /// dynamic_cast<D*>(&b); |
| 2595 | /// in |
| 2596 | /// \code |
| 2597 | /// struct B { virtual ~B() {} }; struct D : B {}; |
| 2598 | /// B b; |
| 2599 | /// D* p = dynamic_cast<D*>(&b); |
| 2600 | /// \endcode |
| 2601 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr> |
| 2602 | cxxDynamicCastExpr; |
| 2603 | |
| 2604 | /// Matches a const_cast expression. |
| 2605 | /// |
| 2606 | /// Example: Matches const_cast<int*>(&r) in |
| 2607 | /// \code |
| 2608 | /// int n = 42; |
| 2609 | /// const int &r(n); |
| 2610 | /// int* p = const_cast<int*>(&r); |
| 2611 | /// \endcode |
| 2612 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr> |
| 2613 | cxxConstCastExpr; |
| 2614 | |
| 2615 | /// Matches a C-style cast expression. |
| 2616 | /// |
| 2617 | /// Example: Matches (int) 2.2f in |
| 2618 | /// \code |
| 2619 | /// int i = (int) 2.2f; |
| 2620 | /// \endcode |
| 2621 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr> |
| 2622 | cStyleCastExpr; |
| 2623 | |
| 2624 | /// Matches explicit cast expressions. |
| 2625 | /// |
| 2626 | /// Matches any cast expression written in user code, whether it be a |
| 2627 | /// C-style cast, a functional-style cast, or a keyword cast. |
| 2628 | /// |
| 2629 | /// Does not match implicit conversions. |
| 2630 | /// |
| 2631 | /// Note: the name "explicitCast" is chosen to match Clang's terminology, as |
| 2632 | /// Clang uses the term "cast" to apply to implicit conversions as well as to |
| 2633 | /// actual cast expressions. |
| 2634 | /// |
| 2635 | /// \see hasDestinationType. |
| 2636 | /// |
| 2637 | /// Example: matches all five of the casts in |
| 2638 | /// \code |
| 2639 | /// int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42))))) |
| 2640 | /// \endcode |
| 2641 | /// but does not match the implicit conversion in |
| 2642 | /// \code |
| 2643 | /// long ell = 42; |
| 2644 | /// \endcode |
| 2645 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr> |
| 2646 | explicitCastExpr; |
| 2647 | |
| 2648 | /// Matches the implicit cast nodes of Clang's AST. |
| 2649 | /// |
| 2650 | /// This matches many different places, including function call return value |
| 2651 | /// eliding, as well as any type conversions. |
| 2652 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr> |
| 2653 | implicitCastExpr; |
| 2654 | |
| 2655 | /// Matches any cast nodes of Clang's AST. |
| 2656 | /// |
| 2657 | /// Example: castExpr() matches each of the following: |
| 2658 | /// \code |
| 2659 | /// (int) 3; |
| 2660 | /// const_cast<Expr *>(SubExpr); |
| 2661 | /// char c = 0; |
| 2662 | /// \endcode |
| 2663 | /// but does not match |
| 2664 | /// \code |
| 2665 | /// int i = (0); |
| 2666 | /// int k = 0; |
| 2667 | /// \endcode |
| 2668 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr; |
| 2669 | |
| 2670 | /// Matches functional cast expressions |
| 2671 | /// |
| 2672 | /// Example: Matches Foo(bar); |
| 2673 | /// \code |
| 2674 | /// Foo f = bar; |
| 2675 | /// Foo g = (Foo) bar; |
| 2676 | /// Foo h = Foo(bar); |
| 2677 | /// \endcode |
| 2678 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr> |
| 2679 | cxxFunctionalCastExpr; |
| 2680 | |
| 2681 | /// Matches functional cast expressions having N != 1 arguments |
| 2682 | /// |
| 2683 | /// Example: Matches Foo(bar, bar) |
| 2684 | /// \code |
| 2685 | /// Foo h = Foo(bar, bar); |
| 2686 | /// \endcode |
| 2687 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr> |
| 2688 | cxxTemporaryObjectExpr; |
| 2689 | |
| 2690 | /// Matches predefined identifier expressions [C99 6.4.2.2]. |
| 2691 | /// |
| 2692 | /// Example: Matches __func__ |
| 2693 | /// \code |
| 2694 | /// printf("%s", __func__); |
| 2695 | /// \endcode |
| 2696 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr> |
| 2697 | predefinedExpr; |
| 2698 | |
| 2699 | /// Matches C99 designated initializer expressions [C99 6.7.8]. |
| 2700 | /// |
| 2701 | /// Example: Matches { [2].y = 1.0, [0].x = 1.0 } |
| 2702 | /// \code |
| 2703 | /// point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 }; |
| 2704 | /// \endcode |
| 2705 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr> |
| 2706 | designatedInitExpr; |
| 2707 | |
| 2708 | /// Matches designated initializer expressions that contain |
| 2709 | /// a specific number of designators. |
| 2710 | /// |
| 2711 | /// Example: Given |
| 2712 | /// \code |
| 2713 | /// point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 }; |
| 2714 | /// point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }; |
| 2715 | /// \endcode |
| 2716 | /// designatorCountIs(2) |
| 2717 | /// matches '{ [2].y = 1.0, [0].x = 1.0 }', |
| 2718 | /// but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'. |
| 2719 | AST_MATCHER_P(DesignatedInitExpr, designatorCountIs, unsigned, N)namespace internal { class matcher_designatorCountIs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< DesignatedInitExpr> { public: explicit matcher_designatorCountIs0Matcher ( unsigned const &AN) : N(AN) {} bool matches(const DesignatedInitExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::Matcher<DesignatedInitExpr> designatorCountIs( unsigned const &N) { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_designatorCountIs0Matcher (N)); } typedef ::clang::ast_matchers::internal::Matcher<DesignatedInitExpr > ( &designatorCountIs_Type0)(unsigned const &N); inline bool internal::matcher_designatorCountIs0Matcher::matches( const DesignatedInitExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 2720 | return Node.size() == N; |
| 2721 | } |
| 2722 | |
| 2723 | /// Matches \c QualTypes in the clang AST. |
| 2724 | extern const internal::VariadicAllOfMatcher<QualType> qualType; |
| 2725 | |
| 2726 | /// Matches \c Types in the clang AST. |
| 2727 | extern const internal::VariadicAllOfMatcher<Type> type; |
| 2728 | |
| 2729 | /// Matches \c TypeLocs in the clang AST. |
| 2730 | extern const internal::VariadicAllOfMatcher<TypeLoc> typeLoc; |
| 2731 | |
| 2732 | /// Matches if any of the given matchers matches. |
| 2733 | /// |
| 2734 | /// Unlike \c anyOf, \c eachOf will generate a match result for each |
| 2735 | /// matching submatcher. |
| 2736 | /// |
| 2737 | /// For example, in: |
| 2738 | /// \code |
| 2739 | /// class A { int a; int b; }; |
| 2740 | /// \endcode |
| 2741 | /// The matcher: |
| 2742 | /// \code |
| 2743 | /// cxxRecordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")), |
| 2744 | /// has(fieldDecl(hasName("b")).bind("v")))) |
| 2745 | /// \endcode |
| 2746 | /// will generate two results binding "v", the first of which binds |
| 2747 | /// the field declaration of \c a, the second the field declaration of |
| 2748 | /// \c b. |
| 2749 | /// |
| 2750 | /// Usable as: Any Matcher |
| 2751 | extern const internal::VariadicOperatorMatcherFunc< |
| 2752 | 2, std::numeric_limits<unsigned>::max()> |
| 2753 | eachOf; |
| 2754 | |
| 2755 | /// Matches if any of the given matchers matches. |
| 2756 | /// |
| 2757 | /// Usable as: Any Matcher |
| 2758 | extern const internal::VariadicOperatorMatcherFunc< |
| 2759 | 2, std::numeric_limits<unsigned>::max()> |
| 2760 | anyOf; |
| 2761 | |
| 2762 | /// Matches if all given matchers match. |
| 2763 | /// |
| 2764 | /// Usable as: Any Matcher |
| 2765 | extern const internal::VariadicOperatorMatcherFunc< |
| 2766 | 2, std::numeric_limits<unsigned>::max()> |
| 2767 | allOf; |
| 2768 | |
| 2769 | /// Matches any node regardless of the submatcher. |
| 2770 | /// |
| 2771 | /// However, \c optionally will retain any bindings generated by the submatcher. |
| 2772 | /// Useful when additional information which may or may not present about a main |
| 2773 | /// matching node is desired. |
| 2774 | /// |
| 2775 | /// For example, in: |
| 2776 | /// \code |
| 2777 | /// class Foo { |
| 2778 | /// int bar; |
| 2779 | /// } |
| 2780 | /// \endcode |
| 2781 | /// The matcher: |
| 2782 | /// \code |
| 2783 | /// cxxRecordDecl( |
| 2784 | /// optionally(has( |
| 2785 | /// fieldDecl(hasName("bar")).bind("var") |
| 2786 | /// ))).bind("record") |
| 2787 | /// \endcode |
| 2788 | /// will produce a result binding for both "record" and "var". |
| 2789 | /// The matcher will produce a "record" binding for even if there is no data |
| 2790 | /// member named "bar" in that class. |
| 2791 | /// |
| 2792 | /// Usable as: Any Matcher |
| 2793 | extern const internal::VariadicOperatorMatcherFunc<1, 1> optionally; |
| 2794 | |
| 2795 | /// Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL) |
| 2796 | /// |
| 2797 | /// Given |
| 2798 | /// \code |
| 2799 | /// Foo x = bar; |
| 2800 | /// int y = sizeof(x) + alignof(x); |
| 2801 | /// \endcode |
| 2802 | /// unaryExprOrTypeTraitExpr() |
| 2803 | /// matches \c sizeof(x) and \c alignof(x) |
| 2804 | extern const internal::VariadicDynCastAllOfMatcher<Stmt, |
| 2805 | UnaryExprOrTypeTraitExpr> |
| 2806 | unaryExprOrTypeTraitExpr; |
| 2807 | |
| 2808 | /// Matches any of the \p NodeMatchers with InnerMatchers nested within |
| 2809 | /// |
| 2810 | /// Given |
| 2811 | /// \code |
| 2812 | /// if (true); |
| 2813 | /// for (; true; ); |
| 2814 | /// \endcode |
| 2815 | /// with the matcher |
| 2816 | /// \code |
| 2817 | /// mapAnyOf(ifStmt, forStmt).with( |
| 2818 | /// hasCondition(cxxBoolLiteralExpr(equals(true))) |
| 2819 | /// ).bind("trueCond") |
| 2820 | /// \endcode |
| 2821 | /// matches the \c if and the \c for. It is equivalent to: |
| 2822 | /// \code |
| 2823 | /// auto trueCond = hasCondition(cxxBoolLiteralExpr(equals(true))); |
| 2824 | /// anyOf( |
| 2825 | /// ifStmt(trueCond).bind("trueCond"), |
| 2826 | /// forStmt(trueCond).bind("trueCond") |
| 2827 | /// ); |
| 2828 | /// \endcode |
| 2829 | /// |
| 2830 | /// The with() chain-call accepts zero or more matchers which are combined |
| 2831 | /// as-if with allOf() in each of the node matchers. |
| 2832 | /// Usable as: Any Matcher |
| 2833 | template <typename T, typename... U> |
| 2834 | auto mapAnyOf(internal::VariadicDynCastAllOfMatcher<T, U> const &...) { |
| 2835 | return internal::MapAnyOfHelper<U...>(); |
| 2836 | } |
| 2837 | |
| 2838 | /// Matches nodes which can be used with binary operators. |
| 2839 | /// |
| 2840 | /// The code |
| 2841 | /// \code |
| 2842 | /// var1 != var2; |
| 2843 | /// \endcode |
| 2844 | /// might be represented in the clang AST as a binaryOperator, a |
| 2845 | /// cxxOperatorCallExpr or a cxxRewrittenBinaryOperator, depending on |
| 2846 | /// |
| 2847 | /// * whether the types of var1 and var2 are fundamental (binaryOperator) or at |
| 2848 | /// least one is a class type (cxxOperatorCallExpr) |
| 2849 | /// * whether the code appears in a template declaration, if at least one of the |
| 2850 | /// vars is a dependent-type (binaryOperator) |
| 2851 | /// * whether the code relies on a rewritten binary operator, such as a |
| 2852 | /// spaceship operator or an inverted equality operator |
| 2853 | /// (cxxRewrittenBinaryOperator) |
| 2854 | /// |
| 2855 | /// This matcher elides details in places where the matchers for the nodes are |
| 2856 | /// compatible. |
| 2857 | /// |
| 2858 | /// Given |
| 2859 | /// \code |
| 2860 | /// binaryOperation( |
| 2861 | /// hasOperatorName("!="), |
| 2862 | /// hasLHS(expr().bind("lhs")), |
| 2863 | /// hasRHS(expr().bind("rhs")) |
| 2864 | /// ) |
| 2865 | /// \endcode |
| 2866 | /// matches each use of "!=" in: |
| 2867 | /// \code |
| 2868 | /// struct S{ |
| 2869 | /// bool operator!=(const S&) const; |
| 2870 | /// }; |
| 2871 | /// |
| 2872 | /// void foo() |
| 2873 | /// { |
| 2874 | /// 1 != 2; |
| 2875 | /// S() != S(); |
| 2876 | /// } |
| 2877 | /// |
| 2878 | /// template<typename T> |
| 2879 | /// void templ() |
| 2880 | /// { |
| 2881 | /// 1 != 2; |
| 2882 | /// T() != S(); |
| 2883 | /// } |
| 2884 | /// struct HasOpEq |
| 2885 | /// { |
| 2886 | /// bool operator==(const HasOpEq &) const; |
| 2887 | /// }; |
| 2888 | /// |
| 2889 | /// void inverse() |
| 2890 | /// { |
| 2891 | /// HasOpEq s1; |
| 2892 | /// HasOpEq s2; |
| 2893 | /// if (s1 != s2) |
| 2894 | /// return; |
| 2895 | /// } |
| 2896 | /// |
| 2897 | /// struct HasSpaceship |
| 2898 | /// { |
| 2899 | /// bool operator<=>(const HasOpEq &) const; |
| 2900 | /// }; |
| 2901 | /// |
| 2902 | /// void use_spaceship() |
| 2903 | /// { |
| 2904 | /// HasSpaceship s1; |
| 2905 | /// HasSpaceship s2; |
| 2906 | /// if (s1 != s2) |
| 2907 | /// return; |
| 2908 | /// } |
| 2909 | /// \endcode |
| 2910 | extern const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr, |
| 2911 | CXXRewrittenBinaryOperator> |
| 2912 | binaryOperation; |
| 2913 | |
| 2914 | /// Matches function calls and constructor calls |
| 2915 | /// |
| 2916 | /// Because CallExpr and CXXConstructExpr do not share a common |
| 2917 | /// base class with API accessing arguments etc, AST Matchers for code |
| 2918 | /// which should match both are typically duplicated. This matcher |
| 2919 | /// removes the need for duplication. |
| 2920 | /// |
| 2921 | /// Given code |
| 2922 | /// \code |
| 2923 | /// struct ConstructorTakesInt |
| 2924 | /// { |
| 2925 | /// ConstructorTakesInt(int i) {} |
| 2926 | /// }; |
| 2927 | /// |
| 2928 | /// void callTakesInt(int i) |
| 2929 | /// { |
| 2930 | /// } |
| 2931 | /// |
| 2932 | /// void doCall() |
| 2933 | /// { |
| 2934 | /// callTakesInt(42); |
| 2935 | /// } |
| 2936 | /// |
| 2937 | /// void doConstruct() |
| 2938 | /// { |
| 2939 | /// ConstructorTakesInt cti(42); |
| 2940 | /// } |
| 2941 | /// \endcode |
| 2942 | /// |
| 2943 | /// The matcher |
| 2944 | /// \code |
| 2945 | /// invocation(hasArgument(0, integerLiteral(equals(42)))) |
| 2946 | /// \endcode |
| 2947 | /// matches the expression in both doCall and doConstruct |
| 2948 | extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation; |
| 2949 | |
| 2950 | /// Matches unary expressions that have a specific type of argument. |
| 2951 | /// |
| 2952 | /// Given |
| 2953 | /// \code |
| 2954 | /// int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c); |
| 2955 | /// \endcode |
| 2956 | /// unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int")) |
| 2957 | /// matches \c sizeof(a) and \c alignof(c) |
| 2958 | AST_MATCHER_P(UnaryExprOrTypeTraitExpr, hasArgumentOfType,namespace internal { class matcher_hasArgumentOfType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< UnaryExprOrTypeTraitExpr> { public: explicit matcher_hasArgumentOfType0Matcher ( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches(const UnaryExprOrTypeTraitExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<UnaryExprOrTypeTraitExpr> hasArgumentOfType( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_hasArgumentOfType0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <UnaryExprOrTypeTraitExpr> ( &hasArgumentOfType_Type0 )(internal::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_hasArgumentOfType0Matcher::matches ( const UnaryExprOrTypeTraitExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 2959 | internal::Matcher<QualType>, InnerMatcher)namespace internal { class matcher_hasArgumentOfType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< UnaryExprOrTypeTraitExpr> { public: explicit matcher_hasArgumentOfType0Matcher ( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches(const UnaryExprOrTypeTraitExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<UnaryExprOrTypeTraitExpr> hasArgumentOfType( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_hasArgumentOfType0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <UnaryExprOrTypeTraitExpr> ( &hasArgumentOfType_Type0 )(internal::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_hasArgumentOfType0Matcher::matches ( const UnaryExprOrTypeTraitExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 2960 | const QualType ArgumentType = Node.getTypeOfArgument(); |
| 2961 | return InnerMatcher.matches(ArgumentType, Finder, Builder); |
| 2962 | } |
| 2963 | |
| 2964 | /// Matches unary expressions of a certain kind. |
| 2965 | /// |
| 2966 | /// Given |
| 2967 | /// \code |
| 2968 | /// int x; |
| 2969 | /// int s = sizeof(x) + alignof(x) |
| 2970 | /// \endcode |
| 2971 | /// unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf)) |
| 2972 | /// matches \c sizeof(x) |
| 2973 | /// |
| 2974 | /// If the matcher is use from clang-query, UnaryExprOrTypeTrait parameter |
| 2975 | /// should be passed as a quoted string. e.g., ofKind("UETT_SizeOf"). |
| 2976 | AST_MATCHER_P(UnaryExprOrTypeTraitExpr, ofKind, UnaryExprOrTypeTrait, Kind)namespace internal { class matcher_ofKind0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<UnaryExprOrTypeTraitExpr > { public: explicit matcher_ofKind0Matcher( UnaryExprOrTypeTrait const &AKind) : Kind(AKind) {} bool matches(const UnaryExprOrTypeTraitExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: UnaryExprOrTypeTrait Kind ; }; } inline ::clang::ast_matchers::internal::Matcher<UnaryExprOrTypeTraitExpr > ofKind( UnaryExprOrTypeTrait const &Kind) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_ofKind0Matcher (Kind)); } typedef ::clang::ast_matchers::internal::Matcher< UnaryExprOrTypeTraitExpr> ( &ofKind_Type0)(UnaryExprOrTypeTrait const &Kind); inline bool internal::matcher_ofKind0Matcher ::matches( const UnaryExprOrTypeTraitExpr &Node, ::clang:: ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const { |
| 2977 | return Node.getKind() == Kind; |
| 2978 | } |
| 2979 | |
| 2980 | /// Same as unaryExprOrTypeTraitExpr, but only matching |
| 2981 | /// alignof. |
| 2982 | inline internal::BindableMatcher<Stmt> alignOfExpr( |
| 2983 | const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) { |
| 2984 | return stmt(unaryExprOrTypeTraitExpr( |
| 2985 | allOf(anyOf(ofKind(UETT_AlignOf), ofKind(UETT_PreferredAlignOf)), |
| 2986 | InnerMatcher))); |
| 2987 | } |
| 2988 | |
| 2989 | /// Same as unaryExprOrTypeTraitExpr, but only matching |
| 2990 | /// sizeof. |
| 2991 | inline internal::BindableMatcher<Stmt> sizeOfExpr( |
| 2992 | const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) { |
| 2993 | return stmt(unaryExprOrTypeTraitExpr( |
| 2994 | allOf(ofKind(UETT_SizeOf), InnerMatcher))); |
| 2995 | } |
| 2996 | |
| 2997 | /// Matches NamedDecl nodes that have the specified name. |
| 2998 | /// |
| 2999 | /// Supports specifying enclosing namespaces or classes by prefixing the name |
| 3000 | /// with '<enclosing>::'. |
| 3001 | /// Does not match typedefs of an underlying type with the given name. |
| 3002 | /// |
| 3003 | /// Example matches X (Name == "X") |
| 3004 | /// \code |
| 3005 | /// class X; |
| 3006 | /// \endcode |
| 3007 | /// |
| 3008 | /// Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X") |
| 3009 | /// \code |
| 3010 | /// namespace a { namespace b { class X; } } |
| 3011 | /// \endcode |
| 3012 | inline internal::Matcher<NamedDecl> hasName(StringRef Name) { |
| 3013 | return internal::Matcher<NamedDecl>( |
| 3014 | new internal::HasNameMatcher({std::string(Name)})); |
| 3015 | } |
| 3016 | |
| 3017 | /// Matches NamedDecl nodes that have any of the specified names. |
| 3018 | /// |
| 3019 | /// This matcher is only provided as a performance optimization of hasName. |
| 3020 | /// \code |
| 3021 | /// hasAnyName(a, b, c) |
| 3022 | /// \endcode |
| 3023 | /// is equivalent to, but faster than |
| 3024 | /// \code |
| 3025 | /// anyOf(hasName(a), hasName(b), hasName(c)) |
| 3026 | /// \endcode |
| 3027 | extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef, |
| 3028 | internal::hasAnyNameFunc> |
| 3029 | hasAnyName; |
| 3030 | |
| 3031 | /// Matches NamedDecl nodes whose fully qualified names contain |
| 3032 | /// a substring matched by the given RegExp. |
| 3033 | /// |
| 3034 | /// Supports specifying enclosing namespaces or classes by |
| 3035 | /// prefixing the name with '<enclosing>::'. Does not match typedefs |
| 3036 | /// of an underlying type with the given name. |
| 3037 | /// |
| 3038 | /// Example matches X (regexp == "::X") |
| 3039 | /// \code |
| 3040 | /// class X; |
| 3041 | /// \endcode |
| 3042 | /// |
| 3043 | /// Example matches X (regexp is one of "::X", "^foo::.*X", among others) |
| 3044 | /// \code |
| 3045 | /// namespace foo { namespace bar { class X; } } |
| 3046 | /// \endcode |
| 3047 | AST_MATCHER_REGEX(NamedDecl, matchesName, RegExp)namespace internal { class matcher_matchesName0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NamedDecl > { public: explicit matcher_matchesName0Matcher( std::shared_ptr <llvm::Regex> RE) : RegExp(std::move(RE)) {} bool matches (const NamedDecl &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::shared_ptr<llvm:: Regex> RegExp; }; } inline ::clang::ast_matchers::internal ::Matcher<NamedDecl> matchesName( llvm::StringRef RegExp , llvm::Regex::RegexFlags RegexFlags) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_matchesName0Matcher ( ::clang::ast_matchers::internal::createAndVerifyRegex( RegExp , RegexFlags, "matchesName"))); } inline ::clang::ast_matchers ::internal::Matcher<NamedDecl> matchesName( llvm::StringRef RegExp) { return matchesName(RegExp, llvm::Regex::NoFlags); } typedef ::clang::ast_matchers::internal::Matcher<NamedDecl > ( &matchesName_Type0Flags)(llvm::StringRef, llvm::Regex ::RegexFlags); typedef ::clang::ast_matchers::internal::Matcher <NamedDecl> ( &matchesName_Type0)(llvm::StringRef); inline bool internal::matcher_matchesName0Matcher::matches( const NamedDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3048 | std::string FullNameString = "::" + Node.getQualifiedNameAsString(); |
| 3049 | return RegExp->match(FullNameString); |
| 3050 | } |
| 3051 | |
| 3052 | /// Matches overloaded operator names. |
| 3053 | /// |
| 3054 | /// Matches overloaded operator names specified in strings without the |
| 3055 | /// "operator" prefix: e.g. "<<". |
| 3056 | /// |
| 3057 | /// Given: |
| 3058 | /// \code |
| 3059 | /// class A { int operator*(); }; |
| 3060 | /// const A &operator<<(const A &a, const A &b); |
| 3061 | /// A a; |
| 3062 | /// a << a; // <-- This matches |
| 3063 | /// \endcode |
| 3064 | /// |
| 3065 | /// \c cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the |
| 3066 | /// specified line and |
| 3067 | /// \c cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*"))) |
| 3068 | /// matches the declaration of \c A. |
| 3069 | /// |
| 3070 | /// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl> |
| 3071 | inline internal::PolymorphicMatcher< |
| 3072 | internal::HasOverloadedOperatorNameMatcher, |
| 3073 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)void(::clang::ast_matchers::internal::TypeList<CXXOperatorCallExpr , FunctionDecl>), |
| 3074 | std::vector<std::string>> |
| 3075 | hasOverloadedOperatorName(StringRef Name) { |
| 3076 | return internal::PolymorphicMatcher< |
| 3077 | internal::HasOverloadedOperatorNameMatcher, |
| 3078 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)void(::clang::ast_matchers::internal::TypeList<CXXOperatorCallExpr , FunctionDecl>), |
| 3079 | std::vector<std::string>>({std::string(Name)}); |
| 3080 | } |
| 3081 | |
| 3082 | /// Matches overloaded operator names. |
| 3083 | /// |
| 3084 | /// Matches overloaded operator names specified in strings without the |
| 3085 | /// "operator" prefix: e.g. "<<". |
| 3086 | /// |
| 3087 | /// hasAnyOverloadedOperatorName("+", "-") |
| 3088 | /// Is equivalent to |
| 3089 | /// anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-")) |
| 3090 | extern const internal::VariadicFunction< |
| 3091 | internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher, |
| 3092 | AST_POLYMORPHIC_SUPPORTED_TYPES(void(::clang::ast_matchers::internal::TypeList<CXXOperatorCallExpr , FunctionDecl>) |
| 3093 | CXXOperatorCallExpr, FunctionDecl)void(::clang::ast_matchers::internal::TypeList<CXXOperatorCallExpr , FunctionDecl>), |
| 3094 | std::vector<std::string>>, |
| 3095 | StringRef, internal::hasAnyOverloadedOperatorNameFunc> |
| 3096 | hasAnyOverloadedOperatorName; |
| 3097 | |
| 3098 | /// Matches template-dependent, but known, member names. |
| 3099 | /// |
| 3100 | /// In template declarations, dependent members are not resolved and so can |
| 3101 | /// not be matched to particular named declarations. |
| 3102 | /// |
| 3103 | /// This matcher allows to match on the known name of members. |
| 3104 | /// |
| 3105 | /// Given |
| 3106 | /// \code |
| 3107 | /// template <typename T> |
| 3108 | /// struct S { |
| 3109 | /// void mem(); |
| 3110 | /// }; |
| 3111 | /// template <typename T> |
| 3112 | /// void x() { |
| 3113 | /// S<T> s; |
| 3114 | /// s.mem(); |
| 3115 | /// } |
| 3116 | /// \endcode |
| 3117 | /// \c cxxDependentScopeMemberExpr(hasMemberName("mem")) matches `s.mem()` |
| 3118 | AST_MATCHER_P(CXXDependentScopeMemberExpr, hasMemberName, std::string, N)namespace internal { class matcher_hasMemberName0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXDependentScopeMemberExpr > { public: explicit matcher_hasMemberName0Matcher( std::string const &AN) : N(AN) {} bool matches(const CXXDependentScopeMemberExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string N; }; } inline ::clang::ast_matchers::internal::Matcher<CXXDependentScopeMemberExpr > hasMemberName( std::string const &N) { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_hasMemberName0Matcher (N)); } typedef ::clang::ast_matchers::internal::Matcher<CXXDependentScopeMemberExpr > ( &hasMemberName_Type0)(std::string const &N); inline bool internal::matcher_hasMemberName0Matcher::matches( const CXXDependentScopeMemberExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 3119 | return Node.getMember().getAsString() == N; |
| 3120 | } |
| 3121 | |
| 3122 | /// Matches template-dependent, but known, member names against an already-bound |
| 3123 | /// node |
| 3124 | /// |
| 3125 | /// In template declarations, dependent members are not resolved and so can |
| 3126 | /// not be matched to particular named declarations. |
| 3127 | /// |
| 3128 | /// This matcher allows to match on the name of already-bound VarDecl, FieldDecl |
| 3129 | /// and CXXMethodDecl nodes. |
| 3130 | /// |
| 3131 | /// Given |
| 3132 | /// \code |
| 3133 | /// template <typename T> |
| 3134 | /// struct S { |
| 3135 | /// void mem(); |
| 3136 | /// }; |
| 3137 | /// template <typename T> |
| 3138 | /// void x() { |
| 3139 | /// S<T> s; |
| 3140 | /// s.mem(); |
| 3141 | /// } |
| 3142 | /// \endcode |
| 3143 | /// The matcher |
| 3144 | /// @code |
| 3145 | /// \c cxxDependentScopeMemberExpr( |
| 3146 | /// hasObjectExpression(declRefExpr(hasType(templateSpecializationType( |
| 3147 | /// hasDeclaration(classTemplateDecl(has(cxxRecordDecl(has( |
| 3148 | /// cxxMethodDecl(hasName("mem")).bind("templMem") |
| 3149 | /// ))))) |
| 3150 | /// )))), |
| 3151 | /// memberHasSameNameAsBoundNode("templMem") |
| 3152 | /// ) |
| 3153 | /// @endcode |
| 3154 | /// first matches and binds the @c mem member of the @c S template, then |
| 3155 | /// compares its name to the usage in @c s.mem() in the @c x function template |
| 3156 | AST_MATCHER_P(CXXDependentScopeMemberExpr, memberHasSameNameAsBoundNode,namespace internal { class matcher_memberHasSameNameAsBoundNode0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< CXXDependentScopeMemberExpr> { public: explicit matcher_memberHasSameNameAsBoundNode0Matcher ( std::string const &ABindingID) : BindingID(ABindingID) { } bool matches(const CXXDependentScopeMemberExpr &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BindingID; }; } inline ::clang ::ast_matchers::internal::Matcher<CXXDependentScopeMemberExpr > memberHasSameNameAsBoundNode( std::string const &BindingID ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_memberHasSameNameAsBoundNode0Matcher(BindingID)); } typedef ::clang::ast_matchers::internal::Matcher<CXXDependentScopeMemberExpr > ( &memberHasSameNameAsBoundNode_Type0)(std::string const &BindingID); inline bool internal::matcher_memberHasSameNameAsBoundNode0Matcher ::matches( const CXXDependentScopeMemberExpr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 3157 | std::string, BindingID)namespace internal { class matcher_memberHasSameNameAsBoundNode0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< CXXDependentScopeMemberExpr> { public: explicit matcher_memberHasSameNameAsBoundNode0Matcher ( std::string const &ABindingID) : BindingID(ABindingID) { } bool matches(const CXXDependentScopeMemberExpr &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BindingID; }; } inline ::clang ::ast_matchers::internal::Matcher<CXXDependentScopeMemberExpr > memberHasSameNameAsBoundNode( std::string const &BindingID ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_memberHasSameNameAsBoundNode0Matcher(BindingID)); } typedef ::clang::ast_matchers::internal::Matcher<CXXDependentScopeMemberExpr > ( &memberHasSameNameAsBoundNode_Type0)(std::string const &BindingID); inline bool internal::matcher_memberHasSameNameAsBoundNode0Matcher ::matches( const CXXDependentScopeMemberExpr &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const { |
| 3158 | auto MemberName = Node.getMember().getAsString(); |
| 3159 | |
| 3160 | return Builder->removeBindings( |
| 3161 | [this, MemberName](const BoundNodesMap &Nodes) { |
| 3162 | const auto &BN = Nodes.getNode(this->BindingID); |
| 3163 | if (const auto *ND = BN.get<NamedDecl>()) { |
| 3164 | if (!isa<FieldDecl, CXXMethodDecl, VarDecl>(ND)) |
| 3165 | return true; |
| 3166 | return ND->getName() != MemberName; |
| 3167 | } |
| 3168 | return true; |
| 3169 | }); |
| 3170 | } |
| 3171 | |
| 3172 | /// Matches C++ classes that are directly or indirectly derived from a class |
| 3173 | /// matching \c Base, or Objective-C classes that directly or indirectly |
| 3174 | /// subclass a class matching \c Base. |
| 3175 | /// |
| 3176 | /// Note that a class is not considered to be derived from itself. |
| 3177 | /// |
| 3178 | /// Example matches Y, Z, C (Base == hasName("X")) |
| 3179 | /// \code |
| 3180 | /// class X; |
| 3181 | /// class Y : public X {}; // directly derived |
| 3182 | /// class Z : public Y {}; // indirectly derived |
| 3183 | /// typedef X A; |
| 3184 | /// typedef A B; |
| 3185 | /// class C : public B {}; // derived from a typedef of X |
| 3186 | /// \endcode |
| 3187 | /// |
| 3188 | /// In the following example, Bar matches isDerivedFrom(hasName("X")): |
| 3189 | /// \code |
| 3190 | /// class Foo; |
| 3191 | /// typedef Foo X; |
| 3192 | /// class Bar : public Foo {}; // derived from a type that X is a typedef of |
| 3193 | /// \endcode |
| 3194 | /// |
| 3195 | /// In the following example, Bar matches isDerivedFrom(hasName("NSObject")) |
| 3196 | /// \code |
| 3197 | /// @interface NSObject @end |
| 3198 | /// @interface Bar : NSObject @end |
| 3199 | /// \endcode |
| 3200 | /// |
| 3201 | /// Usable as: Matcher<CXXRecordDecl>, Matcher<ObjCInterfaceDecl> |
| 3202 | AST_POLYMORPHIC_MATCHER_P(namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom0Matcher( internal::Matcher< NamedDecl> const &ABase) : Base(ABase) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<NamedDecl > Base; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > isDerivedFrom(internal ::Matcher<NamedDecl> const &Base) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > (Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3203 | isDerivedFrom,namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom0Matcher( internal::Matcher< NamedDecl> const &ABase) : Base(ABase) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<NamedDecl > Base; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > isDerivedFrom(internal ::Matcher<NamedDecl> const &Base) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > (Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3204 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom0Matcher( internal::Matcher< NamedDecl> const &ABase) : Base(ABase) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<NamedDecl > Base; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > isDerivedFrom(internal ::Matcher<NamedDecl> const &Base) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > (Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3205 | internal::Matcher<NamedDecl>, Base)namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom0Matcher( internal::Matcher< NamedDecl> const &ABase) : Base(ABase) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<NamedDecl > Base; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > isDerivedFrom(internal ::Matcher<NamedDecl> const &Base) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > (Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3206 | // Check if the node is a C++ struct/union/class. |
| 3207 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |
| 3208 | return Finder->classIsDerivedFrom(RD, Base, Builder, /*Directly=*/false); |
| 3209 | |
| 3210 | // The node must be an Objective-C class. |
| 3211 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |
| 3212 | return Finder->objcClassIsDerivedFrom(InterfaceDecl, Base, Builder, |
| 3213 | /*Directly=*/false); |
| 3214 | } |
| 3215 | |
| 3216 | /// Overloaded method as shortcut for \c isDerivedFrom(hasName(...)). |
| 3217 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom1Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom1Matcher( std::string const & ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string> isDerivedFrom(std::string const &BaseName ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string>(BaseName); } typedef ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3218 | isDerivedFrom,namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom1Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom1Matcher( std::string const & ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string> isDerivedFrom(std::string const &BaseName ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string>(BaseName); } typedef ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3219 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom1Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom1Matcher( std::string const & ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string> isDerivedFrom(std::string const &BaseName ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string>(BaseName); } typedef ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3220 | std::string, BaseName, 1)namespace internal { template <typename NodeType, typename ParamT> class matcher_isDerivedFrom1Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_isDerivedFrom1Matcher( std::string const & ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string> isDerivedFrom(std::string const &BaseName ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDerivedFrom1Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , std::string>(BaseName); } typedef ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_isDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3221 | if (BaseName.empty()) |
| 3222 | return false; |
| 3223 | |
| 3224 | const auto M = isDerivedFrom(hasName(BaseName)); |
| 3225 | |
| 3226 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |
| 3227 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |
| 3228 | |
| 3229 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |
| 3230 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |
| 3231 | } |
| 3232 | |
| 3233 | /// Matches C++ classes that have a direct or indirect base matching \p |
| 3234 | /// BaseSpecMatcher. |
| 3235 | /// |
| 3236 | /// Example: |
| 3237 | /// matcher hasAnyBase(hasType(cxxRecordDecl(hasName("SpecialBase")))) |
| 3238 | /// \code |
| 3239 | /// class Foo; |
| 3240 | /// class Bar : Foo {}; |
| 3241 | /// class Baz : Bar {}; |
| 3242 | /// class SpecialBase; |
| 3243 | /// class Proxy : SpecialBase {}; // matches Proxy |
| 3244 | /// class IndirectlyDerived : Proxy {}; //matches IndirectlyDerived |
| 3245 | /// \endcode |
| 3246 | /// |
| 3247 | // FIXME: Refactor this and isDerivedFrom to reuse implementation. |
| 3248 | AST_MATCHER_P(CXXRecordDecl, hasAnyBase, internal::Matcher<CXXBaseSpecifier>,namespace internal { class matcher_hasAnyBase0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_hasAnyBase0Matcher( internal:: Matcher<CXXBaseSpecifier> const &ABaseSpecMatcher) : BaseSpecMatcher(ABaseSpecMatcher) {} bool matches(const CXXRecordDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<CXXBaseSpecifier > BaseSpecMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> hasAnyBase( internal::Matcher< CXXBaseSpecifier> const &BaseSpecMatcher) { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_hasAnyBase0Matcher (BaseSpecMatcher)); } typedef ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> ( &hasAnyBase_Type0)(internal ::Matcher<CXXBaseSpecifier> const &BaseSpecMatcher) ; inline bool internal::matcher_hasAnyBase0Matcher::matches( const CXXRecordDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3249 | BaseSpecMatcher)namespace internal { class matcher_hasAnyBase0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_hasAnyBase0Matcher( internal:: Matcher<CXXBaseSpecifier> const &ABaseSpecMatcher) : BaseSpecMatcher(ABaseSpecMatcher) {} bool matches(const CXXRecordDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<CXXBaseSpecifier > BaseSpecMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> hasAnyBase( internal::Matcher< CXXBaseSpecifier> const &BaseSpecMatcher) { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_hasAnyBase0Matcher (BaseSpecMatcher)); } typedef ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> ( &hasAnyBase_Type0)(internal ::Matcher<CXXBaseSpecifier> const &BaseSpecMatcher) ; inline bool internal::matcher_hasAnyBase0Matcher::matches( const CXXRecordDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3250 | return internal::matchesAnyBase(Node, BaseSpecMatcher, Finder, Builder); |
| 3251 | } |
| 3252 | |
| 3253 | /// Matches C++ classes that have a direct base matching \p BaseSpecMatcher. |
| 3254 | /// |
| 3255 | /// Example: |
| 3256 | /// matcher hasDirectBase(hasType(cxxRecordDecl(hasName("SpecialBase")))) |
| 3257 | /// \code |
| 3258 | /// class Foo; |
| 3259 | /// class Bar : Foo {}; |
| 3260 | /// class Baz : Bar {}; |
| 3261 | /// class SpecialBase; |
| 3262 | /// class Proxy : SpecialBase {}; // matches Proxy |
| 3263 | /// class IndirectlyDerived : Proxy {}; // doesn't match |
| 3264 | /// \endcode |
| 3265 | AST_MATCHER_P(CXXRecordDecl, hasDirectBase, internal::Matcher<CXXBaseSpecifier>,namespace internal { class matcher_hasDirectBase0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_hasDirectBase0Matcher( internal ::Matcher<CXXBaseSpecifier> const &ABaseSpecMatcher ) : BaseSpecMatcher(ABaseSpecMatcher) {} bool matches(const CXXRecordDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<CXXBaseSpecifier > BaseSpecMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> hasDirectBase( internal::Matcher <CXXBaseSpecifier> const &BaseSpecMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasDirectBase0Matcher(BaseSpecMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<CXXRecordDecl> ( &hasDirectBase_Type0)(internal::Matcher<CXXBaseSpecifier > const &BaseSpecMatcher); inline bool internal::matcher_hasDirectBase0Matcher ::matches( const CXXRecordDecl &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 3266 | BaseSpecMatcher)namespace internal { class matcher_hasDirectBase0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_hasDirectBase0Matcher( internal ::Matcher<CXXBaseSpecifier> const &ABaseSpecMatcher ) : BaseSpecMatcher(ABaseSpecMatcher) {} bool matches(const CXXRecordDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<CXXBaseSpecifier > BaseSpecMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> hasDirectBase( internal::Matcher <CXXBaseSpecifier> const &BaseSpecMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasDirectBase0Matcher(BaseSpecMatcher)); } typedef :: clang::ast_matchers::internal::Matcher<CXXRecordDecl> ( &hasDirectBase_Type0)(internal::Matcher<CXXBaseSpecifier > const &BaseSpecMatcher); inline bool internal::matcher_hasDirectBase0Matcher ::matches( const CXXRecordDecl &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 3267 | return Node.hasDefinition() && |
| 3268 | llvm::any_of(Node.bases(), [&](const CXXBaseSpecifier &Base) { |
| 3269 | return BaseSpecMatcher.matches(Base, Finder, Builder); |
| 3270 | }); |
| 3271 | } |
| 3272 | |
| 3273 | /// Similar to \c isDerivedFrom(), but also matches classes that directly |
| 3274 | /// match \c Base. |
| 3275 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom0Matcher( internal ::Matcher<NamedDecl> const &ABase) : Base(ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isSameOrDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom0Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isSameOrDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isSameOrDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isSameOrDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3276 | isSameOrDerivedFrom,namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom0Matcher( internal ::Matcher<NamedDecl> const &ABase) : Base(ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isSameOrDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom0Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isSameOrDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isSameOrDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isSameOrDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3277 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom0Matcher( internal ::Matcher<NamedDecl> const &ABase) : Base(ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isSameOrDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom0Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isSameOrDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isSameOrDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isSameOrDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3278 | internal::Matcher<NamedDecl>, Base, 0)namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom0Matcher( internal ::Matcher<NamedDecl> const &ABase) : Base(ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isSameOrDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom0Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isSameOrDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isSameOrDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isSameOrDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3279 | const auto M = anyOf(Base, isDerivedFrom(Base)); |
| 3280 | |
| 3281 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |
| 3282 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |
| 3283 | |
| 3284 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |
| 3285 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |
| 3286 | } |
| 3287 | |
| 3288 | /// Overloaded method as shortcut for |
| 3289 | /// \c isSameOrDerivedFrom(hasName(...)). |
| 3290 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom1Matcher( std ::string const &ABaseName) : BaseName(ABaseName) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang:: ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isSameOrDerivedFrom(std::string const & BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isSameOrDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isSameOrDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3291 | isSameOrDerivedFrom,namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom1Matcher( std ::string const &ABaseName) : BaseName(ABaseName) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang:: ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isSameOrDerivedFrom(std::string const & BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isSameOrDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isSameOrDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3292 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom1Matcher( std ::string const &ABaseName) : BaseName(ABaseName) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang:: ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isSameOrDerivedFrom(std::string const & BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isSameOrDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isSameOrDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3293 | std::string, BaseName, 1)namespace internal { template <typename NodeType, typename ParamT> class matcher_isSameOrDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isSameOrDerivedFrom1Matcher( std ::string const &ABaseName) : BaseName(ABaseName) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang:: ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isSameOrDerivedFrom(std::string const & BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isSameOrDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isSameOrDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isSameOrDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isSameOrDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3294 | if (BaseName.empty()) |
| 3295 | return false; |
| 3296 | |
| 3297 | const auto M = isSameOrDerivedFrom(hasName(BaseName)); |
| 3298 | |
| 3299 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |
| 3300 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |
| 3301 | |
| 3302 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |
| 3303 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |
| 3304 | } |
| 3305 | |
| 3306 | /// Matches C++ or Objective-C classes that are directly derived from a class |
| 3307 | /// matching \c Base. |
| 3308 | /// |
| 3309 | /// Note that a class is not considered to be derived from itself. |
| 3310 | /// |
| 3311 | /// Example matches Y, C (Base == hasName("X")) |
| 3312 | /// \code |
| 3313 | /// class X; |
| 3314 | /// class Y : public X {}; // directly derived |
| 3315 | /// class Z : public Y {}; // indirectly derived |
| 3316 | /// typedef X A; |
| 3317 | /// typedef A B; |
| 3318 | /// class C : public B {}; // derived from a typedef of X |
| 3319 | /// \endcode |
| 3320 | /// |
| 3321 | /// In the following example, Bar matches isDerivedFrom(hasName("X")): |
| 3322 | /// \code |
| 3323 | /// class Foo; |
| 3324 | /// typedef Foo X; |
| 3325 | /// class Bar : public Foo {}; // derived from a type that X is a typedef of |
| 3326 | /// \endcode |
| 3327 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom0Matcher ( internal::Matcher<NamedDecl> const &ABase) : Base (ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isDirectlyDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom0Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isDirectlyDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDirectlyDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3328 | isDirectlyDerivedFrom,namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom0Matcher ( internal::Matcher<NamedDecl> const &ABase) : Base (ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isDirectlyDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom0Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isDirectlyDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDirectlyDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3329 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom0Matcher ( internal::Matcher<NamedDecl> const &ABase) : Base (ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isDirectlyDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom0Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isDirectlyDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDirectlyDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3330 | internal::Matcher<NamedDecl>, Base, 0)namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom0Matcher ( internal::Matcher<NamedDecl> const &ABase) : Base (ABase) {} bool matches(const NodeType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<NamedDecl> Base; }; } inline ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom0Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), internal::Matcher<NamedDecl> > isDirectlyDerivedFrom(internal::Matcher<NamedDecl> const &Base) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom0Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), internal::Matcher<NamedDecl> >(Base); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_isDirectlyDerivedFrom0Matcher, void(::clang::ast_matchers ::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl>) , internal::Matcher<NamedDecl> > (&isDirectlyDerivedFrom_Type0 )(internal::Matcher<NamedDecl> const &Base); template <typename NodeType, typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3331 | // Check if the node is a C++ struct/union/class. |
| 3332 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |
| 3333 | return Finder->classIsDerivedFrom(RD, Base, Builder, /*Directly=*/true); |
| 3334 | |
| 3335 | // The node must be an Objective-C class. |
| 3336 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |
| 3337 | return Finder->objcClassIsDerivedFrom(InterfaceDecl, Base, Builder, |
| 3338 | /*Directly=*/true); |
| 3339 | } |
| 3340 | |
| 3341 | /// Overloaded method as shortcut for \c isDirectlyDerivedFrom(hasName(...)). |
| 3342 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom1Matcher ( std::string const &ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isDirectlyDerivedFrom(std::string const &BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom1Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDirectlyDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3343 | isDirectlyDerivedFrom,namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom1Matcher ( std::string const &ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isDirectlyDerivedFrom(std::string const &BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom1Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDirectlyDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3344 | AST_POLYMORPHIC_SUPPORTED_TYPES(CXXRecordDecl, ObjCInterfaceDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom1Matcher ( std::string const &ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isDirectlyDerivedFrom(std::string const &BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom1Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDirectlyDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3345 | std::string, BaseName, 1)namespace internal { template <typename NodeType, typename ParamT> class matcher_isDirectlyDerivedFrom1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<NodeType > { public: explicit matcher_isDirectlyDerivedFrom1Matcher ( std::string const &ABaseName) : BaseName(ABaseName) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher, void(::clang ::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string> isDirectlyDerivedFrom(std::string const &BaseName) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_isDirectlyDerivedFrom1Matcher, void(:: clang::ast_matchers::internal::TypeList<CXXRecordDecl, ObjCInterfaceDecl >), std::string>(BaseName); } typedef ::clang::ast_matchers ::internal::PolymorphicMatcher< internal::matcher_isDirectlyDerivedFrom1Matcher , void(::clang::ast_matchers::internal::TypeList<CXXRecordDecl , ObjCInterfaceDecl>), std::string> (&isDirectlyDerivedFrom_Type1 )(std::string const &BaseName); template <typename NodeType , typename ParamT> bool internal:: matcher_isDirectlyDerivedFrom1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3346 | if (BaseName.empty()) |
| 3347 | return false; |
| 3348 | const auto M = isDirectlyDerivedFrom(hasName(BaseName)); |
| 3349 | |
| 3350 | if (const auto *RD = dyn_cast<CXXRecordDecl>(&Node)) |
| 3351 | return Matcher<CXXRecordDecl>(M).matches(*RD, Finder, Builder); |
| 3352 | |
| 3353 | const auto *InterfaceDecl = cast<ObjCInterfaceDecl>(&Node); |
| 3354 | return Matcher<ObjCInterfaceDecl>(M).matches(*InterfaceDecl, Finder, Builder); |
| 3355 | } |
| 3356 | /// Matches the first method of a class or struct that satisfies \c |
| 3357 | /// InnerMatcher. |
| 3358 | /// |
| 3359 | /// Given: |
| 3360 | /// \code |
| 3361 | /// class A { void func(); }; |
| 3362 | /// class B { void member(); }; |
| 3363 | /// \endcode |
| 3364 | /// |
| 3365 | /// \c cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of |
| 3366 | /// \c A but not \c B. |
| 3367 | AST_MATCHER_P(CXXRecordDecl, hasMethod, internal::Matcher<CXXMethodDecl>,namespace internal { class matcher_hasMethod0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_hasMethod0Matcher( internal:: Matcher<CXXMethodDecl> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXRecordDecl &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<CXXMethodDecl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> hasMethod( internal::Matcher< CXXMethodDecl> const &InnerMatcher) { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_hasMethod0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <CXXRecordDecl> ( &hasMethod_Type0)(internal::Matcher <CXXMethodDecl> const &InnerMatcher); inline bool internal ::matcher_hasMethod0Matcher::matches( const CXXRecordDecl & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 3368 | InnerMatcher)namespace internal { class matcher_hasMethod0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_hasMethod0Matcher( internal:: Matcher<CXXMethodDecl> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXRecordDecl &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<CXXMethodDecl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<CXXRecordDecl> hasMethod( internal::Matcher< CXXMethodDecl> const &InnerMatcher) { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_hasMethod0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <CXXRecordDecl> ( &hasMethod_Type0)(internal::Matcher <CXXMethodDecl> const &InnerMatcher); inline bool internal ::matcher_hasMethod0Matcher::matches( const CXXRecordDecl & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const { |
| 3369 | BoundNodesTreeBuilder Result(*Builder); |
| 3370 | auto MatchIt = matchesFirstInPointerRange(InnerMatcher, Node.method_begin(), |
| 3371 | Node.method_end(), Finder, &Result); |
| 3372 | if (MatchIt == Node.method_end()) |
| 3373 | return false; |
| 3374 | |
| 3375 | if (Finder->isTraversalIgnoringImplicitNodes() && (*MatchIt)->isImplicit()) |
| 3376 | return false; |
| 3377 | *Builder = std::move(Result); |
| 3378 | return true; |
| 3379 | } |
| 3380 | |
| 3381 | /// Matches the generated class of lambda expressions. |
| 3382 | /// |
| 3383 | /// Given: |
| 3384 | /// \code |
| 3385 | /// auto x = []{}; |
| 3386 | /// \endcode |
| 3387 | /// |
| 3388 | /// \c cxxRecordDecl(isLambda()) matches the implicit class declaration of |
| 3389 | /// \c decltype(x) |
| 3390 | AST_MATCHER(CXXRecordDecl, isLambda)namespace internal { class matcher_isLambdaMatcher : public :: clang::ast_matchers::internal::MatcherInterface<CXXRecordDecl > { public: explicit matcher_isLambdaMatcher() = default; bool matches(const CXXRecordDecl &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<CXXRecordDecl> isLambda() { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_isLambdaMatcher()); } inline bool internal ::matcher_isLambdaMatcher::matches( const CXXRecordDecl & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const { |
| 3391 | return Node.isLambda(); |
| 3392 | } |
| 3393 | |
| 3394 | /// Matches AST nodes that have child AST nodes that match the |
| 3395 | /// provided matcher. |
| 3396 | /// |
| 3397 | /// Example matches X, Y |
| 3398 | /// (matcher = cxxRecordDecl(has(cxxRecordDecl(hasName("X"))) |
| 3399 | /// \code |
| 3400 | /// class X {}; // Matches X, because X::X is a class of name X inside X. |
| 3401 | /// class Y { class X {}; }; |
| 3402 | /// class Z { class Y { class X {}; }; }; // Does not match Z. |
| 3403 | /// \endcode |
| 3404 | /// |
| 3405 | /// ChildT must be an AST base type. |
| 3406 | /// |
| 3407 | /// Usable as: Any Matcher |
| 3408 | /// Note that has is direct matcher, so it also matches things like implicit |
| 3409 | /// casts and paren casts. If you are matching with expr then you should |
| 3410 | /// probably consider using ignoringParenImpCasts like: |
| 3411 | /// has(ignoringParenImpCasts(expr())). |
| 3412 | extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has; |
| 3413 | |
| 3414 | /// Matches AST nodes that have descendant AST nodes that match the |
| 3415 | /// provided matcher. |
| 3416 | /// |
| 3417 | /// Example matches X, Y, Z |
| 3418 | /// (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X"))))) |
| 3419 | /// \code |
| 3420 | /// class X {}; // Matches X, because X::X is a class of name X inside X. |
| 3421 | /// class Y { class X {}; }; |
| 3422 | /// class Z { class Y { class X {}; }; }; |
| 3423 | /// \endcode |
| 3424 | /// |
| 3425 | /// DescendantT must be an AST base type. |
| 3426 | /// |
| 3427 | /// Usable as: Any Matcher |
| 3428 | extern const internal::ArgumentAdaptingMatcherFunc< |
| 3429 | internal::HasDescendantMatcher> |
| 3430 | hasDescendant; |
| 3431 | |
| 3432 | /// Matches AST nodes that have child AST nodes that match the |
| 3433 | /// provided matcher. |
| 3434 | /// |
| 3435 | /// Example matches X, Y, Y::X, Z::Y, Z::Y::X |
| 3436 | /// (matcher = cxxRecordDecl(forEach(cxxRecordDecl(hasName("X"))) |
| 3437 | /// \code |
| 3438 | /// class X {}; |
| 3439 | /// class Y { class X {}; }; // Matches Y, because Y::X is a class of name X |
| 3440 | /// // inside Y. |
| 3441 | /// class Z { class Y { class X {}; }; }; // Does not match Z. |
| 3442 | /// \endcode |
| 3443 | /// |
| 3444 | /// ChildT must be an AST base type. |
| 3445 | /// |
| 3446 | /// As opposed to 'has', 'forEach' will cause a match for each result that |
| 3447 | /// matches instead of only on the first one. |
| 3448 | /// |
| 3449 | /// Usable as: Any Matcher |
| 3450 | extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher> |
| 3451 | forEach; |
| 3452 | |
| 3453 | /// Matches AST nodes that have descendant AST nodes that match the |
| 3454 | /// provided matcher. |
| 3455 | /// |
| 3456 | /// Example matches X, A, A::X, B, B::C, B::C::X |
| 3457 | /// (matcher = cxxRecordDecl(forEachDescendant(cxxRecordDecl(hasName("X"))))) |
| 3458 | /// \code |
| 3459 | /// class X {}; |
| 3460 | /// class A { class X {}; }; // Matches A, because A::X is a class of name |
| 3461 | /// // X inside A. |
| 3462 | /// class B { class C { class X {}; }; }; |
| 3463 | /// \endcode |
| 3464 | /// |
| 3465 | /// DescendantT must be an AST base type. |
| 3466 | /// |
| 3467 | /// As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for |
| 3468 | /// each result that matches instead of only on the first one. |
| 3469 | /// |
| 3470 | /// Note: Recursively combined ForEachDescendant can cause many matches: |
| 3471 | /// cxxRecordDecl(forEachDescendant(cxxRecordDecl( |
| 3472 | /// forEachDescendant(cxxRecordDecl()) |
| 3473 | /// ))) |
| 3474 | /// will match 10 times (plus injected class name matches) on: |
| 3475 | /// \code |
| 3476 | /// class A { class B { class C { class D { class E {}; }; }; }; }; |
| 3477 | /// \endcode |
| 3478 | /// |
| 3479 | /// Usable as: Any Matcher |
| 3480 | extern const internal::ArgumentAdaptingMatcherFunc< |
| 3481 | internal::ForEachDescendantMatcher> |
| 3482 | forEachDescendant; |
| 3483 | |
| 3484 | /// Matches if the node or any descendant matches. |
| 3485 | /// |
| 3486 | /// Generates results for each match. |
| 3487 | /// |
| 3488 | /// For example, in: |
| 3489 | /// \code |
| 3490 | /// class A { class B {}; class C {}; }; |
| 3491 | /// \endcode |
| 3492 | /// The matcher: |
| 3493 | /// \code |
| 3494 | /// cxxRecordDecl(hasName("::A"), |
| 3495 | /// findAll(cxxRecordDecl(isDefinition()).bind("m"))) |
| 3496 | /// \endcode |
| 3497 | /// will generate results for \c A, \c B and \c C. |
| 3498 | /// |
| 3499 | /// Usable as: Any Matcher |
| 3500 | template <typename T> |
| 3501 | internal::Matcher<T> findAll(const internal::Matcher<T> &Matcher) { |
| 3502 | return eachOf(Matcher, forEachDescendant(Matcher)); |
| 3503 | } |
| 3504 | |
| 3505 | /// Matches AST nodes that have a parent that matches the provided |
| 3506 | /// matcher. |
| 3507 | /// |
| 3508 | /// Given |
| 3509 | /// \code |
| 3510 | /// void f() { for (;;) { int x = 42; if (true) { int x = 43; } } } |
| 3511 | /// \endcode |
| 3512 | /// \c compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }". |
| 3513 | /// |
| 3514 | /// Usable as: Any Matcher |
| 3515 | extern const internal::ArgumentAdaptingMatcherFunc< |
| 3516 | internal::HasParentMatcher, |
| 3517 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>, |
| 3518 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>> |
| 3519 | hasParent; |
| 3520 | |
| 3521 | /// Matches AST nodes that have an ancestor that matches the provided |
| 3522 | /// matcher. |
| 3523 | /// |
| 3524 | /// Given |
| 3525 | /// \code |
| 3526 | /// void f() { if (true) { int x = 42; } } |
| 3527 | /// void g() { for (;;) { int x = 43; } } |
| 3528 | /// \endcode |
| 3529 | /// \c expr(integerLiteral(hasAncestor(ifStmt()))) matches \c 42, but not 43. |
| 3530 | /// |
| 3531 | /// Usable as: Any Matcher |
| 3532 | extern const internal::ArgumentAdaptingMatcherFunc< |
| 3533 | internal::HasAncestorMatcher, |
| 3534 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>, |
| 3535 | internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>> |
| 3536 | hasAncestor; |
| 3537 | |
| 3538 | /// Matches if the provided matcher does not match. |
| 3539 | /// |
| 3540 | /// Example matches Y (matcher = cxxRecordDecl(unless(hasName("X")))) |
| 3541 | /// \code |
| 3542 | /// class X {}; |
| 3543 | /// class Y {}; |
| 3544 | /// \endcode |
| 3545 | /// |
| 3546 | /// Usable as: Any Matcher |
| 3547 | extern const internal::VariadicOperatorMatcherFunc<1, 1> unless; |
| 3548 | |
| 3549 | /// Matches a node if the declaration associated with that node |
| 3550 | /// matches the given matcher. |
| 3551 | /// |
| 3552 | /// The associated declaration is: |
| 3553 | /// - for type nodes, the declaration of the underlying type |
| 3554 | /// - for CallExpr, the declaration of the callee |
| 3555 | /// - for MemberExpr, the declaration of the referenced member |
| 3556 | /// - for CXXConstructExpr, the declaration of the constructor |
| 3557 | /// - for CXXNewExpr, the declaration of the operator new |
| 3558 | /// - for ObjCIvarExpr, the declaration of the ivar |
| 3559 | /// |
| 3560 | /// For type nodes, hasDeclaration will generally match the declaration of the |
| 3561 | /// sugared type. Given |
| 3562 | /// \code |
| 3563 | /// class X {}; |
| 3564 | /// typedef X Y; |
| 3565 | /// Y y; |
| 3566 | /// \endcode |
| 3567 | /// in varDecl(hasType(hasDeclaration(decl()))) the decl will match the |
| 3568 | /// typedefDecl. A common use case is to match the underlying, desugared type. |
| 3569 | /// This can be achieved by using the hasUnqualifiedDesugaredType matcher: |
| 3570 | /// \code |
| 3571 | /// varDecl(hasType(hasUnqualifiedDesugaredType( |
| 3572 | /// recordType(hasDeclaration(decl()))))) |
| 3573 | /// \endcode |
| 3574 | /// In this matcher, the decl will match the CXXRecordDecl of class X. |
| 3575 | /// |
| 3576 | /// Usable as: Matcher<AddrLabelExpr>, Matcher<CallExpr>, |
| 3577 | /// Matcher<CXXConstructExpr>, Matcher<CXXNewExpr>, Matcher<DeclRefExpr>, |
| 3578 | /// Matcher<EnumType>, Matcher<InjectedClassNameType>, Matcher<LabelStmt>, |
| 3579 | /// Matcher<MemberExpr>, Matcher<QualType>, Matcher<RecordType>, |
| 3580 | /// Matcher<TagType>, Matcher<TemplateSpecializationType>, |
| 3581 | /// Matcher<TemplateTypeParmType>, Matcher<TypedefType>, |
| 3582 | /// Matcher<UnresolvedUsingType> |
| 3583 | inline internal::PolymorphicMatcher< |
| 3584 | internal::HasDeclarationMatcher, |
| 3585 | void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>> |
| 3586 | hasDeclaration(const internal::Matcher<Decl> &InnerMatcher) { |
| 3587 | return internal::PolymorphicMatcher< |
| 3588 | internal::HasDeclarationMatcher, |
| 3589 | void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>( |
| 3590 | InnerMatcher); |
| 3591 | } |
| 3592 | |
| 3593 | /// Matches a \c NamedDecl whose underlying declaration matches the given |
| 3594 | /// matcher. |
| 3595 | /// |
| 3596 | /// Given |
| 3597 | /// \code |
| 3598 | /// namespace N { template<class T> void f(T t); } |
| 3599 | /// template <class T> void g() { using N::f; f(T()); } |
| 3600 | /// \endcode |
| 3601 | /// \c unresolvedLookupExpr(hasAnyDeclaration( |
| 3602 | /// namedDecl(hasUnderlyingDecl(hasName("::N::f"))))) |
| 3603 | /// matches the use of \c f in \c g() . |
| 3604 | AST_MATCHER_P(NamedDecl, hasUnderlyingDecl, internal::Matcher<NamedDecl>,namespace internal { class matcher_hasUnderlyingDecl0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NamedDecl> { public: explicit matcher_hasUnderlyingDecl0Matcher ( internal::Matcher<NamedDecl> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NamedDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<NamedDecl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<NamedDecl> hasUnderlyingDecl( internal::Matcher <NamedDecl> const &InnerMatcher) { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_hasUnderlyingDecl0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <NamedDecl> ( &hasUnderlyingDecl_Type0)(internal::Matcher <NamedDecl> const &InnerMatcher); inline bool internal ::matcher_hasUnderlyingDecl0Matcher::matches( const NamedDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3605 | InnerMatcher)namespace internal { class matcher_hasUnderlyingDecl0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< NamedDecl> { public: explicit matcher_hasUnderlyingDecl0Matcher ( internal::Matcher<NamedDecl> const &AInnerMatcher ) : InnerMatcher(AInnerMatcher) {} bool matches(const NamedDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<NamedDecl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<NamedDecl> hasUnderlyingDecl( internal::Matcher <NamedDecl> const &InnerMatcher) { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_hasUnderlyingDecl0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <NamedDecl> ( &hasUnderlyingDecl_Type0)(internal::Matcher <NamedDecl> const &InnerMatcher); inline bool internal ::matcher_hasUnderlyingDecl0Matcher::matches( const NamedDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3606 | const NamedDecl *UnderlyingDecl = Node.getUnderlyingDecl(); |
| 3607 | |
| 3608 | return UnderlyingDecl != nullptr && |
| 3609 | InnerMatcher.matches(*UnderlyingDecl, Finder, Builder); |
| 3610 | } |
| 3611 | |
| 3612 | /// Matches on the implicit object argument of a member call expression, after |
| 3613 | /// stripping off any parentheses or implicit casts. |
| 3614 | /// |
| 3615 | /// Given |
| 3616 | /// \code |
| 3617 | /// class Y { public: void m(); }; |
| 3618 | /// Y g(); |
| 3619 | /// class X : public Y {}; |
| 3620 | /// void z(Y y, X x) { y.m(); (g()).m(); x.m(); } |
| 3621 | /// \endcode |
| 3622 | /// cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y"))))) |
| 3623 | /// matches `y.m()` and `(g()).m()`. |
| 3624 | /// cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("X"))))) |
| 3625 | /// matches `x.m()`. |
| 3626 | /// cxxMemberCallExpr(on(callExpr())) |
| 3627 | /// matches `(g()).m()`. |
| 3628 | /// |
| 3629 | /// FIXME: Overload to allow directly matching types? |
| 3630 | AST_MATCHER_P(CXXMemberCallExpr, on, internal::Matcher<Expr>,namespace internal { class matcher_on0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<CXXMemberCallExpr > { public: explicit matcher_on0Matcher( internal::Matcher <Expr> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const CXXMemberCallExpr &Node, ::clang:: ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<CXXMemberCallExpr> on ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_on0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers ::internal::Matcher<CXXMemberCallExpr> ( &on_Type0) (internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_on0Matcher::matches( const CXXMemberCallExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3631 | InnerMatcher)namespace internal { class matcher_on0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<CXXMemberCallExpr > { public: explicit matcher_on0Matcher( internal::Matcher <Expr> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const CXXMemberCallExpr &Node, ::clang:: ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Expr> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<CXXMemberCallExpr> on ( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_on0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers ::internal::Matcher<CXXMemberCallExpr> ( &on_Type0) (internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_on0Matcher::matches( const CXXMemberCallExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3632 | const Expr *ExprNode = Node.getImplicitObjectArgument() |
| 3633 | ->IgnoreParenImpCasts(); |
| 3634 | return (ExprNode != nullptr && |
| 3635 | InnerMatcher.matches(*ExprNode, Finder, Builder)); |
| 3636 | } |
| 3637 | |
| 3638 | |
| 3639 | /// Matches on the receiver of an ObjectiveC Message expression. |
| 3640 | /// |
| 3641 | /// Example |
| 3642 | /// matcher = objCMessageExpr(hasReceiverType(asString("UIWebView *"))); |
| 3643 | /// matches the [webView ...] message invocation. |
| 3644 | /// \code |
| 3645 | /// NSString *webViewJavaScript = ... |
| 3646 | /// UIWebView *webView = ... |
| 3647 | /// [webView stringByEvaluatingJavaScriptFromString:webViewJavascript]; |
| 3648 | /// \endcode |
| 3649 | AST_MATCHER_P(ObjCMessageExpr, hasReceiverType, internal::Matcher<QualType>,namespace internal { class matcher_hasReceiverType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasReceiverType0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ObjCMessageExpr &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<QualType> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > hasReceiverType( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_hasReceiverType0Matcher(InnerMatcher )); } typedef ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > ( &hasReceiverType_Type0)(internal::Matcher<QualType > const &InnerMatcher); inline bool internal::matcher_hasReceiverType0Matcher ::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 3650 | InnerMatcher)namespace internal { class matcher_hasReceiverType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasReceiverType0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ObjCMessageExpr &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<QualType> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > hasReceiverType( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_hasReceiverType0Matcher(InnerMatcher )); } typedef ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > ( &hasReceiverType_Type0)(internal::Matcher<QualType > const &InnerMatcher); inline bool internal::matcher_hasReceiverType0Matcher ::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 3651 | const QualType TypeDecl = Node.getReceiverType(); |
| 3652 | return InnerMatcher.matches(TypeDecl, Finder, Builder); |
| 3653 | } |
| 3654 | |
| 3655 | /// Returns true when the Objective-C method declaration is a class method. |
| 3656 | /// |
| 3657 | /// Example |
| 3658 | /// matcher = objcMethodDecl(isClassMethod()) |
| 3659 | /// matches |
| 3660 | /// \code |
| 3661 | /// @interface I + (void)foo; @end |
| 3662 | /// \endcode |
| 3663 | /// but not |
| 3664 | /// \code |
| 3665 | /// @interface I - (void)bar; @end |
| 3666 | /// \endcode |
| 3667 | AST_MATCHER(ObjCMethodDecl, isClassMethod)namespace internal { class matcher_isClassMethodMatcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMethodDecl > { public: explicit matcher_isClassMethodMatcher() = default ; bool matches(const ObjCMethodDecl &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMethodDecl> isClassMethod() { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_isClassMethodMatcher()); } inline bool internal::matcher_isClassMethodMatcher::matches( const ObjCMethodDecl &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3668 | return Node.isClassMethod(); |
| 3669 | } |
| 3670 | |
| 3671 | /// Returns true when the Objective-C method declaration is an instance method. |
| 3672 | /// |
| 3673 | /// Example |
| 3674 | /// matcher = objcMethodDecl(isInstanceMethod()) |
| 3675 | /// matches |
| 3676 | /// \code |
| 3677 | /// @interface I - (void)bar; @end |
| 3678 | /// \endcode |
| 3679 | /// but not |
| 3680 | /// \code |
| 3681 | /// @interface I + (void)foo; @end |
| 3682 | /// \endcode |
| 3683 | AST_MATCHER(ObjCMethodDecl, isInstanceMethod)namespace internal { class matcher_isInstanceMethodMatcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMethodDecl > { public: explicit matcher_isInstanceMethodMatcher() = default ; bool matches(const ObjCMethodDecl &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMethodDecl> isInstanceMethod() { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_isInstanceMethodMatcher()) ; } inline bool internal::matcher_isInstanceMethodMatcher::matches ( const ObjCMethodDecl &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3684 | return Node.isInstanceMethod(); |
| 3685 | } |
| 3686 | |
| 3687 | /// Returns true when the Objective-C message is sent to a class. |
| 3688 | /// |
| 3689 | /// Example |
| 3690 | /// matcher = objcMessageExpr(isClassMessage()) |
| 3691 | /// matches |
| 3692 | /// \code |
| 3693 | /// [NSString stringWithFormat:@"format"]; |
| 3694 | /// \endcode |
| 3695 | /// but not |
| 3696 | /// \code |
| 3697 | /// NSString *x = @"hello"; |
| 3698 | /// [x containsString:@"h"]; |
| 3699 | /// \endcode |
| 3700 | AST_MATCHER(ObjCMessageExpr, isClassMessage)namespace internal { class matcher_isClassMessageMatcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_isClassMessageMatcher() = default ; bool matches(const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr> isClassMessage() { return ::clang::ast_matchers::internal::makeMatcher ( new internal::matcher_isClassMessageMatcher()); } inline bool internal::matcher_isClassMessageMatcher::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3701 | return Node.isClassMessage(); |
| 3702 | } |
| 3703 | |
| 3704 | /// Returns true when the Objective-C message is sent to an instance. |
| 3705 | /// |
| 3706 | /// Example |
| 3707 | /// matcher = objcMessageExpr(isInstanceMessage()) |
| 3708 | /// matches |
| 3709 | /// \code |
| 3710 | /// NSString *x = @"hello"; |
| 3711 | /// [x containsString:@"h"]; |
| 3712 | /// \endcode |
| 3713 | /// but not |
| 3714 | /// \code |
| 3715 | /// [NSString stringWithFormat:@"format"]; |
| 3716 | /// \endcode |
| 3717 | AST_MATCHER(ObjCMessageExpr, isInstanceMessage)namespace internal { class matcher_isInstanceMessageMatcher : public ::clang::ast_matchers::internal::MatcherInterface< ObjCMessageExpr> { public: explicit matcher_isInstanceMessageMatcher () = default; bool matches(const ObjCMessageExpr &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher <ObjCMessageExpr> isInstanceMessage() { return ::clang:: ast_matchers::internal::makeMatcher( new internal::matcher_isInstanceMessageMatcher ()); } inline bool internal::matcher_isInstanceMessageMatcher ::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 3718 | return Node.isInstanceMessage(); |
| 3719 | } |
| 3720 | |
| 3721 | /// Matches if the Objective-C message is sent to an instance, |
| 3722 | /// and the inner matcher matches on that instance. |
| 3723 | /// |
| 3724 | /// For example the method call in |
| 3725 | /// \code |
| 3726 | /// NSString *x = @"hello"; |
| 3727 | /// [x containsString:@"h"]; |
| 3728 | /// \endcode |
| 3729 | /// is matched by |
| 3730 | /// objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x")))))) |
| 3731 | AST_MATCHER_P(ObjCMessageExpr, hasReceiver, internal::Matcher<Expr>,namespace internal { class matcher_hasReceiver0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasReceiver0Matcher( internal ::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ObjCMessageExpr &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > hasReceiver( internal::Matcher<Expr> const &InnerMatcher ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_hasReceiver0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<ObjCMessageExpr> ( & hasReceiver_Type0)(internal::Matcher<Expr> const &InnerMatcher ); inline bool internal::matcher_hasReceiver0Matcher::matches ( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3732 | InnerMatcher)namespace internal { class matcher_hasReceiver0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasReceiver0Matcher( internal ::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const ObjCMessageExpr &Node , ::clang::ast_matchers::internal::ASTMatchFinder *Finder, :: clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > hasReceiver( internal::Matcher<Expr> const &InnerMatcher ) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_hasReceiver0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<ObjCMessageExpr> ( & hasReceiver_Type0)(internal::Matcher<Expr> const &InnerMatcher ); inline bool internal::matcher_hasReceiver0Matcher::matches ( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3733 | const Expr *ReceiverNode = Node.getInstanceReceiver(); |
| 3734 | return (ReceiverNode != nullptr && |
| 3735 | InnerMatcher.matches(*ReceiverNode->IgnoreParenImpCasts(), Finder, |
| 3736 | Builder)); |
| 3737 | } |
| 3738 | |
| 3739 | /// Matches when BaseName == Selector.getAsString() |
| 3740 | /// |
| 3741 | /// matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:")); |
| 3742 | /// matches the outer message expr in the code below, but NOT the message |
| 3743 | /// invocation for self.bodyView. |
| 3744 | /// \code |
| 3745 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |
| 3746 | /// \endcode |
| 3747 | AST_MATCHER_P(ObjCMessageExpr, hasSelector, std::string, BaseName)namespace internal { class matcher_hasSelector0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasSelector0Matcher( std::string const &ABaseName) : BaseName(ABaseName) {} bool matches( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: std::string BaseName; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > hasSelector( std::string const &BaseName) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_hasSelector0Matcher (BaseName)); } typedef ::clang::ast_matchers::internal::Matcher <ObjCMessageExpr> ( &hasSelector_Type0)(std::string const &BaseName); inline bool internal::matcher_hasSelector0Matcher ::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 3748 | Selector Sel = Node.getSelector(); |
| 3749 | return BaseName == Sel.getAsString(); |
| 3750 | } |
| 3751 | |
| 3752 | /// Matches when at least one of the supplied string equals to the |
| 3753 | /// Selector.getAsString() |
| 3754 | /// |
| 3755 | /// matcher = objCMessageExpr(hasSelector("methodA:", "methodB:")); |
| 3756 | /// matches both of the expressions below: |
| 3757 | /// \code |
| 3758 | /// [myObj methodA:argA]; |
| 3759 | /// [myObj methodB:argB]; |
| 3760 | /// \endcode |
| 3761 | extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>, |
| 3762 | StringRef, |
| 3763 | internal::hasAnySelectorFunc> |
| 3764 | hasAnySelector; |
| 3765 | |
| 3766 | /// Matches ObjC selectors whose name contains |
| 3767 | /// a substring matched by the given RegExp. |
| 3768 | /// matcher = objCMessageExpr(matchesSelector("loadHTMLString\:baseURL?")); |
| 3769 | /// matches the outer message expr in the code below, but NOT the message |
| 3770 | /// invocation for self.bodyView. |
| 3771 | /// \code |
| 3772 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |
| 3773 | /// \endcode |
| 3774 | AST_MATCHER_REGEX(ObjCMessageExpr, matchesSelector, RegExp)namespace internal { class matcher_matchesSelector0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_matchesSelector0Matcher( std:: shared_ptr<llvm::Regex> RE) : RegExp(std::move(RE)) {} bool matches(const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: std ::shared_ptr<llvm::Regex> RegExp; }; } inline ::clang:: ast_matchers::internal::Matcher<ObjCMessageExpr> matchesSelector ( llvm::StringRef RegExp, llvm::Regex::RegexFlags RegexFlags) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_matchesSelector0Matcher( ::clang::ast_matchers::internal ::createAndVerifyRegex( RegExp, RegexFlags, "matchesSelector" ))); } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > matchesSelector( llvm::StringRef RegExp) { return matchesSelector (RegExp, llvm::Regex::NoFlags); } typedef ::clang::ast_matchers ::internal::Matcher<ObjCMessageExpr> ( &matchesSelector_Type0Flags )(llvm::StringRef, llvm::Regex::RegexFlags); typedef ::clang:: ast_matchers::internal::Matcher<ObjCMessageExpr> ( & matchesSelector_Type0)(llvm::StringRef); inline bool internal ::matcher_matchesSelector0Matcher::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3775 | std::string SelectorString = Node.getSelector().getAsString(); |
| 3776 | return RegExp->match(SelectorString); |
| 3777 | } |
| 3778 | |
| 3779 | /// Matches when the selector is the empty selector |
| 3780 | /// |
| 3781 | /// Matches only when the selector of the objCMessageExpr is NULL. This may |
| 3782 | /// represent an error condition in the tree! |
| 3783 | AST_MATCHER(ObjCMessageExpr, hasNullSelector)namespace internal { class matcher_hasNullSelectorMatcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasNullSelectorMatcher() = default ; bool matches(const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr> hasNullSelector() { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_hasNullSelectorMatcher()); } inline bool internal::matcher_hasNullSelectorMatcher::matches ( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3784 | return Node.getSelector().isNull(); |
| 3785 | } |
| 3786 | |
| 3787 | /// Matches when the selector is a Unary Selector |
| 3788 | /// |
| 3789 | /// matcher = objCMessageExpr(matchesSelector(hasUnarySelector()); |
| 3790 | /// matches self.bodyView in the code below, but NOT the outer message |
| 3791 | /// invocation of "loadHTMLString:baseURL:". |
| 3792 | /// \code |
| 3793 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |
| 3794 | /// \endcode |
| 3795 | AST_MATCHER(ObjCMessageExpr, hasUnarySelector)namespace internal { class matcher_hasUnarySelectorMatcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_hasUnarySelectorMatcher() = default ; bool matches(const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr> hasUnarySelector() { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_hasUnarySelectorMatcher()) ; } inline bool internal::matcher_hasUnarySelectorMatcher::matches ( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3796 | return Node.getSelector().isUnarySelector(); |
| 3797 | } |
| 3798 | |
| 3799 | /// Matches when the selector is a keyword selector |
| 3800 | /// |
| 3801 | /// objCMessageExpr(hasKeywordSelector()) matches the generated setFrame |
| 3802 | /// message expression in |
| 3803 | /// |
| 3804 | /// \code |
| 3805 | /// UIWebView *webView = ...; |
| 3806 | /// CGRect bodyFrame = webView.frame; |
| 3807 | /// bodyFrame.size.height = self.bodyContentHeight; |
| 3808 | /// webView.frame = bodyFrame; |
| 3809 | /// // ^---- matches here |
| 3810 | /// \endcode |
| 3811 | AST_MATCHER(ObjCMessageExpr, hasKeywordSelector)namespace internal { class matcher_hasKeywordSelectorMatcher : public ::clang::ast_matchers::internal::MatcherInterface< ObjCMessageExpr> { public: explicit matcher_hasKeywordSelectorMatcher () = default; bool matches(const ObjCMessageExpr &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; }; } inline ::clang::ast_matchers::internal::Matcher <ObjCMessageExpr> hasKeywordSelector() { return ::clang ::ast_matchers::internal::makeMatcher( new internal::matcher_hasKeywordSelectorMatcher ()); } inline bool internal::matcher_hasKeywordSelectorMatcher ::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 3812 | return Node.getSelector().isKeywordSelector(); |
| 3813 | } |
| 3814 | |
| 3815 | /// Matches when the selector has the specified number of arguments |
| 3816 | /// |
| 3817 | /// matcher = objCMessageExpr(numSelectorArgs(0)); |
| 3818 | /// matches self.bodyView in the code below |
| 3819 | /// |
| 3820 | /// matcher = objCMessageExpr(numSelectorArgs(2)); |
| 3821 | /// matches the invocation of "loadHTMLString:baseURL:" but not that |
| 3822 | /// of self.bodyView |
| 3823 | /// \code |
| 3824 | /// [self.bodyView loadHTMLString:html baseURL:NULL]; |
| 3825 | /// \endcode |
| 3826 | AST_MATCHER_P(ObjCMessageExpr, numSelectorArgs, unsigned, N)namespace internal { class matcher_numSelectorArgs0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<ObjCMessageExpr > { public: explicit matcher_numSelectorArgs0Matcher( unsigned const &AN) : N(AN) {} bool matches(const ObjCMessageExpr &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: unsigned N; }; } inline :: clang::ast_matchers::internal::Matcher<ObjCMessageExpr> numSelectorArgs( unsigned const &N) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_numSelectorArgs0Matcher (N)); } typedef ::clang::ast_matchers::internal::Matcher<ObjCMessageExpr > ( &numSelectorArgs_Type0)(unsigned const &N); inline bool internal::matcher_numSelectorArgs0Matcher::matches( const ObjCMessageExpr &Node, ::clang::ast_matchers::internal:: ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3827 | return Node.getSelector().getNumArgs() == N; |
| 3828 | } |
| 3829 | |
| 3830 | /// Matches if the call expression's callee expression matches. |
| 3831 | /// |
| 3832 | /// Given |
| 3833 | /// \code |
| 3834 | /// class Y { void x() { this->x(); x(); Y y; y.x(); } }; |
| 3835 | /// void f() { f(); } |
| 3836 | /// \endcode |
| 3837 | /// callExpr(callee(expr())) |
| 3838 | /// matches this->x(), x(), y.x(), f() |
| 3839 | /// with callee(...) |
| 3840 | /// matching this->x, x, y.x, f respectively |
| 3841 | /// |
| 3842 | /// Note: Callee cannot take the more general internal::Matcher<Expr> |
| 3843 | /// because this introduces ambiguous overloads with calls to Callee taking a |
| 3844 | /// internal::Matcher<Decl>, as the matcher hierarchy is purely |
| 3845 | /// implemented in terms of implicit casts. |
| 3846 | AST_MATCHER_P(CallExpr, callee, internal::Matcher<Stmt>,namespace internal { class matcher_callee0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<CallExpr> { public: explicit matcher_callee0Matcher( internal::Matcher <Stmt> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const CallExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<Stmt> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::Matcher<CallExpr> callee( internal::Matcher <Stmt> const &InnerMatcher) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_callee0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <CallExpr> ( &callee_Type0)(internal::Matcher<Stmt > const &InnerMatcher); inline bool internal::matcher_callee0Matcher ::matches( const CallExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3847 | InnerMatcher)namespace internal { class matcher_callee0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<CallExpr> { public: explicit matcher_callee0Matcher( internal::Matcher <Stmt> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const CallExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<Stmt> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::Matcher<CallExpr> callee( internal::Matcher <Stmt> const &InnerMatcher) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_callee0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <CallExpr> ( &callee_Type0)(internal::Matcher<Stmt > const &InnerMatcher); inline bool internal::matcher_callee0Matcher ::matches( const CallExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3848 | const Expr *ExprNode = Node.getCallee(); |
| 3849 | return (ExprNode != nullptr && |
| 3850 | InnerMatcher.matches(*ExprNode, Finder, Builder)); |
| 3851 | } |
| 3852 | |
| 3853 | /// Matches 1) if the call expression's callee's declaration matches the |
| 3854 | /// given matcher; or 2) if the Obj-C message expression's callee's method |
| 3855 | /// declaration matches the given matcher. |
| 3856 | /// |
| 3857 | /// Example matches y.x() (matcher = callExpr(callee( |
| 3858 | /// cxxMethodDecl(hasName("x"))))) |
| 3859 | /// \code |
| 3860 | /// class Y { public: void x(); }; |
| 3861 | /// void z() { Y y; y.x(); } |
| 3862 | /// \endcode |
| 3863 | /// |
| 3864 | /// Example 2. Matches [I foo] with |
| 3865 | /// objcMessageExpr(callee(objcMethodDecl(hasName("foo")))) |
| 3866 | /// |
| 3867 | /// \code |
| 3868 | /// @interface I: NSObject |
| 3869 | /// +(void)foo; |
| 3870 | /// @end |
| 3871 | /// ... |
| 3872 | /// [I foo] |
| 3873 | /// \endcode |
| 3874 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_callee1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_callee1Matcher( internal::Matcher<Decl> const & AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_callee1Matcher, void (::clang::ast_matchers::internal::TypeList<ObjCMessageExpr , CallExpr>), internal::Matcher<Decl> > callee(internal ::Matcher<Decl> const &InnerMatcher) { return ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_callee1Matcher , void(::clang::ast_matchers::internal::TypeList<ObjCMessageExpr , CallExpr>), internal::Matcher<Decl> >(InnerMatcher ); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_callee1Matcher, void(::clang::ast_matchers ::internal::TypeList<ObjCMessageExpr, CallExpr>), internal ::Matcher<Decl> > (&callee_Type1)(internal::Matcher <Decl> const &InnerMatcher); template <typename NodeType , typename ParamT> bool internal:: matcher_callee1Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 3875 | callee, AST_POLYMORPHIC_SUPPORTED_TYPES(ObjCMessageExpr, CallExpr),namespace internal { template <typename NodeType, typename ParamT> class matcher_callee1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_callee1Matcher( internal::Matcher<Decl> const & AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_callee1Matcher, void (::clang::ast_matchers::internal::TypeList<ObjCMessageExpr , CallExpr>), internal::Matcher<Decl> > callee(internal ::Matcher<Decl> const &InnerMatcher) { return ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_callee1Matcher , void(::clang::ast_matchers::internal::TypeList<ObjCMessageExpr , CallExpr>), internal::Matcher<Decl> >(InnerMatcher ); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_callee1Matcher, void(::clang::ast_matchers ::internal::TypeList<ObjCMessageExpr, CallExpr>), internal ::Matcher<Decl> > (&callee_Type1)(internal::Matcher <Decl> const &InnerMatcher); template <typename NodeType , typename ParamT> bool internal:: matcher_callee1Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const |
| 3876 | internal::Matcher<Decl>, InnerMatcher, 1)namespace internal { template <typename NodeType, typename ParamT> class matcher_callee1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_callee1Matcher( internal::Matcher<Decl> const & AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches( const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_callee1Matcher, void (::clang::ast_matchers::internal::TypeList<ObjCMessageExpr , CallExpr>), internal::Matcher<Decl> > callee(internal ::Matcher<Decl> const &InnerMatcher) { return ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_callee1Matcher , void(::clang::ast_matchers::internal::TypeList<ObjCMessageExpr , CallExpr>), internal::Matcher<Decl> >(InnerMatcher ); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_callee1Matcher, void(::clang::ast_matchers ::internal::TypeList<ObjCMessageExpr, CallExpr>), internal ::Matcher<Decl> > (&callee_Type1)(internal::Matcher <Decl> const &InnerMatcher); template <typename NodeType , typename ParamT> bool internal:: matcher_callee1Matcher< NodeType, ParamT>::matches( const NodeType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const { |
| 3877 | if (const auto *CallNode = dyn_cast<CallExpr>(&Node)) |
| 3878 | return callExpr(hasDeclaration(InnerMatcher)) |
| 3879 | .matches(Node, Finder, Builder); |
| 3880 | else { |
| 3881 | // The dynamic cast below is guaranteed to succeed as there are only 2 |
| 3882 | // supported return types. |
| 3883 | const auto *MsgNode = cast<ObjCMessageExpr>(&Node); |
| 3884 | const Decl *DeclNode = MsgNode->getMethodDecl(); |
| 3885 | return (DeclNode != nullptr && |
| 3886 | InnerMatcher.matches(*DeclNode, Finder, Builder)); |
| 3887 | } |
| 3888 | } |
| 3889 | |
| 3890 | /// Matches if the expression's or declaration's type matches a type |
| 3891 | /// matcher. |
| 3892 | /// |
| 3893 | /// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X"))))) |
| 3894 | /// and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X"))))) |
| 3895 | /// and U (matcher = typedefDecl(hasType(asString("int"))) |
| 3896 | /// and friend class X (matcher = friendDecl(hasType("X")) |
| 3897 | /// and public virtual X (matcher = cxxBaseSpecifier(hasType( |
| 3898 | /// asString("class X"))) |
| 3899 | /// \code |
| 3900 | /// class X {}; |
| 3901 | /// void y(X &x) { x; X z; } |
| 3902 | /// typedef int U; |
| 3903 | /// class Y { friend class X; }; |
| 3904 | /// class Z : public virtual X {}; |
| 3905 | /// \endcode |
| 3906 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType0Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType0Matcher( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType0Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > hasType(internal::Matcher<QualType > const &InnerMatcher) { return ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> >(InnerMatcher); } typedef ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > (&hasType_Type0)(internal:: Matcher<QualType> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3907 | hasType,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType0Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType0Matcher( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType0Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > hasType(internal::Matcher<QualType > const &InnerMatcher) { return ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> >(InnerMatcher); } typedef ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > (&hasType_Type0)(internal:: Matcher<QualType> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3908 | AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, FriendDecl, TypedefNameDecl,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType0Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType0Matcher( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType0Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > hasType(internal::Matcher<QualType > const &InnerMatcher) { return ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> >(InnerMatcher); } typedef ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > (&hasType_Type0)(internal:: Matcher<QualType> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3909 | ValueDecl, CXXBaseSpecifier),namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType0Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType0Matcher( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType0Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > hasType(internal::Matcher<QualType > const &InnerMatcher) { return ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> >(InnerMatcher); } typedef ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > (&hasType_Type0)(internal:: Matcher<QualType> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3910 | internal::Matcher<QualType>, InnerMatcher, 0)namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType0Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType0Matcher( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType0Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > hasType(internal::Matcher<QualType > const &InnerMatcher) { return ::clang::ast_matchers:: internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> >(InnerMatcher); } typedef ::clang ::ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasType0Matcher , void(::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , TypedefNameDecl, ValueDecl, CXXBaseSpecifier>), internal ::Matcher<QualType> > (&hasType_Type0)(internal:: Matcher<QualType> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3911 | QualType QT = internal::getUnderlyingType(Node); |
| 3912 | if (!QT.isNull()) |
| 3913 | return InnerMatcher.matches(QT, Finder, Builder); |
| 3914 | return false; |
| 3915 | } |
| 3916 | |
| 3917 | /// Overloaded to match the declaration of the expression's or value |
| 3918 | /// declaration's type. |
| 3919 | /// |
| 3920 | /// In case of a value declaration (for example a variable declaration), |
| 3921 | /// this resolves one layer of indirection. For example, in the value |
| 3922 | /// declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of |
| 3923 | /// X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the |
| 3924 | /// declaration of x. |
| 3925 | /// |
| 3926 | /// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X"))))) |
| 3927 | /// and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X"))))) |
| 3928 | /// and friend class X (matcher = friendDecl(hasType("X")) |
| 3929 | /// and public virtual X (matcher = cxxBaseSpecifier(hasType( |
| 3930 | /// cxxRecordDecl(hasName("X")))) |
| 3931 | /// \code |
| 3932 | /// class X {}; |
| 3933 | /// void y(X &x) { x; X z; } |
| 3934 | /// class Y { friend class X; }; |
| 3935 | /// class Z : public virtual X {}; |
| 3936 | /// \endcode |
| 3937 | /// |
| 3938 | /// Example matches class Derived |
| 3939 | /// (matcher = cxxRecordDecl(hasAnyBase(hasType(cxxRecordDecl(hasName("Base")))))) |
| 3940 | /// \code |
| 3941 | /// class Base {}; |
| 3942 | /// class Derived : Base {}; |
| 3943 | /// \endcode |
| 3944 | /// |
| 3945 | /// Usable as: Matcher<Expr>, Matcher<FriendDecl>, Matcher<ValueDecl>, |
| 3946 | /// Matcher<CXXBaseSpecifier> |
| 3947 | AST_POLYMORPHIC_MATCHER_P_OVERLOAD(namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType1Matcher( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType1Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , ValueDecl, CXXBaseSpecifier>), internal::Matcher<Decl > > hasType(internal::Matcher<Decl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasType1Matcher, void(::clang::ast_matchers ::internal::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier >), internal::Matcher<Decl> >(InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasType1Matcher, void(::clang::ast_matchers::internal ::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier> ), internal::Matcher<Decl> > (&hasType_Type1)(internal ::Matcher<Decl> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3948 | hasType,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType1Matcher( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType1Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , ValueDecl, CXXBaseSpecifier>), internal::Matcher<Decl > > hasType(internal::Matcher<Decl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasType1Matcher, void(::clang::ast_matchers ::internal::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier >), internal::Matcher<Decl> >(InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasType1Matcher, void(::clang::ast_matchers::internal ::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier> ), internal::Matcher<Decl> > (&hasType_Type1)(internal ::Matcher<Decl> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3949 | AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, FriendDecl, ValueDecl,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType1Matcher( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType1Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , ValueDecl, CXXBaseSpecifier>), internal::Matcher<Decl > > hasType(internal::Matcher<Decl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasType1Matcher, void(::clang::ast_matchers ::internal::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier >), internal::Matcher<Decl> >(InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasType1Matcher, void(::clang::ast_matchers::internal ::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier> ), internal::Matcher<Decl> > (&hasType_Type1)(internal ::Matcher<Decl> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3950 | CXXBaseSpecifier),namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType1Matcher( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType1Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , ValueDecl, CXXBaseSpecifier>), internal::Matcher<Decl > > hasType(internal::Matcher<Decl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasType1Matcher, void(::clang::ast_matchers ::internal::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier >), internal::Matcher<Decl> >(InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasType1Matcher, void(::clang::ast_matchers::internal ::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier> ), internal::Matcher<Decl> > (&hasType_Type1)(internal ::Matcher<Decl> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3951 | internal::Matcher<Decl>, InnerMatcher, 1)namespace internal { template <typename NodeType, typename ParamT> class matcher_hasType1Matcher : public ::clang::ast_matchers ::internal::MatcherInterface<NodeType> { public: explicit matcher_hasType1Matcher( internal::Matcher<Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches (const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<Decl > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::PolymorphicMatcher< internal::matcher_hasType1Matcher, void (::clang::ast_matchers::internal::TypeList<Expr, FriendDecl , ValueDecl, CXXBaseSpecifier>), internal::Matcher<Decl > > hasType(internal::Matcher<Decl> const &InnerMatcher ) { return ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasType1Matcher, void(::clang::ast_matchers ::internal::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier >), internal::Matcher<Decl> >(InnerMatcher); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasType1Matcher, void(::clang::ast_matchers::internal ::TypeList<Expr, FriendDecl, ValueDecl, CXXBaseSpecifier> ), internal::Matcher<Decl> > (&hasType_Type1)(internal ::Matcher<Decl> const &InnerMatcher); template < typename NodeType, typename ParamT> bool internal:: matcher_hasType1Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3952 | QualType QT = internal::getUnderlyingType(Node); |
| 3953 | if (!QT.isNull()) |
| 3954 | return qualType(hasDeclaration(InnerMatcher)).matches(QT, Finder, Builder); |
| 3955 | return false; |
| 3956 | } |
| 3957 | |
| 3958 | /// Matches if the type location of a node matches the inner matcher. |
| 3959 | /// |
| 3960 | /// Examples: |
| 3961 | /// \code |
| 3962 | /// int x; |
| 3963 | /// \endcode |
| 3964 | /// declaratorDecl(hasTypeLoc(loc(asString("int")))) |
| 3965 | /// matches int x |
| 3966 | /// |
| 3967 | /// \code |
| 3968 | /// auto x = int(3); |
| 3969 | /// \endcode |
| 3970 | /// cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("int")))) |
| 3971 | /// matches int(3) |
| 3972 | /// |
| 3973 | /// \code |
| 3974 | /// struct Foo { Foo(int, int); }; |
| 3975 | /// auto x = Foo(1, 2); |
| 3976 | /// \endcode |
| 3977 | /// cxxFunctionalCastExpr(hasTypeLoc(loc(asString("struct Foo")))) |
| 3978 | /// matches Foo(1, 2) |
| 3979 | /// |
| 3980 | /// Usable as: Matcher<BlockDecl>, Matcher<CXXBaseSpecifier>, |
| 3981 | /// Matcher<CXXCtorInitializer>, Matcher<CXXFunctionalCastExpr>, |
| 3982 | /// Matcher<CXXNewExpr>, Matcher<CXXTemporaryObjectExpr>, |
| 3983 | /// Matcher<CXXUnresolvedConstructExpr>, |
| 3984 | /// Matcher<ClassTemplateSpecializationDecl>, Matcher<CompoundLiteralExpr>, |
| 3985 | /// Matcher<DeclaratorDecl>, Matcher<ExplicitCastExpr>, |
| 3986 | /// Matcher<ObjCPropertyDecl>, Matcher<TemplateArgumentLoc>, |
| 3987 | /// Matcher<TypedefNameDecl> |
| 3988 | AST_POLYMORPHIC_MATCHER_P(namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3989 | hasTypeLoc,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3990 | AST_POLYMORPHIC_SUPPORTED_TYPES(namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3991 | BlockDecl, CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3992 | CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3993 | ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3994 | ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc,namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3995 | TypedefNameDecl),namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 3996 | internal::Matcher<TypeLoc>, Inner)namespace internal { template <typename NodeType, typename ParamT> class matcher_hasTypeLoc0Matcher : public ::clang ::ast_matchers::internal::MatcherInterface<NodeType> { public : explicit matcher_hasTypeLoc0Matcher( internal::Matcher<TypeLoc > const &AInner) : Inner(AInner) {} bool matches(const NodeType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<TypeLoc > Inner; }; } inline ::clang::ast_matchers::internal::PolymorphicMatcher < internal::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers ::internal::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > hasTypeLoc(internal ::Matcher<TypeLoc> const &Inner) { return ::clang:: ast_matchers::internal::PolymorphicMatcher< internal::matcher_hasTypeLoc0Matcher , void(::clang::ast_matchers::internal::TypeList<BlockDecl , CXXBaseSpecifier, CXXCtorInitializer, CXXFunctionalCastExpr , CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> >(Inner); } typedef ::clang::ast_matchers::internal::PolymorphicMatcher< internal ::matcher_hasTypeLoc0Matcher, void(::clang::ast_matchers::internal ::TypeList<BlockDecl, CXXBaseSpecifier, CXXCtorInitializer , CXXFunctionalCastExpr, CXXNewExpr, CXXTemporaryObjectExpr, CXXUnresolvedConstructExpr , ClassTemplateSpecializationDecl, CompoundLiteralExpr, DeclaratorDecl , ExplicitCastExpr, ObjCPropertyDecl, TemplateArgumentLoc, TypedefNameDecl >), internal::Matcher<TypeLoc> > (&hasTypeLoc_Type0 )(internal::Matcher<TypeLoc> const &Inner); template <typename NodeType, typename ParamT> bool internal:: matcher_hasTypeLoc0Matcher <NodeType, ParamT>::matches( const NodeType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 3997 | TypeSourceInfo *source = internal::GetTypeSourceInfo(Node); |
| 3998 | if (source == nullptr) { |
| 3999 | // This happens for example for implicit destructors. |
| 4000 | return false; |
| 4001 | } |
| 4002 | return Inner.matches(source->getTypeLoc(), Finder, Builder); |
| 4003 | } |
| 4004 | |
| 4005 | /// Matches if the matched type is represented by the given string. |
| 4006 | /// |
| 4007 | /// Given |
| 4008 | /// \code |
| 4009 | /// class Y { public: void x(); }; |
| 4010 | /// void z() { Y* y; y->x(); } |
| 4011 | /// \endcode |
| 4012 | /// cxxMemberCallExpr(on(hasType(asString("class Y *")))) |
| 4013 | /// matches y->x() |
| 4014 | AST_MATCHER_P(QualType, asString, std::string, Name)namespace internal { class matcher_asString0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<QualType> { public: explicit matcher_asString0Matcher( std::string const &AName) : Name(AName) {} bool matches(const QualType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: std::string Name; }; } inline ::clang ::ast_matchers::internal::Matcher<QualType> asString( std ::string const &Name) { return ::clang::ast_matchers::internal ::makeMatcher( new internal::matcher_asString0Matcher(Name)); } typedef ::clang::ast_matchers::internal::Matcher<QualType > ( &asString_Type0)(std::string const &Name); inline bool internal::matcher_asString0Matcher::matches( const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4015 | return Name == Node.getAsString(); |
| 4016 | } |
| 4017 | |
| 4018 | /// Matches if the matched type is a pointer type and the pointee type |
| 4019 | /// matches the specified matcher. |
| 4020 | /// |
| 4021 | /// Example matches y->x() |
| 4022 | /// (matcher = cxxMemberCallExpr(on(hasType(pointsTo |
| 4023 | /// cxxRecordDecl(hasName("Y"))))))) |
| 4024 | /// \code |
| 4025 | /// class Y { public: void x(); }; |
| 4026 | /// void z() { Y *y; y->x(); } |
| 4027 | /// \endcode |
| 4028 | AST_MATCHER_P(namespace internal { class matcher_pointsTo0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<QualType> { public: explicit matcher_pointsTo0Matcher( internal::Matcher <QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const QualType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<QualType> InnerMatcher; }; } inline ::clang:: ast_matchers::internal::Matcher<QualType> pointsTo( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_pointsTo0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &pointsTo_Type0)(internal::Matcher< QualType> const &InnerMatcher); inline bool internal:: matcher_pointsTo0Matcher::matches( const QualType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4029 | QualType, pointsTo, internal::Matcher<QualType>,namespace internal { class matcher_pointsTo0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<QualType> { public: explicit matcher_pointsTo0Matcher( internal::Matcher <QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const QualType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<QualType> InnerMatcher; }; } inline ::clang:: ast_matchers::internal::Matcher<QualType> pointsTo( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_pointsTo0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &pointsTo_Type0)(internal::Matcher< QualType> const &InnerMatcher); inline bool internal:: matcher_pointsTo0Matcher::matches( const QualType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4030 | InnerMatcher)namespace internal { class matcher_pointsTo0Matcher : public :: clang::ast_matchers::internal::MatcherInterface<QualType> { public: explicit matcher_pointsTo0Matcher( internal::Matcher <QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const QualType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<QualType> InnerMatcher; }; } inline ::clang:: ast_matchers::internal::Matcher<QualType> pointsTo( internal ::Matcher<QualType> const &InnerMatcher) { return :: clang::ast_matchers::internal::makeMatcher( new internal::matcher_pointsTo0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &pointsTo_Type0)(internal::Matcher< QualType> const &InnerMatcher); inline bool internal:: matcher_pointsTo0Matcher::matches( const QualType &Node, :: clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang ::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4031 | return (!Node.isNull() && Node->isAnyPointerType() && |
| 4032 | InnerMatcher.matches(Node->getPointeeType(), Finder, Builder)); |
| 4033 | } |
| 4034 | |
| 4035 | /// Overloaded to match the pointee type's declaration. |
| 4036 | AST_MATCHER_P_OVERLOAD(QualType, pointsTo, internal::Matcher<Decl>,namespace internal { class matcher_pointsTo1Matcher : public :: clang::ast_matchers::internal::MatcherInterface<QualType> { public: explicit matcher_pointsTo1Matcher( internal::Matcher <Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const QualType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<Decl> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::Matcher<QualType> pointsTo( internal::Matcher <Decl> const &InnerMatcher) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_pointsTo1Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &pointsTo_Type1)(internal::Matcher< Decl> const &InnerMatcher); inline bool internal::matcher_pointsTo1Matcher ::matches( const QualType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4037 | InnerMatcher, 1)namespace internal { class matcher_pointsTo1Matcher : public :: clang::ast_matchers::internal::MatcherInterface<QualType> { public: explicit matcher_pointsTo1Matcher( internal::Matcher <Decl> const &AInnerMatcher) : InnerMatcher(AInnerMatcher ) {} bool matches(const QualType &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const override; private: internal ::Matcher<Decl> InnerMatcher; }; } inline ::clang::ast_matchers ::internal::Matcher<QualType> pointsTo( internal::Matcher <Decl> const &InnerMatcher) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_pointsTo1Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &pointsTo_Type1)(internal::Matcher< Decl> const &InnerMatcher); inline bool internal::matcher_pointsTo1Matcher ::matches( const QualType &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4038 | return pointsTo(qualType(hasDeclaration(InnerMatcher))) |
| 4039 | .matches(Node, Finder, Builder); |
| 4040 | } |
| 4041 | |
| 4042 | /// Matches if the matched type matches the unqualified desugared |
| 4043 | /// type of the matched node. |
| 4044 | /// |
| 4045 | /// For example, in: |
| 4046 | /// \code |
| 4047 | /// class A {}; |
| 4048 | /// using B = A; |
| 4049 | /// \endcode |
| 4050 | /// The matcher type(hasUnqualifiedDesugaredType(recordType())) matches |
| 4051 | /// both B and A. |
| 4052 | AST_MATCHER_P(Type, hasUnqualifiedDesugaredType, internal::Matcher<Type>,namespace internal { class matcher_hasUnqualifiedDesugaredType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Type> { public: explicit matcher_hasUnqualifiedDesugaredType0Matcher ( internal::Matcher<Type> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Type &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Type> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Type> hasUnqualifiedDesugaredType ( internal::Matcher<Type> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasUnqualifiedDesugaredType0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<Type> ( &hasUnqualifiedDesugaredType_Type0)(internal::Matcher< Type> const &InnerMatcher); inline bool internal::matcher_hasUnqualifiedDesugaredType0Matcher ::matches( const Type &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4053 | InnerMatcher)namespace internal { class matcher_hasUnqualifiedDesugaredType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< Type> { public: explicit matcher_hasUnqualifiedDesugaredType0Matcher ( internal::Matcher<Type> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const Type &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Type> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<Type> hasUnqualifiedDesugaredType ( internal::Matcher<Type> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_hasUnqualifiedDesugaredType0Matcher(InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher<Type> ( &hasUnqualifiedDesugaredType_Type0)(internal::Matcher< Type> const &InnerMatcher); inline bool internal::matcher_hasUnqualifiedDesugaredType0Matcher ::matches( const Type &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4054 | return InnerMatcher.matches(*Node.getUnqualifiedDesugaredType(), Finder, |
| 4055 | Builder); |
| 4056 | } |
| 4057 | |
| 4058 | /// Matches if the matched type is a reference type and the referenced |
| 4059 | /// type matches the specified matcher. |
| 4060 | /// |
| 4061 | /// Example matches X &x and const X &y |
| 4062 | /// (matcher = varDecl(hasType(references(cxxRecordDecl(hasName("X")))))) |
| 4063 | /// \code |
| 4064 | /// class X { |
| 4065 | /// void a(X b) { |
| 4066 | /// X &x = b; |
| 4067 | /// const X &y = b; |
| 4068 | /// } |
| 4069 | /// }; |
| 4070 | /// \endcode |
| 4071 | AST_MATCHER_P(QualType, references, internal::Matcher<QualType>,namespace internal { class matcher_references0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<QualType > { public: explicit matcher_references0Matcher( internal:: Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const QualType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<QualType> InnerMatcher; }; } inline ::clang::ast_matchers::internal::Matcher<QualType> references ( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_references0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<QualType> ( &references_Type0 )(internal::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_references0Matcher::matches( const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4072 | InnerMatcher)namespace internal { class matcher_references0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<QualType > { public: explicit matcher_references0Matcher( internal:: Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const QualType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<QualType> InnerMatcher; }; } inline ::clang::ast_matchers::internal::Matcher<QualType> references ( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal ::matcher_references0Matcher(InnerMatcher)); } typedef ::clang ::ast_matchers::internal::Matcher<QualType> ( &references_Type0 )(internal::Matcher<QualType> const &InnerMatcher); inline bool internal::matcher_references0Matcher::matches( const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4073 | return (!Node.isNull() && Node->isReferenceType() && |
| 4074 | InnerMatcher.matches(Node->getPointeeType(), Finder, Builder)); |
| 4075 | } |
| 4076 | |
| 4077 | /// Matches QualTypes whose canonical type matches InnerMatcher. |
| 4078 | /// |
| 4079 | /// Given: |
| 4080 | /// \code |
| 4081 | /// typedef int &int_ref; |
| 4082 | /// int a; |
| 4083 | /// int_ref b = a; |
| 4084 | /// \endcode |
| 4085 | /// |
| 4086 | /// \c varDecl(hasType(qualType(referenceType()))))) will not match the |
| 4087 | /// declaration of b but \c |
| 4088 | /// varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does. |
| 4089 | AST_MATCHER_P(QualType, hasCanonicalType, internal::Matcher<QualType>,namespace internal { class matcher_hasCanonicalType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< QualType> { public: explicit matcher_hasCanonicalType0Matcher ( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches(const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<QualType> hasCanonicalType( internal::Matcher <QualType> const &InnerMatcher) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_hasCanonicalType0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &hasCanonicalType_Type0)(internal::Matcher <QualType> const &InnerMatcher); inline bool internal ::matcher_hasCanonicalType0Matcher::matches( const QualType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const |
| 4090 | InnerMatcher)namespace internal { class matcher_hasCanonicalType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< QualType> { public: explicit matcher_hasCanonicalType0Matcher ( internal::Matcher<QualType> const &AInnerMatcher) : InnerMatcher(AInnerMatcher) {} bool matches(const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override; private: internal::Matcher<QualType > InnerMatcher; }; } inline ::clang::ast_matchers::internal ::Matcher<QualType> hasCanonicalType( internal::Matcher <QualType> const &InnerMatcher) { return ::clang::ast_matchers ::internal::makeMatcher( new internal::matcher_hasCanonicalType0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <QualType> ( &hasCanonicalType_Type0)(internal::Matcher <QualType> const &InnerMatcher); inline bool internal ::matcher_hasCanonicalType0Matcher::matches( const QualType & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const { |
| 4091 | if (Node.isNull()) |
| 4092 | return false; |
| 4093 | return InnerMatcher.matches(Node.getCanonicalType(), Finder, Builder); |
| 4094 | } |
| 4095 | |
| 4096 | /// Overloaded to match the referenced type's declaration. |
| 4097 | AST_MATCHER_P_OVERLOAD(QualType, references, internal::Matcher<Decl>,namespace internal { class matcher_references1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<QualType > { public: explicit matcher_references1Matcher( internal:: Matcher<Decl> const &AInnerMatcher) : InnerMatcher( AInnerMatcher) {} bool matches(const QualType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Decl> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<QualType> references( internal::Matcher<Decl> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_references1Matcher(InnerMatcher)); } typedef ::clang:: ast_matchers::internal::Matcher<QualType> ( &references_Type1 )(internal::Matcher<Decl> const &InnerMatcher); inline bool internal::matcher_references1Matcher::matches( const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4098 | InnerMatcher, 1)namespace internal { class matcher_references1Matcher : public ::clang::ast_matchers::internal::MatcherInterface<QualType > { public: explicit matcher_references1Matcher( internal:: Matcher<Decl> const &AInnerMatcher) : InnerMatcher( AInnerMatcher) {} bool matches(const QualType &Node, ::clang ::ast_matchers::internal::ASTMatchFinder *Finder, ::clang::ast_matchers ::internal::BoundNodesTreeBuilder *Builder) const override; private : internal::Matcher<Decl> InnerMatcher; }; } inline ::clang ::ast_matchers::internal::Matcher<QualType> references( internal::Matcher<Decl> const &InnerMatcher) { return ::clang::ast_matchers::internal::makeMatcher( new internal:: matcher_references1Matcher(InnerMatcher)); } typedef ::clang:: ast_matchers::internal::Matcher<QualType> ( &references_Type1 )(internal::Matcher<Decl> const &InnerMatcher); inline bool internal::matcher_references1Matcher::matches( const QualType &Node, ::clang::ast_matchers::internal::ASTMatchFinder * Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4099 | return references(qualType(hasDeclaration(InnerMatcher))) |
| 4100 | .matches(Node, Finder, Builder); |
| 4101 | } |
| 4102 | |
| 4103 | /// Matches on the implicit object argument of a member call expression. Unlike |
| 4104 | /// `on`, matches the argument directly without stripping away anything. |
| 4105 | /// |
| 4106 | /// Given |
| 4107 | /// \code |
| 4108 | /// class Y { public: void m(); }; |
| 4109 | /// Y g(); |
| 4110 | /// class X : public Y { void g(); }; |
| 4111 | /// void z(Y y, X x) { y.m(); x.m(); x.g(); (g()).m(); } |
| 4112 | /// \endcode |
| 4113 | /// cxxMemberCallExpr(onImplicitObjectArgument(hasType( |
| 4114 | /// cxxRecordDecl(hasName("Y"))))) |
| 4115 | /// matches `y.m()`, `x.m()` and (g()).m(), but not `x.g()`. |
| 4116 | /// cxxMemberCallExpr(on(callExpr())) |
| 4117 | /// does not match `(g()).m()`, because the parens are not ignored. |
| 4118 | /// |
| 4119 | /// FIXME: Overload to allow directly matching types? |
| 4120 | AST_MATCHER_P(CXXMemberCallExpr, onImplicitObjectArgument,namespace internal { class matcher_onImplicitObjectArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< CXXMemberCallExpr> { public: explicit matcher_onImplicitObjectArgument0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXMemberCallExpr & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXMemberCallExpr > onImplicitObjectArgument( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_onImplicitObjectArgument0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <CXXMemberCallExpr> ( &onImplicitObjectArgument_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_onImplicitObjectArgument0Matcher::matches ( const CXXMemberCallExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const |
| 4121 | internal::Matcher<Expr>, InnerMatcher)namespace internal { class matcher_onImplicitObjectArgument0Matcher : public ::clang::ast_matchers::internal::MatcherInterface< CXXMemberCallExpr> { public: explicit matcher_onImplicitObjectArgument0Matcher ( internal::Matcher<Expr> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXMemberCallExpr & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<Expr> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXMemberCallExpr > onImplicitObjectArgument( internal::Matcher<Expr> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_onImplicitObjectArgument0Matcher (InnerMatcher)); } typedef ::clang::ast_matchers::internal::Matcher <CXXMemberCallExpr> ( &onImplicitObjectArgument_Type0 )(internal::Matcher<Expr> const &InnerMatcher); inline bool internal::matcher_onImplicitObjectArgument0Matcher::matches ( const CXXMemberCallExpr &Node, ::clang::ast_matchers::internal ::ASTMatchFinder *Finder, ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const { |
| 4122 | const Expr *ExprNode = Node.getImplicitObjectArgument(); |
| 4123 | return (ExprNode != nullptr && |
| 4124 | InnerMatcher.matches(*ExprNode, Finder, Builder)); |
| 4125 | } |
| 4126 | |
| 4127 | /// Matches if the type of the expression's implicit object argument either |
| 4128 | /// matches the InnerMatcher, or is a pointer to a type that matches the |
| 4129 | /// InnerMatcher. |
| 4130 | /// |
| 4131 | /// Given |
| 4132 | /// \code |
| 4133 | /// class Y { public: void m(); }; |
| 4134 | /// class X : public Y { void g(); }; |
| 4135 | /// void z() { Y y; y.m(); Y *p; p->m(); X x; x.m(); x.g(); } |
| 4136 | /// \endcode |
| 4137 | /// cxxMemberCallExpr(thisPointerType(hasDeclaration( |
| 4138 | /// cxxRecordDecl(hasName("Y"))))) |
| 4139 | /// matches `y.m()`, `p->m()` and `x.m()`. |
| 4140 | /// cxxMemberCallExpr(thisPointerType(hasDeclaration( |
| 4141 | /// cxxRecordDecl(hasName("X"))))) |
| 4142 | /// matches `x.g()`. |
| 4143 | AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType,namespace internal { class matcher_thisPointerType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXMemberCallExpr > { public: explicit matcher_thisPointerType0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXMemberCallExpr & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<QualType> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXMemberCallExpr > thisPointerType( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_thisPointerType0Matcher(InnerMatcher )); } typedef ::clang::ast_matchers::internal::Matcher<CXXMemberCallExpr > ( &thisPointerType_Type0)(internal::Matcher<QualType > const &InnerMatcher); inline bool internal::matcher_thisPointerType0Matcher ::matches( const CXXMemberCallExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const |
| 4144 | internal::Matcher<QualType>, InnerMatcher, 0)namespace internal { class matcher_thisPointerType0Matcher : public ::clang::ast_matchers::internal::MatcherInterface<CXXMemberCallExpr > { public: explicit matcher_thisPointerType0Matcher( internal ::Matcher<QualType> const &AInnerMatcher) : InnerMatcher (AInnerMatcher) {} bool matches(const CXXMemberCallExpr & Node, ::clang::ast_matchers::internal::ASTMatchFinder *Finder , ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder ) const override; private: internal::Matcher<QualType> InnerMatcher ; }; } inline ::clang::ast_matchers::internal::Matcher<CXXMemberCallExpr > thisPointerType( internal::Matcher<QualType> const &InnerMatcher) { return ::clang::ast_matchers::internal:: makeMatcher( new internal::matcher_thisPointerType0Matcher(InnerMatcher )); } typedef ::clang::ast_matchers::internal::Matcher<CXXMemberCallExpr > ( &thisPointerType_Type0)(internal::Matcher<QualType > const &InnerMatcher); inline bool internal::matcher_thisPointerType0Matcher ::matches( const CXXMemberCallExpr &Node, ::clang::ast_matchers ::internal::ASTMatchFinder *Finder, ::clang::ast_matchers::internal ::BoundNodesTreeBuilder *Builder) const { |
| 4145 | return onImplicitObjectArgument( |
| 4146 | anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher)))) |
| 4147 | .matches(Node, Finder, Builder); |
| 4148 | } |