use unforgettable reporter registration

Author: Tsche

CMakeLists.txt

@@ -9,16 +9,10 @@ add_library(rsltest SHARED)
 
 set_target_properties(rsltest PROPERTIES OUTPUT_NAME rsltest)
 target_compile_options(rsltest PUBLIC 
-  "-stdlib=libc++"
-  "-freflection"
-  "-fannotation-attributes"
-  "-fparameter-reflection"
-  "-fexpansion-statements"
-  # "-Wno-c++26-extensions"
+  "-freflection-latest"
   # "-ftime-trace"
   # "-fconstexpr-steps=10000000" # required to scan the global namespace
 )
-target_link_options(rsltest PUBLIC "-stdlib=libc++" "-lc++abi")
 target_include_directories(rsltest PUBLIC 
     $<INSTALL_INTERFACE:include>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)

include/rsl/testing/_impl/factory.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include <memory>
+#include <string>
+#include <string_view>
+#include <meta>
+#include <unordered_map>
+
+#include "../annotations.hpp"
+
+namespace rsl::testing::_impl {
+template <class Base, class... Args>
+class Factory {
+public:
+  template <class... T>
+  static std::unique_ptr<Base> make(const std::string& s, T&&... args) {
+    return data().at(s)(std::forward<T>(args)...);
+  }
+
+  template <class T>
+  struct Registrar : Base {
+    friend T;
+
+    static consteval std::string_view get_name() {
+      auto annotations = annotations_of(^^T, ^^annotations::Rename);
+      if (annotations.size() == 1) {
+        auto opt = extract<annotations::Rename>(constant_of(annotations[0]));
+        return opt.value;
+      }
+      return identifier_of(^^T);
+    }
+
+    static bool registerT() {
+      static constexpr std::string_view name = define_static_string(get_name());
+      Factory::data()[name]                  = [](Args... args) -> std::unique_ptr<Base> {
+        return std::make_unique<T>(std::forward<Args>(args)...);
+      };
+      return true;
+    }
+    inline static const std::nullptr_t registration = (registerT(), nullptr);
+    static constexpr std::integral_constant<std::nullptr_t const*, &registration>
+        registration_helper{};
+
+  private:
+    Registrar() : Base(Key{}) { (void)registration; }
+  };
+
+  friend Base;
+
+private:
+  class Key {
+    Key() {};
+    template <class T>
+    friend struct Registrar;
+  };
+  using FuncType = std::unique_ptr<Base> (*)(Args...);
+  Factory()      = default;
+
+  static auto& data() {
+    static std::unordered_map<std::string_view, FuncType> s;
+    return s;
+  }
+};
+}  // namespace rsl::testing::_impl

include/rsl/testing/output.hpp

@@ -18,7 +18,9 @@ struct Output {
   }
 };
 
-struct Reporter {
+struct Reporter : _impl::Factory<Reporter> {
+  explicit Reporter(Key) {}
+
   virtual ~Reporter() = default;
   virtual void before_run(TestNamespace const& tests) {}
   virtual void after_run(std::span<TestResult> results) {}
@@ -36,31 +38,4 @@ struct Reporter {
 
   virtual void finalize(Output& output) {}
 };
-
-namespace _reporter_impl {
-consteval std::string_view get_name(std::meta::info R) {
-  auto annotations = annotations_of(R, ^^annotations::Rename);
-  if (annotations.size() == 1) {
-    auto opt = extract<annotations::Rename>(constant_of(annotations[0]));
-    return opt.value;
-  }
-  return identifier_of(R);
-}
-}  // namespace _reporter_impl
-
-using ReporterDef = std::unique_ptr<Reporter> (*)();
-std::unordered_map<std::string_view, ReporterDef>& reporter_registry();
-
-template <typename T>
-bool register_reporter() {
-  reporter_registry()[_reporter_impl::get_name(^^T)] =
-      +[] -> std::unique_ptr<Reporter> { return std::make_unique<T>(); };
-  return true;
-}
-}  // namespace rsl::testing
-
-#define REGISTER_REPORTER(classname)                        \
-  namespace {                                               \
-  [[maybe_unused]] static bool const _reporter_registered = \
-      rsl::testing::register_reporter<classname>();         \
-  }
+}  // namespace rsl::testing

src/discovery.cpp

@@ -7,10 +7,4 @@ std::set<TestDef>& _testing_impl::registry() {
   static std::set<TestDef> data;
   return data;
 }
-
-std::unordered_map<std::string_view, ReporterDef>& reporter_registry() {
-  static std::unordered_map<std::string_view, ReporterDef> data;
-  return data;
-}
-
 }  // namespace rsl::testing

src/main.cpp

@@ -101,9 +101,9 @@ class[[= rsl::cli::description("rsl::test (in Catch2 v3.8.1 compatibility mode)"
   void run() {
     std::unique_ptr<rsl::testing::Reporter> selected_reporter;
     if (reporter.empty()) {
-      selected_reporter = rsl::testing::reporter_registry().at("plain")();
+      selected_reporter = rsl::testing::Reporter::make("plain");
     } else {
-      selected_reporter = rsl::testing::reporter_registry().at(reporter)();
+      selected_reporter = rsl::testing::Reporter::make(reporter);
     }
 
     if (list_tests) {

src/reporters/catch2xml.cpp

@@ -111,7 +111,7 @@ struct MatchingTests {
   [[=xml::node]] std::vector<MatchingTests::TestCase> tests;
 };
 
-class[[= annotations::rename("xml")]] Catch2XmlReporter : public Reporter {
+class[[= annotations::rename("xml")]] Catch2XmlReporter : public Reporter::Registrar<Catch2XmlReporter> {
   Catch2TestRun report;
 
 public:
@@ -178,6 +178,4 @@ class[[= annotations::rename("xml")]] Catch2XmlReporter : public Reporter {
     }
   }
 };
-
-REGISTER_REPORTER(Catch2XmlReporter);
 }  // namespace rsl::testing::_xml_impl

src/reporters/terminal.cpp

@@ -5,7 +5,7 @@
 #include <libassert/assert.hpp>
 
 namespace rsl::testing::_impl {
-class [[=annotations::rename("plain")]] ConsoleReporter : public Reporter {
+class [[=annotations::rename("plain")]] ConsoleReporter : public Reporter::Registrar<ConsoleReporter> {
 public:
   void before_run(TestNamespace const& tests) override { std::print("Running {} tests...\n", tests.count()); }
   void before_test(Test::TestRun const& test) override { std::print("[ RUN      ] {}\n", test.name); }
@@ -38,6 +38,4 @@ class [[=annotations::rename("plain")]] ConsoleReporter : public Reporter {
   //   return libassert::isatty(libassert::stderr_fileno);
   // }
 };
-
-REGISTER_REPORTER(ConsoleReporter);
 }  // namespace rsl::_impl

src/reporters/xml.cpp

@@ -16,7 +16,7 @@ struct testsuite {
   std::vector<testcase> tests;
 };
 
-class [[=annotations::rename("junit")]] JUnitXmlReporter : public Reporter {
+class [[=annotations::rename("junit")]] JUnitXmlReporter : public Reporter::Registrar<JUnitXmlReporter> {
   testsuite suite;
 public:
   void before_run(TestNamespace const&) override {}
@@ -35,6 +35,4 @@ class [[=annotations::rename("junit")]] JUnitXmlReporter : public Reporter {
 
   void finalize(Output& target) override { target.print(rsl::to_xml(suite)); }
 };
-
-REGISTER_REPORTER(JUnitXmlReporter);
 }  // namespace rsl::testing::_impl