From 71d24224a7e63cbea0329c3b02c63c45d73cd015 Mon Sep 17 00:00:00 2001
From: Nana Sakisaka <1901813+saki7@users.noreply.github.com>
Date: Tue, 18 Aug 2026 22:14:58 +0900
Subject: [PATCH] Add `make_integer_of_size`, `make_(signed|unsigned)_of_size`

---
 include/iris/bits/is_function_object.hpp |   2 +
 include/iris/bits/specialization_of.hpp  |   2 +
 include/iris/requirements.hpp            |   4 +-
 include/iris/stdint.hpp                  | 130 +++++++++++++++++++++++
 include/iris/type_traits.hpp             |  41 ++++++-
 test/CMakeLists.txt                      |   1 +
 test/stdint.cpp                          | 118 ++++++++++++++++++++
 7 files changed, 295 insertions(+), 3 deletions(-)
 create mode 100644 include/iris/stdint.hpp
 create mode 100644 test/stdint.cpp

diff --git a/include/iris/bits/is_function_object.hpp b/include/iris/bits/is_function_object.hpp
index 420aaa0..59c2788 100644
--- a/include/iris/bits/is_function_object.hpp
+++ b/include/iris/bits/is_function_object.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <type_traits>
 
 namespace iris {
diff --git a/include/iris/bits/specialization_of.hpp b/include/iris/bits/specialization_of.hpp
index 43d5609..b9a771c 100644
--- a/include/iris/bits/specialization_of.hpp
+++ b/include/iris/bits/specialization_of.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <type_traits>
 
 namespace iris {
diff --git a/include/iris/requirements.hpp b/include/iris/requirements.hpp
index 16be80e..6a43bda 100644
--- a/include/iris/requirements.hpp
+++ b/include/iris/requirements.hpp
@@ -3,11 +3,13 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <iris/hash_fwd.hpp>
 #include <iris/bits/is_function_object.hpp>
 #include <iris/bits/specialization_of.hpp>
 
-#include <concepts>
+#include <concepts> // IWYU pragma: export
 #include <type_traits>
 #include <utility>
 
diff --git a/include/iris/stdint.hpp b/include/iris/stdint.hpp
new file mode 100644
index 0000000..1edf9e4
--- /dev/null
+++ b/include/iris/stdint.hpp
@@ -0,0 +1,130 @@
+#ifndef IRIS_ZZ_STDINT_HPP
+#define IRIS_ZZ_STDINT_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/type_traits.hpp>
+
+#include <concepts>
+#include <type_traits>
+
+#include <cstdint> // IWYU pragma: export
+#include <cstddef> // IWYU pragma: keep
+
+namespace iris {
+
+// `std::make_signed<T>` family requires T to be nonbool integer or enum
+
+namespace detail {
+
+template<bool IsSigned, std::size_t Bytes>
+struct integer_of_size_impl;
+
+template<>
+struct integer_of_size_impl<true, 1>
+{
+    using type = std::int8_t;
+};
+
+template<>
+struct integer_of_size_impl<true, 2>
+{
+    using type = std::int16_t;
+};
+
+template<>
+struct integer_of_size_impl<true, 4>
+{
+    using type = std::int32_t;
+};
+
+template<>
+struct integer_of_size_impl<true, 8>
+{
+    using type = std::int64_t;
+};
+
+// ----------------------------------------------
+
+template<>
+struct integer_of_size_impl<false, 1>
+{
+    using type = std::uint8_t;
+};
+
+template<>
+struct integer_of_size_impl<false, 2>
+{
+    using type = std::uint16_t;
+};
+
+template<>
+struct integer_of_size_impl<false, 4>
+{
+    using type = std::uint32_t;
+};
+
+template<>
+struct integer_of_size_impl<false, 8>
+{
+    using type = std::uint64_t;
+};
+
+template<class T>
+struct signedness_of_integral;
+
+template<std::integral T>
+struct signedness_of_integral<T> : std::bool_constant<std::is_signed_v<T>>
+{};
+
+template<class T>
+    requires std::is_enum_v<T>
+struct signedness_of_integral<T> : std::bool_constant<std::is_signed_v<std::underlying_type_t<T>>>
+{};
+
+template<class T>
+using make_signed_of_size_impl_t = integer_of_size_impl<true, sizeof(T)>::type;
+
+template<class T>
+using make_unsigned_of_size_impl_t = integer_of_size_impl<false, sizeof(T)>::type;
+
+template<class T>
+using make_integer_of_size_impl_t = integer_of_size_impl<signedness_of_integral<T>::value, sizeof(T)>::type;
+
+} // detail
+
+template<class T>
+struct make_signed_of_size
+{
+    static_assert(std::integral<T> && !std::same_as<std::remove_cv_t<T>, bool> || std::is_enum_v<T>);
+    using type = remove_cv<T>::template apply<detail::make_signed_of_size_impl_t>;
+};
+
+template<class T>
+using make_signed_of_size_t = make_signed_of_size<T>::type;
+
+template<class T>
+struct make_unsigned_of_size
+{
+    static_assert(std::integral<T> && !std::same_as<std::remove_cv_t<T>, bool> || std::is_enum_v<T>);
+    using type = remove_cv<T>::template apply<detail::make_unsigned_of_size_impl_t>;
+};
+
+template<class T>
+using make_unsigned_of_size_t = make_unsigned_of_size<T>::type;
+
+template<class T>
+struct make_integer_of_size
+{
+    static_assert(std::integral<T> && !std::same_as<std::remove_cv_t<T>, bool> || std::is_enum_v<T>);
+    using type = remove_cv<T>::template apply<detail::make_integer_of_size_impl_t>;
+};
+
+template<class T>
+using make_integer_of_size_t = make_integer_of_size<T>::type;
+
+} // iris
+
+#endif
diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
index 7400713..fcce5ad 100644
--- a/include/iris/type_traits.hpp
+++ b/include/iris/type_traits.hpp
@@ -3,7 +3,7 @@
 
 // SPDX-License-Identifier: MIT
 
-#include <iris/config.hpp>
+#include <iris/config.hpp> // IWYU pragma: keep
 
 #include <iris/bits/is_function_object.hpp>  // IWYU pragma: export
 #include <iris/bits/specialization_of.hpp>  // IWYU pragma: export
@@ -11,13 +11,50 @@
 #include <iris/requirements.hpp>
 
 #include <concepts>
-#include <type_traits>
+#include <type_traits> // IWYU pragma: export
 #include <utility>
 
 #include <cstddef>
 
 namespace iris {
 
+template<class T>
+struct remove_cv
+{
+    using type = T;
+
+    template<template <class> class F>
+    using apply = F<T>;
+};
+
+template<class T>
+struct remove_cv<T const>
+{
+    using type = T;
+
+    template<template <class> class F>
+    using apply = F<T> const;
+};
+
+template<class T>
+struct remove_cv<T volatile>
+{
+    using type = T;
+
+    template<template <class> class F>
+    using apply = F<T> volatile;
+};
+
+template<class T>
+struct remove_cv<T const volatile>
+{
+    using type = T;
+
+    template<template <class> class F>
+    using apply = F<T> const volatile;
+};
+
+
 template<class... Ts>
 struct type_list
 {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 846ac6c..6a46bc3 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -179,6 +179,7 @@ if(PROJECT_IS_TOP_LEVEL)
             IRIS_TEST_IRIS_TESTS
             core
             type_traits
+            stdint
             enum
             indirect
             colorize_format
diff --git a/test/stdint.cpp b/test/stdint.cpp
new file mode 100644
index 0000000..44952e6
--- /dev/null
+++ b/test/stdint.cpp
@@ -0,0 +1,118 @@
+#include "iris_test.hpp"
+
+#include <iris/stdint.hpp>
+
+#include <concepts>
+
+#include <cstdint>
+#include <cstddef> // std::byte
+
+enum non_scoped_int16_t : std::int16_t {};
+enum struct scoped_int16_t : std::int16_t {};
+
+TEST_CASE("stdint")
+{
+    static_assert(sizeof(char) == 1);
+
+    {
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int8_t>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int32_t>, std::int32_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int64_t>, std::int64_t>);
+
+        // If cv variants works here, everything else works; skip other test cases.
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int8_t const>, std::int8_t const>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int16_t const>, std::int16_t const>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int32_t const>, std::int32_t const>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int64_t const>, std::int64_t const>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int8_t const volatile>, std::int8_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int16_t const volatile>, std::int16_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int32_t const volatile>, std::int32_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::int64_t const volatile>, std::int64_t const volatile>);
+
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::uint8_t>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::uint16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::uint32_t>, std::int32_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::uint64_t>, std::int64_t>);
+
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<char>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<signed char>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<unsigned char>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<char8_t>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<char16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<char32_t>, std::int32_t>);
+
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<std::byte>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<non_scoped_int16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_signed_of_size_t<scoped_int16_t>, std::int16_t>);
+    }
+    {
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int8_t>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int32_t>, std::uint32_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int64_t>, std::uint64_t>);
+
+        // If cv variants works here, everything else works; skip other test cases.
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int8_t const>, std::uint8_t const>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int16_t const>, std::uint16_t const>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int32_t const>, std::uint32_t const>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int64_t const>, std::uint64_t const>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int8_t const volatile>, std::uint8_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int16_t const volatile>, std::uint16_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int32_t const volatile>, std::uint32_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::int64_t const volatile>, std::uint64_t const volatile>);
+
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::uint8_t>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::uint16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::uint32_t>, std::uint32_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::uint64_t>, std::uint64_t>);
+
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<char>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<signed char>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<unsigned char>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<char8_t>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<char16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<char32_t>, std::uint32_t>);
+
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::byte>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<std::byte const>, std::uint8_t const>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<non_scoped_int16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<non_scoped_int16_t const>, std::uint16_t const>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<scoped_int16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_unsigned_of_size_t<scoped_int16_t const>, std::uint16_t const>);
+    }
+    {
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int8_t>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int32_t>, std::int32_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int64_t>, std::int64_t>);
+
+        // If cv variants works here, everything else works; skip other test cases.
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int8_t const>, std::int8_t const>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int16_t const>, std::int16_t const>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int32_t const>, std::int32_t const>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int64_t const>, std::int64_t const>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int8_t const volatile>, std::int8_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int16_t const volatile>, std::int16_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int32_t const volatile>, std::int32_t const volatile>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::int64_t const volatile>, std::int64_t const volatile>);
+
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::uint8_t>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::uint16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::uint32_t>, std::uint32_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::uint64_t>, std::uint64_t>);
+
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<signed char>, std::int8_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<unsigned char>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<char8_t>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<char16_t>, std::uint16_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<char32_t>, std::uint32_t>);
+
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::byte>, std::uint8_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<std::byte const>, std::uint8_t const>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<non_scoped_int16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<non_scoped_int16_t const>, std::int16_t const>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<scoped_int16_t>, std::int16_t>);
+        STATIC_CHECK(std::same_as<iris::make_integer_of_size_t<scoped_int16_t const>, std::int16_t const>);
+    }
+}