stl: std::is_nothrow_*

src/entt/core/compressed_pair.hpp

@@ -20,7 +20,7 @@ struct compressed_pair_element {
     using const_reference = const Type &;
 
     // NOLINTNEXTLINE(modernize-use-equals-default)
-    constexpr compressed_pair_element() noexcept(std::is_nothrow_default_constructible_v<Type>)
+    constexpr compressed_pair_element() noexcept(stl::is_nothrow_default_constructible_v<Type>)
     requires std::default_initializable<Type> {}
 
     template<typename Arg>
@@ -51,7 +51,7 @@ struct compressed_pair_element<Type, Tag>: Type {
     using const_reference = const Type &;
     using base_type = Type;
 
-    constexpr compressed_pair_element() noexcept(std::is_nothrow_default_constructible_v<base_type>)
+    constexpr compressed_pair_element() noexcept(stl::is_nothrow_default_constructible_v<base_type>)
     requires std::default_initializable<Type>
         : base_type{} {}
 
@@ -104,7 +104,7 @@ public:
      * This constructor is only available when the types that the pair stores
      * are both at least default constructible.
      */
-    constexpr compressed_pair() noexcept(std::is_nothrow_default_constructible_v<first_base> && std::is_nothrow_default_constructible_v<second_base>)
+    constexpr compressed_pair() noexcept(stl::is_nothrow_default_constructible_v<first_base> && stl::is_nothrow_default_constructible_v<second_base>)
     requires std::default_initializable<first_type> && std::default_initializable<second_type>
         : first_base{},
           second_base{} {}

src/entt/core/iterator.hpp

@@ -130,7 +130,7 @@ struct iterable_adaptor final {
     using sentinel = Sentinel;
 
     /*! @brief Default constructor. */
-    constexpr iterable_adaptor() noexcept(std::is_nothrow_default_constructible_v<iterator> && std::is_nothrow_default_constructible_v<sentinel>)
+    constexpr iterable_adaptor() noexcept(stl::is_nothrow_default_constructible_v<iterator> && stl::is_nothrow_default_constructible_v<sentinel>)
         : first{},
           last{} {}
 

src/entt/core/memory.hpp

@@ -68,14 +68,14 @@ struct allocation_deleter: private Allocator {
      * @brief Inherited constructors.
      * @param alloc The allocator to use.
      */
-    constexpr allocation_deleter(const allocator_type &alloc) noexcept(std::is_nothrow_copy_constructible_v<allocator_type>)
+    constexpr allocation_deleter(const allocator_type &alloc) noexcept(stl::is_nothrow_copy_constructible_v<allocator_type>)
         : Allocator{alloc} {}
 
     /**
      * @brief Destroys the pointed object and deallocates its memory.
      * @param ptr A valid pointer to an object of the given type.
      */
-    constexpr void operator()(pointer ptr) noexcept(std::is_nothrow_destructible_v<typename allocator_type::value_type>) {
+    constexpr void operator()(pointer ptr) noexcept(stl::is_nothrow_destructible_v<typename allocator_type::value_type>) {
         using alloc_traits = std::allocator_traits<Allocator>;
         alloc_traits::destroy(*this, stl::to_address(ptr));
         alloc_traits::deallocate(*this, ptr, 1u);

src/entt/core/utility.hpp

@@ -65,13 +65,13 @@ struct y_combinator {
      * @return Return value of the underlying function, if any.
      */
     template<typename... Args>
-    constexpr decltype(auto) operator()(Args &&...args) const noexcept(std::is_nothrow_invocable_v<Func, const y_combinator &, Args...>) {
+    constexpr decltype(auto) operator()(Args &&...args) const noexcept(stl::is_nothrow_invocable_v<Func, const y_combinator &, Args...>) {
         return func(*this, stl::forward<Args>(args)...);
     }
 
     /*! @copydoc operator()() */
     template<typename... Args>
-    constexpr decltype(auto) operator()(Args &&...args) noexcept(std::is_nothrow_invocable_v<Func, y_combinator &, Args...>) {
+    constexpr decltype(auto) operator()(Args &&...args) noexcept(stl::is_nothrow_invocable_v<Func, y_combinator &, Args...>) {
         return func(*this, stl::forward<Args>(args)...);
     }
 

src/entt/stl/type_traits.hpp

@@ -26,6 +26,10 @@ using std::is_lvalue_reference_v;
 using std::is_member_object_pointer_v;
 using std::is_move_assignable_v;
 using std::is_nothrow_constructible_v;
+using std::is_nothrow_copy_constructible_v;
+using std::is_nothrow_default_constructible_v;
+using std::is_nothrow_destructible_v;
+using std::is_nothrow_invocable_v;
 using std::is_nothrow_move_constructible_v;
 using std::is_pointer_v;
 using std::is_same_v;