Add new API for returning matching matchers

[steveire]

Summary

The MatchingMatcher struct currently contains only a string, but it will
be expanded in the future.

[aaron.ballman]

lib/ASTMatchers/Dynamic/Registry.cpp

604–605

std::vector<ArgKind> AcceptedTypes{StaticType}; instead?

608–611

Elide the identifiers for arguments that are not named in the lambda.

unittests/ASTMatchers/Dynamic/RegistryTest.cpp

563

Move the const to the other side of the declaration.

564

std::find_if(C.begin(), C.end(), ...) -> llvm::find_if(C, ...)

[steveire]

Update

[aaron.ballman]

LGTM aside from a minor commenting nit.

include/clang/ASTMatchers/Dynamic/Registry.h

106

I think we typically go with \p instead of @p in our doc comments.

include/clang/ASTMatchers/Dynamic/Registry.h

struct MatcherCompletion {
   /// Value corresponding to the "specificity" of the converted matcher.
   ///
   /// 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.
   unsigned Specificity;
 };
 
+struct MatchingMatcher {
+  MatchingMatcher(std::string MatcherString)
+      : MatcherString(std::move(MatcherString)) {}
+  std::string MatcherString;
+};
+
 class Registry {
 public:
   Registry() = delete;
 
   /// 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.
public:
   ///
   /// \return All completions for the specified types.
   /// Completions should be valid when used in \c lookupMatcherCtor().
   /// The matcher constructed from the return of \c lookupMatcherCtor()
   /// should be convertible to some type in \p AcceptedTypes.
   static std::vector<MatcherCompletion>
   getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes);
 
+  /// Compute matchers which can be used within a matcher of
+  /// type @p StaticType.
+  static std::vector<MatchingMatcher>
+  getMatchingMatchers(ast_type_traits::ASTNodeKind StaticType);
+
   /// 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

lib/ASTMatchers/Dynamic/Registry.cpp

for (const auto &M : RegistryData->constructors()) {
     }
 
     if (!RetKinds.empty() && MaxSpecificity > 0) {
       std::forward<Callable>(Func)(Name, Matcher, RetKinds, ArgsKinds, MaxSpecificity);
     }
   }
 }
 
+std::vector<MatchingMatcher>
+Registry::getMatchingMatchers(ast_type_traits::ASTNodeKind StaticType) {
+  std::vector<MatchingMatcher> Result;
+
+  std::vector<ArgKind> AcceptedTypes{StaticType};
+
+  processAcceptableMatchers(
+      AcceptedTypes,
+      [&Result](StringRef Name, const MatcherDescriptor &,
+                std::set<ASTNodeKind> &, std::vector<std::vector<ArgKind>>,
+                unsigned) { Result.emplace_back((Name + "()").str()); });
+
+  return Result;
+}
+
 std::vector<MatcherCompletion>
 Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {
   std::vector<MatcherCompletion> Completions;
 
   processAcceptableMatchers(
       AcceptedTypes,
       [&Completions](StringRef Name, const MatcherDescriptor &Matcher,
                      std::set<ASTNodeKind> &RetKinds,

unittests/ASTMatchers/Dynamic/RegistryTest.cpp

Matcher<Stmt> CharStmt = constructMatcher(
       .getTypedMatcher<Stmt>();
   EXPECT_TRUE(matches("int x = 'x';", CharStmt));
   EXPECT_TRUE(matches("int x = L'x';", CharStmt));
   EXPECT_TRUE(matches("int x = u'x';", CharStmt));
   EXPECT_TRUE(matches("int x = U'x';", CharStmt));
   EXPECT_FALSE(matches("int x = 120;", CharStmt));
 }
 
+TEST_F(RegistryTest, MatchingMatchers) {
+
+  auto Matchers = Registry::getMatchingMatchers(
+      ast_type_traits::ASTNodeKind::getFromNodeKind<FunctionDecl>());
+
+  auto Contains = [](const std::vector<MatchingMatcher> &C, StringRef Name) {
+    return llvm::find_if(C, [Name](const MatchingMatcher &M) {
+             return M.MatcherString == Name;
+           }) != C.end();
+  };
+
+  EXPECT_TRUE(Contains(Matchers, "isPublic()"));
+  EXPECT_TRUE(Contains(Matchers, "hasName()"));
+  EXPECT_TRUE(Contains(Matchers, "hasType()"));
+  EXPECT_TRUE(Contains(Matchers, "hasTypeLoc()"));
+  EXPECT_TRUE(Contains(Matchers, "parameterCountIs()"));
+
+  EXPECT_TRUE(!Contains(Matchers, "decl()"));
+  EXPECT_TRUE(!Contains(Matchers, "namedDecl()"));
+  EXPECT_TRUE(!Contains(Matchers, "valueDecl()"));
+  EXPECT_TRUE(!Contains(Matchers, "declaratorDecl()"));
+  EXPECT_TRUE(!Contains(Matchers, "functionDecl()"));
+
+  EXPECT_TRUE(Contains(Matchers, "cxxMethodDecl()"));
+}
+
 } // end anonymous namespace
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang