fix: remove additional tuple wrapper on lift

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

include/cmcpp/lift.hpp

@@ -43,18 +43,16 @@ namespace cmcpp
     template <Option T>
     inline T lift_flat(const LiftLowerContext &cx, const CoreValueIter &vi);
 
-    template <Tuple T>
+    template <Field T>
     inline T lift_heap_values(const LiftLowerContext &cx, const CoreValueIter &vi)
     {
         uint32_t ptr = vi.next<int32_t>();
-        using tuple_type = typename std::tuple_element<0, typename ValTrait<T>::inner_type>::type;
-        trap_if(cx, ptr != align_to(ptr, ValTrait<tuple_type>::alignment));
-        trap_if(cx, ptr + ValTrait<tuple_type>::size > cx.opts.memory.size());
-        auto retVal = load<tuple_type>(cx, ptr);
-        return retVal;
+        trap_if(cx, ptr != align_to(ptr, ValTrait<T>::alignment));
+        trap_if(cx, ptr + ValTrait<T>::size > cx.opts.memory.size());
+        return load<T>(cx, ptr);
     }
 
-    template <Tuple T>
+    template <Field T>
     inline T lift_flat_values(const LiftLowerContext &cx, uint max_flat, const CoreValueIter &vi)
     {
         auto flat_types = ValTrait<T>::flat_types;

include/cmcpp/traits.hpp

@@ -722,9 +722,9 @@ namespace cmcpp
         static constexpr ValType type = ValType::Func;
         using inner_type = std::function<R(Args...)>;
         using params_t = tuple_t<Args...>;
-        using results_t = tuple_t<R>;
+        using result_t = R;
         static constexpr auto flat_params_types = ValTrait<params_t>::flat_types;
-        static constexpr auto flat_result_types = ValTrait<results_t>::flat_types;
+        static constexpr auto flat_result_types = ValTrait<result_t>::flat_types;
     };
 
     template <typename T>

samples/wamr/main.cpp

@@ -117,7 +117,7 @@ template <typename F>
 func_t<F> attach(const wasm_module_inst_t &module_inst, const wasm_exec_env_t &exec_env, LiftLowerContext &liftLowerContext, const char *name)
 {
     using params_t = typename ValTrait<func_t<F>>::params_t;
-    using results_t = typename ValTrait<func_t<F>>::results_t;
+    using result_t = typename ValTrait<func_t<F>>::result_t;
 
     wasm_function_inst_t guest_func = wasm_runtime_lookup_function(module_inst, name);
     wasm_function_inst_t guest_cleanup_func = wasm_runtime_lookup_function(module_inst, (std::string("cabi_post_") + name).c_str());
@@ -130,7 +130,7 @@ func_t<F> attach(const wasm_module_inst_t &module_inst, const wasm_exec_env_t &e
             {std::forward<decltype(args)>(args)...});
         std::vector<wasm_val_t> inputs = toWamr(lowered_args);
 
-        constexpr size_t output_size = std::tuple_size<results_t>::value;
+        constexpr size_t output_size = std::is_same<result_t, void>::value ? 0 : 1;
         wasm_val_t outputs[output_size];
 
         bool success = wasm_runtime_call_wasm_a(exec_env, guest_func,
@@ -144,15 +144,15 @@ func_t<F> attach(const wasm_module_inst_t &module_inst, const wasm_exec_env_t &e
             liftLowerContext.trap(exception ? exception : "Unknown WAMR execution error");
         }
 
-        WasmValVector flat_results = fromWamr<results_t>(output_size, outputs);
-        auto output = lift_flat_values<results_t>(liftLowerContext, MAX_FLAT_RESULTS, flat_results);
+        WasmValVector flat_results = fromWamr<result_t>(output_size, outputs);
+        auto output = lift_flat_values<result_t>(liftLowerContext, MAX_FLAT_RESULTS, flat_results);
 
         if (guest_cleanup_func)
         {
             wasm_runtime_call_wasm_a(exec_env, guest_cleanup_func, 0, nullptr, output_size, outputs);
         }
 
-        return std::get<0>(output);
+        return output;
     };
 }