maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Introduce Registry::getCompletions. 

This returns a list of valid (and useful) completions for a context (a list
of outer matchers), ordered by decreasing relevance then alphabetically. It
will be used by the matcher parser to implement completion.

Differential Revision: http://llvm-reviews.chandlerc.com/D2210

llvm-svn: 199950
This commit is contained in:
Peter Collingbourne 2014-01-23 22:48:38 +00:00
parent 8a7117d4c8
commit d32e28c87a
5 changed files with 665 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
clang/include/clang/AST/ASTTypeTraits.h
View File

@ -64,6 +64,11 @@ public:
/// \brief String representation of the kind.
StringRef asStringRef() const;
/// \brief Strict weak ordering for ASTNodeKind.
bool operator<(const ASTNodeKind &Other) const {
return KindId < Other.KindId;
}
private:
/// \brief Kind ids.
///
@ -137,6 +142,11 @@ KIND_TO_KIND_ID(Type)
#include "clang/AST/TypeNodes.def"
#undef KIND_TO_KIND_ID
inline raw_ostream &operator<<(raw_ostream &OS, ASTNodeKind K) {
OS << K.asStringRef();
return OS;
}
/// \brief A dynamically typed AST node container.
///
/// Stores an AST node in a type safe way. This allows writing code that

39
clang/include/clang/ASTMatchers/Dynamic/Registry.h
View File

@ -34,6 +34,22 @@ class MatcherDescriptor;
typedef const internal::MatcherDescriptor *MatcherCtor;
struct MatcherCompletion {
MatcherCompletion() {}
MatcherCompletion(StringRef TypedText, StringRef MatcherDecl)
: TypedText(TypedText), MatcherDecl(MatcherDecl) {}
/// \brief The text to type to select this matcher.
std::string TypedText;
/// \brief The "declaration" of the matcher, with type information.
std::string MatcherDecl;
bool operator==(const MatcherCompletion &Other) const {
return TypedText == Other.TypedText && MatcherDecl == Other.MatcherDecl;
}
};
class Registry {
public:
/// \brief Look up a matcher in the registry by name,
@ -45,6 +61,29 @@ public:
lookupMatcherCtor(StringRef MatcherName, const SourceRange &NameRange,
Diagnostics *Error);
/// \brief Compute the list of completions for \p Context.
///
/// Each element of \p Context represents a matcher invocation, going from
/// outermost to innermost. Elements are pairs consisting of a reference to the
/// matcher constructor and the index of the next element in the argument list
/// of that matcher (or for the last element, the index of the completion
/// point in the argument list). An empty list requests completion for the
/// root matcher.
///
/// The completions are ordered first by decreasing relevance, then
/// alphabetically. Relevance is determined by how closely the matcher's
/// type matches that of the context. For example, if the innermost matcher
/// takes a FunctionDecl matcher, the FunctionDecl matchers are returned
/// first, followed by the ValueDecl matchers, then NamedDecl, then Decl, then
/// polymorphic matchers.
///
/// Matchers which are technically convertible to the innermost context but
/// which would match either all or no nodes are excluded. For example,
/// namedDecl and varDecl are excluded in a FunctionDecl context, because
/// those matchers would match respectively all or no nodes in such a context.
static std::vector<MatcherCompletion>
getCompletions(llvm::ArrayRef<std::pair<MatcherCtor, unsigned> > Context);
/// \brief Construct a matcher from the registry.
///
/// \param Ctor The matcher constructor to instantiate.

484
clang/lib/ASTMatchers/Dynamic/Marshallers.h
View File

@ -34,6 +34,45 @@ namespace dynamic {
namespace internal {
struct ArgKind {
enum Kind {
AK_Matcher,
AK_Unsigned,
AK_String
};
ArgKind(Kind K)
: K(K) {}
ArgKind(ast_type_traits::ASTNodeKind MatcherKind)
: K(AK_Matcher), MatcherKind(MatcherKind) {}
std::string asString() const {
switch (getArgKind()) {
case AK_Matcher:
return (Twine("Matcher<") + MatcherKind.asStringRef() + ">").str();
case AK_Unsigned:
return "unsigned";
case AK_String:
return "string";
}
}
Kind getArgKind() const { return K; }
ast_type_traits::ASTNodeKind getMatcherKind() const {
assert(K == AK_Matcher);
return MatcherKind;
}
bool operator<(const ArgKind &Other) const {
if (K == AK_Matcher && Other.K == AK_Matcher)
return MatcherKind < Other.MatcherKind;
return K < Other.K;
}
private:
Kind K;
ast_type_traits::ASTNodeKind MatcherKind;
};
/// \brief Helper template class to just from argument type to the right is/get
/// functions in VariantValue.
/// Used to verify and extract the matcher arguments below.
@ -42,11 +81,13 @@ 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();
}
static ArgKind getKind() {
return ArgKind(ArgKind::AK_String);
}
};
template <>
@ -54,39 +95,88 @@ 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>();
}
static ArgKind getKind() {
return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<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();
}
static ArgKind getKind() {
return ArgKind(ArgKind::AK_Unsigned);
}
};
/// \brief Matcher descriptor interface.
///
/// Provides a \c create() method that constructs the matcher from the provided
/// arguments.
/// arguments, and various other methods for type introspection.
class MatcherDescriptor {
public:
virtual ~MatcherDescriptor() {}
virtual VariantMatcher create(const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error) const = 0;
/// Returns whether the matcher is variadic. Variadic matchers can take any
/// number of arguments, but they must be of the same type.
virtual bool isVariadic() const = 0;
/// Returns the number of arguments accepted by the matcher if not variadic.
virtual unsigned getNumArgs() const = 0;
/// Given that the matcher is being converted to type \p ThisKind, append the
/// set of argument types accepted for argument \p ArgNo to \p ArgKinds.
// FIXME: We should provide the ability to constrain the output of this
// function based on the types of other matcher arguments.
virtual void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &ArgKinds) const = 0;
/// Returns whether this matcher is convertible to the given type. If it is
/// so convertible, store in *Specificity a value corresponding to the
/// "specificity" of the converted matcher to the given context, and in
/// *LeastDerivedKind the least derived matcher kind which would result in the
/// same matcher overload. Zero specificity indicates that this conversion
/// would produce a trivial matcher that will either always or never match.
/// Such matchers are excluded from code completion results.
virtual bool isConvertibleTo(
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity = 0,
ast_type_traits::ASTNodeKind *LeastDerivedKind = 0) const = 0;
/// Returns whether the matcher will, given a matcher of any type T, yield a
/// matcher of type T.
virtual bool isPolymorphic() const { return false; }
};
inline bool isRetKindConvertibleTo(
llvm::ArrayRef<ast_type_traits::ASTNodeKind> RetKinds,
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) {
for (llvm::ArrayRef<ast_type_traits::ASTNodeKind>::const_iterator
i = RetKinds.begin(),
e = RetKinds.end();
i != e; ++i) {
unsigned Distance;
if (i->isBaseOf(Kind, &Distance)) {
if (Specificity)
*Specificity = 100 - Distance;
if (LeastDerivedKind)
*LeastDerivedKind = *i;
return true;
}
}
return false;
}
/// \brief Simple callback implementation. Marshaller and function are provided.
///
/// This class wraps a function of arbitrary signature and a marshaller
@ -104,64 +194,42 @@ public:
/// \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.
FixedArgCountMatcherDescriptor(MarshallerType Marshaller, void (*Func)(),
StringRef MatcherName)
: Marshaller(Marshaller), Func(Func), MatcherName(MatcherName) {}
/// \param RetKinds The list of matcher types to which the matcher is
/// convertible.
/// \param ArgKinds The types of the arguments this matcher takes.
FixedArgCountMatcherDescriptor(
MarshallerType Marshaller, void (*Func)(), StringRef MatcherName,
llvm::ArrayRef<ast_type_traits::ASTNodeKind> RetKinds,
llvm::ArrayRef<ArgKind> ArgKinds)
: Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
RetKinds(RetKinds.begin(), RetKinds.end()),
ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
VariantMatcher create(const SourceRange &NameRange,
ArrayRef<ParserValue> Args, Diagnostics *Error) const {
return Marshaller(Func, MatcherName, NameRange, Args, Error);
}
bool isVariadic() const { return false; }
unsigned getNumArgs() const { return ArgKinds.size(); }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const {
Kinds.push_back(ArgKinds[ArgNo]);
}
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
LeastDerivedKind);
}
private:
const MarshallerType Marshaller;
void (* const Func)();
const std::string MatcherName;
const std::vector<ast_type_traits::ASTNodeKind> RetKinds;
const std::vector<ArgKind> ArgKinds;
};
/// \brief Simple callback implementation. Free function is wrapped.
///
/// This class simply wraps a free function with the right signature to export
/// it as a MatcherDescriptor.
/// 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 FreeFuncMatcherDescriptor : public MatcherDescriptor {
public:
typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error);
FreeFuncMatcherDescriptor(RunFunc Func, StringRef MatcherName)
: Func(Func), MatcherName(MatcherName.str()) {}
VariantMatcher create(const SourceRange &NameRange,
ArrayRef<ParserValue> Args, Diagnostics *Error) const {
return Func(MatcherName, NameRange, Args, Error);
}
private:
const RunFunc Func;
const std::string MatcherName;
};
/// \brief Helper macros to check the arguments on all marshaller functions.
#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(); \
}
/// \brief Helper methods to extract and merge all possible typed matchers
/// out of the polymorphic object.
template <class PolyMatcher>
@ -196,6 +264,174 @@ static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
return Out;
}
template <typename T>
inline void buildReturnTypeVectorFromTypeList(
std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
RetTypes.push_back(
ast_type_traits::ASTNodeKind::getFromNodeKind<typename T::head>());
buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
}
template <>
inline void
buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {}
template <typename T>
struct BuildReturnTypeVector {
static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
}
};
template <typename T>
struct BuildReturnTypeVector<ast_matchers::internal::Matcher<T> > {
static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
}
};
template <typename T>
struct BuildReturnTypeVector<ast_matchers::internal::BindableMatcher<T> > {
static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
}
};
/// \brief Variadic marshaller function.
template <typename ResultT, typename ArgT,
ResultT (*Func)(ArrayRef<const ArgT *>)>
VariantMatcher
variadicMatcherDescriptor(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::getKind().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;
}
/// \brief Matcher descriptor for variadic functions.
///
/// This class simply wraps a VariadicFunction with the right signature to export
/// it as a MatcherDescriptor.
/// 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 VariadicFuncMatcherDescriptor : public MatcherDescriptor {
public:
typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
const SourceRange &NameRange,
ArrayRef<ParserValue> Args,
Diagnostics *Error);
template <typename ResultT, typename ArgT,
ResultT (*F)(ArrayRef<const ArgT *>)>
VariadicFuncMatcherDescriptor(llvm::VariadicFunction<ResultT, ArgT, F> Func,
StringRef MatcherName)
: Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
MatcherName(MatcherName.str()),
ArgsKind(ArgTypeTraits<ArgT>::getKind()) {
BuildReturnTypeVector<ResultT>::build(RetKinds);
}
VariantMatcher create(const SourceRange &NameRange,
ArrayRef<ParserValue> Args, Diagnostics *Error) const {
return Func(MatcherName, NameRange, Args, Error);
}
bool isVariadic() const { return true; }
unsigned getNumArgs() const { return 0; }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const {
Kinds.push_back(ArgsKind);
}
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
LeastDerivedKind);
}
private:
const RunFunc Func;
const std::string MatcherName;
std::vector<ast_type_traits::ASTNodeKind> RetKinds;
const ArgKind ArgsKind;
};
/// \brief Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers.
class DynCastAllOfMatcherDescriptor : public VariadicFuncMatcherDescriptor {
public:
template <typename BaseT, typename DerivedT>
DynCastAllOfMatcherDescriptor(
ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
StringRef MatcherName)
: VariadicFuncMatcherDescriptor(Func, MatcherName),
DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
}
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) const
LLVM_OVERRIDE {
// If Kind is not a base of DerivedKind, either DerivedKind is a base of
// Kind (in which case the match will always succeed) or Kind and
// DerivedKind are unrelated (in which case it will always fail), so set
// Specificity to 0.
if (VariadicFuncMatcherDescriptor::isConvertibleTo(Kind, Specificity,
LeastDerivedKind)) {
if (Kind.isSame(DerivedKind) || !Kind.isBaseOf(DerivedKind)) {
if (Specificity)
*Specificity = 0;
}
return true;
} else {
return false;
}
}
private:
const ast_type_traits::ASTNodeKind DerivedKind;
};
/// \brief Helper macros to check the arguments on all marshaller functions.
#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>::getKind().asString() \
<< Args[index].Value.getTypeAsString(); \
return VariantMatcher(); \
}
/// \brief 0-arg marshaller function.
template <typename ReturnType>
static VariantMatcher matcherMarshall0(void (*Func)(), StringRef MatcherName,
@ -238,41 +474,6 @@ static VariantMatcher matcherMarshall2(void (*Func)(), StringRef MatcherName,
#undef CHECK_ARG_COUNT
#undef CHECK_ARG_TYPE
/// \brief Variadic marshaller function.
template <typename ResultT, typename ArgT,
ResultT (*Func)(ArrayRef<const ArgT *>)>
VariantMatcher
variadicMatcherDescriptor(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;
}
/// \brief Helper class used to collect all the possible overloads of an
/// argument adaptative matcher function.
template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
@ -338,6 +539,51 @@ public:
return Constructed[0];
}
bool isVariadic() const {
bool Overload0Variadic = Overloads[0]->isVariadic();
#ifndef NDEBUG
for (std::vector<MatcherDesc *>::const_iterator I = Overloads.begin(),
E = Overloads.end();
I != E; ++I) {
assert(Overload0Variadic == (*I)->isVariadic());
}
#endif
return Overload0Variadic;
}
unsigned getNumArgs() const {
unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
#ifndef NDEBUG
for (std::vector<MatcherDesc *>::const_iterator I = Overloads.begin(),
E = Overloads.end();
I != E; ++I) {
assert(Overload0NumArgs == (*I)->getNumArgs());
}
#endif
return Overload0NumArgs;
}
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const {
for (std::vector<MatcherDescriptor *>::const_iterator I = Overloads.begin(),
E = Overloads.end();
I != E; ++I) {
if ((*I)->isConvertibleTo(ThisKind))
(*I)->getArgKinds(ThisKind, ArgNo, Kinds);
}
}
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
for (std::vector<MatcherDescriptor *>::const_iterator I = Overloads.begin(),
E = Overloads.end();
I != E; ++I) {
if ((*I)->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
return true;
}
return false;
}
private:
std::vector<MatcherDescriptor *> Overloads;
};
@ -376,6 +622,22 @@ public:
return VariantMatcher::VariadicOperatorMatcher(Func, InnerArgs);
}
bool isVariadic() const { return true; }
unsigned getNumArgs() const { return 0; }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const {
Kinds.push_back(ThisKind);
}
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
if (Specificity)
*Specificity = 1;
if (LeastDerivedKind)
*LeastDerivedKind = Kind;
return true;
}
bool isPolymorphic() const LLVM_OVERRIDE { return true; }
private:
const unsigned MinCount;
const unsigned MaxCount;
@ -383,36 +645,43 @@ private:
const StringRef MatcherName;
};
/// Helper functions to select the appropriate marshaller functions.
/// They detect the number of arguments, arguments types and return type.
/// \brief 0-arg overload
template <typename ReturnType>
MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(),
StringRef MatcherName) {
return new FixedArgCountMatcherDescriptor(matcherMarshall0<ReturnType>,
reinterpret_cast<void (*)()>(Func),
MatcherName);
StringRef MatcherName) {
std::vector<ast_type_traits::ASTNodeKind> RetTypes;
BuildReturnTypeVector<ReturnType>::build(RetTypes);
return new FixedArgCountMatcherDescriptor(
matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
MatcherName, RetTypes, llvm::ArrayRef<ArgKind>());
}
/// \brief 1-arg overload
template <typename ReturnType, typename ArgType1>
MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1),
StringRef MatcherName) {
StringRef MatcherName) {
std::vector<ast_type_traits::ASTNodeKind> RetTypes;
BuildReturnTypeVector<ReturnType>::build(RetTypes);
ArgKind AK = ArgTypeTraits<ArgType1>::getKind();
return new FixedArgCountMatcherDescriptor(
matcherMarshall1<ReturnType, ArgType1>,
reinterpret_cast<void (*)()>(Func), MatcherName);
reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AK);
}
/// \brief 2-arg overload
template <typename ReturnType, typename ArgType1, typename ArgType2>
MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1,
ArgType2),
StringRef MatcherName) {
MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
StringRef MatcherName) {
std::vector<ast_type_traits::ASTNodeKind> RetTypes;
BuildReturnTypeVector<ReturnType>::build(RetTypes);
ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(),
ArgTypeTraits<ArgType2>::getKind() };
return new FixedArgCountMatcherDescriptor(
matcherMarshall2<ReturnType, ArgType1, ArgType2>,
reinterpret_cast<void (*)()>(Func), MatcherName);
reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AKs);
}
/// \brief Variadic overload.
@ -421,8 +690,19 @@ template <typename ResultT, typename ArgT,
MatcherDescriptor *
makeMatcherAutoMarshall(llvm::VariadicFunction<ResultT, ArgT, Func> VarFunc,
StringRef MatcherName) {
return new FreeFuncMatcherDescriptor(
&variadicMatcherDescriptor<ResultT, ArgT, Func>, MatcherName);
return new VariadicFuncMatcherDescriptor(VarFunc, MatcherName);
}
/// \brief Overload for VariadicDynCastAllOfMatchers.
///
/// Not strictly necessary, but DynCastAllOfMatcherDescriptor gives us better
/// completion results for that type of matcher.
template <typename BaseT, typename DerivedT>
MatcherDescriptor *
makeMatcherAutoMarshall(ast_matchers::internal::VariadicDynCastAllOfMatcher<
BaseT, DerivedT> VarFunc,
StringRef MatcherName) {
return new DynCastAllOfMatcherDescriptor(VarFunc, MatcherName);
}
/// \brief Argument adaptative overload.

149
clang/lib/ASTMatchers/Dynamic/Registry.cpp
View File

@ -18,8 +18,11 @@
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ManagedStatic.h"
#include <set>
#include <utility>
using namespace clang::ast_type_traits;
namespace clang {
namespace ast_matchers {
namespace dynamic {
@ -332,6 +335,152 @@ Registry::lookupMatcherCtor(StringRef MatcherName, const SourceRange &NameRange,
return it->second;
}
namespace {
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const std::set<ASTNodeKind> &KS) {
unsigned Count = 0;
for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();
I != E; ++I) {
if (I != KS.begin())
OS << "|";
if (Count++ == 3) {
OS << "...";
break;
}
OS << *I;
}
return OS;
}
struct ReverseSpecificityThenName {
bool operator()(const std::pair<unsigned, std::string> &A,
const std::pair<unsigned, std::string> &B) const {
return A.first > B.first || (A.first == B.first && A.second < B.second);
}
};
}
std::vector<MatcherCompletion> Registry::getCompletions(
llvm::ArrayRef<std::pair<MatcherCtor, unsigned> > Context) {
ASTNodeKind InitialTypes[] = {
ASTNodeKind::getFromNodeKind<Decl>(),
ASTNodeKind::getFromNodeKind<QualType>(),
ASTNodeKind::getFromNodeKind<Type>(),
ASTNodeKind::getFromNodeKind<Stmt>(),
ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),
ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),
ASTNodeKind::getFromNodeKind<TypeLoc>()
};
llvm::ArrayRef<ASTNodeKind> InitialTypesRef(InitialTypes);
// Starting with the above seed of acceptable top-level matcher types, compute
// the acceptable type set for the argument indicated by each context element.
std::set<ASTNodeKind> TypeSet(InitialTypesRef.begin(), InitialTypesRef.end());
for (llvm::ArrayRef<std::pair<MatcherCtor, unsigned> >::iterator
CtxI = Context.begin(),
CtxE = Context.end();
CtxI != CtxE; ++CtxI) {
std::vector<internal::ArgKind> NextTypeSet;
for (std::set<ASTNodeKind>::iterator I = TypeSet.begin(), E = TypeSet.end();
I != E; ++I) {
if (CtxI->first->isConvertibleTo(*I) &&
(CtxI->first->isVariadic() ||
CtxI->second < CtxI->first->getNumArgs()))
CtxI->first->getArgKinds(*I, CtxI->second, NextTypeSet);
}
TypeSet.clear();
for (std::vector<internal::ArgKind>::iterator I = NextTypeSet.begin(),
E = NextTypeSet.end();
I != E; ++I) {
if (I->getArgKind() == internal::ArgKind::AK_Matcher)
TypeSet.insert(I->getMatcherKind());
}
}
typedef std::map<std::pair<unsigned, std::string>, MatcherCompletion,
ReverseSpecificityThenName> CompletionsTy;
CompletionsTy Completions;
// TypeSet now contains the list of acceptable types for the argument we are
// completing. Search the registry for acceptable matchers.
for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(),
E = RegistryData->constructors().end();
I != E; ++I) {
std::set<ASTNodeKind> RetKinds;
unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs();
bool IsPolymorphic = I->second->isPolymorphic();
std::vector<std::vector<internal::ArgKind> > ArgsKinds(NumArgs);
unsigned MaxSpecificity = 0;
for (std::set<ASTNodeKind>::iterator TI = TypeSet.begin(),
TE = TypeSet.end();
TI != TE; ++TI) {
unsigned Specificity;
ASTNodeKind LeastDerivedKind;
if (I->second->isConvertibleTo(*TI, &Specificity, &LeastDerivedKind)) {
if (MaxSpecificity < Specificity)
MaxSpecificity = Specificity;
RetKinds.insert(LeastDerivedKind);
for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
I->second->getArgKinds(*TI, Arg, ArgsKinds[Arg]);
if (IsPolymorphic)
break;
}
}
if (!RetKinds.empty() && MaxSpecificity > 0) {
std::string Decl;
llvm::raw_string_ostream OS(Decl);
if (IsPolymorphic) {
OS << "Matcher<T> " << I->first() << "(Matcher<T>";
} else {
OS << "Matcher<" << RetKinds << "> " << I->first() << "(";
for (std::vector<std::vector<internal::ArgKind> >::iterator
KI = ArgsKinds.begin(),
KE = ArgsKinds.end();
KI != KE; ++KI) {
if (KI != ArgsKinds.begin())
OS << ", ";
// This currently assumes that a matcher may not overload a
// non-matcher, and all non-matcher overloads have identical
// arguments.
if ((*KI)[0].getArgKind() == internal::ArgKind::AK_Matcher) {
std::set<ASTNodeKind> MatcherKinds;
std::transform(
KI->begin(), KI->end(),
std::inserter(MatcherKinds, MatcherKinds.end()),
std::mem_fun_ref(&internal::ArgKind::getMatcherKind));
OS << "Matcher<" << MatcherKinds << ">";
} else {
OS << (*KI)[0].asString();
}
}
}
if (I->second->isVariadic())
OS << "...";
OS << ")";
std::string TypedText = I->first();
TypedText += "(";
if (ArgsKinds.empty())
TypedText += ")";
else if (ArgsKinds[0][0].getArgKind() == internal::ArgKind::AK_String)
TypedText += "\"";
Completions[std::make_pair(MaxSpecificity, I->first())] =
MatcherCompletion(TypedText, OS.str());
}
}
std::vector<MatcherCompletion> RetVal;
for (CompletionsTy::iterator I = Completions.begin(), E = Completions.end();
I != E; ++I)
RetVal.push_back(I->second);
return RetVal;
}
// static
VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,
const SourceRange &NameRange,

85
clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
View File

@ -84,6 +84,50 @@ public:
EXPECT_EQ("", DummyError.toStringFull());
return Out;
}
typedef std::vector<MatcherCompletion> CompVector;
CompVector getCompletions() {
return Registry::getCompletions(
llvm::ArrayRef<std::pair<MatcherCtor, unsigned> >());
}
CompVector getCompletions(StringRef MatcherName1, unsigned ArgNo1) {
std::vector<std::pair<MatcherCtor, unsigned> > Context;
llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName1);
if (!Ctor)
return CompVector();
Context.push_back(std::make_pair(*Ctor, ArgNo1));
return Registry::getCompletions(Context);
}
CompVector getCompletions(StringRef MatcherName1, unsigned ArgNo1,
StringRef MatcherName2, unsigned ArgNo2) {
std::vector<std::pair<MatcherCtor, unsigned> > Context;
llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName1);
if (!Ctor)
return CompVector();
Context.push_back(std::make_pair(*Ctor, ArgNo1));
Ctor = lookupMatcherCtor(MatcherName2);
if (!Ctor)
return CompVector();
Context.push_back(std::make_pair(*Ctor, ArgNo2));
return Registry::getCompletions(Context);
}
bool hasCompletion(const CompVector &Comps, StringRef TypedText,
StringRef MatcherDecl = StringRef(), unsigned *Index = 0) {
for (CompVector::const_iterator I = Comps.begin(), E = Comps.end(); I != E;
++I) {
if (I->TypedText == TypedText &&
(MatcherDecl.empty() || I->MatcherDecl == MatcherDecl)) {
if (Index)
*Index = I - Comps.begin();
return true;
}
}
return false;
}
};
TEST_F(RegistryTest, CanConstructNoArgs) {
@ -378,6 +422,47 @@ TEST_F(RegistryTest, Errors) {
Error->toString());
}
TEST_F(RegistryTest, Completion) {
CompVector Comps = getCompletions();
EXPECT_TRUE(hasCompletion(
Comps, "hasParent(", "Matcher<Decl|Stmt> hasParent(Matcher<Decl|Stmt>)"));
EXPECT_TRUE(hasCompletion(Comps, "whileStmt(",
"Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)"));
CompVector WhileComps = getCompletions("whileStmt", 0);
unsigned HasBodyIndex, HasParentIndex, AllOfIndex;
EXPECT_TRUE(hasCompletion(WhileComps, "hasBody(",
"Matcher<WhileStmt> hasBody(Matcher<Stmt>)",
&HasBodyIndex));
EXPECT_TRUE(hasCompletion(WhileComps, "hasParent(",
"Matcher<Stmt> hasParent(Matcher<Decl|Stmt>)",
&HasParentIndex));
EXPECT_TRUE(hasCompletion(WhileComps, "allOf(",
"Matcher<T> allOf(Matcher<T>...)", &AllOfIndex));
EXPECT_GT(HasParentIndex, HasBodyIndex);
EXPECT_GT(AllOfIndex, HasParentIndex);
EXPECT_FALSE(hasCompletion(WhileComps, "whileStmt("));
EXPECT_FALSE(hasCompletion(WhileComps, "ifStmt("));
CompVector AllOfWhileComps =
getCompletions("allOf", 0, "whileStmt", 0);
ASSERT_EQ(AllOfWhileComps.size(), WhileComps.size());
EXPECT_TRUE(std::equal(WhileComps.begin(), WhileComps.end(),
AllOfWhileComps.begin()));
CompVector DeclWhileComps =
getCompletions("decl", 0, "whileStmt", 0);
EXPECT_EQ(0u, DeclWhileComps.size());
CompVector NamedDeclComps = getCompletions("namedDecl", 0);
EXPECT_TRUE(
hasCompletion(NamedDeclComps, "isPublic()", "Matcher<Decl> isPublic()"));
EXPECT_TRUE(hasCompletion(NamedDeclComps, "hasName(\"",
"Matcher<NamedDecl> hasName(string)"));
}
} // end anonymous namespace
} // end namespace dynamic
} // end namespace ast_matchers