Add an argumentsAre matcher

[fowles]

Summary

Add an argumentsAreMatcher

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));