Hi sbenza, klimek,
The new names will be more appropriate when the objects are taught to return
type information for the code completer.
http://llvm-reviews.chandlerc.com/D2208
Files:
include/clang/ASTMatchers/Dynamic/Registry.h
lib/ASTMatchers/Dynamic/Marshallers.h
lib/ASTMatchers/Dynamic/Registry.cpp
Index: include/clang/ASTMatchers/Dynamic/Registry.h
===================================================================
--- include/clang/ASTMatchers/Dynamic/Registry.h
+++ include/clang/ASTMatchers/Dynamic/Registry.h
@@ -28,10 +28,10 @@
namespace dynamic {
namespace internal {
-class MatcherCreateCallback;
+class MatcherDesc;
}
-typedef const internal::MatcherCreateCallback *MatcherCtor;
+typedef const internal::MatcherDesc *MatcherCtor;
class Registry {
public:
Index: lib/ASTMatchers/Dynamic/Marshallers.h
===================================================================
--- lib/ASTMatchers/Dynamic/Marshallers.h
+++ lib/ASTMatchers/Dynamic/Marshallers.h
@@ -76,25 +76,25 @@
}
};
-/// \brief Generic MatcherCreate interface.
+/// \brief Matcher descriptor interface.
///
-/// Provides a \c run() method that constructs the matcher from the provided
+/// Provides a \c create() method that constructs the matcher from the provided
/// arguments.
-class MatcherCreateCallback {
+class MatcherDesc {
public:
- virtual ~MatcherCreateCallback() {}
- virtual VariantMatcher run(const SourceRange &NameRange,
- ArrayRef<ParserValue> Args,
- Diagnostics *Error) const = 0;
+ virtual ~MatcherDesc() {}
+ virtual VariantMatcher create(const SourceRange &NameRange,
+ ArrayRef<ParserValue> Args,
+ Diagnostics *Error) const = 0;
};
/// \brief Simple callback implementation. Marshaller and function are provided.
///
/// This class wraps a function of arbitrary signature and a marshaller
-/// function into a MatcherCreateCallback.
+/// function into a MatcherDesc.
/// The marshaller is in charge of taking the VariantValue arguments, checking
/// their types, unpacking them and calling the underlying function.
-class FixedArgCountMatcherCreateCallback : public MatcherCreateCallback {
+class FixedArgCountMatcherDesc : public MatcherDesc {
public:
typedef VariantMatcher (*MarshallerType)(void (*Func)(),
StringRef MatcherName,
@@ -105,12 +105,12 @@
/// \param Marshaller Function to unpack the arguments and call \c Func
/// \param Func Matcher construct function. This is the function that
/// compile-time matcher expressions would use to create the matcher.
- FixedArgCountMatcherCreateCallback(MarshallerType Marshaller, void (*Func)(),
- StringRef MatcherName)
+ FixedArgCountMatcherDesc(MarshallerType Marshaller, void (*Func)(),
+ StringRef MatcherName)
: Marshaller(Marshaller), Func(Func), MatcherName(MatcherName) {}
- VariantMatcher run(const SourceRange &NameRange, ArrayRef<ParserValue> Args,
- Diagnostics *Error) const {
+ VariantMatcher create(const SourceRange &NameRange,
+ ArrayRef<ParserValue> Args, Diagnostics *Error) const {
return Marshaller(Func, MatcherName, NameRange, Args, Error);
}
@@ -123,22 +123,22 @@
/// \brief Simple callback implementation. Free function is wrapped.
///
/// This class simply wraps a free function with the right signature to export
-/// it as a MatcherCreateCallback.
+/// it as a MatcherDesc.
/// This allows us to have one implementation of the interface for as many free
/// functions as we want, reducing the number of symbols and size of the
/// object file.
-class FreeFuncMatcherCreateCallback : public MatcherCreateCallback {
+class FreeFuncMatcherDesc : public MatcherDesc {
public:
typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error);
- FreeFuncMatcherCreateCallback(RunFunc Func, StringRef MatcherName)
+ FreeFuncMatcherDesc(RunFunc Func, StringRef MatcherName)
: Func(Func), MatcherName(MatcherName.str()) {}
- VariantMatcher run(const SourceRange &NameRange, ArrayRef<ParserValue> Args,
- Diagnostics *Error) const {
+ VariantMatcher create(const SourceRange &NameRange,
+ ArrayRef<ParserValue> Args, Diagnostics *Error) const {
return Func(MatcherName, NameRange, Args, Error);
}
@@ -242,10 +242,10 @@
/// \brief Variadic marshaller function.
template <typename ResultT, typename ArgT,
ResultT (*Func)(ArrayRef<const ArgT *>)>
-VariantMatcher
-variadicMatcherCreateCallback(StringRef MatcherName,
- const SourceRange &NameRange,
- ArrayRef<ParserValue> Args, Diagnostics *Error) {
+VariantMatcher variadicMatcherDesc(StringRef MatcherName,
+ const SourceRange &NameRange,
+ ArrayRef<ParserValue> Args,
+ Diagnostics *Error) {
ArgT **InnerArgs = new ArgT *[Args.size()]();
bool HasError = false;
@@ -281,8 +281,7 @@
typename FromTypes, typename ToTypes>
class AdaptativeOverloadCollector {
public:
- AdaptativeOverloadCollector(StringRef Name,
- std::vector<MatcherCreateCallback *> &Out)
+ AdaptativeOverloadCollector(StringRef Name, std::vector<MatcherDesc *> &Out)
: Name(Name), Out(Out) {
collect(FromTypes());
}
@@ -296,33 +295,32 @@
/// \brief Recursive case. Get the overload for the head of the list, and
/// recurse to the tail.
- template <typename FromTypeList> inline void collect(FromTypeList);
+ template <typename FromTypeList>
+ inline void collect(FromTypeList);
const StringRef Name;
- std::vector<MatcherCreateCallback *> &Out;
+ std::vector<MatcherDesc *> &Out;
};
-/// \brief MatcherCreateCallback that wraps multiple "overloads" of the same
+/// \brief MatcherDesc that wraps multiple "overloads" of the same
/// matcher.
///
/// It will try every overload and generate appropriate errors for when none or
/// more than one overloads match the arguments.
-class OverloadedMatcherCreateCallback : public MatcherCreateCallback {
+class OverloadedMatcherDesc : public MatcherDesc {
public:
- OverloadedMatcherCreateCallback(ArrayRef<MatcherCreateCallback *> Callbacks)
+ OverloadedMatcherDesc(ArrayRef<MatcherDesc *> Callbacks)
: Overloads(Callbacks) {}
- virtual ~OverloadedMatcherCreateCallback() {
- llvm::DeleteContainerPointers(Overloads);
- }
+ virtual ~OverloadedMatcherDesc() { llvm::DeleteContainerPointers(Overloads); }
- virtual VariantMatcher run(const SourceRange &NameRange,
- ArrayRef<ParserValue> Args,
- Diagnostics *Error) const {
+ virtual VariantMatcher create(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);
+ VariantMatcher SubMatcher = Overloads[i]->create(NameRange, Args, Error);
if (!SubMatcher.isNull()) {
Constructed.push_back(SubMatcher);
}
@@ -339,20 +337,20 @@
return Constructed[0];
}
-private:
- std::vector<MatcherCreateCallback *> Overloads;
+ private:
+ std::vector<MatcherDesc *> Overloads;
};
/// \brief Variadic operator marshaller function.
-class VariadicOperatorMatcherCreateCallback : public MatcherCreateCallback {
+class VariadicOperatorMatcherDesc : public MatcherDesc {
public:
typedef ast_matchers::internal::VariadicOperatorFunction VarFunc;
- VariadicOperatorMatcherCreateCallback(VarFunc Func, StringRef MatcherName)
+ VariadicOperatorMatcherDesc(VarFunc Func, StringRef MatcherName)
: Func(Func), MatcherName(MatcherName) {}
- virtual VariantMatcher run(const SourceRange &NameRange,
- ArrayRef<ParserValue> Args,
- Diagnostics *Error) const {
+ virtual VariantMatcher create(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];
@@ -378,71 +376,69 @@
/// \brief 0-arg overload
template <typename ReturnType>
-MatcherCreateCallback *makeMatcherAutoMarshall(ReturnType (*Func)(),
- StringRef MatcherName) {
- return new FixedArgCountMatcherCreateCallback(
- matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
- MatcherName);
+MatcherDesc *makeMatcherAutoMarshall(ReturnType (*Func)(),
+ StringRef MatcherName) {
+ return new FixedArgCountMatcherDesc(matcherMarshall0<ReturnType>,
+ reinterpret_cast<void (*)()>(Func),
+ MatcherName);
}
/// \brief 1-arg overload
template <typename ReturnType, typename ArgType1>
-MatcherCreateCallback *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1),
- StringRef MatcherName) {
- return new FixedArgCountMatcherCreateCallback(
- matcherMarshall1<ReturnType, ArgType1>,
- reinterpret_cast<void (*)()>(Func), MatcherName);
+MatcherDesc *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1),
+ StringRef MatcherName) {
+ return new FixedArgCountMatcherDesc(matcherMarshall1<ReturnType, ArgType1>,
+ reinterpret_cast<void (*)()>(Func),
+ MatcherName);
}
/// \brief 2-arg overload
template <typename ReturnType, typename ArgType1, typename ArgType2>
-MatcherCreateCallback *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1,
- ArgType2),
- StringRef MatcherName) {
- return new FixedArgCountMatcherCreateCallback(
+MatcherDesc *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
+ StringRef MatcherName) {
+ return new FixedArgCountMatcherDesc(
matcherMarshall2<ReturnType, ArgType1, ArgType2>,
reinterpret_cast<void (*)()>(Func), MatcherName);
}
/// \brief Variadic overload.
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);
+MatcherDesc *makeMatcherAutoMarshall(
+ llvm::VariadicFunction<ResultT, ArgT, Func> VarFunc,
+ StringRef MatcherName) {
+ return new FreeFuncMatcherDesc(&variadicMatcherDesc<ResultT, ArgT, Func>,
+ MatcherName);
}
/// \brief Argument adaptative overload.
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;
+MatcherDesc *makeMatcherAutoMarshall(
+ ast_matchers::internal::ArgumentAdaptingMatcherFunc<ArgumentAdapterT,
+ FromTypes, ToTypes>,
+ StringRef MatcherName) {
+ std::vector<MatcherDesc *> Overloads;
AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>(MatcherName,
Overloads);
- return new OverloadedMatcherCreateCallback(Overloads);
+ return new OverloadedMatcherDesc(Overloads);
}
template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
typename FromTypes, typename ToTypes>
template <typename FromTypeList>
-inline void
-AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>::collect(
- FromTypeList) {
+inline void AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes,
+ ToTypes>::collect(FromTypeList) {
Out.push_back(makeMatcherAutoMarshall(
&AdaptativeFunc::template create<typename FromTypeList::head>, Name));
collect(typename FromTypeList::tail());
}
/// \brief Variadic operator overload.
-MatcherCreateCallback *makeMatcherAutoMarshall(
+MatcherDesc *makeMatcherAutoMarshall(
ast_matchers::internal::VariadicOperatorMatcherFunc Func,
StringRef MatcherName) {
- return new VariadicOperatorMatcherCreateCallback(Func.Func, MatcherName);
+ return new VariadicOperatorMatcherDesc(Func.Func, MatcherName);
}
} // namespace internal
Index: lib/ASTMatchers/Dynamic/Registry.cpp
===================================================================
--- lib/ASTMatchers/Dynamic/Registry.cpp
+++ lib/ASTMatchers/Dynamic/Registry.cpp
@@ -27,23 +27,23 @@
namespace dynamic {
namespace {
-using internal::MatcherCreateCallback;
+using internal::MatcherDesc;
-typedef llvm::StringMap<const MatcherCreateCallback *> ConstructorMap;
+typedef llvm::StringMap<const MatcherDesc *> ConstructorMap;
class RegistryMaps {
public:
RegistryMaps();
~RegistryMaps();
const ConstructorMap &constructors() const { return Constructors; }
-private:
- void registerMatcher(StringRef MatcherName, MatcherCreateCallback *Callback);
+ private:
+ void registerMatcher(StringRef MatcherName, MatcherDesc *Callback);
ConstructorMap Constructors;
};
void RegistryMaps::registerMatcher(StringRef MatcherName,
- MatcherCreateCallback *Callback) {
+ MatcherDesc *Callback) {
assert(Constructors.find(MatcherName) == Constructors.end());
Constructors[MatcherName] = Callback;
}
@@ -56,16 +56,14 @@
static_cast< ::clang::ast_matchers::name##_Type##Id>( \
::clang::ast_matchers::name)
-#define REGISTER_OVERLOADED_2(name) \
- do { \
- MatcherCreateCallback *Callbacks[] = { \
- internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \
- #name), \
- internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \
- #name) \
- }; \
- registerMatcher(#name, \
- new internal::OverloadedMatcherCreateCallback(Callbacks)); \
+#define REGISTER_OVERLOADED_2(name) \
+ do { \
+ MatcherDesc *Callbacks[] = { \
+ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \
+ #name), \
+ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \
+ #name)}; \
+ registerMatcher(#name, new internal::OverloadedMatcherDesc(Callbacks)); \
} while (0)
/// \brief Generate a registry map with all the known matchers.
@@ -324,7 +322,7 @@
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
- return Ctor->run(NameRange, Args, Error);
+ return Ctor->create(NameRange, Args, Error);
}
// static
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
