feat: test against wit-bingen tests

Signed-off-by: Gordon Smith <[email protected]>

Author: GordonSmith

.gitignore

@@ -16,3 +16,7 @@ antlr-*.jar
 # Python cache files
 __pycache__/
 *.pyc
+
+# Generated test stubs
+/test/generated_stubs/
+/test/test_stubs_sample/

include/cmcpp.hpp

@@ -2,13 +2,16 @@
 #define CMCPP_HPP
 
 #include <cmcpp/context.hpp>
+#include <cmcpp/monostate.hpp>
+#include <cmcpp/bool.hpp>
 #include <cmcpp/integer.hpp>
 #include <cmcpp/float.hpp>
 #include <cmcpp/string.hpp>
 #include <cmcpp/error_context.hpp>
 #include <cmcpp/flags.hpp>
-#include <cmcpp/list.hpp>
 #include <cmcpp/tuple.hpp>
+#include <cmcpp/record.hpp>
+#include <cmcpp/list.hpp>
 #include <cmcpp/variant.hpp>
 #include <cmcpp/func.hpp>
 #include <cmcpp/lower.hpp>

include/cmcpp/bool.hpp

@@ -0,0 +1,38 @@
+#ifndef CMCPP_BOOL_HPP
+#define CMCPP_BOOL_HPP
+
+#include "context.hpp"
+#include "integer.hpp"
+#include "util.hpp"
+
+namespace cmcpp
+{
+    //  Boolean  ------------------------------------------------------------------
+    template <Boolean T>
+    inline void store(LiftLowerContext &cx, const T &v, uint32_t ptr)
+    {
+        uint8_t byte = v ? 1 : 0;
+        integer::store<uint8_t>(cx, byte, ptr);
+    }
+
+    template <Boolean T>
+    inline WasmValVector lower_flat(LiftLowerContext &cx, const T &v)
+    {
+        using WasmValType = WasmValTypeTrait<ValTrait<T>::flat_types[0]>::type;
+        return {static_cast<WasmValType>(v)};
+    }
+
+    template <Boolean T>
+    inline T load(const LiftLowerContext &cx, uint32_t ptr)
+    {
+        return convert_int_to_bool(integer::load<uint8_t>(cx, ptr));
+    }
+
+    template <Boolean T>
+    inline T lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi)
+    {
+        return convert_int_to_bool(vi.next<int32_t>());
+    }
+}
+
+#endif // CMCPP_BOOL_HPP

include/cmcpp/integer.hpp

@@ -49,32 +49,6 @@ namespace cmcpp
         }
     }
 
-    //  Boolean  ------------------------------------------------------------------
-    template <Boolean T>
-    inline void store(LiftLowerContext &cx, const T &v, uint32_t ptr)
-    {
-        uint8_t byte = v ? 1 : 0;
-        integer::store<uint8_t>(cx, byte, ptr);
-    }
-    template <Boolean T>
-    inline WasmValVector lower_flat(LiftLowerContext &cx, const T &v)
-    {
-        using WasmValType = WasmValTypeTrait<ValTrait<T>::flat_types[0]>::type;
-        return {static_cast<WasmValType>(v)};
-    }
-
-    template <Boolean T>
-    inline T load(const LiftLowerContext &cx, uint32_t ptr)
-    {
-        return convert_int_to_bool(integer::load<uint8_t>(cx, ptr));
-    }
-
-    template <Boolean T>
-    inline T lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi)
-    {
-        return convert_int_to_bool(vi.next<int32_t>());
-    }
-
     //  Char  ------------------------------------------------------------------
     template <Char T>
     inline void store(LiftLowerContext &cx, const T &v, uint32_t ptr)

include/cmcpp/monostate.hpp

@@ -0,0 +1,205 @@
+#ifndef CMCPP_MONOSTATE_HPP
+#define CMCPP_MONOSTATE_HPP
+
+#include "context.hpp"
+#include "traits.hpp"
+#include "util.hpp"
+
+namespace cmcpp
+{
+    //  Monostate (unit type for variant cases without payload)  ---------------
+    template <typename T>
+        requires std::is_same_v<T, std::monostate>
+    inline void store(LiftLowerContext &cx, const T &v, uint32_t ptr)
+    {
+        // Monostate has no data to store (size = 0)
+    }
+
+    template <typename T>
+        requires std::is_same_v<T, std::monostate>
+    inline T load(const LiftLowerContext &cx, uint32_t ptr)
+    {
+        // Monostate has no data to load (size = 0)
+        return T{};
+    }
+
+    template <typename T>
+        requires std::is_same_v<T, std::monostate>
+    inline WasmValVector lower_flat(LiftLowerContext &cx, const T &v)
+    {
+        // Monostate has no flat representation (empty vector)
+        return {};
+    }
+
+    template <typename T>
+        requires std::is_same_v<T, std::monostate>
+    inline T lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi)
+    {
+        // Monostate has no data to lift
+        return T{};
+    }
+
+    //  Result-specific monostates (for result<_, _> edge cases)  --------------
+    template <typename T>
+        requires std::is_same_v<T, result_ok_monostate> || std::is_same_v<T, result_err_monostate>
+    inline void store(LiftLowerContext &cx, const T &v, uint32_t ptr)
+    {
+        // Result monostates have no data to store (size = 0)
+    }
+
+    template <typename T>
+        requires std::is_same_v<T, result_ok_monostate> || std::is_same_v<T, result_err_monostate>
+    inline T load(const LiftLowerContext &cx, uint32_t ptr)
+    {
+        // Result monostates have no data to load (size = 0)
+        return T{};
+    }
+
+    template <typename T>
+        requires std::is_same_v<T, result_ok_monostate> || std::is_same_v<T, result_err_monostate>
+    inline WasmValVector lower_flat(LiftLowerContext &cx, const T &v)
+    {
+        // Result monostates have no flat representation (empty vector)
+        return {};
+    }
+
+    template <typename T>
+        requires std::is_same_v<T, result_ok_monostate> || std::is_same_v<T, result_err_monostate>
+    inline T lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi)
+    {
+        // Result monostates have no data to lift
+        return T{};
+    }
+
+    //  Result wrappers (for result<T, T> edge cases)  -------------------------
+    template <typename T>
+    inline void store(LiftLowerContext &cx, const result_ok_wrapper<T> &v, uint32_t ptr)
+    {
+        store(cx, v.value, ptr);
+    }
+
+    template <typename T>
+    inline void store(LiftLowerContext &cx, const result_err_wrapper<T> &v, uint32_t ptr)
+    {
+        store(cx, v.value, ptr);
+    }
+
+    template <typename T>
+    inline result_ok_wrapper<T> load(const LiftLowerContext &cx, uint32_t ptr)
+    {
+        return result_ok_wrapper<T>{load<T>(cx, ptr)};
+    }
+
+    template <typename T>
+    inline result_err_wrapper<T> load(const LiftLowerContext &cx, uint32_t ptr)
+    {
+        return result_err_wrapper<T>{load<T>(cx, ptr)};
+    }
+
+    template <typename T>
+    inline WasmValVector lower_flat(LiftLowerContext &cx, const result_ok_wrapper<T> &v)
+    {
+        return lower_flat(cx, v.value);
+    }
+
+    template <typename T>
+    inline WasmValVector lower_flat(LiftLowerContext &cx, const result_err_wrapper<T> &v)
+    {
+        return lower_flat(cx, v.value);
+    }
+
+    template <typename T>
+    inline result_ok_wrapper<T> lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi)
+    {
+        return result_ok_wrapper<T>{lift_flat<T>(cx, vi)};
+    }
+
+    template <typename T>
+    inline result_err_wrapper<T> lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi)
+    {
+        return result_err_wrapper<T>{lift_flat<T>(cx, vi)};
+    }
+}
+
+// std::tuple_size and std::tuple_element specializations for result wrappers
+// These are needed for std::apply to work with result_ok_wrapper/result_err_wrapper
+// The wrappers act as single-element tuples containing their wrapped value
+namespace std
+{
+    template <typename T>
+    struct tuple_size<cmcpp::result_ok_wrapper<T>> : std::integral_constant<std::size_t, std::tuple_size_v<T>>
+    {
+    };
+
+    template <std::size_t I, typename T>
+    struct tuple_element<I, cmcpp::result_ok_wrapper<T>>
+    {
+        using type = std::tuple_element_t<I, T>;
+    };
+
+    template <typename T>
+    struct tuple_size<cmcpp::result_err_wrapper<T>> : std::integral_constant<std::size_t, std::tuple_size_v<T>>
+    {
+    };
+
+    template <std::size_t I, typename T>
+    struct tuple_element<I, cmcpp::result_err_wrapper<T>>
+    {
+        using type = std::tuple_element_t<I, T>;
+    };
+}
+
+// std::get specializations for result wrappers to support structured bindings and std::apply
+// Forward get<I> calls to the wrapped tuple
+namespace std
+{
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(cmcpp::result_ok_wrapper<T> &wrapper) noexcept
+    {
+        return std::get<I>(wrapper.value);
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(const cmcpp::result_ok_wrapper<T> &wrapper) noexcept
+    {
+        return std::get<I>(wrapper.value);
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(cmcpp::result_ok_wrapper<T> &&wrapper) noexcept
+    {
+        return std::get<I>(std::move(wrapper.value));
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(const cmcpp::result_ok_wrapper<T> &&wrapper) noexcept
+    {
+        return std::get<I>(std::move(wrapper.value));
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(cmcpp::result_err_wrapper<T> &wrapper) noexcept
+    {
+        return std::get<I>(wrapper.value);
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(const cmcpp::result_err_wrapper<T> &wrapper) noexcept
+    {
+        return std::get<I>(wrapper.value);
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(cmcpp::result_err_wrapper<T> &&wrapper) noexcept
+    {
+        return std::get<I>(std::move(wrapper.value));
+    }
+
+    template <std::size_t I, typename T>
+    constexpr decltype(auto) get(const cmcpp::result_err_wrapper<T> &&wrapper) noexcept
+    {
+        return std::get<I>(std::move(wrapper.value));
+    }
+}
+
+#endif // CMCPP_MONOSTATE_HPP

include/cmcpp/record.hpp

@@ -0,0 +1,65 @@
+#ifndef CMCPP_RECORD_HPP
+#define CMCPP_RECORD_HPP
+
+#include "context.hpp"
+#include "store.hpp"
+#include "load.hpp"
+#include "tuple.hpp"
+#include "util.hpp"
+#include <boost/pfr.hpp>
+
+namespace cmcpp
+{
+    // Helper to convert tuple to struct (works with plain structs, not just record_t)
+    template <Struct S, Tuple T, std::size_t... I>
+    S tuple_to_struct_impl(const T &t, std::index_sequence<I...>)
+    {
+        return S{std::get<I>(t)...};
+    }
+
+    template <Struct S, Tuple T>
+    S tuple_to_struct(const T &t)
+    {
+        return tuple_to_struct_impl<S>(t, std::make_index_sequence<std::tuple_size_v<T>>{});
+    }
+
+    // Store a record to WebAssembly linear memory
+    // Records are stored as tuples of their fields using Boost PFR for reflection
+    template <Record T>
+    inline void store(LiftLowerContext &cx, const T &v, uint32_t ptr)
+    {
+        // record_t<R> inherits from R, so we need to work with the base struct
+        using base_type = typename ValTrait<T>::inner_type;
+        const base_type &base = static_cast<const base_type &>(v);
+
+        // Convert the base struct to a tuple using Boost PFR reflection
+        auto tuple_value = boost::pfr::structure_to_tuple(base);
+
+        // Store the tuple (which handles all fields sequentially)
+        tuple::store(cx, tuple_value, ptr);
+    }
+
+    // Load a record from WebAssembly linear memory
+    // Records are loaded as tuples of their fields using Boost PFR for reflection
+    template <Record T>
+    inline T load(const LiftLowerContext &cx, uint32_t ptr)
+    {
+        // Get the tuple type for this record
+        using tuple_type = typename ValTrait<T>::tuple_type;
+
+        // Load as a tuple
+        auto tuple_value = tuple::load<tuple_type>(cx, ptr);
+
+        // Convert tuple back to the base struct
+        using base_type = typename ValTrait<T>::inner_type;
+        base_type base = tuple_to_struct<base_type>(tuple_value);
+
+        // Construct the record_t wrapper from the base
+        T result;
+        static_cast<base_type &>(result) = base;
+        return result;
+    }
+
+} // namespace cmcpp
+
+#endif // CMCPP_RECORD_HPP