#ifndef LLVM_CLANG_AST_MATCHERS_DYNAMIC_MARSHALLERS_H
#define LLVM_CLANG_AST_MATCHERS_DYNAMIC_MARSHALLERS_H
#include <string>
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/Dynamic/Diagnostics.h"
#include "clang/ASTMatchers/Dynamic/VariantValue.h"
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/type_traits.h"
namespace clang {
namespace ast_matchers {
namespace dynamic {
namespace internal {
template <class T> struct ArgTypeTraits;
template <class T> struct ArgTypeTraits<const T &> : public ArgTypeTraits<T> {
};
template <> struct ArgTypeTraits<std::string> {
static StringRef asString() { return "String"; }
static bool is(const VariantValue &Value) { return Value.isString(); }
static const std::string &get(const VariantValue &Value) {
return Value.getString();
}
};
template <>
struct ArgTypeTraits<StringRef> : public ArgTypeTraits<std::string> {
};
template <class T> struct ArgTypeTraits<ast_matchers::internal::Matcher<T> > {
static std::string asString() {
return (Twine("Matcher<") +
ast_type_traits::ASTNodeKind::getFromNodeKind<T>().asStringRef() +
">").str();
}
static bool is(const VariantValue &Value) {
return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
}
static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
return Value.getMatcher().getTypedMatcher<T>();
}
};
template <> struct ArgTypeTraits<unsigned> {
static std::string asString() { return "Unsigned"; }
static bool is(const VariantValue &Value) { return Value.isUnsigned(); }
static unsigned get(const VariantValue &Value) {
return Value.getUnsigned();
}
};
class MatcherCreateCallback {
public:
virtual ~MatcherCreateCallback() {}
virtual VariantMatcher run(const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) const = 0;
};
class FixedArgCountMatcherCreateCallback : public MatcherCreateCallback {
public:
typedef VariantMatcher (*MarshallerType)(void (*Func)(),
StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error);
FixedArgCountMatcherCreateCallback(MarshallerType Marshaller, void (*Func)(),
StringRef MatcherName)
: Marshaller(Marshaller), Func(Func), MatcherName(MatcherName) {}
VariantMatcher run(const SourceRange &NameRange, ArrayRef<ParserValue> Args,
Diagnostics *Error) const {
return Marshaller(Func, MatcherName, NameRange, Args, Error);
}
private:
const MarshallerType Marshaller;
void (* const Func)();
const std::string MatcherName;
};
class FreeFuncMatcherCreateCallback : public MatcherCreateCallback {
public:
typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error);
FreeFuncMatcherCreateCallback(RunFunc Func, StringRef MatcherName)
: Func(Func), MatcherName(MatcherName.str()) {}
VariantMatcher run(const SourceRange &NameRange, ArrayRef<ParserValue> Args,
Diagnostics *Error) const {
return Func(MatcherName, NameRange, Args, Error);
}
private:
const RunFunc Func;
const std::string MatcherName;
};
#define CHECK_ARG_COUNT(count) \
if (Args.size() != count) { \
Error->addError(NameRange, Error->ET_RegistryWrongArgCount) \
<< count << Args.size(); \
return VariantMatcher(); \
}
#define CHECK_ARG_TYPE(index, type) \
if (!ArgTypeTraits<type>::is(Args[index].Value)) { \
Error->addError(Args[index].Range, Error->ET_RegistryWrongArgType) \
<< (index + 1) << ArgTypeTraits<type>::asString() \
<< Args[index].Value.getTypeAsString(); \
return VariantMatcher(); \
}
template <class PolyMatcher>
static void mergePolyMatchers(const PolyMatcher &Poly,
std::vector<DynTypedMatcher> &Out,
ast_matchers::internal::EmptyTypeList) {}
template <class PolyMatcher, class TypeList>
static void mergePolyMatchers(const PolyMatcher &Poly,
std::vector<DynTypedMatcher> &Out, TypeList) {
Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
mergePolyMatchers(Poly, Out, typename TypeList::tail());
}
static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher) {
return VariantMatcher::SingleMatcher(Matcher);
}
template <typename T>
static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
typename T::ReturnTypes * =
NULL) {
std::vector<DynTypedMatcher> Matchers;
mergePolyMatchers(PolyMatcher, Matchers, typename T::ReturnTypes());
VariantMatcher Out = VariantMatcher::PolymorphicMatcher(Matchers);
return Out;
}
template <typename ReturnType>
static VariantMatcher matcherMarshall0(void (*Func)(), StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
typedef ReturnType (*FuncType)();
CHECK_ARG_COUNT(0);
return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)());
}
template <typename ReturnType, typename ArgType1>
static VariantMatcher matcherMarshall1(void (*Func)(), StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
typedef ReturnType (*FuncType)(ArgType1);
CHECK_ARG_COUNT(1);
CHECK_ARG_TYPE(0, ArgType1);
return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
ArgTypeTraits<ArgType1>::get(Args[0].Value)));
}
template <typename ReturnType, typename ArgType1, typename ArgType2>
static VariantMatcher matcherMarshall2(void (*Func)(), StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
typedef ReturnType (*FuncType)(ArgType1, ArgType2);
CHECK_ARG_COUNT(2);
CHECK_ARG_TYPE(0, ArgType1);
CHECK_ARG_TYPE(1, ArgType2);
return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
ArgTypeTraits<ArgType1>::get(Args[0].Value),
ArgTypeTraits<ArgType2>::get(Args[1].Value)));
}
#undef CHECK_ARG_COUNT
#undef CHECK_ARG_TYPE
template <typename ResultT, typename ArgT,
ResultT (*Func)(ArrayRef<const ArgT *>)>
VariantMatcher
variadicMatcherCreateCallback(StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args, Diagnostics *Error) {
ArgT **InnerArgs = new ArgT *[Args.size()]();
bool HasError = false;
for (size_t i = 0, e = Args.size(); i != e; ++i) {
typedef ArgTypeTraits<ArgT> ArgTraits;
const ParserValue &Arg = Args[i];
const VariantValue &Value = Arg.Value;
if (!ArgTraits::is(Value)) {
Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
<< (i + 1) << ArgTraits::asString() << Value.getTypeAsString();
HasError = true;
break;
}
InnerArgs[i] = new ArgT(ArgTraits::get(Value));
}
VariantMatcher Out;
if (!HasError) {
Out = outvalueToVariantMatcher(
Func(ArrayRef<const ArgT *>(InnerArgs, Args.size())));
}
for (size_t i = 0, e = Args.size(); i != e; ++i) {
delete InnerArgs[i];
}
delete[] InnerArgs;
return Out;
}
template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
typename FromTypes, typename ToTypes>
class AdaptativeOverloadCollector {
public:
AdaptativeOverloadCollector(StringRef Name,
std::vector<MatcherCreateCallback *> &Out)
: Name(Name), Out(Out) {
collect(FromTypes());
}
private:
typedef ast_matchers::internal::ArgumentAdaptingMatcherFunc<
ArgumentAdapterT, FromTypes, ToTypes> AdaptativeFunc;
static void collect(ast_matchers::internal::EmptyTypeList) {}
template <typename FromTypeList> inline void collect(FromTypeList);
const StringRef Name;
std::vector<MatcherCreateCallback *> &Out;
};
class OverloadedMatcherCreateCallback : public MatcherCreateCallback {
public:
OverloadedMatcherCreateCallback(ArrayRef<MatcherCreateCallback *> Callbacks)
: Overloads(Callbacks) {}
virtual ~OverloadedMatcherCreateCallback() {
llvm::DeleteContainerPointers(Overloads);
}
virtual VariantMatcher run(const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) const {
std::vector<VariantMatcher> Constructed;
Diagnostics::OverloadContext Ctx(Error);
for (size_t i = 0, e = Overloads.size(); i != e; ++i) {
VariantMatcher SubMatcher = Overloads[i]->run(NameRange, Args, Error);
if (!SubMatcher.isNull()) {
Constructed.push_back(SubMatcher);
}
}
if (Constructed.empty()) return VariantMatcher(); Ctx.revertErrors();
if (Constructed.size() > 1) {
Error->addError(NameRange, Error->ET_RegistryAmbiguousOverload);
return VariantMatcher();
}
return Constructed[0];
}
private:
std::vector<MatcherCreateCallback *> Overloads;
};
class VariadicOperatorMatcherCreateCallback : public MatcherCreateCallback {
public:
typedef ast_matchers::internal::VariadicOperatorFunction VarFunc;
VariadicOperatorMatcherCreateCallback(VarFunc Func, StringRef MatcherName)
: Func(Func), MatcherName(MatcherName) {}
virtual VariantMatcher run(const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) const {
std::vector<VariantMatcher> InnerArgs;
for (size_t i = 0, e = Args.size(); i != e; ++i) {
const ParserValue &Arg = Args[i];
const VariantValue &Value = Arg.Value;
if (!Value.isMatcher()) {
Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
<< (i + 1) << "Matcher<>" << Value.getTypeAsString();
return VariantMatcher();
}
InnerArgs.push_back(Value.getMatcher());
}
return VariantMatcher::VariadicOperatorMatcher(Func, InnerArgs);
}
private:
const VarFunc Func;
const StringRef MatcherName;
};
template <typename ReturnType>
MatcherCreateCallback *makeMatcherAutoMarshall(ReturnType (*Func)(),
StringRef MatcherName) {
return new FixedArgCountMatcherCreateCallback(
matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
MatcherName);
}
template <typename ReturnType, typename ArgType1>
MatcherCreateCallback *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1),
StringRef MatcherName) {
return new FixedArgCountMatcherCreateCallback(
matcherMarshall1<ReturnType, ArgType1>,
reinterpret_cast<void (*)()>(Func), MatcherName);
}
template <typename ReturnType, typename ArgType1, typename ArgType2>
MatcherCreateCallback *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1,
ArgType2),
StringRef MatcherName) {
return new FixedArgCountMatcherCreateCallback(
matcherMarshall2<ReturnType, ArgType1, ArgType2>,
reinterpret_cast<void (*)()>(Func), MatcherName);
}
template <typename ResultT, typename ArgT,
ResultT (*Func)(ArrayRef<const ArgT *>)>
MatcherCreateCallback *
makeMatcherAutoMarshall(llvm::VariadicFunction<ResultT, ArgT, Func> VarFunc,
StringRef MatcherName) {
return new FreeFuncMatcherCreateCallback(
&variadicMatcherCreateCallback<ResultT, ArgT, Func>, MatcherName);
}
template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
typename FromTypes, typename ToTypes>
MatcherCreateCallback *
makeMatcherAutoMarshall(ast_matchers::internal::ArgumentAdaptingMatcherFunc<
ArgumentAdapterT, FromTypes, ToTypes>,
StringRef MatcherName) {
std::vector<MatcherCreateCallback *> Overloads;
AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>(MatcherName,
Overloads);
return new OverloadedMatcherCreateCallback(Overloads);
}
template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
typename FromTypes, typename ToTypes>
template <typename FromTypeList>
inline void
AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>::collect(
FromTypeList) {
Out.push_back(makeMatcherAutoMarshall(
&AdaptativeFunc::template create<typename FromTypeList::head>, Name));
collect(typename FromTypeList::tail());
}
MatcherCreateCallback *makeMatcherAutoMarshall(
ast_matchers::internal::VariadicOperatorMatcherFunc Func,
StringRef MatcherName) {
return new VariadicOperatorMatcherCreateCallback(Func.Func, MatcherName);
}
} } } }
#endif // LLVM_CLANG_AST_MATCHERS_DYNAMIC_MARSHALLERS_H