19 #ifndef LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
20 #define LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
31 #include "llvm/ADT/ArrayRef.h"
32 #include "llvm/ADT/None.h"
33 #include "llvm/ADT/Optional.h"
34 #include "llvm/ADT/STLExtras.h"
35 #include "llvm/ADT/StringRef.h"
36 #include "llvm/ADT/StringSwitch.h"
37 #include "llvm/ADT/Twine.h"
38 #include "llvm/Support/Regex.h"
49 namespace ast_matchers {
62 return Value.isString();
67 return Value.getString();
83 template <
class T>
struct ArgTypeTraits<ast_matchers::internal::Matcher<T>> {
85 return Value.isMatcher();
88 return Value.getMatcher().hasTypedMatcher<T>();
92 return Value.getMatcher().getTypedMatcher<T>();
106 return Value.isBoolean();
111 return Value.getBoolean();
125 return Value.isDouble();
130 return Value.getDouble();
144 return Value.isUnsigned();
149 return Value.getUnsigned();
164 if (!AttrKind.consume_front(
"attr::"))
166 return llvm::StringSwitch<Optional<attr::Kind>>(AttrKind)
168 #include "clang/Basic/AttrList.inc"
169 .Default(llvm::None);
174 return Value.isString();
177 return getAttrKind(
Value.getString()).has_value();
181 return *getAttrKind(
Value.getString());
194 if (!AttrKind.consume_front(
"CK_"))
196 return llvm::StringSwitch<Optional<CastKind>>(AttrKind)
198 #include "clang/AST/OperationKinds.def"
199 .Default(llvm::None);
204 return Value.isString();
207 return getCastKind(
Value.getString()).has_value();
211 return *getCastKind(
Value.getString());
227 return Value.isString();
230 return getFlags(
Value.getString()).has_value();
234 return *getFlags(
Value.getString());
245 return llvm::StringSwitch<Optional<OpenMPClauseKind>>(ClauseKind)
247 #define
CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum)
248 #include "llvm/Frontend/OpenMP/OMP.inc"
249 .Default(llvm::None);
254 return Value.isString();
257 return getClauseKind(
Value.getString()).has_value();
261 return *getClauseKind(
Value.getString());
272 getUnaryOrTypeTraitKind(llvm::StringRef ClauseKind) {
273 if (!ClauseKind.consume_front(
"UETT_"))
275 return llvm::StringSwitch<Optional<UnaryExprOrTypeTrait>>(ClauseKind)
277 #define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) \
278 .Case(#Name, UETT_##Name)
279 #include "clang/Basic/TokenKinds.def"
280 .Default(llvm::None);
285 return Value.isString();
288 return getUnaryOrTypeTraitKind(
Value.getString()).has_value();
292 return *getUnaryOrTypeTraitKind(
Value.getString());
316 virtual std::unique_ptr<MatcherDescriptor>
334 std::vector<ArgKind> &ArgKinds)
const = 0;
345 ASTNodeKind *LeastDerivedKind =
nullptr)
const = 0;
358 if (LeastDerivedKind)
375 StringRef MatcherName,
387 StringRef MatcherName,
390 : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
391 RetKinds(RetKinds.begin(), RetKinds.end()),
392 ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
397 return Marshaller(Func, MatcherName, NameRange, Args,
Error);
401 unsigned getNumArgs()
const override {
return ArgKinds.size(); }
404 std::vector<ArgKind> &Kinds)
const override {
405 Kinds.push_back(ArgKinds[ArgNo]);
416 void (*
const Func)();
418 const std::vector<ASTNodeKind> RetKinds;
419 const std::vector<ArgKind> ArgKinds;
424 template <
class PolyMatcher>
426 std::vector<DynTypedMatcher> &Out,
427 ast_matchers::internal::EmptyTypeList) {}
429 template <
class PolyMatcher,
class TypeList>
431 std::vector<DynTypedMatcher> &Out, TypeList) {
432 Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
446 template <
typename T>
448 typename T::ReturnTypes * =
450 std::vector<DynTypedMatcher> Matchers;
456 template <
typename T>
459 RetTypes.push_back(ASTNodeKind::getFromNodeKind<typename T::head>());
460 buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
465 buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
466 std::vector<ASTNodeKind> &RetTypes) {}
468 template <
typename T>
470 static void build(std::vector<ASTNodeKind> &RetTypes) {
471 buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
475 template <
typename T>
477 static void build(std::vector<ASTNodeKind> &RetTypes) {
478 RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
482 template <
typename T>
484 static void build(std::vector<ASTNodeKind> &RetTypes) {
485 RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
490 template <
typename ResultT,
typename ArgT,
496 InnerArgsPtr.resize_for_overwrite(Args.size());
498 InnerArgs.reserve(Args.size());
500 for (
size_t i = 0, e = Args.size(); i != e; ++i) {
505 if (!ArgTraits::hasCorrectType(
Value)) {
510 if (!ArgTraits::hasCorrectValue(
Value)) {
514 << i + 1 <<
Value.getString() << *BestGuess;
515 }
else if (
Value.isString()) {
517 <<
Value.getString();
523 <<
Value.getTypeAsString();
527 assert(InnerArgs.size() < InnerArgs.capacity());
528 InnerArgs.emplace_back(ArgTraits::get(
Value));
529 InnerArgsPtr[i] = &InnerArgs[i];
548 template <
typename ResultT,
typename ArgT,
551 ast_matchers::internal::VariadicFunction<ResultT, ArgT, F> Func,
552 StringRef MatcherName)
553 : Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
554 MatcherName(MatcherName.str()),
562 return Func(MatcherName, NameRange, Args,
Error);
569 std::vector<ArgKind> &Kinds)
const override {
570 Kinds.push_back(ArgsKind);
584 std::vector<ASTNodeKind> RetKinds;
591 template <
typename BaseT,
typename DerivedT>
593 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
594 StringRef MatcherName)
596 DerivedKind(
ASTNodeKind::getFromNodeKind<DerivedT>()) {}
606 if (
Kind.isSame(DerivedKind) || !
Kind.isBaseOf(DerivedKind)) {
623 #define CHECK_ARG_COUNT(count) \
624 if (Args.size() != count) { \
625 Error->addError(NameRange, Error->ET_RegistryWrongArgCount) \
626 << count << Args.size(); \
627 return VariantMatcher(); \
630 #define CHECK_ARG_TYPE(index, type) \
631 if (!ArgTypeTraits<type>::hasCorrectType(Args[index].Value)) { \
632 Error->addError(Args[index].Range, Error->ET_RegistryWrongArgType) \
633 << (index + 1) << ArgTypeTraits<type>::getKind().asString() \
634 << Args[index].Value.getTypeAsString(); \
635 return VariantMatcher(); \
637 if (!ArgTypeTraits<type>::hasCorrectValue(Args[index].Value)) { \
638 if (llvm::Optional<std::string> BestGuess = \
639 ArgTypeTraits<type>::getBestGuess(Args[index].Value)) { \
640 Error->addError(Args[index].Range, \
641 Error->ET_RegistryUnknownEnumWithReplace) \
642 << index + 1 << Args[index].Value.getString() << *BestGuess; \
643 } else if (Args[index].Value.isString()) { \
644 Error->addError(Args[index].Range, Error->ET_RegistryValueNotFound) \
645 << Args[index].Value.getString(); \
647 return VariantMatcher(); \
651 template <
typename ReturnType>
656 using FuncType = ReturnType (*)();
662 template <
typename ReturnType,
typename ArgType1>
667 using FuncType = ReturnType (*)(ArgType1);
675 template <
typename ReturnType,
typename ArgType1,
typename ArgType2>
680 using FuncType = ReturnType (*)(ArgType1, ArgType2);
689 #undef CHECK_ARG_COUNT
690 #undef CHECK_ARG_TYPE
694 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
695 typename FromTypes,
typename ToTypes>
699 StringRef Name, std::vector<std::unique_ptr<MatcherDescriptor>> &Out)
700 : Name(Name), Out(Out) {
701 collect(FromTypes());
705 using AdaptativeFunc = ast_matchers::internal::ArgumentAdaptingMatcherFunc<
706 ArgumentAdapterT, FromTypes, ToTypes>;
709 static void collect(ast_matchers::internal::EmptyTypeList) {}
713 template <
typename FromTypeList>
714 inline void collect(FromTypeList);
717 std::vector<std::unique_ptr<MatcherDescriptor>> &Out;
729 : Overloads(
std::make_move_iterator(Callbacks.begin()),
730 std::make_move_iterator(Callbacks.end())) {}
737 std::vector<VariantMatcher> Constructed;
739 for (
const auto &O : Overloads) {
741 if (!SubMatcher.
isNull()) {
742 Constructed.push_back(SubMatcher);
749 if (Constructed.size() > 1) {
751 Error->addError(NameRange,
Error->ET_RegistryAmbiguousOverload);
754 return Constructed[0];
758 bool Overload0Variadic = Overloads[0]->isVariadic();
760 for (
const auto &O : Overloads) {
761 assert(Overload0Variadic == O->isVariadic());
764 return Overload0Variadic;
768 unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
770 for (
const auto &O : Overloads) {
771 assert(Overload0NumArgs == O->getNumArgs());
774 return Overload0NumArgs;
778 std::vector<ArgKind> &Kinds)
const override {
779 for (
const auto &O : Overloads) {
780 if (O->isConvertibleTo(ThisKind))
781 O->getArgKinds(ThisKind, ArgNo, Kinds);
787 for (
const auto &O : Overloads) {
788 if (O->isConvertibleTo(
Kind, Specificity, LeastDerivedKind))
795 std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
798 template <
typename ReturnType>
802 llvm::Regex::RegexFlags),
803 ReturnType (*NoFlags)(StringRef),
805 : WithFlags(WithFlags), NoFlags(NoFlags),
806 RetKinds(RetKinds.begin(), RetKinds.end()) {}
811 std::vector<ArgKind> &Kinds)
const override {
824 if (Args.size() < 1 || Args.size() > 2) {
826 <<
"1 or 2" << Args.size();
830 Error->addError(Args[0].Range,
Error->ET_RegistryWrongArgType)
832 << Args[0].Value.getTypeAsString();
835 if (Args.size() == 1) {
841 Error->addError(Args[1].Range,
Error->ET_RegistryWrongArgType)
843 << Args[1].Value.getTypeAsString();
851 Error->addError(Args[1].Range,
Error->ET_RegistryUnknownEnumWithReplace)
852 << 2 << Args[1].Value.getString() << *BestGuess;
854 Error->addError(Args[1].Range,
Error->ET_RegistryValueNotFound)
855 << Args[1].Value.getString();
865 ReturnType (*
const WithFlags)(StringRef, llvm::Regex::RegexFlags);
866 ReturnType (*
const NoFlags)(StringRef);
867 const std::vector<ASTNodeKind> RetKinds;
873 using VarOp = DynTypedMatcher::VariadicOperator;
876 VarOp Op, StringRef MatcherName)
877 : MinCount(MinCount), MaxCount(MaxCount), Op(Op),
878 MatcherName(MatcherName) {}
883 if (Args.size() < MinCount || MaxCount < Args.size()) {
888 Error->addError(NameRange,
Error->ET_RegistryWrongArgCount)
889 << (
"(" + Twine(MinCount) +
", " + MaxStr +
")") << Args.size();
893 std::vector<VariantMatcher> InnerArgs;
894 for (
size_t i = 0, e = Args.size(); i != e; ++i) {
897 if (!
Value.isMatcher()) {
899 << (i + 1) <<
"Matcher<>" <<
Value.getTypeAsString();
902 InnerArgs.push_back(
Value.getMatcher());
911 std::vector<ArgKind> &Kinds)
const override {
919 if (LeastDerivedKind)
920 *LeastDerivedKind =
Kind;
927 const unsigned MinCount;
928 const unsigned MaxCount;
930 const StringRef MatcherName;
935 std::vector<ASTNodeKind> NodeKinds;
939 std::vector<ASTNodeKind> NodeKinds)
940 : CladeNodeKind(CladeNodeKind), NodeKinds(NodeKinds) {}
945 std::vector<DynTypedMatcher> NodeArgs;
947 for (
auto NK : NodeKinds) {
948 std::vector<DynTypedMatcher> InnerArgs;
950 for (
const auto &Arg : Args) {
951 if (!Arg.Value.isMatcher())
956 InnerArgs.push_back(DM);
960 if (InnerArgs.empty()) {
962 DynTypedMatcher::trueMatcher(NK).dynCastTo(CladeNodeKind));
965 DynTypedMatcher::constructVariadic(
966 ast_matchers::internal::DynTypedMatcher::VO_AllOf, NK,
968 .dynCastTo(CladeNodeKind));
972 auto Result = DynTypedMatcher::constructVariadic(
973 ast_matchers::internal::DynTypedMatcher::VO_AnyOf, CladeNodeKind,
975 Result.setAllowBind(
true);
983 std::vector<ArgKind> &Kinds)
const override {
991 if (LeastDerivedKind)
992 *LeastDerivedKind = CladeNodeKind;
1006 std::unique_ptr<MatcherDescriptor>
1010 std::vector<ASTNodeKind> NodeKinds;
1011 for (
auto Arg : Args) {
1012 if (!Arg.Value.isNodeKind())
1014 NodeKinds.push_back(Arg.Value.getNodeKind());
1017 if (NodeKinds.empty())
1022 for (
auto NK : NodeKinds)
1024 if (!NK.getCladeKind().isSame(CladeNodeKind))
1028 return std::make_unique<MapAnyOfMatcherDescriptor>(CladeNodeKind,
1037 std::vector<ArgKind> &ArgKinds)
const override {
1041 ASTNodeKind *LeastDerivedKind =
nullptr)
const override {
1044 if (LeastDerivedKind)
1045 *LeastDerivedKind =
Kind;
1056 template <
typename ReturnType>
1057 std::unique_ptr<MatcherDescriptor>
1059 std::vector<ASTNodeKind> RetTypes;
1061 return std::make_unique<FixedArgCountMatcherDescriptor>(
1062 matcherMarshall0<ReturnType>,
reinterpret_cast<void (*)()
>(Func),
1063 MatcherName, RetTypes, None);
1067 template <
typename ReturnType,
typename ArgType1>
1068 std::unique_ptr<MatcherDescriptor>
1070 std::vector<ASTNodeKind> RetTypes;
1073 return std::make_unique<FixedArgCountMatcherDescriptor>(
1074 matcherMarshall1<ReturnType, ArgType1>,
1075 reinterpret_cast<void (*)()
>(Func), MatcherName, RetTypes, AK);
1079 template <
typename ReturnType,
typename ArgType1,
typename ArgType2>
1080 std::unique_ptr<MatcherDescriptor>
1082 StringRef MatcherName) {
1083 std::vector<ASTNodeKind> RetTypes;
1087 return std::make_unique<FixedArgCountMatcherDescriptor>(
1088 matcherMarshall2<ReturnType, ArgType1, ArgType2>,
1089 reinterpret_cast<void (*)()
>(Func), MatcherName, RetTypes, AKs);
1092 template <
typename ReturnType>
1094 ReturnType (*FuncFlags)(llvm::StringRef, llvm::Regex::RegexFlags),
1095 ReturnType (*Func)(llvm::StringRef)) {
1096 std::vector<ASTNodeKind> RetTypes;
1098 return std::make_unique<RegexMatcherDescriptor<ReturnType>>(FuncFlags, Func,
1103 template <
typename ResultT,
typename ArgT,
1106 ast_matchers::internal::VariadicFunction<ResultT, ArgT, Func> VarFunc,
1107 StringRef MatcherName) {
1108 return std::make_unique<VariadicFuncMatcherDescriptor>(VarFunc, MatcherName);
1115 template <
typename BaseT,
typename DerivedT>
1117 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
1119 StringRef MatcherName) {
1120 return std::make_unique<DynCastAllOfMatcherDescriptor>(VarFunc, MatcherName);
1124 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
1125 typename FromTypes,
typename ToTypes>
1127 ast_matchers::internal::ArgumentAdaptingMatcherFunc<ArgumentAdapterT,
1128 FromTypes, ToTypes>,
1129 StringRef MatcherName) {
1130 std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
1133 return std::make_unique<OverloadedMatcherDescriptor>(Overloads);
1136 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
1137 typename FromTypes,
typename ToTypes>
1138 template <
typename FromTypeList>
1139 inline void AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes,
1140 ToTypes>::collect(FromTypeList) {
1142 &AdaptativeFunc::template create<typename FromTypeList::head>, Name));
1143 collect(
typename FromTypeList::tail());
1147 template <
unsigned MinCount,
unsigned MaxCount>
1149 ast_matchers::internal::VariadicOperatorMatcherFunc<MinCount, MaxCount>
1151 StringRef MatcherName) {
1152 return std::make_unique<VariadicOperatorMatcherDescriptor>(
1153 MinCount, MaxCount, Func.Op, MatcherName);
1156 template <
typename CladeType,
typename... MatcherT>
1158 ast_matchers::internal::MapAnyOfMatcherImpl<CladeType, MatcherT...>,
1159 StringRef MatcherName) {
1160 return std::make_unique<MapAnyOfMatcherDescriptor>(
1161 ASTNodeKind::getFromNodeKind<CladeType>(),
1162 std::vector<ASTNodeKind>{ASTNodeKind::getFromNodeKind<MatcherT>()...});
1170 #endif // LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H