20 #ifndef LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
21 #define LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
27 #include "llvm/ADT/STLExtras.h"
31 namespace ast_matchers {
46 return Value.getString();
62 return Value.getMatcher().getTypedMatcher<T>();
65 return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
72 return Value.getUnsigned();
81 static attr::Kind getAttrKind(llvm::StringRef AttrKind) {
82 return llvm::StringSwitch<attr::Kind>(AttrKind)
84 #include "clang/Basic/AttrList.inc"
93 return getAttrKind(
Value.getString());
123 std::vector<ArgKind> &ArgKinds)
const = 0;
146 if (
ArgKind(NodeKind).isConvertibleTo(Kind, Specificity)) {
147 if (LeastDerivedKind)
148 *LeastDerivedKind = NodeKind;
164 StringRef MatcherName,
179 : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
180 RetKinds(RetKinds.begin(), RetKinds.end()),
181 ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
186 return Marshaller(Func, MatcherName, NameRange, Args, Error);
190 unsigned getNumArgs()
const override {
return ArgKinds.size(); }
192 std::vector<ArgKind> &Kinds)
const override {
193 Kinds.push_back(ArgKinds[ArgNo]);
204 void (*
const Func)();
205 const std::string MatcherName;
206 const std::vector<ast_type_traits::ASTNodeKind> RetKinds;
207 const std::vector<ArgKind> ArgKinds;
212 template <
class PolyMatcher>
214 std::vector<DynTypedMatcher> &Out,
215 ast_matchers::internal::EmptyTypeList) {}
217 template <
class PolyMatcher,
class TypeList>
219 std::vector<DynTypedMatcher> &Out, TypeList) {
220 Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
234 template <
typename T>
236 typename T::ReturnTypes * =
238 std::vector<DynTypedMatcher>
Matchers;
244 template <
typename T>
246 std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
248 ast_type_traits::ASTNodeKind::getFromNodeKind<typename T::head>());
249 buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
254 buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
255 std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {}
257 template <
typename T>
259 static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
260 buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
264 template <
typename T>
266 static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
267 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
271 template <
typename T>
273 static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
274 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
279 template <
typename ResultT,
typename ArgT,
284 ArgT **InnerArgs =
new ArgT *[Args.size()]();
286 bool HasError =
false;
287 for (
size_t i = 0, e = Args.size(); i != e; ++i) {
291 if (!ArgTraits::is(Value)) {
297 InnerArgs[i] =
new ArgT(ArgTraits::get(Value));
306 for (
size_t i = 0, e = Args.size(); i != e; ++i) {
327 template <
typename ResultT,
typename ArgT,
330 StringRef MatcherName)
331 : Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
332 MatcherName(MatcherName.str()),
340 return Func(MatcherName, NameRange, Args, Error);
346 std::vector<ArgKind> &Kinds)
const override {
347 Kinds.push_back(ArgsKind);
358 const std::string MatcherName;
359 std::vector<ast_type_traits::ASTNodeKind> RetKinds;
366 template <
typename BaseT,
typename DerivedT>
368 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
369 StringRef MatcherName)
371 DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
398 #define CHECK_ARG_COUNT(count) \
399 if (Args.size() != count) { \
400 Error->addError(NameRange, Error->ET_RegistryWrongArgCount) \
401 << count << Args.size(); \
402 return VariantMatcher(); \
405 #define CHECK_ARG_TYPE(index, type) \
406 if (!ArgTypeTraits<type>::is(Args[index].Value)) { \
407 Error->addError(Args[index].Range, Error->ET_RegistryWrongArgType) \
408 << (index + 1) << ArgTypeTraits<type>::getKind().asString() \
409 << Args[index].Value.getTypeAsString(); \
410 return VariantMatcher(); \
415 template <
typename ReturnType>
420 typedef ReturnType (*FuncType)();
426 template <
typename ReturnType,
typename ArgType1>
431 typedef ReturnType (*FuncType)(ArgType1);
439 template <
typename ReturnType,
typename ArgType1,
typename ArgType2>
444 typedef ReturnType (*FuncType)(ArgType1, ArgType2);
453 #undef CHECK_ARG_COUNT
454 #undef CHECK_ARG_TYPE
458 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
459 typename FromTypes,
typename ToTypes>
463 std::vector<MatcherDescriptor *> &Out)
464 : Name(Name), Out(Out) {
465 collect(FromTypes());
469 typedef ast_matchers::internal::ArgumentAdaptingMatcherFunc<
470 ArgumentAdapterT, FromTypes, ToTypes> AdaptativeFunc;
473 static void collect(ast_matchers::internal::EmptyTypeList) {}
477 template <
typename FromTypeList>
478 inline void collect(FromTypeList);
481 std::vector<MatcherDescriptor *> &Out;
492 : Overloads(Callbacks.begin(), Callbacks.end()) {}
499 std::vector<VariantMatcher> Constructed;
501 for (
const auto &O : Overloads) {
503 if (!SubMatcher.
isNull()) {
504 Constructed.push_back(SubMatcher);
511 if (Constructed.size() > 1) {
516 return Constructed[0];
520 bool Overload0Variadic = Overloads[0]->isVariadic();
522 for (
const auto &O : Overloads) {
523 assert(Overload0Variadic == O->isVariadic());
526 return Overload0Variadic;
530 unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
532 for (
const auto &O : Overloads) {
533 assert(Overload0NumArgs == O->getNumArgs());
536 return Overload0NumArgs;
540 std::vector<ArgKind> &Kinds)
const override {
541 for (
const auto &O : Overloads) {
542 if (O->isConvertibleTo(ThisKind))
543 O->getArgKinds(ThisKind, ArgNo, Kinds);
550 for (
const auto &O : Overloads) {
551 if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
558 std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
564 typedef DynTypedMatcher::VariadicOperator
VarOp;
566 VarOp Op, StringRef MatcherName)
567 : MinCount(MinCount), MaxCount(MaxCount), Op(Op),
568 MatcherName(MatcherName) {}
573 if (Args.size() < MinCount || MaxCount < Args.size()) {
574 const std::string MaxStr =
575 (MaxCount ==
UINT_MAX ?
"" : Twine(MaxCount)).str();
577 << (
"(" + Twine(MinCount) +
", " + MaxStr +
")") << Args.size();
581 std::vector<VariantMatcher> InnerArgs;
582 for (
size_t i = 0, e = Args.size(); i != e; ++i) {
598 std::vector<ArgKind> &Kinds)
const override {
599 Kinds.push_back(ThisKind);
605 if (LeastDerivedKind)
606 *LeastDerivedKind =
Kind;
612 const unsigned MinCount;
613 const unsigned MaxCount;
615 const StringRef MatcherName;
622 template <
typename ReturnType>
624 StringRef MatcherName) {
625 std::vector<ast_type_traits::ASTNodeKind> RetTypes;
628 matcherMarshall0<ReturnType>,
reinterpret_cast<void (*)()
>(Func),
629 MatcherName, RetTypes,
None);
633 template <
typename ReturnType,
typename ArgType1>
635 StringRef MatcherName) {
636 std::vector<ast_type_traits::ASTNodeKind> RetTypes;
640 matcherMarshall1<ReturnType, ArgType1>,
641 reinterpret_cast<void (*)()
>(Func), MatcherName, RetTypes, AK);
645 template <
typename ReturnType,
typename ArgType1,
typename ArgType2>
647 StringRef MatcherName) {
648 std::vector<ast_type_traits::ASTNodeKind> RetTypes;
653 matcherMarshall2<ReturnType, ArgType1, ArgType2>,
654 reinterpret_cast<void (*)()
>(Func), MatcherName, RetTypes, AKs);
658 template <
typename ResultT,
typename ArgT,
662 StringRef MatcherName) {
670 template <
typename BaseT,
typename DerivedT>
673 BaseT, DerivedT> VarFunc,
674 StringRef MatcherName) {
679 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
680 typename FromTypes,
typename ToTypes>
683 ArgumentAdapterT, FromTypes, ToTypes>,
684 StringRef MatcherName) {
685 std::vector<MatcherDescriptor *> Overloads;
691 template <
template <
typename ToArg,
typename FromArg>
class ArgumentAdapterT,
692 typename FromTypes,
typename ToTypes>
693 template <
typename FromTypeList>
694 inline void AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes,
695 ToTypes>::collect(FromTypeList) {
697 &AdaptativeFunc::template create<typename FromTypeList::head>, Name));
698 collect(
typename FromTypeList::tail());
702 template <
unsigned MinCount,
unsigned MaxCount>
705 MinCount, MaxCount> Func,
706 StringRef MatcherName) {
716 #endif // LLVM_CLANG_AST_MATCHERS_DYNAMIC_MARSHALLERS_H
Variadic operator marshaller function.
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
const MatchFinder::MatchersByType * Matchers
bool isMatcher() const
Matcher value functions.
std::string getTypeAsString() const
String representation of the type of the value.
AdaptativeOverloadCollector(StringRef Name, std::vector< MatcherDescriptor * > &Out)
ArgStream addError(const SourceRange &Range, ErrorType Error)
Add an error to the diagnostics.
static bool is(const VariantValue &Value)
const DynTypedMatcher *const Matcher
bool isPolymorphic() const override
static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher)
Clones the provided matcher.
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
static VariantMatcher VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, std::vector< VariantMatcher > Args)
Creates a 'variadic' operator matcher.
bool isUnsigned() const
Unsigned value functions.
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
FixedArgCountMatcherDescriptor(MarshallerType Marshaller, void(*Func)(), StringRef MatcherName, ArrayRef< ast_type_traits::ASTNodeKind > RetKinds, ArrayRef< ArgKind > ArgKinds)
bool isBaseOf(ASTNodeKind Other, unsigned *Distance=nullptr) const
Returns true if this is a base kind of (or same as) Other.
VariantMatcher create(const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Matcher descriptor interface.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
virtual ~MatcherDescriptor()
static VariantMatcher matcherMarshall0(void(*Func)(), StringRef MatcherName, const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
0-arg marshaller function.
OverloadedMatcherDescriptor(ArrayRef< MatcherDescriptor * > Callbacks)
VariadicOperatorMatcherDescriptor(unsigned MinCount, unsigned MaxCount, VarOp Op, StringRef MatcherName)
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
VariadicFuncMatcherDescriptor(llvm::VariadicFunction< ResultT, ArgT, F > Func, StringRef MatcherName)
void revertErrors()
Revert all errors that happened within this context.
static bool is(const VariantValue &Value)
bool isVariadic() const override
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
bool isNull() const
Whether the matcher is null.
Matcher descriptor for variadic functions.
A VariantValue instance annotated with its parser context.
static bool is(const VariantValue &Value)
bool isRetKindConvertibleTo(ArrayRef< ast_type_traits::ASTNodeKind > RetKinds, ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind)
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
~OverloadedMatcherDescriptor() override
DynTypedMatcher::VariadicOperator VarOp
static void build(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
static bool is(const VariantValue &Value)
Diagnostics class to manage error messages.
VariantMatcher create(const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
VariantMatcher create(const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Helper class to manage error messages.
static VariantMatcher matcherMarshall1(void(*Func)(), StringRef MatcherName, const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
1-arg marshaller function.
static void build(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
VariantMatcher(* MarshallerType)(void(*Func)(), StringRef MatcherName, const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
virtual bool isPolymorphic() const
bool isVariadic() const override
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
VariantMatcher create(const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const override
Simple callback implementation. Marshaller and function are provided.
Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers.
MatcherDescriptor * makeMatcherAutoMarshall(ReturnType(*Func)(), StringRef MatcherName)
0-arg overload
#define CHECK_ARG_COUNT(count)
Helper macros to check the arguments on all marshaller functions.
virtual bool isVariadic() const =0
bool isVariadic() const override
MatcherDescriptor that wraps multiple "overloads" of the same matcher.
virtual unsigned getNumArgs() const =0
Returns the number of arguments accepted by the matcher if not variadic.
bool isSame(ASTNodeKind Other) const
Returns true if this and Other represent the same kind.
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
static VariantMatcher PolymorphicMatcher(std::vector< DynTypedMatcher > Matchers)
Clones the provided matchers.
static void mergePolyMatchers(const PolyMatcher &Poly, std::vector< DynTypedMatcher > &Out, ast_matchers::internal::EmptyTypeList)
Helper methods to extract and merge all possible typed matchers out of the polymorphic object...
Helper template class to just from argument type to the right is/get functions in VariantValue...
bool isString() const
String value functions.
Context for overloaded matcher construction.
A variant matcher object.
#define CHECK_ARG_TYPE(index, type)
VariantMatcher variadicMatcherDescriptor(StringRef MatcherName, const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
Variadic marshaller function.
const std::string & getString() const
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &Kinds) const override
DynCastAllOfMatcherDescriptor(ast_matchers::internal::VariadicDynCastAllOfMatcher< BaseT, DerivedT > Func, StringRef MatcherName)
static void build(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
static Decl::Kind getKind(const Decl *D)
static VariantMatcher matcherMarshall2(void(*Func)(), StringRef MatcherName, const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error)
2-arg marshaller function.
virtual VariantMatcher create(const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const =0
virtual void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &ArgKinds) const =0
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ast_type_traits::ASTNodeKind *LeastDerivedKind) const override
static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher)
Convert the return values of the functions into a VariantMatcher.
Helper class used to collect all the possible overloads of an argument adaptative matcher function...
const VariantMatcher & getMatcher() const
virtual bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity=nullptr, ast_type_traits::ASTNodeKind *LeastDerivedKind=nullptr) const =0
bool hasTypedMatcher() const
Determines if the contained matcher can be converted to Matcher<T>.
unsigned getNumArgs() const override
Returns the number of arguments accepted by the matcher if not variadic.
void buildReturnTypeVectorFromTypeList(std::vector< ast_type_traits::ASTNodeKind > &RetTypes)
bool isVariadic() const override