35 #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
36 #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
49 #include "llvm/ADT/ArrayRef.h"
50 #include "llvm/ADT/Optional.h"
51 #include "llvm/ADT/SmallVector.h"
52 #include "llvm/Support/ManagedStatic.h"
58 namespace ast_matchers {
69 template <
typename ResultT,
typename ArgT,
70 ResultT (*Func)(ArrayRef<const ArgT *>)>
71 struct VariadicFunction {
72 ResultT operator()()
const {
return Func(None); }
74 template <
typename... ArgsT>
75 ResultT operator()(
const ArgT &Arg1,
const ArgsT &... Args)
const {
76 return Execute(Arg1, static_cast<const ArgT &>(Args)...);
81 ResultT operator()(ArrayRef<ArgT> Args)
const {
82 SmallVector<const ArgT*, 8> InnerArgs;
83 for (
const ArgT &Arg : Args)
84 InnerArgs.push_back(&Arg);
85 return Func(InnerArgs);
91 template <
typename... ArgsT> ResultT Execute(
const ArgsT &... Args)
const {
92 const ArgT *
const ArgsArray[] = {&Args...};
93 return Func(ArrayRef<const ArgT *>(ArgsArray,
sizeof...(ArgsT)));
102 return Node.getType();
106 return Node.getUnderlyingType();
111 inline const FunctionProtoType *
112 getFunctionProtoType(
const FunctionProtoType &Node) {
116 inline const FunctionProtoType *getFunctionProtoType(
const FunctionDecl &Node) {
117 return Node.getType()->getAs<FunctionProtoType>();
121 class BoundNodesMap {
126 void addNode(StringRef
ID,
const ast_type_traits::DynTypedNode& DynNode) {
127 NodeMap[
ID] = DynNode;
134 template <
typename T>
135 const T *getNodeAs(StringRef
ID)
const {
136 IDToNodeMap::const_iterator It = NodeMap.find(ID);
137 if (It == NodeMap.end()) {
140 return It->second.get<T>();
143 ast_type_traits::DynTypedNode getNode(StringRef ID)
const {
144 IDToNodeMap::const_iterator It = NodeMap.find(ID);
145 if (It == NodeMap.end()) {
146 return ast_type_traits::DynTypedNode();
152 bool operator<(
const BoundNodesMap &Other)
const {
153 return NodeMap < Other.NodeMap;
161 typedef std::map<std::string, ast_type_traits::DynTypedNode> IDToNodeMap;
163 const IDToNodeMap &getMap()
const {
169 bool isComparable()
const {
170 for (
const auto &IDAndNode : NodeMap) {
171 if (!IDAndNode.second.getMemoizationData())
185 class BoundNodesTreeBuilder {
191 virtual ~Visitor() {}
196 virtual void visitMatch(
const BoundNodes& BoundNodesView) = 0;
200 void setBinding(StringRef Id,
const ast_type_traits::DynTypedNode &DynNode) {
201 if (Bindings.empty())
202 Bindings.emplace_back();
203 for (BoundNodesMap &Binding : Bindings)
204 Binding.addNode(Id, DynNode);
208 void addMatch(
const BoundNodesTreeBuilder &Bindings);
213 void visitMatches(Visitor* ResultVisitor);
215 template <
typename ExcludePredicate>
216 bool removeBindings(
const ExcludePredicate &Predicate) {
217 Bindings.erase(std::remove_if(Bindings.begin(), Bindings.end(), Predicate),
219 return !Bindings.empty();
223 bool operator<(
const BoundNodesTreeBuilder &Other)
const {
224 return Bindings < Other.Bindings;
229 bool isComparable()
const {
230 for (
const BoundNodesMap &NodesMap : Bindings) {
231 if (!NodesMap.isComparable())
238 SmallVector<BoundNodesMap, 16> Bindings;
241 class ASTMatchFinder;
248 class DynMatcherInterface
249 :
public llvm::ThreadSafeRefCountedBase<DynMatcherInterface> {
251 virtual ~DynMatcherInterface() {}
257 virtual bool dynMatches(
const ast_type_traits::DynTypedNode &DynNode,
259 BoundNodesTreeBuilder *
Builder)
const = 0;
269 template <
typename T>
270 class MatcherInterface :
public DynMatcherInterface {
276 virtual bool matches(
const T &Node,
278 BoundNodesTreeBuilder *
Builder)
const = 0;
280 bool dynMatches(
const ast_type_traits::DynTypedNode &DynNode,
282 BoundNodesTreeBuilder *
Builder)
const override {
283 return matches(DynNode.getUnchecked<T>(), Finder, Builder);
289 template <
typename T>
290 class SingleNodeMatcherInterface :
public MatcherInterface<T> {
295 virtual bool matchesNode(
const T &Node)
const = 0;
301 BoundNodesTreeBuilder * )
const override {
302 return matchesNode(Node);
306 template <
typename>
class Matcher;
315 class DynTypedMatcher {
318 template <
typename T>
319 DynTypedMatcher(MatcherInterface<T> *Implementation)
321 SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
322 RestrictKind(SupportedKind), Implementation(Implementation) {}
325 enum VariadicOperator {
340 static DynTypedMatcher
341 constructVariadic(VariadicOperator Op,
342 ast_type_traits::ASTNodeKind SupportedKind,
348 static DynTypedMatcher trueMatcher(ast_type_traits::ASTNodeKind NodeKind);
350 void setAllowBind(
bool AB) { AllowBind = AB; }
355 bool canMatchNodesOfKind(ast_type_traits::ASTNodeKind
Kind)
const;
359 DynTypedMatcher dynCastTo(
const ast_type_traits::ASTNodeKind
Kind)
const;
362 bool matches(
const ast_type_traits::DynTypedNode &DynNode,
363 ASTMatchFinder *
Finder, BoundNodesTreeBuilder *
Builder)
const;
369 bool matchesNoKindCheck(
const ast_type_traits::DynTypedNode &DynNode,
371 BoundNodesTreeBuilder *
Builder)
const;
385 typedef std::pair<ast_type_traits::ASTNodeKind, uint64_t> MatcherIDType;
386 MatcherIDType getID()
const {
389 return std::make_pair(RestrictKind,
390 reinterpret_cast<uint64_t>(Implementation.get()));
397 ast_type_traits::ASTNodeKind getSupportedKind()
const {
398 return SupportedKind;
406 template <
typename T>
bool canConvertTo()
const {
407 return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
409 bool canConvertTo(ast_type_traits::ASTNodeKind To)
const;
416 template <
typename T> Matcher<T> convertTo()
const {
417 assert(canConvertTo<T>());
418 return unconditionalConvertTo<T>();
425 template <
typename T> Matcher<T> unconditionalConvertTo()
const;
428 DynTypedMatcher(ast_type_traits::ASTNodeKind SupportedKind,
429 ast_type_traits::ASTNodeKind RestrictKind,
430 IntrusiveRefCntPtr<DynMatcherInterface> Implementation)
432 SupportedKind(SupportedKind),
433 RestrictKind(RestrictKind),
434 Implementation(std::move(Implementation)) {}
437 ast_type_traits::ASTNodeKind SupportedKind;
442 ast_type_traits::ASTNodeKind RestrictKind;
443 IntrusiveRefCntPtr<DynMatcherInterface> Implementation;
450 template <
typename T>
451 class WrapperMatcherInterface :
public MatcherInterface<T> {
453 explicit WrapperMatcherInterface(DynTypedMatcher &&
InnerMatcher)
467 template <
typename T>
471 explicit Matcher(MatcherInterface<T> *Implementation)
472 : Implementation(Implementation) {}
477 template <
typename From>
478 Matcher(
const Matcher<From> &Other,
479 typename std::enable_if<std::is_base_of<From, T>::value &&
480 !std::is_same<From, T>::value>::
type * =
nullptr)
481 : Implementation(restrictMatcher(Other.Implementation)) {
482 assert(Implementation.getSupportedKind().isSame(
483 ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
489 template <
typename TypeT>
490 Matcher(
const Matcher<TypeT> &Other,
491 typename std::enable_if<
492 std::is_same<T, QualType>::value &&
493 std::is_same<TypeT, Type>::value>::
type* =
nullptr)
494 : Implementation(new TypeToQualType<TypeT>(Other)) {}
499 template <
typename To>
500 Matcher<To> dynCastTo()
const {
501 static_assert(std::is_base_of<To, T>::value,
"Invalid dynCast call.");
502 return Matcher<To>(Implementation);
508 BoundNodesTreeBuilder *
Builder)
const {
514 DynTypedMatcher::MatcherIDType getID()
const {
515 return Implementation.getID();
522 operator DynTypedMatcher()
const {
return Implementation; }
530 template <
typename TypeT>
531 class TypeToQualType :
public WrapperMatcherInterface<QualType> {
534 : TypeToQualType::WrapperMatcherInterface(InnerMatcher) {}
536 bool matches(
const QualType &Node, ASTMatchFinder *Finder,
537 BoundNodesTreeBuilder *Builder)
const override {
547 template <
typename U>
friend class Matcher;
549 friend class DynTypedMatcher;
551 static DynTypedMatcher restrictMatcher(
const DynTypedMatcher &Other) {
552 return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
555 explicit Matcher(
const DynTypedMatcher &Implementation)
556 : Implementation(restrictMatcher(Implementation)) {
557 assert(this->Implementation.getSupportedKind()
558 .isSame(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
561 DynTypedMatcher Implementation;
566 template <
typename T>
567 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
568 return Matcher<T>(Implementation);
576 inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>()
const {
577 assert(canConvertTo<QualType>());
578 const ast_type_traits::ASTNodeKind SourceKind = getSupportedKind();
579 if (SourceKind.isSame(
580 ast_type_traits::ASTNodeKind::getFromNodeKind<Type>())) {
582 return unconditionalConvertTo<Type>();
584 return unconditionalConvertTo<QualType>();
588 template <
typename MatcherT,
typename IteratorT>
589 bool matchesFirstInRange(
const MatcherT &
Matcher, IteratorT Start,
590 IteratorT
End, ASTMatchFinder *Finder,
591 BoundNodesTreeBuilder *Builder) {
592 for (IteratorT
I = Start;
I !=
End; ++
I) {
593 BoundNodesTreeBuilder
Result(*Builder);
594 if (Matcher.matches(*
I, Finder, &
Result)) {
595 *Builder = std::move(
Result);
604 template <
typename MatcherT,
typename IteratorT>
605 bool matchesFirstInPointerRange(
const MatcherT &Matcher, IteratorT Start,
606 IteratorT End, ASTMatchFinder *Finder,
607 BoundNodesTreeBuilder *Builder) {
608 for (IteratorT
I = Start;
I !=
End; ++
I) {
609 BoundNodesTreeBuilder
Result(*Builder);
610 if (Matcher.matches(**
I, Finder, &
Result)) {
611 *Builder = std::move(
Result);
619 template <
typename Ty>
624 template <
typename Inner>
625 static yes& test(Inner *
I, decltype(I->getDecl()) * =
nullptr);
628 static no& test(...);
631 static const bool value =
sizeof(test<Ty>(
nullptr)) ==
sizeof(yes);
638 template <
typename T,
typename ArgT>
639 class HasOverloadedOperatorNameMatcher :
public SingleNodeMatcherInterface<T> {
640 static_assert(std::is_same<T, CXXOperatorCallExpr>::value ||
641 std::is_base_of<FunctionDecl, T>::value,
642 "unsupported class for matcher");
643 static_assert(std::is_same<ArgT, StringRef>::value,
644 "argument type must be StringRef");
647 explicit HasOverloadedOperatorNameMatcher(
const StringRef
Name)
648 : SingleNodeMatcherInterface<T>(), Name(Name) {}
650 bool matchesNode(
const T &Node)
const override {
651 return matchesSpecialized(Node);
659 bool matchesSpecialized(
const CXXOperatorCallExpr &Node)
const {
665 bool matchesSpecialized(
const FunctionDecl &Node)
const {
666 return Node.isOverloadedOperator() &&
676 class HasNameMatcher :
public SingleNodeMatcherInterface<NamedDecl> {
678 explicit HasNameMatcher(std::vector<std::string>
Names);
680 bool matchesNode(
const NamedDecl &Node)
const override;
687 bool matchesNodeUnqualified(
const NamedDecl &Node)
const;
695 bool matchesNodeFullFast(
const NamedDecl &Node)
const;
702 bool matchesNodeFullSlow(
const NamedDecl &Node)
const;
704 const bool UseUnqualifiedMatch;
705 const std::vector<std::string>
Names;
710 Matcher<NamedDecl>
hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs);
716 template <
typename T,
typename DeclMatcherT>
717 class HasDeclarationMatcher :
public WrapperMatcherInterface<T> {
718 static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value,
719 "instantiated with wrong types");
722 explicit HasDeclarationMatcher(
const Matcher<Decl> &
InnerMatcher)
723 : HasDeclarationMatcher::WrapperMatcherInterface(InnerMatcher) {}
725 bool matches(
const T &Node, ASTMatchFinder *Finder,
726 BoundNodesTreeBuilder *Builder)
const override {
727 return matchesSpecialized(Node, Finder, Builder);
733 template <
typename U>
734 bool matchesSpecialized(
735 const U &Node, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
736 typename std::enable_if<has_getDecl<U>::value,
int>::
type = 0)
const {
742 bool matchesSpecialized(
const QualType &Node, ASTMatchFinder *Finder,
743 BoundNodesTreeBuilder *Builder)
const {
747 if (
auto *TD = Node->getAsTagDecl())
748 return matchesDecl(TD, Finder, Builder);
749 else if (
auto *TT = Node->getAs<TypedefType>())
755 else if (
auto *TTP = dyn_cast<TemplateTypeParmType>(Node.getTypePtr()))
757 else if (
auto *OCIT = Node->getAs<ObjCInterfaceType>())
759 else if (
auto *UUT = Node->getAs<UnresolvedUsingType>())
761 else if (
auto *ICNT = Node->getAs<InjectedClassNameType>())
768 bool matchesSpecialized(
const TemplateSpecializationType &Node,
769 ASTMatchFinder *Finder,
770 BoundNodesTreeBuilder *Builder)
const {
771 return matchesDecl(Node.getTemplateName().getAsTemplateDecl(),
777 bool matchesSpecialized(
const CallExpr &Node, ASTMatchFinder *Finder,
778 BoundNodesTreeBuilder *Builder)
const {
784 bool matchesSpecialized(
const CXXConstructExpr &Node,
785 ASTMatchFinder *Finder,
786 BoundNodesTreeBuilder *Builder)
const {
792 bool matchesSpecialized(
const CXXNewExpr &Node,
793 ASTMatchFinder *Finder,
794 BoundNodesTreeBuilder *Builder)
const {
800 bool matchesSpecialized(
const MemberExpr &Node,
801 ASTMatchFinder *Finder,
802 BoundNodesTreeBuilder *Builder)
const {
808 bool matchesSpecialized(
const AddrLabelExpr &Node,
809 ASTMatchFinder *Finder,
810 BoundNodesTreeBuilder *Builder)
const {
816 bool matchesDecl(
const Decl *Node, ASTMatchFinder *Finder,
817 BoundNodesTreeBuilder *Builder)
const {
818 return Node !=
nullptr &&
826 template <
typename T>
828 static const bool value =
829 std::is_same<T, Decl>::value ||
830 std::is_same<T, Stmt>::value ||
831 std::is_same<T, QualType>::value ||
832 std::is_same<T, Type>::value ||
833 std::is_same<T, TypeLoc>::value ||
834 std::is_same<T, NestedNameSpecifier>::value ||
835 std::is_same<T, NestedNameSpecifierLoc>::value ||
836 std::is_same<T, CXXCtorInitializer>::value;
838 template <
typename T>
839 const bool IsBaseType<T>::value;
859 class ASTMatchFinder {
867 TK_IgnoreImplicitCastsAndParentheses
879 enum AncestorMatchMode {
886 virtual ~ASTMatchFinder() {}
892 virtual bool classIsDerivedFrom(
const CXXRecordDecl *Declaration,
893 const Matcher<NamedDecl> &
Base,
894 BoundNodesTreeBuilder *Builder) = 0;
896 template <
typename T>
897 bool matchesChildOf(
const T &Node,
898 const DynTypedMatcher &Matcher,
899 BoundNodesTreeBuilder *Builder,
900 TraversalKind Traverse,
902 static_assert(std::is_base_of<Decl, T>::value ||
903 std::is_base_of<Stmt, T>::value ||
904 std::is_base_of<NestedNameSpecifier, T>::value ||
905 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
906 std::is_base_of<TypeLoc, T>::value ||
907 std::is_base_of<QualType, T>::value,
908 "unsupported type for recursive matching");
910 Matcher, Builder, Traverse, Bind);
913 template <
typename T>
914 bool matchesDescendantOf(
const T &Node,
915 const DynTypedMatcher &Matcher,
916 BoundNodesTreeBuilder *Builder,
918 static_assert(std::is_base_of<Decl, T>::value ||
919 std::is_base_of<Stmt, T>::value ||
920 std::is_base_of<NestedNameSpecifier, T>::value ||
921 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
922 std::is_base_of<TypeLoc, T>::value ||
923 std::is_base_of<QualType, T>::value,
924 "unsupported type for recursive matching");
926 Matcher, Builder, Bind);
930 template <
typename T>
931 bool matchesAncestorOf(
const T &Node,
932 const DynTypedMatcher &Matcher,
933 BoundNodesTreeBuilder *Builder,
934 AncestorMatchMode MatchMode) {
935 static_assert(std::is_base_of<Decl, T>::value ||
936 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
937 std::is_base_of<Stmt, T>::value ||
938 std::is_base_of<TypeLoc, T>::value,
939 "type not allowed for recursive matching");
941 Matcher, Builder, MatchMode);
944 virtual ASTContext &getASTContext()
const = 0;
947 virtual bool matchesChildOf(
const ast_type_traits::DynTypedNode &Node,
948 const DynTypedMatcher &Matcher,
949 BoundNodesTreeBuilder *Builder,
950 TraversalKind Traverse,
953 virtual bool matchesDescendantOf(
const ast_type_traits::DynTypedNode &Node,
954 const DynTypedMatcher &Matcher,
955 BoundNodesTreeBuilder *Builder,
958 virtual bool matchesAncestorOf(
const ast_type_traits::DynTypedNode &Node,
959 const DynTypedMatcher &Matcher,
960 BoundNodesTreeBuilder *Builder,
961 AncestorMatchMode MatchMode) = 0;
968 template <
typename... Ts>
struct TypeList {};
970 template <
typename T1,
typename... Ts>
struct TypeList<T1, Ts...> {
978 typedef TypeList<Ts...> tail;
982 typedef TypeList<> EmptyTypeList;
986 template <
typename AnyTypeList,
typename T>
987 struct TypeListContainsSuperOf {
988 static const bool value =
989 std::is_base_of<typename AnyTypeList::head, T>::value ||
990 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
992 template <
typename T>
993 struct TypeListContainsSuperOf<EmptyTypeList, T> {
994 static const bool value =
false;
1000 typedef TypeList<
Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc,
1001 QualType,
Type, TypeLoc, CXXCtorInitializer> AllNodeBaseTypes;
1007 template <
class T>
struct ExtractFunctionArgMeta;
1008 template <
class T>
struct ExtractFunctionArgMeta<void(T)> {
1013 typedef AllNodeBaseTypes AdaptativeDefaultFromTypes;
1014 typedef TypeList<
Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc,
1015 TypeLoc, QualType> AdaptativeDefaultToTypes;
1018 typedef TypeList<CallExpr, CXXConstructExpr, CXXNewExpr, DeclRefExpr, EnumType,
1019 InjectedClassNameType, LabelStmt, AddrLabelExpr, MemberExpr,
1020 QualType, RecordType, TagType, TemplateSpecializationType,
1021 TemplateTypeParmType, TypedefType, UnresolvedUsingType>
1022 HasDeclarationSupportedTypes;
1037 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
1038 typename FromTypes = AdaptativeDefaultFromTypes,
1039 typename ToTypes = AdaptativeDefaultToTypes>
1040 struct ArgumentAdaptingMatcherFunc {
1041 template <
typename T>
class Adaptor {
1044 : InnerMatcher(InnerMatcher) {}
1046 typedef ToTypes ReturnTypes;
1048 template <
typename To>
operator Matcher<To>()
const {
1049 return Matcher<To>(
new ArgumentAdapterT<To, T>(
InnerMatcher));
1056 template <
typename T>
1061 template <
typename T>
1062 Adaptor<T> operator()(
const Matcher<T> &
InnerMatcher)
const {
1063 return create(InnerMatcher);
1079 template <
template <
typename T>
class MatcherT,
1080 typename ReturnTypesF = void(AllNodeBaseTypes)>
1081 class PolymorphicMatcherWithParam0 {
1084 template <
typename T>
1085 operator Matcher<T>()
const {
1086 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1087 "right polymorphic conversion");
1088 return Matcher<T>(
new MatcherT<T>());
1092 template <
template <
typename T,
typename P1>
class MatcherT,
1094 typename ReturnTypesF = void(AllNodeBaseTypes)>
1095 class PolymorphicMatcherWithParam1 {
1097 explicit PolymorphicMatcherWithParam1(
const P1 &Param1)
1102 template <
typename T>
1103 operator Matcher<T>()
const {
1104 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1105 "right polymorphic conversion");
1106 return Matcher<T>(
new MatcherT<T, P1>(Param1));
1113 template <
template <
typename T,
typename P1,
typename P2>
class MatcherT,
1114 typename P1,
typename P2,
1115 typename ReturnTypesF = void(AllNodeBaseTypes)>
1116 class PolymorphicMatcherWithParam2 {
1118 PolymorphicMatcherWithParam2(
const P1 &Param1,
const P2 &Param2)
1119 : Param1(Param1), Param2(Param2) {}
1123 template <
typename T>
1124 operator Matcher<T>()
const {
1125 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1126 "right polymorphic conversion");
1127 return Matcher<T>(
new MatcherT<T, P1, P2>(Param1, Param2));
1141 typedef AllNodeBaseTypes ReturnTypes;
1143 template <
typename T>
1144 operator Matcher<T>()
const {
1145 return DynTypedMatcher::trueMatcher(
1146 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1147 .template unconditionalConvertTo<T>();
1155 template <
typename T>
1156 class BindableMatcher :
public Matcher<T> {
1158 explicit BindableMatcher(
const Matcher<T> &M) : Matcher<T>(M) {}
1159 explicit BindableMatcher(MatcherInterface<T> *Implementation)
1160 : Matcher<T>(Implementation) {}
1166 Matcher<T> bind(StringRef ID)
const {
1167 return DynTypedMatcher(*
this)
1169 ->template unconditionalConvertTo<T>();
1174 operator DynTypedMatcher()
const {
1175 DynTypedMatcher
Result =
static_cast<const Matcher<T>&
>(*this);
1176 Result.setAllowBind(
true);
1185 template <
typename T,
typename ChildT>
1186 class HasMatcher :
public WrapperMatcherInterface<T> {
1189 explicit HasMatcher(
const Matcher<ChildT> &ChildMatcher)
1190 : HasMatcher::WrapperMatcherInterface(ChildMatcher) {}
1192 bool matches(
const T &Node, ASTMatchFinder *Finder,
1193 BoundNodesTreeBuilder *Builder)
const override {
1194 return Finder->matchesChildOf(Node, this->
InnerMatcher, Builder,
1195 ASTMatchFinder::TK_AsIs,
1196 ASTMatchFinder::BK_First);
1205 template <
typename T,
typename ChildT>
1206 class ForEachMatcher :
public WrapperMatcherInterface<T> {
1207 static_assert(IsBaseType<ChildT>::value,
1208 "for each only accepts base type matcher");
1211 explicit ForEachMatcher(
const Matcher<ChildT> &ChildMatcher)
1212 : ForEachMatcher::WrapperMatcherInterface(ChildMatcher) {}
1214 bool matches(
const T& Node, ASTMatchFinder* Finder,
1215 BoundNodesTreeBuilder* Builder)
const override {
1216 return Finder->matchesChildOf(
1218 ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
1219 ASTMatchFinder::BK_All);
1232 template <
typename... Ps>
class VariadicOperatorMatcher {
1234 VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params)
1235 : Op(Op), Params(std::forward<Ps>(Params)...) {}
1237 template <
typename T>
operator Matcher<T>()
const {
1238 return DynTypedMatcher::constructVariadic(
1239 Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1240 getMatchers<T>(llvm::index_sequence_for<Ps...>()))
1241 .template unconditionalConvertTo<T>();
1247 std::vector<DynTypedMatcher> getMatchers(llvm::index_sequence<Is...>)
const {
1248 return {Matcher<T>(std::get<Is>(Params))...};
1251 const DynTypedMatcher::VariadicOperator Op;
1252 std::tuple<Ps...> Params;
1257 template <
unsigned MinCount,
unsigned MaxCount>
1258 struct VariadicOperatorMatcherFunc {
1259 DynTypedMatcher::VariadicOperator Op;
1261 template <
typename... Ms>
1262 VariadicOperatorMatcher<Ms...> operator()(Ms &&... Ps)
const {
1263 static_assert(MinCount <=
sizeof...(Ms) &&
sizeof...(Ms) <= MaxCount,
1264 "invalid number of parameters for variadic matcher");
1265 return VariadicOperatorMatcher<Ms...>(Op, std::forward<Ms>(Ps)...);
1271 template <
typename T>
1272 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo()
const {
1273 return Matcher<T>(*this);
1277 template<
typename T>
1278 BindableMatcher<T> makeAllOfComposite(
1282 return BindableMatcher<T>(TrueMatcher());
1290 typedef llvm::pointee_iterator<const Matcher<T> *
const *> PI;
1291 std::vector<DynTypedMatcher> DynMatchers(PI(
InnerMatchers.begin()),
1293 return BindableMatcher<T>(
1294 DynTypedMatcher::constructVariadic(
1295 DynTypedMatcher::VO_AllOf,
1296 ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1297 std::move(DynMatchers))
1298 .template unconditionalConvertTo<T>());
1307 template<
typename T,
typename InnerT>
1308 BindableMatcher<T> makeDynCastAllOfComposite(
1310 return BindableMatcher<T>(
1318 template <
typename T,
typename DescendantT>
1319 class HasDescendantMatcher :
public WrapperMatcherInterface<T> {
1320 static_assert(IsBaseType<DescendantT>::value,
1321 "has descendant only accepts base type matcher");
1324 explicit HasDescendantMatcher(
const Matcher<DescendantT> &DescendantMatcher)
1325 : HasDescendantMatcher::WrapperMatcherInterface(DescendantMatcher) {}
1327 bool matches(
const T &Node, ASTMatchFinder *Finder,
1328 BoundNodesTreeBuilder *Builder)
const override {
1329 return Finder->matchesDescendantOf(Node, this->
InnerMatcher, Builder,
1330 ASTMatchFinder::BK_First);
1338 template <
typename T,
typename ParentT>
1339 class HasParentMatcher :
public WrapperMatcherInterface<T> {
1340 static_assert(IsBaseType<ParentT>::value,
1341 "has parent only accepts base type matcher");
1344 explicit HasParentMatcher(
const Matcher<ParentT> &ParentMatcher)
1345 : HasParentMatcher::WrapperMatcherInterface(ParentMatcher) {}
1347 bool matches(
const T &Node, ASTMatchFinder *Finder,
1348 BoundNodesTreeBuilder *Builder)
const override {
1349 return Finder->matchesAncestorOf(Node, this->
InnerMatcher, Builder,
1350 ASTMatchFinder::AMM_ParentOnly);
1358 template <
typename T,
typename AncestorT>
1359 class HasAncestorMatcher :
public WrapperMatcherInterface<T> {
1360 static_assert(IsBaseType<AncestorT>::value,
1361 "has ancestor only accepts base type matcher");
1364 explicit HasAncestorMatcher(
const Matcher<AncestorT> &AncestorMatcher)
1365 : HasAncestorMatcher::WrapperMatcherInterface(AncestorMatcher) {}
1367 bool matches(
const T &Node, ASTMatchFinder *Finder,
1368 BoundNodesTreeBuilder *Builder)
const override {
1369 return Finder->matchesAncestorOf(Node, this->
InnerMatcher, Builder,
1370 ASTMatchFinder::AMM_All);
1380 template <
typename T,
typename DescendantT>
1381 class ForEachDescendantMatcher :
public WrapperMatcherInterface<T> {
1382 static_assert(IsBaseType<DescendantT>::value,
1383 "for each descendant only accepts base type matcher");
1386 explicit ForEachDescendantMatcher(
1387 const Matcher<DescendantT> &DescendantMatcher)
1388 : ForEachDescendantMatcher::WrapperMatcherInterface(DescendantMatcher) {}
1390 bool matches(
const T &Node, ASTMatchFinder *Finder,
1391 BoundNodesTreeBuilder *Builder)
const override {
1392 return Finder->matchesDescendantOf(Node, this->
InnerMatcher, Builder,
1393 ASTMatchFinder::BK_All);
1399 template <
typename T,
typename ValueT>
1400 class ValueEqualsMatcher :
public SingleNodeMatcherInterface<T> {
1401 static_assert(std::is_base_of<CharacterLiteral, T>::value ||
1402 std::is_base_of<CXXBoolLiteralExpr, T>::value ||
1403 std::is_base_of<FloatingLiteral, T>::value ||
1404 std::is_base_of<IntegerLiteral, T>::value,
1405 "the node must have a getValue method");
1408 explicit ValueEqualsMatcher(
const ValueT &ExpectedValue)
1409 : ExpectedValue(ExpectedValue) {}
1411 bool matchesNode(
const T &Node)
const override {
1412 return Node.getValue() == ExpectedValue;
1416 const ValueT ExpectedValue;
1422 inline bool ValueEqualsMatcher<FloatingLiteral, double>::matchesNode(
1423 const FloatingLiteral &Node)
const {
1424 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
1425 return Node.getValue().convertToFloat() == ExpectedValue;
1426 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
1427 return Node.getValue().convertToDouble() == ExpectedValue;
1431 inline bool ValueEqualsMatcher<FloatingLiteral, float>::matchesNode(
1432 const FloatingLiteral &Node)
const {
1433 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
1434 return Node.getValue().convertToFloat() == ExpectedValue;
1435 if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
1436 return Node.getValue().convertToDouble() == ExpectedValue;
1440 inline bool ValueEqualsMatcher<FloatingLiteral, llvm::APFloat>::matchesNode(
1441 const FloatingLiteral &Node)
const {
1442 return ExpectedValue.compare(Node.getValue()) == llvm::APFloat::cmpEqual;
1457 template <
typename SourceT,
typename TargetT>
1458 class VariadicDynCastAllOfMatcher
1459 :
public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1460 makeDynCastAllOfComposite<SourceT, TargetT>> {
1462 VariadicDynCastAllOfMatcher() {}
1475 template <
typename T>
1476 class VariadicAllOfMatcher
1477 :
public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1478 makeAllOfComposite<T>> {
1480 VariadicAllOfMatcher() {}
1485 template <
typename TLoc,
typename T>
1486 class LocMatcher :
public WrapperMatcherInterface<TLoc> {
1489 : LocMatcher::WrapperMatcherInterface(InnerMatcher) {}
1491 bool matches(
const TLoc &Node, ASTMatchFinder *Finder,
1492 BoundNodesTreeBuilder *Builder)
const override {
1495 return this->
InnerMatcher.matches(extract(Node), Finder, Builder);
1499 static ast_type_traits::DynTypedNode
1500 extract(
const NestedNameSpecifierLoc &Loc) {
1509 class TypeLocTypeMatcher :
public WrapperMatcherInterface<TypeLoc> {
1511 explicit TypeLocTypeMatcher(
const Matcher<QualType> &
InnerMatcher)
1512 : TypeLocTypeMatcher::WrapperMatcherInterface(InnerMatcher) {}
1514 bool matches(
const TypeLoc &Node, ASTMatchFinder *Finder,
1515 BoundNodesTreeBuilder *Builder)
const override {
1526 template <
typename T>
1527 class TypeTraverseMatcher :
public WrapperMatcherInterface<T> {
1529 explicit TypeTraverseMatcher(
const Matcher<QualType> &
InnerMatcher,
1530 QualType (T::*TraverseFunction)()
const)
1531 : TypeTraverseMatcher::WrapperMatcherInterface(InnerMatcher),
1532 TraverseFunction(TraverseFunction) {}
1534 bool matches(
const T &Node, ASTMatchFinder *Finder,
1535 BoundNodesTreeBuilder *Builder)
const override {
1536 QualType NextNode = (Node.*TraverseFunction)();
1537 if (NextNode.isNull())
1539 return this->InnerMatcher.matches(
1544 QualType (T::*TraverseFunction)()
const;
1550 template <
typename T>
1551 class TypeLocTraverseMatcher :
public WrapperMatcherInterface<T> {
1553 explicit TypeLocTraverseMatcher(
const Matcher<TypeLoc> &InnerMatcher,
1554 TypeLoc (T::*TraverseFunction)()
const)
1555 : TypeLocTraverseMatcher::WrapperMatcherInterface(InnerMatcher),
1556 TraverseFunction(TraverseFunction) {}
1558 bool matches(
const T &Node, ASTMatchFinder *Finder,
1559 BoundNodesTreeBuilder *Builder)
const override {
1560 TypeLoc NextNode = (Node.*TraverseFunction)();
1563 return this->InnerMatcher.matches(
1568 TypeLoc (T::*TraverseFunction)()
const;
1577 template <
typename InnerTBase,
1578 template <
typename OuterT>
class Getter,
1579 template <
typename OuterT>
class MatcherImpl,
1580 typename ReturnTypesF>
1581 class TypeTraversePolymorphicMatcher {
1583 typedef TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl,
1590 explicit TypeTraversePolymorphicMatcher(
1594 template <
typename OuterT>
operator Matcher<OuterT>()
const {
1595 return Matcher<OuterT>(
1596 new MatcherImpl<OuterT>(
InnerMatcher, Getter<OuterT>::value()));
1600 :
public VariadicFunction<Self, Matcher<InnerTBase>, &Self::create> {
1612 template <
typename Matcher, Matcher (*Func)()>
class MemoizedMatcher {
1614 Wrapper() : M(Func()) {}
1619 static const Matcher &getInstance() {
1620 static llvm::ManagedStatic<Wrapper> Instance;
1628 template <
typename InnerTBase,
template <
typename OuterT>
class Getter,
1629 template <
typename OuterT>
class MatcherImpl,
typename ReturnTypesF>
1630 TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, ReturnTypesF>
1631 TypeTraversePolymorphicMatcher<
1632 InnerTBase, Getter, MatcherImpl,
1639 inline ArrayRef<TemplateArgument>
1640 getTemplateSpecializationArgs(
const ClassTemplateSpecializationDecl &D) {
1641 return D.getTemplateArgs().asArray();
1644 inline ArrayRef<TemplateArgument>
1645 getTemplateSpecializationArgs(
const TemplateSpecializationType &T) {
1646 return llvm::makeArrayRef(T.getArgs(), T.getNumArgs());
1649 inline ArrayRef<TemplateArgument>
1650 getTemplateSpecializationArgs(
const FunctionDecl &FD) {
1651 if (
const auto* TemplateArgs = FD.getTemplateSpecializationArgs())
1652 return TemplateArgs->asArray();
1653 return ArrayRef<TemplateArgument>();
1656 struct NotEqualsBoundNodePredicate {
1657 bool operator()(
const internal::BoundNodesMap &
Nodes)
const {
1658 return Nodes.getNode(ID) !=
Node;
1661 ast_type_traits::DynTypedNode
Node;
1664 template <
typename Ty>
1665 struct GetBodyMatcher {
1666 static const Stmt *
get(
const Ty &
Node) {
1667 return Node.getBody();
1672 inline const Stmt *GetBodyMatcher<FunctionDecl>::get(
const FunctionDecl &Node) {
1673 return Node.doesThisDeclarationHaveABody() ? Node.getBody() :
nullptr;
1676 template <
typename Ty>
1677 struct HasSizeMatcher {
1678 static bool hasSize(
const Ty &Node,
unsigned int N) {
1679 return Node.getSize() == N;
1684 inline bool HasSizeMatcher<StringLiteral>::hasSize(
1685 const StringLiteral &Node,
unsigned int N) {
1686 return Node.getLength() == N;
1689 template <
typename Ty>
1690 struct GetSourceExpressionMatcher {
1691 static const Expr *
get(
const Ty &
Node) {
1692 return Node.getSubExpr();
1697 inline const Expr *GetSourceExpressionMatcher<OpaqueValueExpr>::get(
1698 const OpaqueValueExpr &Node) {
1699 return Node.getSourceExpr();
1702 template <
typename Ty>
1703 struct CompoundStmtMatcher {
1704 static const CompoundStmt *
get(
const Ty &
Node) {
1710 inline const CompoundStmt *
1711 CompoundStmtMatcher<StmtExpr>::get(
const StmtExpr &Node) {
1712 return Node.getSubStmt();
1720 #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
C Language Family Type Representation.
Defines the C++ template declaration subclasses.
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
const DynTypedMatcher *const Matcher
Defines the Objective-C statement AST node classes.
Defines the clang::Expr interface and subclasses for C++ expressions.
BoundNodesTreeBuilder Nodes
const ASTMatchFinder::BindKind Bind
std::vector< DynTypedMatcher > InnerMatchers
const IntrusiveRefCntPtr< DynMatcherInterface > InnerMatcher
detail::InMemoryDirectory::const_iterator I
Matcher< NamedDecl > hasAnyNameFunc(ArrayRef< const StringRef * > NameRefs)
The l-value was considered opaque, so the alignment was determined from a type.
ASTMatchFinder *const Finder
static QualType getUnderlyingType(const SubRegion *R)
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
static DynTypedNode create(const T &Node)
Creates a DynTypedNode from Node.
BoundNodesTreeBuilder BoundNodes
ast_type_traits::DynTypedNode Node
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
BoundNodesTreeBuilder *const Builder
bool matches(const til::SExpr *E1, const til::SExpr *E2)