| //===--- Registry.h - Matcher registry -----*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// \brief Registry of all known matchers. |
| /// |
| /// The registry provides a generic interface to construct any matcher by name. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_CLANG_AST_MATCHERS_DYNAMIC_REGISTRY_H |
| #define LLVM_CLANG_AST_MATCHERS_DYNAMIC_REGISTRY_H |
| |
| #include "clang/ASTMatchers/Dynamic/Diagnostics.h" |
| #include "clang/ASTMatchers/Dynamic/VariantValue.h" |
| #include "clang/Basic/LLVM.h" |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/Optional.h" |
| #include "llvm/ADT/StringRef.h" |
| |
| namespace clang { |
| namespace ast_matchers { |
| namespace dynamic { |
| |
| namespace internal { |
| 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, |
| /// |
| /// \return An opaque value which may be used to refer to the matcher |
| /// constructor, or Optional<MatcherCtor>() if not found. |
| static llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName); |
| |
| /// \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. |
| /// |
| /// \param NameRange The location of the name in the matcher source. |
| /// Useful for error reporting. |
| /// |
| /// \param Args The argument list for the matcher. The number and types of the |
| /// values must be valid for the matcher requested. Otherwise, the function |
| /// will return an error. |
| /// |
| /// \return The matcher object constructed if no error was found. |
| /// A null matcher if the number of arguments or argument types do not match |
| /// the signature. In that case \c Error will contain the description of |
| /// the error. |
| static VariantMatcher constructMatcher(MatcherCtor Ctor, |
| const SourceRange &NameRange, |
| ArrayRef<ParserValue> Args, |
| Diagnostics *Error); |
| |
| /// \brief Construct a matcher from the registry and bind it. |
| /// |
| /// Similar the \c constructMatcher() above, but it then tries to bind the |
| /// matcher to the specified \c BindID. |
| /// If the matcher is not bindable, it sets an error in \c Error and returns |
| /// a null matcher. |
| static VariantMatcher constructBoundMatcher(MatcherCtor Ctor, |
| const SourceRange &NameRange, |
| StringRef BindID, |
| ArrayRef<ParserValue> Args, |
| Diagnostics *Error); |
| |
| private: |
| Registry() LLVM_DELETED_FUNCTION; |
| }; |
| |
| } // namespace dynamic |
| } // namespace ast_matchers |
| } // namespace clang |
| |
| #endif // LLVM_CLANG_AST_MATCHERS_DYNAMIC_REGISTRY_H |