diff --git a/libcxx/include/__config b/libcxx/include/__config index 0f6c77dd9817..5e0db7c95a1e 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -160,6 +160,10 @@ typedef __char32_t char32_t; #define _LIBCPP_NO_RTTI #endif +#if !(__has_feature(cxx_strong_enums)) +#define _LIBCPP_HAS_NO_STRONG_ENUMS +#endif + #if !(__has_feature(cxx_decltype)) #define _LIBCPP_HAS_NO_DECLTYPE #endif @@ -223,6 +227,7 @@ typedef __char32_t char32_t; #if __has_feature(objc_arc_weak) #define _LIBCPP_HAS_OBJC_ARC_WEAK +#define _LIBCPP_HAS_NO_STRONG_ENUMS #endif #if !(__has_feature(cxx_constexpr)) @@ -371,6 +376,18 @@ template struct __static_assert_check {}; #define __has_feature(__x) 0 #endif +#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS +#define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_VISIBLE x { enum _ +#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \ + _ __v_; \ + _LIBCPP_ALWAYS_INLINE x(_ __v) : __v_(__v) {} \ + _LIBCPP_ALWAYS_INLINE operator int() const {return __v_;} \ + }; +#else // _LIBCPP_HAS_NO_STRONG_ENUMS +#define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_VISIBLE x +#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) +#endif // _LIBCPP_HAS_NO_STRONG_ENUMS + #if __APPLE__ || __FreeBSD__ || _WIN32 #define _LIBCPP_LOCALE__L_EXTENSIONS 1 #endif diff --git a/libcxx/include/future b/libcxx/include/future index 0e61869f2786..aae707e1e4e8 100644 --- a/libcxx/include/future +++ b/libcxx/include/future @@ -377,56 +377,40 @@ template struct uses_allocator, Alloc>; _LIBCPP_BEGIN_NAMESPACE_STD //enum class future_errc -struct _LIBCPP_VISIBLE future_errc +_LIBCPP_DECLARE_STRONG_ENUM(future_errc) { -enum _ { broken_promise, future_already_retrieved, promise_already_satisfied, no_state }; - - _ __v_; - - _LIBCPP_INLINE_VISIBILITY future_errc(_ __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) template <> struct _LIBCPP_VISIBLE is_error_code_enum : public true_type {}; +#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS +template <> +struct _LIBCPP_VISIBLE is_error_code_enum : public true_type { }; +#endif + //enum class launch -struct _LIBCPP_VISIBLE launch +_LIBCPP_DECLARE_STRONG_ENUM(launch) { -enum _ { async = 1, deferred = 2, any = async | deferred }; - - _ __v_; - - _LIBCPP_INLINE_VISIBILITY launch(_ __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch) //enum class future_status -struct _LIBCPP_VISIBLE future_status +_LIBCPP_DECLARE_STRONG_ENUM(future_status) { -enum _ { ready, timeout, deferred }; - - _ __v_; - - _LIBCPP_INLINE_VISIBILITY future_status(_ __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status) _LIBCPP_VISIBLE const error_category& future_category(); @@ -2252,10 +2236,10 @@ async(launch __policy, _Fp&& __f, _Args&&... __args) typedef __async_func::type, typename decay<_Args>::type...> _BF; typedef typename _BF::_Rp _Rp; future<_Rp> __r; - if (__policy & launch::async) + if (int(__policy) & int(launch::async)) __r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), __decay_copy(_VSTD::forward<_Args>(__args))...)); - else if (__policy & launch::deferred) + else if (int(__policy) & int(launch::deferred)) __r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), __decay_copy(_VSTD::forward<_Args>(__args))...)); return __r; diff --git a/libcxx/include/ios b/libcxx/include/ios index 7ea63a31ca71..3aa066bfe632 100644 --- a/libcxx/include/ios +++ b/libcxx/include/ios @@ -373,21 +373,19 @@ private: }; //enum class io_errc -struct _LIBCPP_VISIBLE io_errc +_LIBCPP_DECLARE_STRONG_ENUM(io_errc) { -enum _ { stream = 1 }; - _ __v_; - - _LIBCPP_ALWAYS_INLINE io_errc(_ __v) : __v_(__v) {} - _LIBCPP_ALWAYS_INLINE operator int() const {return __v_;} -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) template <> struct _LIBCPP_VISIBLE is_error_code_enum : public true_type { }; + +#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> struct _LIBCPP_VISIBLE is_error_code_enum : public true_type { }; +#endif _LIBCPP_VISIBLE const error_category& iostream_category(); diff --git a/libcxx/include/support/win32/support.h b/libcxx/include/support/win32/support.h index 38ea51e46b1e..209f72047b74 100644 --- a/libcxx/include/support/win32/support.h +++ b/libcxx/include/support/win32/support.h @@ -31,7 +31,7 @@ size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src, size_t nmc, size_t len, mbstate_t *__restrict ps ); size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src, size_t nwc, size_t len, mbstate_t *__restrict ps ); - + #if defined(_MSC_VER) #define snprintf _snprintf @@ -91,8 +91,8 @@ _LIBCPP_ALWAYS_INLINE int __builtin_ctzl( unsigned long x ) _LIBCPP_ALWAYS_INLINE int __builtin_ctzll( unsigned long long x ) { DWORD r = 0; - _BitScanReverse64(&r, x); - return static_cast(r); + _BitScanReverse64(&r, x); + return static_cast(r); } _LIBCPP_ALWAYS_INLINE int __builtin_clz( unsigned int x ) { @@ -106,8 +106,8 @@ _LIBCPP_ALWAYS_INLINE int __builtin_clzl( unsigned long x ) _LIBCPP_ALWAYS_INLINE int __builtin_clzll( unsigned long long x ) { DWORD r = 0; - _BitScanForward64(&r, x); - return static_cast(r); + _BitScanForward64(&r, x); + return static_cast(r); } #endif // !__clang__ #endif // _MSC_VER diff --git a/libcxx/include/system_error b/libcxx/include/system_error index c9a8097d5108..971be3374728 100644 --- a/libcxx/include/system_error +++ b/libcxx/include/system_error @@ -245,9 +245,8 @@ struct _LIBCPP_VISIBLE is_error_condition_enum // for them: //enum class errc -struct errc +_LIBCPP_DECLARE_STRONG_ENUM(errc) { -enum _ { address_family_not_supported = EAFNOSUPPORT, address_in_use = EADDRINUSE, address_not_available = EADDRNOTAVAIL, @@ -343,23 +342,17 @@ enum _ { value_too_large = EOVERFLOW, wrong_protocol_type = EPROTOTYPE }; - - _ __v_; - - _LIBCPP_ALWAYS_INLINE - errc(_ __v) : __v_(__v) {} - _LIBCPP_ALWAYS_INLINE - operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc) template <> struct _LIBCPP_VISIBLE is_error_condition_enum : true_type { }; +#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> struct _LIBCPP_VISIBLE is_error_condition_enum : true_type { }; +#endif class error_condition; class error_code; diff --git a/libcxx/test/diagnostics/syserr/errc.pass.cpp b/libcxx/test/diagnostics/syserr/errc.pass.cpp index 043add4deeb1..247e10bf8d6b 100644 --- a/libcxx/test/diagnostics/syserr/errc.pass.cpp +++ b/libcxx/test/diagnostics/syserr/errc.pass.cpp @@ -15,90 +15,90 @@ int main() { - static_assert(std::errc::address_family_not_supported == EAFNOSUPPORT, ""); - static_assert(std::errc::address_in_use == EADDRINUSE, ""); - static_assert(std::errc::address_not_available == EADDRNOTAVAIL, ""); - static_assert(std::errc::already_connected == EISCONN, ""); - static_assert(std::errc::argument_list_too_long == E2BIG, ""); - static_assert(std::errc::argument_out_of_domain == EDOM, ""); - static_assert(std::errc::bad_address == EFAULT, ""); - static_assert(std::errc::bad_file_descriptor == EBADF, ""); - static_assert(std::errc::bad_message == EBADMSG, ""); - static_assert(std::errc::broken_pipe == EPIPE, ""); - static_assert(std::errc::connection_aborted == ECONNABORTED, ""); - static_assert(std::errc::connection_already_in_progress == EALREADY, ""); - static_assert(std::errc::connection_refused == ECONNREFUSED, ""); - static_assert(std::errc::connection_reset == ECONNRESET, ""); - static_assert(std::errc::cross_device_link == EXDEV, ""); - static_assert(std::errc::destination_address_required == EDESTADDRREQ, ""); - static_assert(std::errc::device_or_resource_busy == EBUSY, ""); - static_assert(std::errc::directory_not_empty == ENOTEMPTY, ""); - static_assert(std::errc::executable_format_error == ENOEXEC, ""); - static_assert(std::errc::file_exists == EEXIST, ""); - static_assert(std::errc::file_too_large == EFBIG, ""); - static_assert(std::errc::filename_too_long == ENAMETOOLONG, ""); - static_assert(std::errc::function_not_supported == ENOSYS, ""); - static_assert(std::errc::host_unreachable == EHOSTUNREACH, ""); - static_assert(std::errc::identifier_removed == EIDRM, ""); - static_assert(std::errc::illegal_byte_sequence == EILSEQ, ""); - static_assert(std::errc::inappropriate_io_control_operation == ENOTTY, ""); - static_assert(std::errc::interrupted == EINTR, ""); - static_assert(std::errc::invalid_argument == EINVAL, ""); - static_assert(std::errc::invalid_seek == ESPIPE, ""); - static_assert(std::errc::io_error == EIO, ""); - static_assert(std::errc::is_a_directory == EISDIR, ""); - static_assert(std::errc::message_size == EMSGSIZE, ""); - static_assert(std::errc::network_down == ENETDOWN, ""); - static_assert(std::errc::network_reset == ENETRESET, ""); - static_assert(std::errc::network_unreachable == ENETUNREACH, ""); - static_assert(std::errc::no_buffer_space == ENOBUFS, ""); - static_assert(std::errc::no_child_process == ECHILD, ""); - static_assert(std::errc::no_link == ENOLINK, ""); - static_assert(std::errc::no_lock_available == ENOLCK, ""); + static_assert(static_cast(std::errc::address_family_not_supported) == EAFNOSUPPORT, ""); + static_assert(static_cast(std::errc::address_in_use) == EADDRINUSE, ""); + static_assert(static_cast(std::errc::address_not_available) == EADDRNOTAVAIL, ""); + static_assert(static_cast(std::errc::already_connected) == EISCONN, ""); + static_assert(static_cast(std::errc::argument_list_too_long) == E2BIG, ""); + static_assert(static_cast(std::errc::argument_out_of_domain) == EDOM, ""); + static_assert(static_cast(std::errc::bad_address) == EFAULT, ""); + static_assert(static_cast(std::errc::bad_file_descriptor) == EBADF, ""); + static_assert(static_cast(std::errc::bad_message) == EBADMSG, ""); + static_assert(static_cast(std::errc::broken_pipe) == EPIPE, ""); + static_assert(static_cast(std::errc::connection_aborted) == ECONNABORTED, ""); + static_assert(static_cast(std::errc::connection_already_in_progress) == EALREADY, ""); + static_assert(static_cast(std::errc::connection_refused) == ECONNREFUSED, ""); + static_assert(static_cast(std::errc::connection_reset) == ECONNRESET, ""); + static_assert(static_cast(std::errc::cross_device_link) == EXDEV, ""); + static_assert(static_cast(std::errc::destination_address_required) == EDESTADDRREQ, ""); + static_assert(static_cast(std::errc::device_or_resource_busy) == EBUSY, ""); + static_assert(static_cast(std::errc::directory_not_empty) == ENOTEMPTY, ""); + static_assert(static_cast(std::errc::executable_format_error) == ENOEXEC, ""); + static_assert(static_cast(std::errc::file_exists) == EEXIST, ""); + static_assert(static_cast(std::errc::file_too_large) == EFBIG, ""); + static_assert(static_cast(std::errc::filename_too_long) == ENAMETOOLONG, ""); + static_assert(static_cast(std::errc::function_not_supported) == ENOSYS, ""); + static_assert(static_cast(std::errc::host_unreachable) == EHOSTUNREACH, ""); + static_assert(static_cast(std::errc::identifier_removed) == EIDRM, ""); + static_assert(static_cast(std::errc::illegal_byte_sequence) == EILSEQ, ""); + static_assert(static_cast(std::errc::inappropriate_io_control_operation) == ENOTTY, ""); + static_assert(static_cast(std::errc::interrupted) == EINTR, ""); + static_assert(static_cast(std::errc::invalid_argument) == EINVAL, ""); + static_assert(static_cast(std::errc::invalid_seek) == ESPIPE, ""); + static_assert(static_cast(std::errc::io_error) == EIO, ""); + static_assert(static_cast(std::errc::is_a_directory) == EISDIR, ""); + static_assert(static_cast(std::errc::message_size) == EMSGSIZE, ""); + static_assert(static_cast(std::errc::network_down) == ENETDOWN, ""); + static_assert(static_cast(std::errc::network_reset) == ENETRESET, ""); + static_assert(static_cast(std::errc::network_unreachable) == ENETUNREACH, ""); + static_assert(static_cast(std::errc::no_buffer_space) == ENOBUFS, ""); + static_assert(static_cast(std::errc::no_child_process) == ECHILD, ""); + static_assert(static_cast(std::errc::no_link) == ENOLINK, ""); + static_assert(static_cast(std::errc::no_lock_available) == ENOLCK, ""); #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) - static_assert(std::errc::no_message_available == ENODATA, ""); + static_assert(static_cast(std::errc::no_message_available) == ENODATA, ""); #endif - static_assert(std::errc::no_message == ENOMSG, ""); - static_assert(std::errc::no_protocol_option == ENOPROTOOPT, ""); - static_assert(std::errc::no_space_on_device == ENOSPC, ""); + static_assert(static_cast(std::errc::no_message) == ENOMSG, ""); + static_assert(static_cast(std::errc::no_protocol_option) == ENOPROTOOPT, ""); + static_assert(static_cast(std::errc::no_space_on_device) == ENOSPC, ""); #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) - static_assert(std::errc::no_stream_resources == ENOSR, ""); + static_assert(static_cast(std::errc::no_stream_resources) == ENOSR, ""); #endif - static_assert(std::errc::no_such_device_or_address == ENXIO, ""); - static_assert(std::errc::no_such_device == ENODEV, ""); - static_assert(std::errc::no_such_file_or_directory == ENOENT, ""); - static_assert(std::errc::no_such_process == ESRCH, ""); - static_assert(std::errc::not_a_directory == ENOTDIR, ""); - static_assert(std::errc::not_a_socket == ENOTSOCK, ""); + static_assert(static_cast(std::errc::no_such_device_or_address) == ENXIO, ""); + static_assert(static_cast(std::errc::no_such_device) == ENODEV, ""); + static_assert(static_cast(std::errc::no_such_file_or_directory) == ENOENT, ""); + static_assert(static_cast(std::errc::no_such_process) == ESRCH, ""); + static_assert(static_cast(std::errc::not_a_directory) == ENOTDIR, ""); + static_assert(static_cast(std::errc::not_a_socket) == ENOTSOCK, ""); #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) - static_assert(std::errc::not_a_stream == ENOSTR, ""); + static_assert(static_cast(std::errc::not_a_stream) == ENOSTR, ""); #endif - static_assert(std::errc::not_connected == ENOTCONN, ""); - static_assert(std::errc::not_enough_memory == ENOMEM, ""); - static_assert(std::errc::not_supported == ENOTSUP, ""); - static_assert(std::errc::operation_canceled == ECANCELED, ""); - static_assert(std::errc::operation_in_progress == EINPROGRESS, ""); - static_assert(std::errc::operation_not_permitted == EPERM, ""); - static_assert(std::errc::operation_not_supported == EOPNOTSUPP, ""); - static_assert(std::errc::operation_would_block == EWOULDBLOCK, ""); - static_assert(std::errc::owner_dead == EOWNERDEAD, ""); - static_assert(std::errc::permission_denied == EACCES, ""); - static_assert(std::errc::protocol_error == EPROTO, ""); - static_assert(std::errc::protocol_not_supported == EPROTONOSUPPORT, ""); - static_assert(std::errc::read_only_file_system == EROFS, ""); - static_assert(std::errc::resource_deadlock_would_occur == EDEADLK, ""); - static_assert(std::errc::resource_unavailable_try_again == EAGAIN, ""); - static_assert(std::errc::result_out_of_range == ERANGE, ""); - static_assert(std::errc::state_not_recoverable == ENOTRECOVERABLE, ""); + static_assert(static_cast(std::errc::not_connected) == ENOTCONN, ""); + static_assert(static_cast(std::errc::not_enough_memory) == ENOMEM, ""); + static_assert(static_cast(std::errc::not_supported) == ENOTSUP, ""); + static_assert(static_cast(std::errc::operation_canceled) == ECANCELED, ""); + static_assert(static_cast(std::errc::operation_in_progress) == EINPROGRESS, ""); + static_assert(static_cast(std::errc::operation_not_permitted) == EPERM, ""); + static_assert(static_cast(std::errc::operation_not_supported) == EOPNOTSUPP, ""); + static_assert(static_cast(std::errc::operation_would_block) == EWOULDBLOCK, ""); + static_assert(static_cast(std::errc::owner_dead) == EOWNERDEAD, ""); + static_assert(static_cast(std::errc::permission_denied) == EACCES, ""); + static_assert(static_cast(std::errc::protocol_error) == EPROTO, ""); + static_assert(static_cast(std::errc::protocol_not_supported) == EPROTONOSUPPORT, ""); + static_assert(static_cast(std::errc::read_only_file_system) == EROFS, ""); + static_assert(static_cast(std::errc::resource_deadlock_would_occur) == EDEADLK, ""); + static_assert(static_cast(std::errc::resource_unavailable_try_again) == EAGAIN, ""); + static_assert(static_cast(std::errc::result_out_of_range) == ERANGE, ""); + static_assert(static_cast(std::errc::state_not_recoverable) == ENOTRECOVERABLE, ""); #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) - static_assert(std::errc::stream_timeout == ETIME, ""); + static_assert(static_cast(std::errc::stream_timeout) == ETIME, ""); #endif - static_assert(std::errc::text_file_busy == ETXTBSY, ""); - static_assert(std::errc::timed_out == ETIMEDOUT, ""); - static_assert(std::errc::too_many_files_open_in_system == ENFILE, ""); - static_assert(std::errc::too_many_files_open == EMFILE, ""); - static_assert(std::errc::too_many_links == EMLINK, ""); - static_assert(std::errc::too_many_symbolic_link_levels == ELOOP, ""); - static_assert(std::errc::value_too_large == EOVERFLOW, ""); - static_assert(std::errc::wrong_protocol_type == EPROTOTYPE, ""); + static_assert(static_cast(std::errc::text_file_busy) == ETXTBSY, ""); + static_assert(static_cast(std::errc::timed_out) == ETIMEDOUT, ""); + static_assert(static_cast(std::errc::too_many_files_open_in_system) == ENFILE, ""); + static_assert(static_cast(std::errc::too_many_files_open) == EMFILE, ""); + static_assert(static_cast(std::errc::too_many_links) == EMLINK, ""); + static_assert(static_cast(std::errc::too_many_symbolic_link_levels) == ELOOP, ""); + static_assert(static_cast(std::errc::value_too_large) == EOVERFLOW, ""); + static_assert(static_cast(std::errc::wrong_protocol_type) == EPROTOTYPE, ""); } diff --git a/libcxx/test/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp b/libcxx/test/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp index 42c9d85d49bd..dd51827128b1 100644 --- a/libcxx/test/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp +++ b/libcxx/test/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp @@ -19,7 +19,7 @@ int main() { const std::error_category& e_cat = std::generic_category(); - std::error_condition e_cond = e_cat.default_error_condition(std::errc::not_a_directory); + std::error_condition e_cond = e_cat.default_error_condition(static_cast(std::errc::not_a_directory)); assert(e_cond.category() == e_cat); - assert(e_cond.value() == std::errc::not_a_directory); + assert(e_cond.value() == static_cast(std::errc::not_a_directory)); } diff --git a/libcxx/test/thread/futures/futures.errors/default_error_condition.pass.cpp b/libcxx/test/thread/futures/futures.errors/default_error_condition.pass.cpp index 38b11512abf2..35afe5ab1d7d 100644 --- a/libcxx/test/thread/futures/futures.errors/default_error_condition.pass.cpp +++ b/libcxx/test/thread/futures/futures.errors/default_error_condition.pass.cpp @@ -19,7 +19,7 @@ int main() { const std::error_category& e_cat = std::future_category(); - std::error_condition e_cond = e_cat.default_error_condition(std::errc::not_a_directory); + std::error_condition e_cond = e_cat.default_error_condition(static_cast(std::errc::not_a_directory)); assert(e_cond.category() == e_cat); - assert(e_cond.value() == std::errc::not_a_directory); + assert(e_cond.value() == static_cast(std::errc::not_a_directory)); } diff --git a/libcxx/test/thread/futures/futures.overview/future_errc.pass.cpp b/libcxx/test/thread/futures/futures.overview/future_errc.pass.cpp index fe41aa7e2965..6ffaca47427e 100644 --- a/libcxx/test/thread/futures/futures.overview/future_errc.pass.cpp +++ b/libcxx/test/thread/futures/futures.overview/future_errc.pass.cpp @@ -21,8 +21,8 @@ int main() { - static_assert(std::future_errc::broken_promise == 0, ""); - static_assert(std::future_errc::future_already_retrieved == 1, ""); - static_assert(std::future_errc::promise_already_satisfied == 2, ""); - static_assert(std::future_errc::no_state == 3, ""); + static_assert(static_cast(std::future_errc::broken_promise) == 0, ""); + static_assert(static_cast(std::future_errc::future_already_retrieved) == 1, ""); + static_assert(static_cast(std::future_errc::promise_already_satisfied) == 2, ""); + static_assert(static_cast(std::future_errc::no_state) == 3, ""); } diff --git a/libcxx/test/thread/futures/futures.overview/future_status.pass.cpp b/libcxx/test/thread/futures/futures.overview/future_status.pass.cpp index 11fbe2192761..0b6d32ca4c79 100644 --- a/libcxx/test/thread/futures/futures.overview/future_status.pass.cpp +++ b/libcxx/test/thread/futures/futures.overview/future_status.pass.cpp @@ -20,7 +20,7 @@ int main() { - static_assert(std::future_status::ready == 0, ""); - static_assert(std::future_status::timeout == 1, ""); - static_assert(std::future_status::deferred == 2, ""); + static_assert(static_cast(std::future_status::ready) == 0, ""); + static_assert(static_cast(std::future_status::timeout) == 1, ""); + static_assert(static_cast(std::future_status::deferred) == 2, ""); } diff --git a/libcxx/test/thread/futures/futures.overview/launch.pass.cpp b/libcxx/test/thread/futures/futures.overview/launch.pass.cpp index f4c4ca11c7fb..75534f793c89 100644 --- a/libcxx/test/thread/futures/futures.overview/launch.pass.cpp +++ b/libcxx/test/thread/futures/futures.overview/launch.pass.cpp @@ -20,7 +20,8 @@ int main() { - static_assert(std::launch::any == (std::launch::async | std::launch::deferred), ""); - static_assert(std::launch::async == 1, ""); - static_assert(std::launch::deferred == 2, ""); + static_assert(static_cast(std::launch::any) == + (static_cast(std::launch::async) | static_cast(std::launch::deferred)), ""); + static_assert(static_cast(std::launch::async) == 1, ""); + static_assert(static_cast(std::launch::deferred) == 2, ""); }