Use concepts instead of enable_if and void_t

strings/base_array.h

@@ -71,18 +71,20 @@ WINRT_EXPORT namespace winrt
         {}
 
         template <typename OtherType>
-        array_view(array_view<OtherType> const& other,
-            std::enable_if_t<std::is_convertible_v<OtherType(*)[], T(*)[]>, int> = 0) noexcept :
+            requires std::convertible_to<OtherType(*)[], T(*)[]>
+        array_view(array_view<OtherType> const& other) noexcept :
             array_view(other.data(), other.size())
         {}
 
-        template <typename U, std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::remove_cv_t<U>>, int> = 0>
+        template <typename U>
+            requires std::same_as<std::remove_cv_t<T>, std::remove_cv_t<U>>
         bool operator==(array_view<U> const& right) const noexcept
         {
             return std::equal(begin(), end(), right.begin(), right.end());
         }
 
-        template <typename U, std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::remove_cv_t<U>>, int> = 0>
+        template <typename U>
+            requires std::same_as<std::remove_cv_t<T>, std::remove_cv_t<U>>
         std::weak_ordering operator<=>(array_view<U> const& right) const noexcept
         {
             return std::lexicographical_compare_three_way(begin(), end(), right.begin(), right.end());
@@ -284,7 +286,8 @@ WINRT_EXPORT namespace winrt
             std::uninitialized_fill_n(this->m_data, count, value);
         }
 
-        template <typename InIt, typename = std::void_t<typename std::iterator_traits<InIt>::difference_type>>
+        template <typename InIt>
+            requires std::input_iterator<InIt>
         com_array(InIt first, InIt last)
         {
             alloc(static_cast<size_type>(std::distance(first, last)));
@@ -317,7 +320,8 @@ WINRT_EXPORT namespace winrt
             com_array(value.begin(), value.end())
         {}
 
-        template <typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
+        template <typename U>
+            requires std::convertible_to<U, T>
         com_array(std::initializer_list<U> value) :
             com_array(value.begin(), value.end())
         {}
@@ -402,7 +406,8 @@ WINRT_EXPORT namespace winrt
     };
 
     template <typename C> com_array(std::uint32_t, C const&) -> com_array<std::decay_t<C>>;
-    template <typename InIt, typename = std::void_t<typename std::iterator_traits<InIt>::difference_type>>
+    template <typename InIt>
+        requires std::input_iterator<InIt>
     com_array(InIt, InIt) -> com_array<std::decay_t<typename std::iterator_traits<InIt>::value_type>>;
     template <typename C> com_array(std::vector<C> const&) -> com_array<std::decay_t<C>>;
     template <std::size_t N, typename C> com_array(std::array<C, N> const&) -> com_array<std::decay_t<C>>;

strings/base_collections_base.h

@@ -46,7 +46,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename D>
-    struct removed_values<D, std::enable_if_t<!std::is_trivially_destructible_v<typename container_type_t<D>::value_type>>>
+    requires (!std::is_trivially_destructible_v<typename container_type_t<D>::value_type>)
+    struct removed_values<D, void>
     {
         container_type_t<D> m_value;
 
@@ -65,7 +66,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename T>
-    struct removed_value<T, std::enable_if_t<std::is_move_constructible_v<T> && !std::is_trivially_destructible_v<T>>>
+    requires (std::is_move_constructible_v<T> && !std::is_trivially_destructible_v<T>)
+    struct removed_value<T, void>
     {
         std::optional<T> m_value;
 

strings/base_collections_input_iterable.h

@@ -92,7 +92,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         iterable(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -112,7 +113,8 @@ WINRT_EXPORT namespace winrt::param
         {
         }
 
-        template <typename U, std::enable_if_t<std::is_convertible_v<U, value_type>, int> = 0>
+        template <typename U>
+            requires std::convertible_to<U, value_type>
         iterable(std::initializer_list<U> values) : m_pair(impl::make_scoped_input_iterable<value_type>(values.begin(), values.end()))
         {
         }
@@ -164,7 +166,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         iterable(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -247,7 +250,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_iterable(Collection const& values) noexcept
         {
             m_interface = values;
@@ -301,7 +305,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_iterable(Collection const& values) noexcept
         {
             m_interface = values;

strings/base_collections_input_map.h

@@ -61,7 +61,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         map(Collection const& values) noexcept
         {
             m_interface = values;

strings/base_collections_input_map_view.h

@@ -91,7 +91,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         map_view(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -169,7 +170,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_map_view(Collection const& values) noexcept
         {
             m_interface = values;

strings/base_collections_input_vector.h

@@ -55,7 +55,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         vector(Collection const& values) noexcept
         {
             m_interface = values;

strings/base_collections_input_vector_view.h

@@ -86,7 +86,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_pair.first, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         vector_view(Collection const& values) noexcept
         {
             m_pair.first = values;
@@ -106,7 +107,8 @@ WINRT_EXPORT namespace winrt::param
         {
         }
 
-        template <typename U, std::enable_if_t<std::is_convertible_v<U, value_type>, int> = 0>
+        template <typename U>
+            requires std::convertible_to<U, value_type>
         vector_view(std::initializer_list<U> values) : m_pair(impl::make_scoped_input_vector_view<value_type>(values.begin(), values.end()))
         {
         }
@@ -164,7 +166,8 @@ WINRT_EXPORT namespace winrt::param
             attach_abi(m_interface, winrt::get_abi(values));
         }
 
-        template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>, int> = 0>
+        template <typename Collection>
+            requires std::convertible_to<Collection, interface_type>
         async_vector_view(Collection const& values) noexcept
         {
             m_interface = values;

strings/base_com_ptr.h

@@ -24,7 +24,8 @@ WINRT_EXPORT namespace winrt::impl
         return function(args..., guid_of<T>(), capture_decay{ result });
     }
 
-    template <typename T, typename O, typename M, typename...Args, std::enable_if_t<std::is_class_v<O> || std::is_union_v<O>, int> = 0>
+    template <typename T, typename O, typename M, typename...Args>
+        requires (std::is_class_v<O> || std::is_union_v<O>)
     std::int32_t capture_to(void** result, O* object, M method, Args&& ...args)
     {
         return (object->*method)(args..., guid_of<T>(), capture_decay{ result });

strings/base_coroutine_foundation.h

@@ -259,7 +259,8 @@ WINRT_EXPORT namespace winrt::impl
 
 WINRT_EXPORT namespace winrt
 {
-    template<typename Async, typename = std::enable_if_t<std::is_convertible_v<Async, winrt::Windows::Foundation::IAsyncInfo>>>
+    template<typename Async>
+        requires std::convertible_to<Async, winrt::Windows::Foundation::IAsyncInfo>
     inline impl::await_adapter<std::decay_t<Async>, false> resume_agile(Async&& async)
     {
         return { std::forward<Async>(async) };

strings/base_implements.h

@@ -145,14 +145,15 @@ WINRT_EXPORT namespace winrt::impl
     template <typename D, typename... I>
     struct root_implements;
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct unwrap_implements
     {
         using type = T;
     };
 
     template <typename T>
-    struct unwrap_implements<T, std::void_t<typename T::implements_type>>
+        requires requires { typename T::implements_type; }
+    struct unwrap_implements<T>
     {
         using type = typename T::implements_type;
     };
@@ -173,28 +174,31 @@ WINRT_EXPORT namespace winrt::impl
             "Duplicate nested implements found");
     };
 
-    template <typename D, typename Dummy = std::void_t<>, typename... I>
+    template <typename D, typename Dummy = void, typename... I>
     struct base_implements_impl
         : impl::identity<root_implements<D, I...>> {};
 
     template <typename D, typename... I>
-    struct base_implements_impl<D, std::void_t<typename nested_implements<I...>::type>, I...>
+        requires requires { typename nested_implements<I...>::type; }
+    struct base_implements_impl<D, void, I...>
         : nested_implements<I...> {};
 
     template <typename D, typename... I>
     using base_implements = base_implements_impl<D, void, I...>;
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct has_composable : std::false_type {};
 
     template <typename T>
-    struct has_composable<T, std::void_t<typename T::composable>> : std::true_type {};
+        requires requires { typename T::composable; }
+    struct has_composable<T> : std::true_type {};
 
-    template <typename T, typename = std::void_t<>>
+    template <typename T>
     struct has_class_type : std::false_type {};
 
     template <typename T>
-    struct has_class_type<T, std::void_t<typename T::class_type>> : std::true_type {};
+        requires requires { typename T::class_type; }
+    struct has_class_type<T> : std::true_type {};
 
     template <typename>
     struct has_static_lifetime : std::false_type {};
@@ -367,20 +371,22 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr std::array<guid, sizeof...(T)> value{ winrt::guid_of<T>() ... };
     };
 
-    template <typename T, typename = void>
+    template <typename T>
     struct implements_default_interface
     {
         using type = typename default_interface<typename implemented_interfaces<T>::first_interface>::type;
     };
 
     template <typename T>
-    struct implements_default_interface<T, std::void_t<typename T::class_type>>
+        requires requires { typename T::class_type; }
+    struct implements_default_interface<T>
     {
         using type = winrt::default_interface<typename T::class_type>;
     };
 
     template <typename T>
-    struct default_interface<T, std::void_t<typename T::implements_type>>
+        requires requires { typename T::implements_type; }
+    struct default_interface<T>
     {
         using type = typename implements_default_interface<T>::type;
     };
@@ -480,7 +486,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename I, typename = std::void_t<>>
+    template <typename I>
     struct runtime_class_name
     {
         static hstring get()
@@ -490,7 +496,8 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename I>
-    struct runtime_class_name<I, std::void_t<decltype(name_v<I>)>>
+        requires requires { name_v<I>; }
+    struct runtime_class_name<I>
     {
         static hstring get()
         {
@@ -554,15 +561,17 @@ WINRT_EXPORT namespace winrt::impl
     };
 
     template <typename D, typename I>
-    struct producer<D, I, std::enable_if_t<is_classic_com_interface<I>::value>> : I
+        requires is_classic_com_interface<I>::value
+    struct producer<D, I> : I
     {
 #ifndef WINRT_IMPL_IUNKNOWN_DEFINED
         static_assert(std::is_void_v<I> /* dependent_false */, "To implement classic COM interfaces, you must #include <unknwn.h> before including C++/WinRT headers.");
 #endif
     };
 
     template <typename D, typename I>
-    struct producer_convert<D, I, std::enable_if_t<is_classic_com_interface<I>::value>> : producer<D, I>
+        requires is_classic_com_interface<I>::value
+    struct producer_convert<D, I> : producer<D, I>
     {
     };
 

strings/base_includes.h

@@ -21,6 +21,7 @@
 #include <thread>
 #include <tuple>
 #include <type_traits>
+#include <concepts>
 #include <unordered_map>
 #include <utility>
 #include <vector>

strings/base_iterator.h

@@ -120,7 +120,8 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr bool value = get_value<T>(0);
     };
 
-    template <typename T, std::enable_if_t<!has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires (!has_GetAt<T>::value)
     auto get_begin_iterator(T const& collection) -> decltype(collection.First())
     {
         auto result = collection.First();
@@ -133,31 +134,36 @@ WINRT_EXPORT namespace winrt::impl
         return result;
     }
 
-    template <typename T, std::enable_if_t<!has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires (!has_GetAt<T>::value)
     auto get_end_iterator([[maybe_unused]] T const& collection) noexcept -> decltype(collection.First())
     {
         return {};
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     fast_iterator<T> get_begin_iterator(T const& collection) noexcept
     {
         return { collection, 0 };
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     fast_iterator<T> get_end_iterator(T const& collection)
     {
         return { collection, collection.Size() };
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     auto rbegin(T const& collection)
     {
         return std::make_reverse_iterator(get_end_iterator(collection));
     }
 
-    template <typename T, std::enable_if_t<has_GetAt<T>::value, int> = 0>
+    template <typename T>
+        requires has_GetAt<T>::value
     auto rend(T const& collection)
     {
         return std::make_reverse_iterator(get_begin_iterator(collection));