[Util] Fix #146: Refactor visitor header (1/X).

Refactor the implementation of making a class hierarchy STL-style
`visit()`-able.  Replace the macro code by template magic.

Reader discretion advised!  This is not for the faint of heart.

Author: ImmanuelHaffner

include/mutable/storage/DataLayout.hpp

@@ -243,8 +243,8 @@ M_LCOV_EXCL_STOP
     X(DataLayout::INode) \
     X(DataLayout::Leaf) \
     X(DataLayout)
-M_DECLARE_VISITOR(ConstDataLayoutVisitor, const DataLayout::Node, M_DATA_LAYOUT_CLASSES)
 
+M_DECLARE_VISITOR(ConstDataLayoutVisitor, const storage::DataLayout::Node, M_DATA_LAYOUT_CLASSES)
 
 /*======================================================================================================================
  * Helper functions for SIMD support

include/mutable/util/Visitor.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <mutable/mutable-config.hpp>
+#include <mutable/util/crtp.hpp>
+#include <mutable/util/fn.hpp>
 #include <mutable/util/macro.hpp>
 #include <mutable/util/some.hpp>
 #include <mutable/util/tag.hpp>
@@ -15,66 +17,119 @@ struct visit_stop_recursion { };
 /** Exception class which can be thrown to skip recursion of the subtree in pre-order visitors. */
 struct visit_skip_subtree { };
 
-/** Visitor base class. */
-template<typename V, typename Base>
-struct Visitor
+/**
+ * Visitor base class, using CRTP.
+ *
+ * \tparam ConcreteVisitor is the actual type of the visitor, \tparam Base is the base type of the class hierarchy to
+ * visit.
+ */
+template<typename ConcreteVisitor, typename Base>
+struct Visitor : crtp<ConcreteVisitor, Visitor, Base>
 {
+    using crtp<ConcreteVisitor, Visitor, Base>::actual;
+
     /** Whether the visited objects are `const`-qualified. */
     static constexpr bool is_const = std::is_const_v<Base>;
 
     /** The base class of the class hierarchy to visit. */
     using base_type = Base;
 
     /** The concrete type of the visitor.  Uses the CRTP design. */
-    using visitor_type = V;
+    using visitor_type = ConcreteVisitor;
 
     /** A helper type to apply the proper `const`-qualification to parameters. */
     template<typename T>
     using Const = std::conditional_t<is_const, const T, T>;
 
     /** Visit the object `obj`. */
-    void operator()(base_type &obj) { static_cast<V*>(this)->operator()(obj); }
+    void operator()(base_type &obj) { actual()(obj); }
+};
+
+/** This helper class creates a single override of `operator()` for one subtype in a class hierarchy, and then
+ * recursively inherits from an instantiation of that same helper class for the next subtype in the hierarchy.  This
+ * enables overriding all visit methods of \tparam Visitor. */
+template<typename Callable, typename ResultType, typename Visitor, typename Class, typename... Classes>
+struct visit_helper : visit_helper<Callable, ResultType, Visitor, Classes...>
+{
+    using super = visit_helper<Callable, ResultType, Visitor, Classes...>;
+
+    visit_helper(Callable &callable, std::optional<some<ResultType>> &result) : super(callable, result) { }
+
+    using super::operator();
+    void operator()(typename Visitor::template Const<Class> &obj) override {
+        if constexpr (std::is_same_v<void, ResultType>) { this->callable(obj); }
+        else { super::result = m::some<ResultType>(this->callable(obj)); }
+    }
+};
+/** This specialization marks the end of the class hierarchy.  It inherits from \tparam Visitor to override the visit
+ * methods. */
+template<typename Callable, typename ResultType, typename Visitor, typename Class>
+struct visit_helper<Callable, ResultType, Visitor, Class> : Visitor
+{
+    Callable &callable;
+    std::optional<some<ResultType>> &result;
+
+    visit_helper(Callable &callable, std::optional<some<ResultType>> &result) : callable(callable), result(result) { }
+
+    using Visitor::operator();
+    void operator()(typename Visitor::template Const<Class> &obj) override {
+        if constexpr (std::is_same_v<void, ResultType>) { this->callable(obj); }
+        else { result = m::some<ResultType>(this->callable(obj)); }
+    }
 };
 
+/**
+ * Generic implementation to visit a class hierarchy, with similar syntax as `std::visit`.  This generic implementation
+ * is meant to be *instantiated* once for each class hierarchy that should be `m::visit()`-able.  The class hierarchy
+ * must provide a \tparam Visitor implementing our `m::Visitor` base class.
+ *
+ * The unnamed third parameter is used for [*tag
+ * dispatching*](https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Tag_Dispatching) to select a particular visitor to
+ * apply.  This is very useful if, for example, you have a compositor pattern implementing a tree structure of objects
+ * and you want to provide pre-order and post-order visitors.  These iterators inherit from `Visitor` base and implement
+ * the pre- or post-order traversal.  You can then call to `m::visit()` and provide `m::tag<MyPreOrderVisitor>` to
+ * select the desired traversal order.
+ *
+ * For an example of how to implement and use the tag dispatch, see `Expr::get_required()` and
+ * `ConstPreOrderExprVisitor`.
+ */
+template<typename Callable, typename Visitor, typename Base, typename... Hierarchy>
+auto visit(Callable &&callable, Base &obj, m::tag<Callable>&& = m::tag<Callable>())
+{
+    ///> compute the result type as the common type of the return types of all visitor applications
+    using result_type = std::common_type_t< std::invoke_result_t<Callable, typename Visitor::template Const<Hierarchy>&>... >;
+
+    std::optional<some<result_type>> result;
+
+    /*----- Create a `visit_helper` and then invoke it on the `obj`. -----*/
+    visit_helper<Callable, result_type, Visitor, Hierarchy...> V(callable, result);
+    try { V(obj); } catch (visit_stop_recursion) { }
+    if constexpr (not std::is_same_v<void, result_type>) {
+        return std::move(V.result->value);
+    } else {
+        return; // result is `void`
+    }
 }
 
-/*----- Generate a function similar to `std::visit` to easily implement a visitor for the given base class. ----------*/
-#define M_GET_INVOKE_RESULT(CLASS) std::invoke_result_t<Vis, Const<CLASS>&>,
-#define M_MAKE_STL_VISIT_METHOD(CLASS) void operator()(Const<CLASS> &obj) override { \
-    if constexpr (std::is_same_v<void, result_type>) { vis(obj); } \
-    else { result = m::some<result_type>(vis(obj)); } \
 }
+
+
+/*----- Generate a function similar to `std::visit` to easily implement a visitor for the given base class. ----------*/
 #define M_MAKE_STL_VISITABLE(VISITOR, BASE_CLASS, CLASS_LIST) \
-    template<typename Vis> \
-    auto M_EXPORT visit(Vis &&vis, BASE_CLASS &obj, m::tag<VISITOR>&& = m::tag<VISITOR>()) { \
-        struct V : VISITOR { \
-            using result_type = std::common_type_t< CLASS_LIST(M_GET_INVOKE_RESULT) std::invoke_result_t<Vis, Const<M_EVAL(M_DEFER1(M_HEAD)(CLASS_LIST(M_COMMA)))>&> >; \
-            Vis &&vis; \
-            std::optional<m::some<result_type>> result; \
-            V(Vis &&vis) : vis(std::forward<Vis>(vis)), result(std::nullopt) { } \
-            V(const V&) = delete; \
-            V(V&&) = default; \
-            using VISITOR::operator(); \
-            CLASS_LIST(M_MAKE_STL_VISIT_METHOD) \
-        }; \
-        V v(std::forward<Vis>(vis)); \
-        try { v(obj); } catch (visit_stop_recursion) { } \
-        if constexpr (not std::is_same_v<void, typename V::result_type>) { \
-            return std::move(v.result->value); \
-        } else { \
-            return; \
-        } \
+    template<typename Callable> \
+    auto visit(Callable &&callable, BASE_CLASS &obj, m::tag<VISITOR>&& = m::tag<VISITOR>()) { \
+        return m::visit<Callable, VISITOR, BASE_CLASS CLASS_LIST(M_COMMA_PRE)>(std::forward<Callable>(callable), obj); \
     }
 
 /*----- Declare a visitor to visit the class hierarchy with the given base class and list of subclasses. -------------*/
 #define M_DECLARE_VISIT_METHOD(CLASS) virtual void operator()(Const<CLASS>&) { };
-#define M_DECLARE_VISITOR(NAME, BASE_CLASS, CLASS_LIST) \
-    struct M_EXPORT NAME : m::Visitor<NAME, BASE_CLASS> \
+#define M_DECLARE_VISITOR(VISITOR_NAME, BASE_CLASS, CLASS_LIST) \
+    struct M_EXPORT VISITOR_NAME : m::Visitor<VISITOR_NAME, BASE_CLASS> \
     { \
-        using super = m::Visitor<NAME, BASE_CLASS>; \
+        using super = m::Visitor<VISITOR_NAME, BASE_CLASS>; \
         template<typename T> using Const = typename super::Const<T>; \
-        virtual ~NAME() {} \
+        virtual ~VISITOR_NAME() {} \
         void operator()(BASE_CLASS &obj) { obj.accept(*this); } \
         CLASS_LIST(M_DECLARE_VISIT_METHOD) \
     }; \
-    M_MAKE_STL_VISITABLE(NAME, BASE_CLASS, CLASS_LIST)
+    M_MAKE_STL_VISITABLE(VISITOR_NAME, BASE_CLASS, CLASS_LIST)