Add an argumentsAre matcher

[fowles]

Summary

Add an argumentsAre matcher

[klimek]

+benjamin

[aaron.ballman]

You should also regenerate the HTML matcher documentation as part of this patch.

include/clang/ASTMatchers/ASTMatchers.h

3075

This is a neat matcher, but I'm not certain it will work with the dynamic matchers, which is an unfortunate divergence for clang-query.

Another concern is that this is leaking implementation details into ASTMatchers.h rather than keeping them in ASTMatchersInternal.h.

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

383

How does this matcher work in the presence of default arguments? e.g.,

void f(int a, int b = 12);
f(1);

Will callExpr(argumentsAre(integerLiteral())) match?

A similar question applies for variadic functions and functions without a prototype (from C).

I suspect it all works fine, but some test cases would be nice.

[aaron.ballman]

Given that this can't be expressed as a dynamic matcher, I'm wondering what the use case is for the matcher. Do you have a specific need for this functionality, or do you see this being generally useful?

[fowles]

@jdennett wanted this matcher for something he is working on and I had some free cycles to write it up. Unfortunately, I am about to leave on an extended vacation, so I will not be able to follow up with this patch for 2 months at the earliest.

I suspect the best solution is for someone to take over this patch and work with James to clarify any corner cases.

include/clang/ASTMatchers/ASTMatchers.h

AST_POLYMORPHIC_MATCHER_P2(hasArgument,
                                                            CXXConstructExpr,
                                                            ObjCMessageExpr),
                            unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
   return (N < Node.getNumArgs() &&
           InnerMatcher.matches(
               *Node.getArg(N)->IgnoreParenImpCasts(), Finder, Builder));
 }
 
+namespace internal {
+inline auto argumentsAreImpl(int n) -> decltype(argumentCountIs(n)) {
+  return argumentCountIs(n);
+}
+
+template <typename First, typename... Rest>
+auto argumentsAreImpl(int n, First &&first, Rest &&... rest)
+    -> decltype(allOf(hasArgument(n, std::forward<First>(first)),
+                      argumentsAreImpl(n + 1, std::forward<Rest>(rest)...))) {
+  return allOf(hasArgument(n, std::forward<First>(first)),
+               argumentsAreImpl(n + 1, std::forward<Rest>(rest)...));
+}
+} // end namespace internal
+
+/// \brief Matches all the arguments of a call expression or a constructor
+/// call expression.
+///
+/// Example matches the call to f2, but not f1 or f3.
+///     (matcher = callExpr(argumentsAre(declRefExpr(), declRefExpr())))
+/// \code
+///   void x(int a, int b, int c) { f1(a); f2(a, b); f3(a, b, c); }
+/// \endcode
+template <typename... T>
+auto argumentsAre(T &&... t)
+    -> decltype(internal::argumentsAreImpl(0, std::forward<T>(t)...)) {
+  return internal::argumentsAreImpl(0, std::forward<T>(t)...);
+}
+
 /// \brief Matches declaration statements that contain a specific number of
 /// declarations.
 ///
 /// Example: Given
 /// \code
 ///   int a, b;
 ///   int c;
 ///   int d = 2, e;

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(
     matches("class X { void x(int) { int y; x(y); } };", CallArgumentY));
   EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
 
   StatementMatcher WrongIndex = callExpr(
     hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
   EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
 }
 
+TEST(Matcher, ArgumentsAre) {
+  StatementMatcher Call = callExpr(argumentsAre(declRefExpr(), declRefExpr()));
+
+  EXPECT_TRUE(notMatches("void f(int x) { f(x); }", Call));
+  EXPECT_TRUE(matches("void f(int x, int y) { f(x, y); }", Call));
+  EXPECT_TRUE(notMatches("void f(int x, int y, int z) { f(x, y, z); }", Call));
+}
+
 TEST(Matcher, AnyArgument) {
   StatementMatcher CallArgumentY = callExpr(
     hasAnyArgument(
       ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("y")))))));
   EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
   EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
   EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));