From cb354f2126fb1eae9254414cbe9fc77256ab384d Mon Sep 17 00:00:00 2001
From: Nana Sakisaka <1901813+saki7@users.noreply.github.com>
Date: Mon, 28 Sep 2026 22:41:48 +0900
Subject: [PATCH] Add `is_*_without_any_narrowing` family that checks
 user-defined conversion

---
 include/iris/type_traits.hpp | 286 ++++++++++++++++++-----
 test/CMakeLists.txt          |   1 +
 test/narrowing.cpp           | 427 +++++++++++++++++++++++++++++++++++
 test/type_traits.cpp         | 426 ----------------------------------
 4 files changed, 662 insertions(+), 478 deletions(-)
 create mode 100644 test/narrowing.cpp

diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
index a27fb64..4a9ece7 100644
--- a/include/iris/type_traits.hpp
+++ b/include/iris/type_traits.hpp
@@ -9,6 +9,7 @@
 #include <iris/bits/specialization_of.hpp>  // IWYU pragma: export
 
 #include <concepts>
+#include <initializer_list>
 #include <type_traits> // IWYU pragma: export
 #include <utility>
 
@@ -193,6 +194,24 @@ template<class T, class U>
 concept weakly_assignable_from = std::is_assignable_v<T, U>;
 
 
+template<class T>
+// ReSharper disable once CppFunctionDoesntReturnValue
+[[nodiscard]] T declval_exact() noexcept
+{
+    // ReSharper disable once CppStaticAssertFailure
+    static_assert(false, "declval_exact() must not be odr-used");
+}
+
+template<class T>
+// ReSharper disable once CppFunctionDoesntReturnValue
+[[nodiscard]] T copy_initialize(T) noexcept
+{
+    // ReSharper disable once CppStaticAssertFailure
+    static_assert(false, "copy_initialize() must not be odr-used");
+}
+
+// ----------------------------------------------
+
 namespace detail {
 
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p0870r8.html
@@ -212,14 +231,6 @@ struct is_convertible_without_narrowing_array_check<From, To>
 
 // ----------------------------------------------
 
-// Array of reference cannot be formed, handle special case.
-template<class From, class To>
-struct is_convertible_without_narrowing_dispatch
-    : is_convertible_without_narrowing_array_check<From, To>
-{
-    static_assert(!std::is_reference_v<To>);
-};
-
 template<class From, class To>
 using is_never_narrowing_family = std::disjunction<
     std::is_same<std::remove_cvref_t<From>, std::remove_cvref_t<To>>,
@@ -227,47 +238,52 @@ using is_never_narrowing_family = std::disjunction<
     std::is_function<std::remove_cvref_t<To>>,
     std::is_array<std::remove_cvref_t<To>>
 >;
-template<class From, class To>
-    requires
-        std::is_reference_v<To> &&
-        is_never_narrowing_family<From, To>::value
-struct is_convertible_without_narrowing_dispatch<From, To>
-    : std::true_type
-{};
 
-template<class From, class To>
+template<bool Direct, class From, class To>
+using reference_binds_to_temporary = std::conditional_t<
+    Direct,
+    std::reference_constructs_from_temporary<To, From>,
+    std::reference_converts_from_temporary<To, From>
+>;
+
+// `Check<From, To>` judges the initialization of a non-reference `To`.
+// Array of reference cannot be formed, so a reference is judged by the temporary it binds to.
+template<template<class, class> class Check, bool Direct, class From, class To>
+struct narrowing_check_dispatch
+    : Check<From, To>
+{
+    static_assert(!std::is_reference_v<To>);
+};
+
+template<template<class, class> class Check, bool Direct, class From, class To>
     requires
         std::is_reference_v<To> &&
-        (!is_never_narrowing_family<From, To>::value) &&
-        (!std::reference_converts_from_temporary_v<To, From>)
-struct is_convertible_without_narrowing_dispatch<From, To>
+        (is_never_narrowing_family<From, To>::value || !reference_binds_to_temporary<Direct, From, To>::value)
+struct narrowing_check_dispatch<Check, Direct, From, To>
     : std::true_type
 {};
 
-template<class From, class To>
+template<template<class, class> class Check, bool Direct, class From, class To>
     requires
         std::is_reference_v<To> &&
         (!is_never_narrowing_family<From, To>::value) &&
-        std::reference_converts_from_temporary_v<To, From>
-struct is_convertible_without_narrowing_dispatch<From, To>
-    : is_convertible_without_narrowing_array_check<
-        From,
-        std::remove_reference_t<To> // temporary type is copy-list-initialized
-    >
+        reference_binds_to_temporary<Direct, From, To>::value
+struct narrowing_check_dispatch<Check, Direct, From, To>
+    : Check<From, std::remove_reference_t<To>> // temporary is copy-initialized
 {};
 
 // ----------------------------------------------
 
-template<class From, class To>
-struct is_convertible_without_narrowing_impl
-    : is_convertible_without_narrowing_dispatch<From, To>
+template<template<class, class> class Check, class From, class To>
+struct convertible_narrowing_check
+    : narrowing_check_dispatch<Check, false, From, To>
 {};
 
 // Corner case mentioned on the paper: void
 // cv variants are already handled via `std::is_convertible`.
-template<class From, class To>
+template<template<class, class> class Check, class From, class To>
     requires std::is_void_v<To>
-struct is_convertible_without_narrowing_impl<From, To>
+struct convertible_narrowing_check<Check, From, To>
     : std::true_type
 {};
 
@@ -277,9 +293,10 @@ struct is_convertible_without_narrowing_impl<From, To>
 // This is already applied to all major vendors, but some implementations
 // disagree with `std::nullptr_t`. Note that `std::nullptr_t` is NOT a
 // pointer type, so it cannot be checked with `std::is_pointer`.
-template<class From, class To>
+template<template<class, class> class Check, class From, class To>
     requires std::is_null_pointer_v<From> && std::same_as<std::remove_cvref_t<To>, bool>
-struct is_convertible_without_narrowing_impl<From, To> : std::false_type
+struct convertible_narrowing_check<Check, From, To>
+    : std::false_type
 {};
 
 } // namespace detail
@@ -291,12 +308,195 @@ struct is_convertible_without_narrowing : std::false_type
 template<class From, class To>
     requires std::is_convertible_v<From, To>
 struct is_convertible_without_narrowing<From, To>
-    : detail::is_convertible_without_narrowing_impl<From, To>
+    : detail::convertible_narrowing_check<detail::is_convertible_without_narrowing_array_check, From, To>
 {};
 
 template<class From, class To>
 inline constexpr bool is_convertible_without_narrowing_v = is_convertible_without_narrowing<From, To>::value;
 
+// ----------------------------------------------
+
+namespace detail {
+
+template<class T>
+concept class_or_union = std::is_class_v<T> || std::is_union_v<T>;
+
+// Unlike `std::is_convertible_v`, false for an incomplete or abstract `T`
+template<class T, class From>
+concept copy_initializable = requires { iris::copy_initialize<T>(std::declval<From>()); };
+
+template<class T, class From>
+concept copy_list_initializable = requires { iris::copy_initialize<std::remove_cv_t<T>>({std::declval<From>()}); };
+
+template<class T, class... Args>
+concept direct_list_initializable = requires { std::type_identity_t<std::remove_cv_t<T>>{std::declval<Args>()...}; };
+
+template<class T, class U>
+concept list_assignable = requires { std::declval<T>() = {std::declval<U>()}; };
+
+// ----------------------------------------------
+
+struct opaque_checker
+{
+    opaque_checker() = default;
+    opaque_checker(opaque_checker const&) = delete;
+};
+
+template<class... Args>
+struct initializer_list_checker : opaque_checker
+{
+    template<class E>
+        requires (copy_initializable<E, Args> && ...)
+    operator std::initializer_list<E>() const;
+};
+
+// `T{args...}` selects an initializer-list constructor regardless of narrowing
+template<class T, class... Args>
+concept selects_initializer_list =
+    !std::is_aggregate_v<T> &&
+    (
+        (!std::is_constructible_v<T, opaque_checker const&> &&
+         std::is_constructible_v<T, initializer_list_checker<Args...> const&>) ||
+        (direct_list_initializable<T, Args..., Args...> && !std::is_constructible_v<T, Args..., Args...>)
+    );
+
+template<class T, class U>
+concept selects_initializer_list_assignment =
+    selects_initializer_list<std::remove_cvref_t<T>, U> ||
+    std::is_assignable_v<T, initializer_list_checker<U> const&>;
+
+// ----------------------------------------------
+
+template<class From, class To>
+concept copy_initializable_without_any_narrowing =
+    !selects_initializer_list<To, From> &&
+    (
+        (class_or_union<To> && class_or_union<std::remove_cvref_t<From>>) ||
+        copy_list_initializable<To, From>
+    );
+
+template<class From, class To>
+struct copy_initialization_narrowing_check
+    : std::bool_constant<copy_initializable_without_any_narrowing<From, To>>
+{};
+
+// ----------------------------------------------
+
+template<class V, bool Strict>
+struct class_checker : opaque_checker
+{
+    template<class P>
+        requires std::is_scalar_v<P> && std::is_convertible_v<V, P>
+    operator P() const = delete;
+
+    template<class Q>
+        requires
+            class_or_union<Q> && copy_initializable<Q, V> &&
+            (!Strict || copy_initializable_without_any_narrowing<V, Q>)
+    operator Q() const;
+};
+
+template<class V>
+struct value_checker : opaque_checker
+{
+    operator std::add_rvalue_reference_t<V>() const;
+};
+
+template<class T, class... Args>
+struct direct_initialization_narrowing_check
+    : std::false_type
+{};
+
+template<class T, class... Args>
+    requires
+        (!selects_initializer_list<T, Args...>) &&
+        direct_list_initializable<T, Args...> &&
+        std::is_constructible_v<
+            T,
+            std::conditional_t<class_or_union<std::remove_cvref_t<Args>>, Args, value_checker<Args>>...
+        >
+struct direct_initialization_narrowing_check<T, Args...>
+    : std::true_type
+{};
+
+template<class T>
+struct direct_initialization_narrowing_check<T>
+    : std::true_type
+{};
+
+template<class T, class Arg>
+concept direct_initializable_without_any_narrowing =
+    !selects_initializer_list<T, Arg> &&
+    direct_list_initializable<T, Arg> &&
+    (
+        // `T{v}` may not check narrowing in the converting constructor of a class-type parameter
+        !std::is_constructible_v<T, class_checker<Arg, false>> ||
+        std::is_constructible_v<T, class_checker<Arg, true>>
+    );
+
+template<class T, class Arg>
+struct direct_initialization_narrowing_check<T, Arg>
+    : std::bool_constant<direct_initializable_without_any_narrowing<T, Arg>>
+{};
+
+template<class T, class Arg>
+    requires std::is_reference_v<T>
+struct direct_initialization_narrowing_check<T, Arg>
+    : narrowing_check_dispatch<copy_initialization_narrowing_check, true, Arg, T>
+{};
+
+// See the note on P1957R2 above
+template<class T, class Arg>
+    requires std::is_null_pointer_v<std::remove_cvref_t<Arg>> && std::same_as<std::remove_cv_t<T>, bool>
+struct direct_initialization_narrowing_check<T, Arg>
+    : std::false_type
+{};
+
+} // detail
+
+// is_convertible_without_narrowing + also rejects user-defined conversion in constructor
+template<class From, class To>
+struct is_convertible_without_any_narrowing : std::false_type
+{};
+
+template<class From, class To>
+    requires std::is_convertible_v<From, To>
+struct is_convertible_without_any_narrowing<From, To>
+    : detail::convertible_narrowing_check<detail::copy_initialization_narrowing_check, From, To>
+{};
+
+template<class From, class To>
+inline constexpr bool is_convertible_without_any_narrowing_v = is_convertible_without_any_narrowing<From, To>::value;
+
+template<class T, class... Args>
+struct is_constructible_without_any_narrowing : std::false_type
+{};
+
+template<class T, class... Args>
+    requires std::is_constructible_v<T, Args...>
+struct is_constructible_without_any_narrowing<T, Args...>
+    : detail::direct_initialization_narrowing_check<T, Args...>
+{};
+
+template<class T, class... Args>
+inline constexpr bool is_constructible_without_any_narrowing_v = is_constructible_without_any_narrowing<T, Args...>::value;
+
+template<class T, class U>
+struct is_assignable_without_any_narrowing : std::false_type
+{};
+
+template<class T, class U>
+    requires
+        std::is_assignable_v<T, U> &&
+        (!detail::selects_initializer_list_assignment<T, U>) &&
+        detail::list_assignable<T, U>
+struct is_assignable_without_any_narrowing<T, U>
+    : std::true_type
+{};
+
+template<class T, class U>
+inline constexpr bool is_assignable_without_any_narrowing_v = is_assignable_without_any_narrowing<T, U>::value;
+
 
 namespace detail {
 
@@ -354,24 +554,6 @@ struct no_narrowing_resolution : detail::no_narrowing_resolution<void, T, Ts...>
 
 // ----------------------------------------------
 
-template<class T>
-// ReSharper disable once CppFunctionDoesntReturnValue
-[[nodiscard]] T declval_exact() noexcept
-{
-    // ReSharper disable once CppStaticAssertFailure
-    static_assert(false, "declval_exact() must not be odr-used");
-}
-
-template<class T>
-// ReSharper disable once CppFunctionDoesntReturnValue
-[[nodiscard]] T copy_initialize(T) noexcept
-{
-    // ReSharper disable once CppStaticAssertFailure
-    static_assert(false, "copy_initialize() must not be odr-used");
-}
-
-// ----------------------------------------------
-
 namespace detail {
 
 // The conversion part of INVOKE<R>: `To` is cv void, or VAL<From> can be
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index a03ca6b..f4163f4 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -183,6 +183,7 @@ if(PROJECT_IS_TOP_LEVEL)
             core
             type_list
             type_traits
+            narrowing
             ranges
             container_traits
             stdint
diff --git a/test/narrowing.cpp b/test/narrowing.cpp
new file mode 100644
index 0000000..a4f2276
--- /dev/null
+++ b/test/narrowing.cpp
@@ -0,0 +1,427 @@
+// SPDX-License-Identifier: MIT
+
+#include "iris_test.hpp"
+
+#include <iris/type_traits.hpp>
+
+#include <initializer_list>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include <cstddef> // IWYU pragma: keep
+
+enum class scoped_enum {};
+enum unscoped_enum {};
+enum class scoped_enum_uint8 : unsigned char {};
+enum unscoped_enum_short : short {};
+
+struct base {};
+struct derived : base {};
+
+struct implicit_conversion_op
+{
+    operator int() const;
+};
+
+struct explicit_conversion_op
+{
+    explicit operator int() const;
+};
+
+struct member_ptr_test
+{
+};
+
+TEST_CASE("is_convertible_without_narrowing", "[type_traits]")
+{
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<double, double>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, float>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, bool>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char, char>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<signed char, signed char>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, unsigned char>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<wchar_t, wchar_t>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char8_t, char8_t>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char16_t, char16_t>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char32_t, char32_t>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, short>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned short, unsigned short>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long, long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned long, unsigned long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long long, long long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned long long, unsigned long long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long double, long double>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, long long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, long long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<signed char, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, unsigned int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned short, unsigned int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned, unsigned long long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned short, unsigned long long>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, short>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, char>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, short>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, char>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, signed char>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unsigned char>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long long, unsigned>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned int, unsigned short>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned int, unsigned char>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unsigned>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long, unsigned long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long, long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, unsigned long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long long, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<short, unsigned short>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned short, short>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<signed char, unsigned char>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned char, signed char>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, double>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, long double>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<double, long double>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, float>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long double, float>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long double, double>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, float>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, double>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, double>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long long, double>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long, float>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<float, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long double, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<float, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, short>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, long long>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, unsigned>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, bool>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char, bool>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, bool>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char16_t, char8_t>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char32_t, char16_t>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char32_t, char8_t>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<scoped_enum, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, scoped_enum>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<scoped_enum, scoped_enum_uint8>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<scoped_enum_uint8, scoped_enum>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unscoped_enum>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum_short, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum_short, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unscoped_enum_short>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int*, int*>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void*, void*>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived*, base*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<base*, derived*>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int*, void*>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<base*, void*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void*, int*>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int*, int const*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int const*, int*>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<std::nullptr_t, int*>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<std::nullptr_t, void const*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, std::nullptr_t>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<std::nullptr_t, bool>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, bool>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, int*>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int member_ptr_test::*, int member_ptr_test::*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int member_ptr_test::*, int*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, int member_ptr_test::*>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void (member_ptr_test::*)(), int>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int const, float>);
+
+    // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p0870r8.html#ch5.9
+    // The paper wants true in this case.
+    // TODO: GCC/Clang and MSVC(2026) disagree; unfixable
+    //STATIC_CHECK(iris::is_convertible_without_narrowing_v<std::integral_constant<int, 42>, float>);
+
+    struct convertible_from_int
+    {
+        convertible_from_int(int);
+    };
+
+    struct not_convertible_from_int {};
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, convertible_from_int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<convertible_from_int, int>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, not_convertible_from_int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<not_convertible_from_int, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, std::string>);
+
+    struct explicit_from_int
+    {
+        explicit explicit_from_int() = default;
+        explicit explicit_from_int(int) {}
+        explicit_from_int& operator=(int) { return *this; }
+    };
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, explicit_from_int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<explicit_from_int, int>);
+
+    struct convertible_to_double
+    {
+        operator double();
+    };
+
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<convertible_to_double, float>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<implicit_conversion_op, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, implicit_conversion_op>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<explicit_conversion_op, int>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived, base>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<base, derived>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived&, base>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived const&, base>);
+
+    {
+        struct S
+        {
+            union
+            {
+                int x;
+                float y;
+            } u;
+        };
+        [[maybe_unused]] S s{42};
+        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
+    }
+    {
+        struct S
+        {
+            int x[1];
+        };
+        [[maybe_unused]] S s{42};
+        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
+    }
+    {
+        struct S
+        {
+            struct
+            {
+                int x;
+            } inner;
+        };
+        [[maybe_unused]] S s{42};
+        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
+    }
+    {
+        struct S
+        {
+            int x;
+            double y;
+        };
+        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
+        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<S, int>);
+    }
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void, void>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void, void const>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void const, void const>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void const, void>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, void>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void, base>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, int const>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long const, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int volatile, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const volatile, int>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const&, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long&, int>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&&, int>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&&, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long&&, int>);
+
+    STATIC_CHECK(std::is_convertible_v<int&, int&>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, int&>);
+
+    STATIC_CHECK(std::is_convertible_v<int&, int const&>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, int const&>);
+
+    STATIC_CHECK(!std::is_convertible_v<int const&, int&>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int const&, int&>);
+
+    STATIC_CHECK(!std::is_convertible_v<int, int&>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, int&>);
+
+    STATIC_CHECK(std::is_convertible_v<float, double const&>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, double const&>);
+
+    using F = void();
+
+    STATIC_CHECK(std::is_convertible_v<F&, F&>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<F&, F&>);
+
+    STATIC_CHECK(std::is_convertible_v<F, F&>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<F, F&>);
+
+    using fp = void(*)();
+    using fp2 = int(*)(double);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<fp, fp>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, fp2>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, int>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, fp>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, bool>);
+
+    // Function pointer to void*: not allowed as per standard, but MSVC accepts this conversion
+    // STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, void*>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int[3], int*>);
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int[3], int const*>);
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, int[3]>);
+
+    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, int[3]>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char[5], std::string>);
+
+    using fn = void();
+    using fnp = void(*)();
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<fn, fnp>);
+}
+
+// ----------------------------------------------
+
+struct port
+{
+    port(int);
+};
+
+struct explicit_port
+{
+    explicit explicit_port(int);
+};
+
+struct to_long_long
+{
+    operator long long() const;
+};
+
+struct aggregate
+{
+    [[maybe_unused]] int i;
+    [[maybe_unused]] double d;
+};
+
+struct aggregate_port
+{
+    [[maybe_unused]] port p;
+};
+
+struct takes_port_int
+{
+    takes_port_int(port, int);
+};
+
+struct value
+{
+    value(long long);
+    value(std::string);
+    value(std::initializer_list<value>);
+};
+
+struct assign_int
+{
+    assign_int& operator=(int);
+};
+
+TEST_CASE("is_convertible_without_any_narrowing", "[type_traits]")
+{
+    STATIC_CHECK(iris::is_convertible_without_any_narrowing_v<int, long long>);
+    STATIC_CHECK(!iris::is_convertible_without_any_narrowing_v<long long, int>);
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_convertible_without_any_narrowing_v<to_long_long, int>);
+
+    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long long, port>);
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_convertible_without_any_narrowing_v<long long, port>);
+    STATIC_CHECK(iris::is_convertible_without_any_narrowing_v<int, port>);
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_convertible_without_any_narrowing_v<long long, port const&>);
+    STATIC_CHECK(iris::is_convertible_without_any_narrowing_v<long long, std::optional<int>>); // narrowing in the body
+    STATIC_CHECK(iris::is_convertible_without_any_narrowing_v<char const*, std::string>);
+
+    STATIC_CHECK(!iris::is_convertible_without_any_narrowing_v<long long, value>); // initializer-list constructor
+    STATIC_CHECK(!iris::is_convertible_without_any_narrowing_v<std::string, value>); // initializer-list constructor
+}
+
+TEST_CASE("is_constructible_without_any_narrowing", "[type_traits]")
+{
+    STATIC_CHECK(iris::is_constructible_without_any_narrowing_v<std::vector<int>>);
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<int, long long>);
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<bool, std::nullptr_t>);
+    STATIC_CHECK(iris::is_constructible_without_any_narrowing_v<explicit_port, int>);
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<explicit_port, long long>);
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<port const&, long long>);
+    STATIC_CHECK(iris::is_constructible_without_any_narrowing_v<std::optional<int>, long long>); // narrowing in the body
+
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<aggregate_port, long long>);
+    STATIC_CHECK(iris::is_constructible_without_any_narrowing_v<aggregate_port, int>);
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<aggregate, long long, double>);
+    STATIC_CHECK(iris::is_constructible_without_any_narrowing_v<aggregate, int, double>);
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<takes_port_int, int, int>); // limitation
+
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<std::vector<int>, std::size_t>); // initializer-list constructor
+    STATIC_CHECK(!iris::is_constructible_without_any_narrowing_v<value, std::string>); // initializer-list constructor
+}
+
+TEST_CASE("is_assignable_without_any_narrowing", "[type_traits]")
+{
+    STATIC_CHECK(!iris::is_assignable_without_any_narrowing_v<int&, long long>);
+    STATIC_CHECK(iris::is_assignable_without_any_narrowing_v<long long&, int>);
+    STATIC_CHECK(!iris::is_assignable_without_any_narrowing_v<assign_int&, long long>);
+    STATIC_CHECK(iris::is_assignable_without_any_narrowing_v<assign_int&, int>);
+    // ReSharper disable once CppStaticAssertFailure
+    STATIC_CHECK(!iris::is_assignable_without_any_narrowing_v<port&, long long>);
+    STATIC_CHECK(iris::is_assignable_without_any_narrowing_v<port&, int>);
+
+    STATIC_CHECK(!iris::is_assignable_without_any_narrowing_v<std::string&, char>); // initializer-list assignment
+}
diff --git a/test/type_traits.cpp b/test/type_traits.cpp
index 9f7fbc8..bbc3e75 100644
--- a/test/type_traits.cpp
+++ b/test/type_traits.cpp
@@ -28,28 +28,6 @@ struct n_tuple;
 template<int... Ns>
 struct n_list;
 
-enum class scoped_enum {};
-enum unscoped_enum {};
-enum class scoped_enum_uint8 : unsigned char {};
-enum unscoped_enum_short : short {};
-
-struct base {};
-struct derived : base {};
-
-struct implicit_conversion_op
-{
-    operator int() const;
-};
-
-struct explicit_conversion_op
-{
-    explicit operator int() const;
-};
-
-struct member_ptr_test
-{
-};
-
 TEST_CASE("type traits")
 {
     STATIC_CHECK(iris::signed_numeric_integral<std::int8_t>);
@@ -208,410 +186,6 @@ TEMPLATE_TEST_CASE("symmetric_common_type", "[type_traits]", IRIS_TEST_NARROW_FP
 
 #undef IRIS_TEST_NARROW_FP_PAIRS
 
-TEST_CASE("is_convertible_without_narrowing: same type identity")
-{
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<double, double>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, float>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, bool>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char, char>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<signed char, signed char>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, unsigned char>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<wchar_t, wchar_t>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char8_t, char8_t>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char16_t, char16_t>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char32_t, char32_t>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, short>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned short, unsigned short>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long, long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned long, unsigned long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long long, long long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned long long, unsigned long long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<long double, long double>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: integer widening")
-{
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<short, long long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, long long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<signed char, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, unsigned int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned short, unsigned int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned, unsigned long long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned short, unsigned long long>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: integer narrowing")
-{
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, short>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, char>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, short>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, char>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, signed char>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long long, unsigned>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned int, unsigned short>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned int, unsigned char>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: signed/unsigned mismatch")
-{
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unsigned>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long, unsigned long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long, long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, unsigned long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long long, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<short, unsigned short>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned short, short>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<signed char, unsigned char>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned char, signed char>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: floating-point widening")
-{
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, double>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, long double>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<double, long double>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: floating-point narrowing")
-{
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, float>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long double, float>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long double, double>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: integer/floating-point cross")
-{
-    // Integer to floating-point: narrowing
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, float>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, double>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long, double>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<unsigned long long, double>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long, float>);
-
-    // Floating-point to integer: narrowing
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<float, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long double, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<float, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, short>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: bool")
-{
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, bool>);
-
-    // bool to integer: widening (bool is an integer type with rank < int)
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, long long>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<bool, unsigned>);
-
-    // Integer/float to bool: narrowing
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, bool>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char, bool>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<double, bool>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: char types")
-{
-    // char8_t, char16_t, char32_t are distinct types with specific widths
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char16_t, char8_t>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char32_t, char16_t>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<char32_t, char8_t>);
-
-    // wchar_t cross: platform-dependent (wchar_t width varies)
-    // On platforms where sizeof(wchar_t) == sizeof(int), these may be non-narrowing.
-
-    // char to int: widening
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<signed char, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unsigned char, int>);
-
-    // int to char: narrowing
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, char>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, signed char>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unsigned char>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: enum types")
-{
-    // Scoped enums: not implicitly convertible to/from anything
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<scoped_enum, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, scoped_enum>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<scoped_enum, scoped_enum_uint8>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<scoped_enum_uint8, scoped_enum>);
-
-    // Unscoped enums: implicitly convertible to integer types
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unscoped_enum>);
-
-    // Unscoped enum with fixed underlying type (short)
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum_short, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<unscoped_enum_short, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, unscoped_enum_short>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: pointer types")
-{
-    // Same pointer type
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int*, int*>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void*, void*>);
-
-    // Derived-to-base pointer conversion
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived*, base*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<base*, derived*>);
-
-    // T* to void*
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int*, void*>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<base*, void*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void*, int*>);
-
-    // Adding const via pointer
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int*, int const*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int const*, int*>);
-
-    // nullptr_t
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<std::nullptr_t, int*>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<std::nullptr_t, void const*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, std::nullptr_t>);
-
-    // pointer to bool: narrowing (all pointers/nullptr to bool is narrowing)
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<std::nullptr_t, bool>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, bool>);
-
-    // Pointer to/from arithmetic: not convertible
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, int*>);
-
-    // Pointer-to-member
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int member_ptr_test::*, int member_ptr_test::*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int member_ptr_test::*, int*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, int member_ptr_test::*>);
-
-    // Member function pointer
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void (member_ptr_test::*)(), int>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: constexpr caveat")
-{
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, float>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int const, float>);
-
-    // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p0870r8.html#ch5.9
-    // The paper wants true in this case.
-    // TODO: GCC/Clang and MSVC(2026) disagree; unfixable
-    //STATIC_CHECK(iris::is_convertible_without_narrowing_v<std::integral_constant<int, 42>, float>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: class types with conversion")
-{
-    struct convertible_from_int
-    {
-        convertible_from_int(int);
-    };
-
-    struct not_convertible_from_int {};
-
-    // Implicit converting constructor
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, convertible_from_int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<convertible_from_int, int>);
-
-    // Not convertible at all
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, not_convertible_from_int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<not_convertible_from_int, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, std::string>);
-
-    // ------------------------------------------
-
-    struct explicit_from_int
-    {
-        explicit explicit_from_int() = default;
-        explicit explicit_from_int(int) {}
-        explicit_from_int& operator=(int) { return *this; }
-    };
-
-    // Explicit ctor: is_convertible is false, so trait is false
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, explicit_from_int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<explicit_from_int, int>);
-
-    // ------------------------------------------
-
-    struct convertible_to_double
-    {
-        operator double();
-    };
-    STATIC_CHECK(!iris::is_convertible_without_narrowing<double, float>::value);
-    // ReSharper disable once CppStaticAssertFailure
-    STATIC_CHECK(!iris::is_convertible_without_narrowing<convertible_to_double, float>::value);
-}
-
-
-TEST_CASE("is_convertible_without_narrowing: class types with conversion operator")
-{
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<implicit_conversion_op, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, implicit_conversion_op>);
-
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<explicit_conversion_op, int>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: class types inheritance")
-{
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived, base>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<base, derived>);
-
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived&, base>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<derived const&, base>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: aggregate types")
-{
-    // Aggregates with brace-init but no implicit conversion
-    {
-        struct S {
-            union {
-                int x;
-                float y;
-            } u;
-        };
-        [[maybe_unused]] S s{42};
-        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
-    }
-    {
-        struct S {
-            int x[1];
-        };
-        [[maybe_unused]] S s{42};
-        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
-    }
-    {
-        struct S {
-            struct {
-                int x;
-            } inner;
-        };
-        [[maybe_unused]] S s{42};
-        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
-    }
-    {
-        struct S {
-            int x;
-            double y;
-        };
-        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, S>);
-        STATIC_CHECK(!iris::is_convertible_without_narrowing_v<S, int>);
-    }
-}
-
-TEST_CASE("is_convertible_without_narrowing: void")
-{
-    // void to void: is_convertible_v<void, void> is true per the standard.
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void, void>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void, void const>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void const, void const>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<void const, void>);
-
-    // void to/from anything else: not convertible
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, void>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<void, base>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: cv-qualified types")
-{
-    // const arithmetic: same narrowing rules
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int, int const>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long const, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int volatile, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const volatile, int>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: reference types as From")
-{
-    // Lvalue reference
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int const&, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long&, int>);
-
-    // Rvalue reference
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&&, int>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&&, long long>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<long long&&, int>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: reference types as To")
-{
-    STATIC_CHECK(std::is_convertible_v<int&, int&>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, int&>);
-
-    STATIC_CHECK(std::is_convertible_v<int&, int const&>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int&, int const&>);
-
-    STATIC_CHECK(!std::is_convertible_v<int const&, int&>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int const&, int&>);
-
-    STATIC_CHECK(!std::is_convertible_v<int, int&>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, int&>);
-
-    STATIC_CHECK(std::is_convertible_v<float, double const&>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<float, double const&>);
-
-    // --------------------------------------------------
-
-    using F = void();
-
-    STATIC_CHECK(std::is_convertible_v<F&, F&>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<F&, F&>);
-
-    STATIC_CHECK(std::is_convertible_v<F, F&>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<F, F&>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: function pointers")
-{
-    using fp = void(*)();
-    using fp2 = int(*)(double);
-
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<fp, fp>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, fp2>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, int>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, fp>);
-
-    // Function pointer to bool: narrowing
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, bool>);
-
-    // Function pointer to void*: not allowed as per standard, but MSVC accepts this conversion
-    // STATIC_CHECK(!iris::is_convertible_without_narrowing_v<fp, void*>);
-}
-
-TEST_CASE("is_convertible_without_narrowing: array and function types")
-{
-    // Array types as From decay to pointers
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int[3], int*>);
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<int[3], int const*>);
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int*, int[3]>);
-
-    // Element types to array types
-    STATIC_CHECK(!iris::is_convertible_without_narrowing_v<int, int[3]>);
-
-    // char[] to string
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<char[5], std::string>);
-
-    // Function type decays to function pointer
-    using fn = void();
-    using fnp = void(*)();
-    STATIC_CHECK(iris::is_convertible_without_narrowing_v<fn, fnp>);
-}
-
 TEST_CASE("specialization_of")
 {
     STATIC_CHECK(iris::is_ttp_specialization_of_v<tuple<>, tuple>);