capi: Add static assertions for FizzyValueType* vs. fizzy:ValType::*

lib/fizzy/CMakeLists.txt

@@ -14,6 +14,7 @@ target_sources(
     asserts.hpp
     cxx20/bit.hpp
     cxx20/span.hpp
+    cxx23/utility.hpp
     bytes.hpp
     capi.cpp
     constexpr_vector.hpp

lib/fizzy/capi.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "cxx20/bit.hpp"
+#include "cxx23/utility.hpp"
 #include "execute.hpp"
 #include "instantiate.hpp"
 #include "parser.hpp"
@@ -95,6 +96,13 @@ inline const fizzy::Module* unwrap(const FizzyModule* module) noexcept
 }
 
 static_assert(sizeof(FizzyValueType) == sizeof(fizzy::ValType));
+static_assert(FizzyValueTypeI32 == fizzy::to_underlying(fizzy::ValType::i32));
+static_assert(FizzyValueTypeI64 == fizzy::to_underlying(fizzy::ValType::i64));
+static_assert(FizzyValueTypeF32 == fizzy::to_underlying(fizzy::ValType::f32));
+static_assert(FizzyValueTypeF64 == fizzy::to_underlying(fizzy::ValType::f64));
+static_assert(FizzyValueTypeVoid == 0);
+static_assert(std::is_same_v<decltype(fizzy::to_underlying(fizzy::ValType::i32)),
+    std::remove_const<decltype(FizzyValueTypeI32)>::type>);
 
 inline const FizzyValueType* wrap(const fizzy::ValType* value_types) noexcept
 {

lib/fizzy/cxx23/utility.hpp

@@ -0,0 +1,18 @@
+// Fizzy: A fast WebAssembly interpreter
+// Copyright 2022 The Fizzy Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <type_traits>
+
+namespace fizzy
+{
+/// C++14 version of the proposed C++23 feature
+/// https://en.cppreference.com/w/cpp/utility/to_underlying
+template <typename T>
+constexpr std::underlying_type_t<T> to_underlying(T value) noexcept
+{
+    return static_cast<std::underlying_type_t<T>>(value);
+}
+}  // namespace fizzy

test/unittests/CMakeLists.txt

@@ -19,6 +19,7 @@ target_sources(
     constexpr_vector_test.cpp
     cxx20_bit_test.cpp
     cxx20_span_test.cpp
+    cxx23_utility_test.cpp
     end_to_end_test.cpp
     execute_call_depth_test.cpp
     execute_call_test.cpp

test/unittests/cxx23_utility_test.cpp

@@ -0,0 +1,44 @@
+// Fizzy: A fast WebAssembly interpreter
+// Copyright 2022 The Fizzy Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+#include "cxx23/utility.hpp"
+#include "stack.hpp"
+#include <gtest/gtest.h>
+#include <array>
+#include <vector>
+
+using namespace fizzy;
+using namespace testing;
+
+TEST(cxx23_utility, to_underlying)
+{
+    enum class A
+    {
+        A = 0xff
+    };
+    static_assert(std::is_same_v<decltype(to_underlying(A::A)), int>);
+    EXPECT_EQ(to_underlying(A::A), 0xff);
+
+    enum class A8 : uint8_t
+    {
+        A = 0xff
+    };
+    static_assert(std::is_same_v<decltype(to_underlying(A8::A)), uint8_t>);
+    EXPECT_EQ(to_underlying(A8::A), 0xff);
+
+    enum class A32 : uint32_t
+    {
+        A = 0xff,
+        B = 0xffffffff
+    };
+    static_assert(std::is_same_v<decltype(to_underlying(A32::A)), uint32_t>);
+    EXPECT_EQ(to_underlying(A32::A), 0xff);
+    EXPECT_EQ(to_underlying(A32::B), 0xffffffff);
+
+    enum C
+    {
+        A = 0xff
+    };
+    EXPECT_EQ(to_underlying(C::A), 0xff);
+}