[VPlan] Simplify operand tuple matching in VPlanPatternMatch (NFC).

Remove some indirection when matching recipe and matcher operands by
directly using fold over parameter pack.

Author: fhahn

llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h

@@ -126,21 +126,6 @@ inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
 /// Match a VPValue, capturing it if we match.
 inline bind_ty<VPValue> m_VPValue(VPValue *&V) { return V; }
 
-namespace detail {
-
-template <typename TupleTy, typename Fn, std::size_t... Is>
-bool CheckTupleElements(const TupleTy &Ops, Fn P, std::index_sequence<Is...>) {
-  return (P(std::get<Is>(Ops), Is) && ...);
-}
-
-/// Helper to check if predicate \p P holds on all tuple elements in \p Ops
-template <typename TupleTy, typename Fn>
-bool all_of_tuple_elements(const TupleTy &Ops, Fn P) {
-  return CheckTupleElements(
-      Ops, P, std::make_index_sequence<std::tuple_size<TupleTy>::value>{});
-}
-} // namespace detail
-
 template <typename Ops_t, unsigned Opcode, bool Commutative,
           typename... RecipeTys>
 struct Recipe_match {
@@ -173,13 +158,14 @@ struct Recipe_match {
     assert(R->getNumOperands() == std::tuple_size<Ops_t>::value &&
            "recipe with matched opcode the expected number of operands");
 
-    if (detail::all_of_tuple_elements(Ops, [R](auto Op, unsigned Idx) {
+    auto IdxSeq = std::make_index_sequence<std::tuple_size<Ops_t>::value>();
+    if (all_of_tuple_elements(IdxSeq, [R](auto Op, unsigned Idx) {
           return Op.match(R->getOperand(Idx));
         }))
       return true;
 
     return Commutative &&
-           detail::all_of_tuple_elements(Ops, [R](auto Op, unsigned Idx) {
+           all_of_tuple_elements(IdxSeq, [R](auto Op, unsigned Idx) {
              return Op.match(R->getOperand(R->getNumOperands() - Idx - 1));
            });
   }
@@ -198,6 +184,13 @@ struct Recipe_match {
     else
       return DefR && DefR->getOpcode() == Opcode;
   }
+
+  /// Helper to check if predicate \p P holds on all tuple elements in Ops using
+  /// the provided index sequence.
+  template <typename Fn, std::size_t... Is>
+  bool all_of_tuple_elements(std::index_sequence<Is...>, Fn P) const {
+    return (P(std::get<Is>(Ops), Is) && ...);
+  }
 };
 
 template <typename Op0_t, unsigned Opcode, typename... RecipeTys>