[ASTMatchers] Make Param functors variadic

[steveire]

This was part of an early attempt to implement mapAnyOf. It's not needed, but it seems like a better idea to have one variadic class than multiple Param1/2 classes.

[steveire]

Update comments

[njames93]

This change is going to break the dump_ast_matchers script. So that will need updating to ensure everything is all correct.

[steveire]

Update dump script

[steveire]

Good catch! Updated the docs generating script.

[njames93]

Is it not nicer to name the class PolymorphicMatcher and do away with WithParamN, It may require partial specialization for the empty parameters case.
But I think it would be worth it.

[steveire]

Update

[steveire]

In D97156#2593209, @njames93 wrote:

Is it not nicer to name the class PolymorphicMatcher and do away with WithParamN, It may require partial specialization for the empty parameters case.
But I think it would be worth it.

I'm not sure any partial specialization is needed?

[njames93]

LGTM, assuming none of the later changes have effected the documentation script.

In D97156#2598398, @steveire wrote:

In D97156#2593209, @njames93 wrote:

Is it not nicer to name the class PolymorphicMatcher and do away with WithParamN, It may require partial specialization for the empty parameters case.
But I think it would be worth it.

I'm not sure any partial specialization is needed?

Oh neat, I wasn't sure if the empty tuple would cause some issues.

clang/docs/tools/dump_ast_matchers.py

m = re.match(
         declaration, flags=re.X)
     if m:
       result, arg, name = m.groups()[:3]
       add_matcher(result, name, '%s, ..., %s' % (arg, arg), comment)
       return
 
     m = re.match(
         r"""^.*internal::VariadicFunction\s*<\s*
-              internal::PolymorphicMatcherWithParam1<[\S\s]+
-              AST_POLYMORPHIC_SUPPORTED_TYPES\(([^)]*)\)>,\s*([^,]+),
-              \s*[^>]+>\s*([a-zA-Z]*);$""", 
+              internal::PolymorphicMatcherWithParamN<[\S\s]+
+              AST_POLYMORPHIC_SUPPORTED_TYPES\(([^)]*)\),\s*(.*);$""",
         declaration, flags=re.X)
 
     if m:
-      results, arg, name = m.groups()[:3]
+      results, trailing = m.groups()
+      trailing, name = trailing.rsplit(">", 1)
+      name = name.strip()
+      trailing, _ = trailing.rsplit(",", 1)
+      _, arg = trailing.rsplit(",", 1)
+      arg = arg.strip()
 
       result_types = [r.strip() for r in results.split(',')]
       for result_type in result_types:
         add_matcher(result_type, name, '%s, ..., %s' % (arg, arg), comment)
       return
       
 
     # Parse Variadic operator matchers.

clang/include/clang/ASTMatchers/ASTMatchers.h

internal::TraversalWrapper<
     internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>>
 traverse(TraversalKind TK, const internal::ArgumentAdaptingMatcherFuncAdaptor<
                                ArgumentAdapterT, T, ToTypes> &InnerMatcher) {
   return internal::TraversalWrapper<
       internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T,
                                                    ToTypes>>(TK, InnerMatcher);
 }
 
-template <template <typename T, typename P1> class MatcherT, typename P1,
+template <template <typename T, typename... P> class MatcherT, typename... P,
           typename ReturnTypesF>
 internal::TraversalWrapper<
-    internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>
-traverse(TraversalKind TK, const internal::PolymorphicMatcherWithParam1<
-                               MatcherT, P1, ReturnTypesF> &InnerMatcher) {
-  return internal::TraversalWrapper<
-      internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>(
-      TK, InnerMatcher);
-}
-
-template <template <typename T, typename P1, typename P2> class MatcherT,
-          typename P1, typename P2, typename ReturnTypesF>
-internal::TraversalWrapper<
-    internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>
-traverse(TraversalKind TK, const internal::PolymorphicMatcherWithParam2<
-                               MatcherT, P1, P2, ReturnTypesF> &InnerMatcher) {
+    internal::PolymorphicMatcherWithParamN<MatcherT, ReturnTypesF, P...>>
+traverse(TraversalKind TK,
+         const internal::PolymorphicMatcherWithParamN<MatcherT, ReturnTypesF,
+                                                      P...> &InnerMatcher) {
   return internal::TraversalWrapper<
-      internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>(
+      internal::PolymorphicMatcherWithParamN<MatcherT, ReturnTypesF, P...>>(
       TK, InnerMatcher);
 }
 
 template <typename... T>
 internal::Matcher<typename internal::GetClade<T...>::Type>
 traverse(TraversalKind TK, const internal::MapAnyOfHelper<T...> &InnerMatcher) {
   return traverse(TK, InnerMatcher.with());
 }

 /// \endcode
 ///
 /// \c cxxOperatorCallExpr(hasOverloadedOperatorName("<<"))) matches the
 /// specified line and
 /// \c cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
 /// matches the declaration of \c A.
 ///
 /// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
-inline internal::PolymorphicMatcherWithParam1<
-    internal::HasOverloadedOperatorNameMatcher, std::vector<std::string>,
-    AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)>
+inline internal::PolymorphicMatcherWithParamN<
+    internal::HasOverloadedOperatorNameMatcher,
+    AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl),
+    std::vector<std::string>>
 hasOverloadedOperatorName(StringRef Name) {
-  return internal::PolymorphicMatcherWithParam1<
-      internal::HasOverloadedOperatorNameMatcher, std::vector<std::string>,
-      AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)>(
-      {std::string(Name)});
+  return internal::PolymorphicMatcherWithParamN<
+      internal::HasOverloadedOperatorNameMatcher,
+      AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl),
+      std::vector<std::string>>({std::string(Name)});
 }
 
 /// Matches overloaded operator names.
 ///
 /// Matches overloaded operator names specified in strings without the
 /// "operator" prefix: e.g. "<<".
 ///
 ///   hasAnyOverloadedOperatorName("+", "-")
 /// Is equivalent to
 ///   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
 extern const internal::VariadicFunction<
-    internal::PolymorphicMatcherWithParam1<
-        internal::HasOverloadedOperatorNameMatcher, std::vector<std::string>,
-        AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)>,
+    internal::PolymorphicMatcherWithParamN<
+        internal::HasOverloadedOperatorNameMatcher,
+        AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl),
+        std::vector<std::string>>,
     StringRef, internal::hasAnyOverloadedOperatorNameFunc>
     hasAnyOverloadedOperatorName;
 
 /// Matches template-dependent, but known, member names.
 ///
 /// In template declarations, dependent members are not resolved and so can
 /// not be matched to particular named declarations.
 ///

 ///
 /// Usable as: Matcher<AddrLabelExpr>, Matcher<CallExpr>,
 ///   Matcher<CXXConstructExpr>, Matcher<CXXNewExpr>, Matcher<DeclRefExpr>,
 ///   Matcher<EnumType>, Matcher<InjectedClassNameType>, Matcher<LabelStmt>,
 ///   Matcher<MemberExpr>, Matcher<QualType>, Matcher<RecordType>,
 ///   Matcher<TagType>, Matcher<TemplateSpecializationType>,
 ///   Matcher<TemplateTypeParmType>, Matcher<TypedefType>,
 ///   Matcher<UnresolvedUsingType>
-inline internal::PolymorphicMatcherWithParam1<
-    internal::HasDeclarationMatcher, internal::Matcher<Decl>,
-    void(internal::HasDeclarationSupportedTypes)>
+inline internal::PolymorphicMatcherWithParamN<
+    internal::HasDeclarationMatcher,
+    void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>
 hasDeclaration(const internal::Matcher<Decl> &InnerMatcher) {
-  return internal::PolymorphicMatcherWithParam1<
-      internal::HasDeclarationMatcher, internal::Matcher<Decl>,
-      void(internal::HasDeclarationSupportedTypes)>(InnerMatcher);
+  return internal::PolymorphicMatcherWithParamN<
+      internal::HasDeclarationMatcher,
+      void(internal::HasDeclarationSupportedTypes), internal::Matcher<Decl>>(
+      InnerMatcher);
 }
 
 /// Matches a \c NamedDecl whose underlying declaration matches the given
 /// matcher.
 ///
 /// Given
 /// \code
 ///   namespace N { template<class T> void f(T t); }

 /// matcher to match the minus sign:
 ///
 /// unaryOperator(hasOperatorName("-"),
 ///               hasUnaryOperand(integerLiteral(equals(13))))
 ///
 /// Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteralExpr>,
 ///            Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
 template <typename ValueT>
-internal::PolymorphicMatcherWithParam1<internal::ValueEqualsMatcher, ValueT>
+internal::PolymorphicMatcherWithParamN<internal::ValueEqualsMatcher,
+                                       void(internal::AllNodeBaseTypes), ValueT>
 equals(const ValueT &Value) {
-  return internal::PolymorphicMatcherWithParam1<
-    internal::ValueEqualsMatcher,
-    ValueT>(Value);
+  return internal::PolymorphicMatcherWithParamN<
+      internal::ValueEqualsMatcher, void(internal::AllNodeBaseTypes), ValueT>(
+      Value);
 }
 
 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(equals,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(CharacterLiteral,
                                                           CXXBoolLiteralExpr,
                                                           IntegerLiteral),
                           bool, Value, 0) {
   return internal::ValueEqualsMatcher<NodeType, ParamT>(Value)

 
 /// Matches operator expressions (binary or unary) that have any of the
 /// specified names.
 ///
 ///    hasAnyOperatorName("+", "-")
 ///  Is equivalent to
 ///    anyOf(hasOperatorName("+"), hasOperatorName("-"))
 extern const internal::VariadicFunction<
-    internal::PolymorphicMatcherWithParam1<
-        internal::HasAnyOperatorNameMatcher, std::vector<std::string>,
+    internal::PolymorphicMatcherWithParamN<
+        internal::HasAnyOperatorNameMatcher,
         AST_POLYMORPHIC_SUPPORTED_TYPES(BinaryOperator, CXXOperatorCallExpr,
                                         CXXRewrittenBinaryOperator,
-                                        UnaryOperator)>,
+                                        UnaryOperator),
+        std::vector<std::string>>,
     StringRef, internal::hasAnyOperatorNameFunc>
     hasAnyOperatorName;
 
 /// Matches all kinds of assignment operators.
 ///
 /// Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
 /// \code
 ///   if (a == b)

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

 
 public:
   static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
 };
 
 /// Matches overloaded operators with a specific name.
 ///
 /// The type argument ArgT is not used by this matcher but is used by
-/// PolymorphicMatcherWithParam1 and should be StringRef.
+/// PolymorphicMatcherWithParamN and should be StringRef.
 template <typename T, typename ArgT>
 class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_same<T, CXXOperatorCallExpr>::value ||
                 std::is_base_of<FunctionDecl, T>::value,
                 "unsupported class for matcher");
   static_assert(std::is_same<ArgT, std::vector<std::string>>::value,
                 "argument type must be std::vector<std::string>");
 

 
 /// Trampoline function to use VariadicFunction<> to construct a
 ///        hasAnySelector matcher.
 Matcher<ObjCMessageExpr> hasAnySelectorFunc(
     ArrayRef<const StringRef *> NameRefs);
 
 /// Matches declarations for QualType and CallExpr.
 ///
-/// Type argument DeclMatcherT is required by PolymorphicMatcherWithParam1 but
+/// Type argument DeclMatcherT is required by PolymorphicMatcherWithParamN but
 /// not actually used.
 template <typename T, typename DeclMatcherT>
 class HasDeclarationMatcher : public MatcherInterface<T> {
   static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value,
                 "instantiated with wrong types");
 
   const DynTypedMatcher InnerMatcher;
 

 ///   type void(Arg).
 ///
 /// See AST_POLYMORPHIC_SUPPORTED_TYPES for details.
 template <class T> struct ExtractFunctionArgMeta;
 template <class T> struct ExtractFunctionArgMeta<void(T)> {
   using type = T;
 };
 
+template <class T, class Tuple, std::size_t... I>
+constexpr T *new_from_tuple_impl(Tuple &&t, std::index_sequence<I...>) {
+  return new T(std::get<I>(std::forward<Tuple>(t))...);
+}
+
+template <class T, class Tuple> constexpr T *new_from_tuple(Tuple &&t) {
+  return new_from_tuple_impl<T>(
+      std::forward<Tuple>(t),
+      std::make_index_sequence<
+          std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
+}
+
 /// Default type lists for ArgumentAdaptingMatcher matchers.
 using AdaptativeDefaultFromTypes = AllNodeBaseTypes;
 using AdaptativeDefaultToTypes =
     TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, TypeLoc,
              QualType>;
 
 /// All types that are supported by HasDeclarationMatcher above.
 using HasDeclarationSupportedTypes =

 ///
 /// For example:
 ///   \c ArgumentAdaptingMatcher<HasMatcher, T>(InnerMatcher);
 /// Given that \c InnerMatcher is of type \c Matcher<T>, this returns a matcher
 /// that is convertible into any matcher of type \c To by constructing
 /// \c HasMatcher<To, T>(InnerMatcher).
 ///
 /// If a matcher does not need knowledge about the inner type, prefer to use
-/// PolymorphicMatcherWithParam1.
+/// PolymorphicMatcherWithParamN.
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename FromTypes = AdaptativeDefaultFromTypes,
           typename ToTypes = AdaptativeDefaultToTypes>
 struct ArgumentAdaptingMatcherFunc {
   template <typename T>
   static ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>
   create(const Matcher<T> &InnerMatcher) {
     return ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>(

 };
 
 /// A PolymorphicMatcherWithParamN<MatcherT, P1, ..., PN> object can be
 /// created from N parameters p1, ..., pN (of type P1, ..., PN) and
 /// used as a Matcher<T> where a MatcherT<T, P1, ..., PN>(p1, ..., pN)
 /// can be constructed.
 ///
 /// For example:
-/// - PolymorphicMatcherWithParam0<IsDefinitionMatcher>()
+/// - PolymorphicMatcherWithParamN<IsDefinitionMatcher>()
 ///   creates an object that can be used as a Matcher<T> for any type T
 ///   where an IsDefinitionMatcher<T>() can be constructed.
-/// - PolymorphicMatcherWithParam1<ValueEqualsMatcher, int>(42)
+/// - PolymorphicMatcherWithParamN<ValueEqualsMatcher, int>(42)
 ///   creates an object that can be used as a Matcher<T> for any type T
 ///   where a ValueEqualsMatcher<T, int>(42) can be constructed.
-template <template <typename T> class MatcherT,
-          typename ReturnTypesF = void(AllNodeBaseTypes)>
-class PolymorphicMatcherWithParam0 {
-public:
-  using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
-
-  template <typename T>
-  operator Matcher<T>() const {
-    static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
-                  "right polymorphic conversion");
-    return Matcher<T>(new MatcherT<T>());
-  }
-};
-
-template <template <typename T, typename P1> class MatcherT,
-          typename P1,
-          typename ReturnTypesF = void(AllNodeBaseTypes)>
-class PolymorphicMatcherWithParam1 {
-public:
-  explicit PolymorphicMatcherWithParam1(const P1 &Param1)
-      : Param1(Param1) {}
-
-  using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
-
-  template <typename T>
-  operator Matcher<T>() const {
-    static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
-                  "right polymorphic conversion");
-    return Matcher<T>(new MatcherT<T, P1>(Param1));
-  }
-
-private:
-  const P1 Param1;
-};
-
-template <template <typename T, typename P1, typename P2> class MatcherT,
-          typename P1, typename P2,
-          typename ReturnTypesF = void(AllNodeBaseTypes)>
-class PolymorphicMatcherWithParam2 {
+template <template <typename T, typename... Params> class MatcherT,
+          typename ReturnTypesF, typename... ParamTypes>
+class PolymorphicMatcherWithParamN {
 public:
-  PolymorphicMatcherWithParam2(const P1 &Param1, const P2 &Param2)
-      : Param1(Param1), Param2(Param2) {}
+  PolymorphicMatcherWithParamN(const ParamTypes &... Params)
+      : Params(Params...) {}
 
   using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
 
   template <typename T>
   operator Matcher<T>() const {
     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
                   "right polymorphic conversion");
-    return Matcher<T>(new MatcherT<T, P1, P2>(Param1, Param2));
+    return Matcher<T>(new_from_tuple<MatcherT<T, ParamTypes...>>(Params));
   }
 
 private:
-  const P1 Param1;
-  const P2 Param2;
+  const std::tuple<ParamTypes...> Params;
 };
 
 /// Matches nodes of type T that have child nodes of type ChildT for
 /// which a specified child matcher matches.
 ///
 /// ChildT must be an AST base type.
 template <typename T, typename ChildT>
 class HasMatcher : public MatcherInterface<T> {
if (!optBinaryOpcode) {
     return UnaryOperator::getOpcodeStr(*optUnaryOpcode);
   }
   return BinaryOperator::getOpcodeStr(*optBinaryOpcode);
 }
 
 /// Matches overloaded operators with a specific name.
 ///
 /// The type argument ArgT is not used by this matcher but is used by
-/// PolymorphicMatcherWithParam1 and should be std::vector<std::string>>.
+/// PolymorphicMatcherWithParamN and should be std::vector<std::string>>.
 template <typename T, typename ArgT = std::vector<std::string>>
 class HasAnyOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_same<T, BinaryOperator>::value ||
                     std::is_same<T, CXXOperatorCallExpr>::value ||
                     std::is_same<T, CXXRewrittenBinaryOperator>::value ||
                     std::is_same<T, UnaryOperator>::value,
                 "Matcher only supports `BinaryOperator`, `UnaryOperator`, "
                 "`CXXOperatorCallExpr` and `CXXRewrittenBinaryOperator`");
if (!optBinaryOpcode) {
       return UnaryOperator::getOpcodeStr(*optUnaryOpcode);
     }
     return BinaryOperator::getOpcodeStr(*optBinaryOpcode);
   }
 
   const std::vector<std::string> Names;
 };
 
-using HasOpNameMatcher = PolymorphicMatcherWithParam1<
-    HasAnyOperatorNameMatcher, std::vector<std::string>,
+using HasOpNameMatcher = PolymorphicMatcherWithParamN<
+    HasAnyOperatorNameMatcher,
     void(TypeList<BinaryOperator, CXXOperatorCallExpr,
-                  CXXRewrittenBinaryOperator, UnaryOperator>)>;
+                  CXXRewrittenBinaryOperator, UnaryOperator>),
+    std::vector<std::string>>;
 
 HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef<const StringRef *> NameRefs);
 
-using HasOverloadOpNameMatcher = PolymorphicMatcherWithParam1<
-    HasOverloadedOperatorNameMatcher, std::vector<std::string>,
-    void(TypeList<CXXOperatorCallExpr, FunctionDecl>)>;
+using HasOverloadOpNameMatcher = PolymorphicMatcherWithParamN<
+    HasOverloadedOperatorNameMatcher,
+    void(TypeList<CXXOperatorCallExpr, FunctionDecl>),
+    std::vector<std::string>>;
 
 HasOverloadOpNameMatcher
 hasAnyOverloadedOperatorNameFunc(ArrayRef<const StringRef *> NameRefs);
 
 /// Returns true if \p Node has a base specifier matching \p BaseSpec.
 ///
 /// A class is not considered to be derived from itself.
 bool matchesAnyBase(const CXXRecordDecl &Node,

clang/include/clang/ASTMatchers/ASTMatchersMacros.h

class matcher_##DefineMatcher##Matcher                                       \
       : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> {   \
   public:                                                                      \
     bool matches(const NodeType &Node,                                         \
                  ::clang::ast_matchers::internal::ASTMatchFinder *Finder,      \
                  ::clang::ast_matchers::internal::BoundNodesTreeBuilder        \
                      *Builder) const override;                                 \
   };                                                                           \
   }                                                                            \
-  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0<        \
+  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<        \
       internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>                \
   DefineMatcher() {                                                            \
-    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0<      \
+    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<      \
         internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>();           \
   }                                                                            \
   template <typename NodeType>                                                 \
   bool internal::matcher_##DefineMatcher##Matcher<NodeType>::matches(          \
       const NodeType &Node,                                                    \
       ::clang::ast_matchers::internal::ASTMatchFinder *Finder,                 \
       ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
 
bool matches(const NodeType &Node,                                         \
                  ::clang::ast_matchers::internal::ASTMatchFinder *Finder,      \
                  ::clang::ast_matchers::internal::BoundNodesTreeBuilder        \
                      *Builder) const override;                                 \
                                                                                \
   private:                                                                     \
     ParamType const Param;                                                     \
   };                                                                           \
   }                                                                            \
-  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<        \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType,       \
-      ReturnTypesF>                                                            \
+  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<        \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      ParamType>                                                               \
   DefineMatcher(ParamType const &Param) {                                      \
-    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<      \
-        internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType,     \
-        ReturnTypesF>(Param);                                                  \
-  }                                                                            \
-  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<       \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType,       \
-      ReturnTypesF>(&DefineMatcher##_Type##OverloadId)(                        \
-      ParamType const &Param);                                                 \
+    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<      \
+        internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,  \
+        ParamType>(Param);                                                     \
+  }                                                                            \
+  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<       \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      ParamType> (&DefineMatcher##_Type##OverloadId)(ParamType const &Param);  \
   template <typename NodeType, typename ParamT>                                \
   bool internal::                                                              \
       matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \
           const NodeType &Node,                                                \
           ::clang::ast_matchers::internal::ASTMatchFinder *Finder,             \
           ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder)     \
           const
 
bool matches(const NodeType &Node,                                         \
                  ::clang::ast_matchers::internal::BoundNodesTreeBuilder        \
                      *Builder) const override;                                 \
                                                                                \
   private:                                                                     \
     ParamType1 const Param1;                                                   \
     ParamType2 const Param2;                                                   \
   };                                                                           \
   }                                                                            \
-  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2<        \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1,      \
-      ParamType2, ReturnTypesF>                                                \
+  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<        \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      ParamType1, ParamType2>                                                  \
   DefineMatcher(ParamType1 const &Param1, ParamType2 const &Param2) {          \
-    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2<      \
-        internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1,    \
-        ParamType2, ReturnTypesF>(Param1, Param2);                             \
-  }                                                                            \
-  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2<       \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1,      \
-      ParamType2, ReturnTypesF>(&DefineMatcher##_Type##OverloadId)(            \
+    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<      \
+        internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,  \
+        ParamType1, ParamType2>(Param1, Param2);                               \
+  }                                                                            \
+  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<       \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      ParamType1, ParamType2> (&DefineMatcher##_Type##OverloadId)(             \
       ParamType1 const &Param1, ParamType2 const &Param2);                     \
   template <typename NodeType, typename ParamT1, typename ParamT2>             \
   bool internal::matcher_##DefineMatcher##OverloadId##Matcher<                 \
       NodeType, ParamT1, ParamT2>::                                            \
       matches(const NodeType &Node,                                            \
               ::clang::ast_matchers::internal::ASTMatchFinder *Finder,         \
               ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \
           const
bool matches(const NodeType &Node,                                         \
                  ::clang::ast_matchers::internal::ASTMatchFinder *Finder,      \
                  ::clang::ast_matchers::internal::BoundNodesTreeBuilder        \
                      *Builder) const override;                                 \
                                                                                \
   private:                                                                     \
     std::shared_ptr<llvm::Regex> const Param;                                  \
   };                                                                           \
   }                                                                            \
-  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<        \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher,                  \
-      std::shared_ptr<llvm::Regex>, ReturnTypesF>                              \
+  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<        \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      std::shared_ptr<llvm::Regex>>                                            \
   DefineMatcher(llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags) {   \
-    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<      \
-        internal::matcher_##DefineMatcher##OverloadId##Matcher,                \
-        std::shared_ptr<llvm::Regex>, ReturnTypesF>(                           \
+    return ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<      \
+        internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,  \
+        std::shared_ptr<llvm::Regex>>(                                         \
         ::clang::ast_matchers::internal::createAndVerifyRegex(                 \
             Param, RegexFlags, #DefineMatcher));                               \
   }                                                                            \
-  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<        \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher,                  \
-      std::shared_ptr<llvm::Regex>, ReturnTypesF>                              \
+  inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<        \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      std::shared_ptr<llvm::Regex>>                                            \
   DefineMatcher(llvm::StringRef Param) {                                       \
     return DefineMatcher(Param, llvm::Regex::NoFlags);                         \
   }                                                                            \
-  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<       \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher,                  \
-      std::shared_ptr<llvm::Regex>, ReturnTypesF> (                            \
+  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<       \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      std::shared_ptr<llvm::Regex>> (                                          \
       &DefineMatcher##_Type##OverloadId##Flags)(                               \
       llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags);              \
-  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1<       \
-      internal::matcher_##DefineMatcher##OverloadId##Matcher,                  \
-      std::shared_ptr<llvm::Regex>, ReturnTypesF> (                            \
-      &DefineMatcher##_Type##OverloadId)(llvm::StringRef Param);               \
+  typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParamN<       \
+      internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF,    \
+      std::shared_ptr<llvm::Regex>> (&DefineMatcher##_Type##OverloadId)(       \
+      llvm::StringRef Param);                                                  \
   template <typename NodeType, typename ParamT>                                \
   bool internal::                                                              \
       matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \
           const NodeType &Node,                                                \
           ::clang::ast_matchers::internal::ASTMatchFinder *Finder,             \
           ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder)     \
           const
 
 #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H