iris-cpp · yaito3014 · Mar 11, 2026 · Mar 12, 2026 · Mar 12, 2026 · Mar 12, 2026
diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
@@ -10,6 +10,7 @@
 
 #include <iris/requirements.hpp>
 
+#include <concepts>
 #include <type_traits>
 #include <utility>
 
@@ -222,6 +223,45 @@ template<class T>
 constexpr bool is_trivially_swappable_v = is_trivially_swappable<T>::value;
 
 
+// P0870R7: is_convertible_without_narrowing
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p0870r7.html
+namespace detail {
+
+template<class From, class To>
+struct is_convertible_without_narrowing_impl
+    : std::false_type
+{};
+
+// void to void "conversion" is valid since `is_convertible` is defined
+// as "returning `From` is valid for function whose return type is `To`?"
+template<>
+struct is_convertible_without_narrowing_impl<void, void>
+    : std::true_type
+{};
+
+template<class From, class To>
+    requires
+        requires (From&& x) {
+            { std::type_identity_t<To[]>{std::forward<From>(x)} } -> std::same_as<To[1]>;
+        }
+struct is_convertible_without_narrowing_impl<From, To>
+    : std::true_type
+{};
+
+} // namespace detail
+
+template<class From, class To>
+struct is_convertible_without_narrowing
+    : std::conjunction<
+        std::is_convertible<From, To>,
+        detail::is_convertible_without_narrowing_impl<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<std::size_t I, class Ti>
@@ -231,19 +271,12 @@ struct aggregate_initialize_tag
     using type = Ti;
 };
 
-// This version works better than MSVC's, does not break IntelliSense or ReSharper
 template<std::size_t I, class Ti>
 struct aggregate_initialize_overload
 {
-    using TiA = Ti[];
-
-    // https://eel.is/c++draft/dcl.init.general#14
-    // https://eel.is/c++draft/dcl.init.list#3.4
-    // https://eel.is/c++draft/dcl.init.aggr#3
-
     template<class T>
     auto operator()(Ti, T&&) -> aggregate_initialize_tag<I, Ti>
-        requires requires(T&& t) { { TiA{std::forward<T>(t)} }; } // emulate `Ti x[] = {std::forward<T>(t)};`
+        requires is_convertible_without_narrowing_v<T, Ti>
     {
         return {}; // silence MSVC warning
     }