From d8f9e15954eff159f29376beeafb6ff35231734f Mon Sep 17 00:00:00 2001
From: Jim Porter <itsjimporter@gmail.com>
Date: Sun, 11 Aug 2024 16:16:56 -0700
Subject: [PATCH] Simplify `suite_builder` and `test_caller`

This lets us remove some repeated tuple-expansion.
---
 include/mettle/suite/detail/test_caller.hpp | 52 +++++--------
 include/mettle/suite/make_suite.hpp         | 85 ++++++++++-----------
 test/suite/test_test_caller.cpp             | 51 ++++++-------
 3 files changed, 85 insertions(+), 103 deletions(-)

diff --git a/include/mettle/suite/detail/test_caller.hpp b/include/mettle/suite/detail/test_caller.hpp
index a5aa420c..803711c2 100644
--- a/include/mettle/suite/detail/test_caller.hpp
+++ b/include/mettle/suite/detail/test_caller.hpp
@@ -28,7 +28,7 @@ namespace mettle::detail {
   struct test_caller_base {
     using function_type = std::function<void(Args&...)>;
 
-    void call_test(Args &...args) {
+    void operator ()(Args &...args) {
       if(setup)
         setup(args...);
 
@@ -48,49 +48,37 @@ namespace mettle::detail {
     function_type setup, teardown, test;
   };
 
-  template<typename Factory, typename Parent, typename InChild,
-           typename OutChild>
-  class test_caller_impl;
+  template<typename ...Parent>
+  struct test_caller : test_caller_base<Parent &...> {
+  private:
+    using base = test_caller_base<Parent &...>;
+  public:
+    template<typename Factory, typename ...T>
+    test_caller(const Factory &, T &&...t)
+      : base{std::forward<T>(t)...} {}
+  };
 
-  template<typename Factory, typename ...Parent, typename InChild,
-           typename OutChild>
-  class test_caller_impl<Factory, std::tuple<Parent...>, InChild, OutChild>
-    : private test_caller_base<Parent &..., OutChild &> {
+  template<typename Factory, typename Child, typename ...Parent>
+  struct fixture_test_caller : test_caller_base<
+    Parent &..., transform_fixture_t<Factory, Child> &
+  > {
   private:
-    using base = test_caller_base<Parent &..., OutChild &>;
+    using base = test_caller_base<
+      Parent &..., transform_fixture_t<Factory, Child> &
+    >;
   public:
     template<typename ...T>
-    test_caller_impl(Factory f, T &&...t)
+    fixture_test_caller(Factory f, T &&...t)
       : base{std::forward<T>(t)...}, factory(std::move(f)) {}
 
     inline void operator ()(Parent &...args) {
-      auto &&child = factory.template make<InChild>();
-      base::call_test(args..., child);
+      auto &&child = factory.template make<Child>();
+      base::operator ()(args..., child);
     }
 
     Factory factory;
   };
 
-  template<typename Factory, typename ...Parent, typename InChild>
-  class test_caller_impl<Factory, std::tuple<Parent...>, InChild, void>
-    : private test_caller_base<Parent &...> {
-  private:
-    using base = test_caller_base<Parent &...>;
-  public:
-    template<typename ...T>
-    test_caller_impl(const Factory &, T &&...t)
-      : base{std::forward<T>(t)...} {}
-  public:
-    inline void operator ()(Parent &...args) {
-      base::call_test(args...);
-    }
-  };
-
-  template<typename Factory, typename Parent, typename Child>
-  using test_caller = test_caller_impl<
-    Factory, Parent, Child, transform_fixture_t<Factory, Child>
-  >;
-
 } // namespace mettle::detail
 
 #endif
diff --git a/include/mettle/suite/make_suite.hpp b/include/mettle/suite/make_suite.hpp
index 0525a958..4deb9821 100644
--- a/include/mettle/suite/make_suite.hpp
+++ b/include/mettle/suite/make_suite.hpp
@@ -32,18 +32,6 @@ namespace mettle {
       return s + " (" + type_name<T>() + ")";
     }
 
-    template<typename Tuple>
-    struct to_func_impl;
-
-    template<typename ...T>
-    struct to_func_impl<std::tuple<T...>> {
-      using type = void(T&...);
-    };
-
-    template<typename T>
-    using to_func = typename to_func_impl<T>::type;
-
-
     template<typename Exception>
     struct wrap_test {
       using compiled_suite_type = runnable_suite;
@@ -72,9 +60,7 @@ namespace mettle {
 
     template<typename Wrap, typename Builder, typename = std::void_t<>>
     struct wrapped_suite {
-      using type = compiled_suite<to_func<
-        typename Builder::parent_fixture_type
-      >>;
+      using type = compiled_suite<typename Builder::parent_fixture_signature>;
     };
 
     template<typename Wrap, typename Builder>
@@ -172,7 +158,7 @@ namespace mettle {
 
 
   template<typename ParentFixture, typename ...Fixture, typename ...Args>
-  inline compiled_suite<detail::to_func<ParentFixture>>
+  inline auto
   make_subsuite(const std::string &name, const attributes &attrs,
                 Args &&...args) {
     return detail::do_build<ParentFixture, Fixture...>(
@@ -181,7 +167,7 @@ namespace mettle {
   }
 
   template<typename ParentFixture, typename ...Fixture, typename ...Args>
-  inline compiled_suite<detail::to_func<ParentFixture>>
+  inline auto
   make_subsuite(const std::string &name, Args &&...args) {
     return detail::do_build<ParentFixture, Fixture...>(
       name, {}, std::forward<Args>(args)..., detail::identity{}
@@ -189,8 +175,7 @@ namespace mettle {
   }
 
   template<typename ParentFixture, typename ...Fixture, typename ...Args>
-  inline std::array<compiled_suite<detail::to_func<ParentFixture>>,
-                    std::max(sizeof...(Fixture), std::size_t(1))>
+  inline auto
   make_subsuites(const std::string &name, const attributes &attrs,
                  Args &&...args) {
     return detail::do_builds<ParentFixture, Fixture...>(
@@ -199,8 +184,7 @@ namespace mettle {
   }
 
   template<typename ParentFixture, typename ...Fixture, typename ...Args>
-  inline std::array<compiled_suite<detail::to_func<ParentFixture>>,
-                    std::max(sizeof...(Fixture), std::size_t(1))>
+  inline auto
   make_subsuites(const std::string &name, Args &&...args) {
     return detail::do_builds<ParentFixture, Fixture...>(
       name, {}, std::forward<Args>(args)..., detail::identity{}
@@ -308,39 +292,52 @@ namespace mettle {
     std::vector<compiled_suite<void(T&...)>> subsuites_;
   };
 
-  template<typename Factory, typename Parent, typename InChild>
-  struct suite_builder_base_type;
+  template<typename Factory, typename ...ParentFixture,
+           typename Fixture /* = detail::no_fixture_t*/>
+  requires(std::same_as<detail::transform_fixture_t<Factory, Fixture>, void>)
+  class suite_builder<Factory, std::tuple<ParentFixture...>, Fixture>
+    : public suite_builder_base<ParentFixture...> {
+    using base = suite_builder_base<ParentFixture...>;
+  public:
+    using factory_type = Factory;
+    using parent_fixture_type = std::tuple<ParentFixture...>;
+    using parent_fixture_signature = void(ParentFixture&...);
+    using fixture_type = Fixture;
 
-  template<typename Factory, typename ...Parent, typename InChild>
-  struct suite_builder_base_type<Factory, std::tuple<Parent...>, InChild> {
-    using out_child_type = detail::transform_fixture_t<Factory, InChild>;
-    using type = std::conditional_t<
-      std::is_same_v<out_child_type, void>,
-      suite_builder_base<Parent...>,
-      suite_builder_base<Parent..., out_child_type>
-    >;
-  };
+    suite_builder(const std::string &name, const attributes &attrs,
+                  Factory factory)
+      : base(name, attrs), factory_(factory) {}
+  private:
+    using test_caller = detail::test_caller<ParentFixture...>;
+
+    template<typename Builder, typename Wrap>
+    friend typename detail::wrapped_suite<Wrap, Builder>::type
+    detail::finalize(Builder &, const Wrap &);
 
-  template<typename Factory, typename Parent, typename InChild>
-  using suite_builder_base_t = typename suite_builder_base_type<
-    Factory, Parent, InChild
-  >::type;
+    factory_type factory_;
+  };
 
-  template<typename Factory, typename ParentFixture,
-           typename Fixture /* = detail::no_fixture_t */>
-  class suite_builder
-    : public suite_builder_base_t<Factory, ParentFixture, Fixture> {
-    using base = suite_builder_base_t<Factory, ParentFixture, Fixture>;
-      public:
+  template<typename Factory, typename ...ParentFixture,
+           typename Fixture /* = detail::no_fixture_t*/>
+  class suite_builder<Factory, std::tuple<ParentFixture...>, Fixture>
+    : public suite_builder_base<ParentFixture...,
+                                detail::transform_fixture_t<Factory, Fixture>> {
+    using base = suite_builder_base<
+      ParentFixture..., detail::transform_fixture_t<Factory, Fixture>
+    >;
+  public:
     using factory_type = Factory;
-    using parent_fixture_type = ParentFixture;
+    using parent_fixture_type = std::tuple<ParentFixture...>;
+    using parent_fixture_signature = void(ParentFixture&...);
     using fixture_type = Fixture;
 
     suite_builder(const std::string &name, const attributes &attrs,
                   Factory factory)
       : base(name, attrs), factory_(factory) {}
   private:
-    using test_caller = detail::test_caller<Factory, ParentFixture, Fixture>;
+    using test_caller = detail::fixture_test_caller<
+      Factory, Fixture, ParentFixture...
+    >;
 
     template<typename Builder, typename Wrap>
     friend typename detail::wrapped_suite<Wrap, Builder>::type
diff --git a/test/suite/test_test_caller.cpp b/test/suite/test_test_caller.cpp
index 3b7fe580..8f1f5d49 100644
--- a/test/suite/test_test_caller.cpp
+++ b/test/suite/test_test_caller.cpp
@@ -3,16 +3,25 @@ using namespace mettle;
 
 #include "run_counter.hpp"
 
-template<typename Tuple>
-struct run_counter_from_tuple_t;
-
-template<typename ...T>
-struct run_counter_from_tuple_t<std::tuple<T...>> {
-  using type = run_counter<T &...>;
+template<template<typename ...> typename T, typename Tuple,
+         template<typename ...> typename Transform>
+struct apply_tuple_t;
+
+template<template<typename ...> typename T, typename ...Args,
+         template<typename ...> typename Transform>
+struct apply_tuple_t<T, std::tuple<Args...>, Transform> {
+  using type = T<Transform<Args>...>;
 };
 
+template<template<typename ...> typename T, typename Tuple,
+         template<typename ...> typename Transform = std::type_identity_t>
+using apply_tuple = typename apply_tuple_t<T, Tuple, Transform>::type;
+
 template<typename Tuple>
-using run_counter_from_tuple = typename run_counter_from_tuple_t<Tuple>::type;
+using run_counter_from_tuple = apply_tuple<
+  run_counter, Tuple, std::add_lvalue_reference_t
+>;
+
 
 using namespace mettle::detail;
 
@@ -20,38 +29,26 @@ suite<std::tuple<>, std::tuple<int, int>>
 test_test_caller("test_caller", [](auto &_) {
   using Fixture = fixture_type_t<decltype(_)>;
 
-  _.test("test with no fixture", [](auto &tup) {
+  _.test("no fixture", [](auto &tup) {
     run_counter_from_tuple<Fixture> setup, teardown, test;
-    test_caller<auto_factory_t, Fixture, no_fixture_t> t(
+    apply_tuple<test_caller, Fixture> caller(
       auto_factory, setup, teardown, test
     );
-    std::apply(t, tup);
+    std::apply(caller, tup);
 
     expect("setup run count", setup.runs(), equal_to(1));
     expect("test run count", test.runs(), equal_to(1));
     expect("teardown run count", teardown.runs(), equal_to(1));
   });
 
-  _.test("test with auto fixture", [](auto &tup) {
+  _.test("fixture", [](auto &tup) {
     run_counter_from_tuple<decltype(
       std::tuple_cat(tup, std::tuple<int>())
     )> setup, teardown, test;
-    test_caller<auto_factory_t, Fixture, int> t(
-      auto_factory, setup, teardown, test
-    );
-    std::apply(t, tup);
-
-    expect("setup run count", setup.runs(), equal_to(1));
-    expect("test run count", test.runs(), equal_to(1));
-    expect("teardown run count", teardown.runs(), equal_to(1));
-  });
-
-  _.test("test with type-only fixture", [](auto &tup) {
-    run_counter_from_tuple<Fixture> setup, teardown, test;
-    test_caller<type_only_factory_t, Fixture, int> t(
-      type_only, setup, teardown, test
-    );
-    std::apply(t, tup);
+    apply_tuple<fixture_test_caller, decltype(
+      std::tuple_cat(std::tuple<auto_factory_t, int>(), tup)
+    )> caller(auto_factory, setup, teardown, test);
+    std::apply(caller, tup);
 
     expect("setup run count", setup.runs(), equal_to(1));
     expect("test run count", test.runs(), equal_to(1));