Date: Sat, 6 Jan 2018 21:36:34 +0000 (UTC) From: Dimitry Andric <dim@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-vendor@freebsd.org Subject: svn commit: r327645 - in vendor/libc++/dist-release_60: . include test/std/containers/sequences/list/list.ops test/std/utilities/meta/meta.unary/meta.unary.prop www Message-ID: <201801062136.w06LaYKc067475@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: dim Date: Sat Jan 6 21:36:34 2018 New Revision: 327645 URL: https://svnweb.freebsd.org/changeset/base/327645 Log: Vendor import of libc++ release_60 branch r321788: https://llvm.org/svn/llvm-project/libcxx/branches/release_60@321788 Added: vendor/libc++/dist-release_60/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp (contents, props changed) Modified: vendor/libc++/dist-release_60/CMakeLists.txt vendor/libc++/dist-release_60/CREDITS.TXT vendor/libc++/dist-release_60/include/__config vendor/libc++/dist-release_60/include/__functional_base vendor/libc++/dist-release_60/include/__mutex_base vendor/libc++/dist-release_60/include/chrono vendor/libc++/dist-release_60/include/functional vendor/libc++/dist-release_60/include/memory vendor/libc++/dist-release_60/include/mutex vendor/libc++/dist-release_60/include/optional vendor/libc++/dist-release_60/include/ratio vendor/libc++/dist-release_60/include/system_error vendor/libc++/dist-release_60/include/tuple vendor/libc++/dist-release_60/include/type_traits vendor/libc++/dist-release_60/include/utility vendor/libc++/dist-release_60/include/variant vendor/libc++/dist-release_60/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp vendor/libc++/dist-release_60/www/cxx1z_status.html Modified: vendor/libc++/dist-release_60/CMakeLists.txt ============================================================================== --- vendor/libc++/dist-release_60/CMakeLists.txt Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/CMakeLists.txt Sat Jan 6 21:36:34 2018 (r327645) @@ -23,7 +23,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR project(libcxx CXX C) set(PACKAGE_NAME libcxx) - set(PACKAGE_VERSION 6.0.0svn) + set(PACKAGE_VERSION 6.0.0) set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}") set(PACKAGE_BUGREPORT "llvm-bugs@lists.llvm.org") Modified: vendor/libc++/dist-release_60/CREDITS.TXT ============================================================================== --- vendor/libc++/dist-release_60/CREDITS.TXT Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/CREDITS.TXT Sat Jan 6 21:36:34 2018 (r327645) @@ -101,7 +101,7 @@ E: nico.rieck@gmail.com D: Windows fixes N: Jon Roelofs -E: jonathan@codesourcery.com +E: jroelofS@jroelofs.com D: Remote testing, Newlib port, baremetal/single-threaded support. N: Jonathan Sauer Modified: vendor/libc++/dist-release_60/include/__config ============================================================================== --- vendor/libc++/dist-release_60/include/__config Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/__config Sat Jan 6 21:36:34 2018 (r327645) @@ -461,9 +461,13 @@ namespace std { #endif #if __has_builtin(__builtin_launder) -#define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER +#define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER #endif +#if !__is_identifier(__has_unique_object_representations) +#define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS +#endif + #elif defined(_LIBCPP_COMPILER_GCC) #define _ALIGNAS(x) __attribute__((__aligned__(x))) @@ -547,9 +551,13 @@ namespace std { #endif #if _GNUC_VER >= 700 -#define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER +#define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER #endif +#if _GNUC_VER >= 700 +#define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS +#endif + #elif defined(_LIBCPP_COMPILER_MSVC) #define _LIBCPP_TOSTRING2(x) #x @@ -980,9 +988,10 @@ template <unsigned> struct __static_assert_check {}; #define _LIBCPP_NODISCARD_AFTER_CXX17 #endif -// FIXME: Remove all usages of this macro once compilers catch up. -#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606L) -# define _LIBCPP_HAS_NO_INLINE_VARIABLES +#if _LIBCPP_STD_VER > 14 && defined(__cpp_inline_variables) && (__cpp_inline_variables >= 201606L) +# define _LIBCPP_INLINE_VAR inline +#else +# define _LIBCPP_INLINE_VAR #endif #ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES Modified: vendor/libc++/dist-release_60/include/__functional_base ============================================================================== --- vendor/libc++/dist-release_60/include/__functional_base Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/__functional_base Sat Jan 6 21:36:34 2018 (r327645) @@ -564,7 +564,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { }; #if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_MEMORY) extern const allocator_arg_t allocator_arg; #else -constexpr allocator_arg_t allocator_arg = allocator_arg_t(); +/* _LIBCPP_INLINE_VAR */ constexpr allocator_arg_t allocator_arg = allocator_arg_t(); #endif // uses_allocator @@ -601,7 +601,7 @@ struct _LIBCPP_TEMPLATE_VIS uses_allocator #if _LIBCPP_STD_VER > 14 template <class _Tp, class _Alloc> -constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value; +_LIBCPP_INLINE_VAR constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value; #endif #ifndef _LIBCPP_CXX03_LANG Modified: vendor/libc++/dist-release_60/include/__mutex_base ============================================================================== --- vendor/libc++/dist-release_60/include/__mutex_base Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/__mutex_base Sat Jan 6 21:36:34 2018 (r327645) @@ -82,9 +82,9 @@ extern const adopt_lock_t adopt_lock; #else -constexpr defer_lock_t defer_lock = defer_lock_t(); -constexpr try_to_lock_t try_to_lock = try_to_lock_t(); -constexpr adopt_lock_t adopt_lock = adopt_lock_t(); +/* _LIBCPP_INLINE_VAR */ constexpr defer_lock_t defer_lock = defer_lock_t(); +/* _LIBCPP_INLINE_VAR */ constexpr try_to_lock_t try_to_lock = try_to_lock_t(); +/* _LIBCPP_INLINE_VAR */ constexpr adopt_lock_t adopt_lock = adopt_lock_t(); #endif Modified: vendor/libc++/dist-release_60/include/chrono ============================================================================== --- vendor/libc++/dist-release_60/include/chrono Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/chrono Sat Jan 6 21:36:34 2018 (r327645) @@ -26,7 +26,7 @@ duration_cast(const duration<Rep, Period>& fd); template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {}; -template <class Rep> constexpr bool treat_as_floating_point_v +template <class Rep> inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value; // C++17 template <class Rep> @@ -419,7 +419,8 @@ template <class _Rep> struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v +template <class _Rep> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value; #endif Modified: vendor/libc++/dist-release_60/include/functional ============================================================================== --- vendor/libc++/dist-release_60/include/functional Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/functional Sat Jan 6 21:36:34 2018 (r327645) @@ -213,9 +213,9 @@ template<class T> struct is_bind_expression; template<class T> struct is_placeholder; // See C++14 20.9.9, Function object binders -template <class T> constexpr bool is_bind_expression_v +template <class T> inline constexpr bool is_bind_expression_v = is_bind_expression<T>::value; // C++17 -template <class T> constexpr int is_placeholder_v +template <class T> inline constexpr int is_placeholder_v = is_placeholder<T>::value; // C++17 @@ -1991,7 +1991,7 @@ template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bin #if _LIBCPP_STD_VER > 14 template <class _Tp> -constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value; +_LIBCPP_INLINE_VAR constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value; #endif template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; @@ -2000,7 +2000,7 @@ template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pla #if _LIBCPP_STD_VER > 14 template <class _Tp> -constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value; +_LIBCPP_INLINE_VAR constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value; #endif namespace placeholders @@ -2020,16 +2020,16 @@ _LIBCPP_FUNC_VIS extern const __ph<8> _8; _LIBCPP_FUNC_VIS extern const __ph<9> _9; _LIBCPP_FUNC_VIS extern const __ph<10> _10; #else -constexpr __ph<1> _1{}; -constexpr __ph<2> _2{}; -constexpr __ph<3> _3{}; -constexpr __ph<4> _4{}; -constexpr __ph<5> _5{}; -constexpr __ph<6> _6{}; -constexpr __ph<7> _7{}; -constexpr __ph<8> _8{}; -constexpr __ph<9> _9{}; -constexpr __ph<10> _10{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<1> _1{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<2> _2{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<3> _3{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<4> _4{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<5> _5{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<6> _6{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<7> _7{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<8> _8{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<9> _9{}; +/* _LIBCPP_INLINE_VAR */ constexpr __ph<10> _10{}; #endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_BIND) } // placeholders Modified: vendor/libc++/dist-release_60/include/memory ============================================================================== --- vendor/libc++/dist-release_60/include/memory Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/memory Sat Jan 6 21:36:34 2018 (r327645) @@ -18,7 +18,7 @@ namespace std { struct allocator_arg_t { }; -constexpr allocator_arg_t allocator_arg = allocator_arg_t(); +inline constexpr allocator_arg_t allocator_arg = allocator_arg_t(); template <class T, class Alloc> struct uses_allocator; @@ -630,6 +630,9 @@ template<class T> template <class T> struct hash; template <class T, class D> struct hash<unique_ptr<T, D> >; template <class T> struct hash<shared_ptr<T> >; + +template <class T, class Alloc> + inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value; // Pointer safety enum class pointer_safety { relaxed, preferred, strict }; Modified: vendor/libc++/dist-release_60/include/mutex ============================================================================== --- vendor/libc++/dist-release_60/include/mutex Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/mutex Sat Jan 6 21:36:34 2018 (r327645) @@ -91,9 +91,9 @@ struct defer_lock_t {}; struct try_to_lock_t {}; struct adopt_lock_t {}; -constexpr defer_lock_t defer_lock{}; -constexpr try_to_lock_t try_to_lock{}; -constexpr adopt_lock_t adopt_lock{}; +inline constexpr defer_lock_t defer_lock{}; +inline constexpr try_to_lock_t try_to_lock{}; +inline constexpr adopt_lock_t adopt_lock{}; template <class Mutex> class lock_guard Modified: vendor/libc++/dist-release_60/include/optional ============================================================================== --- vendor/libc++/dist-release_60/include/optional Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/optional Sat Jan 6 21:36:34 2018 (r327645) @@ -22,7 +22,7 @@ namespace std { // 23.6.4, no-value state indicator struct nullopt_t{see below }; - constexpr nullopt_t nullopt(unspecified ); + inline constexpr nullopt_t nullopt(unspecified ); // 23.6.5, class bad_optional_access class bad_optional_access; @@ -195,7 +195,7 @@ struct nullopt_t _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {} }; -/* inline */ constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}}; +_LIBCPP_INLINE_VAR constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}}; template <class _Tp, bool = is_trivially_destructible<_Tp>::value> struct __optional_destruct_base; Modified: vendor/libc++/dist-release_60/include/ratio ============================================================================== --- vendor/libc++/dist-release_60/include/ratio Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/ratio Sat Jan 6 21:36:34 2018 (r327645) @@ -63,17 +63,17 @@ typedef ratio< 1000000000000000000000, 1> zetta; // typedef ratio<1000000000000000000000000, 1> yotta; // not supported // 20.11.5, ratio comparison - template <class R1, class R2> constexpr bool ratio_equal_v + template <class R1, class R2> inline constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value; // C++17 - template <class R1, class R2> constexpr bool ratio_not_equal_v + template <class R1, class R2> inline constexpr bool ratio_not_equal_v = ratio_not_equal<R1, R2>::value; // C++17 - template <class R1, class R2> constexpr bool ratio_less_v + template <class R1, class R2> inline constexpr bool ratio_less_v = ratio_less<R1, R2>::value; // C++17 - template <class R1, class R2> constexpr bool ratio_less_equal_v + template <class R1, class R2> inline constexpr bool ratio_less_equal_v = ratio_less_equal<R1, R2>::value; // C++17 - template <class R1, class R2> constexpr bool ratio_greater_v + template <class R1, class R2> inline constexpr bool ratio_greater_v = ratio_greater<R1, R2>::value; // C++17 - template <class R1, class R2> constexpr bool ratio_greater_equal_v + template <class R1, class R2> inline constexpr bool ratio_greater_equal_v = ratio_greater_equal<R1, R2>::value; // C++17 } */ @@ -501,22 +501,28 @@ struct __ratio_gcd }; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_equal_v +template <class _R1, class _R2> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_equal_v = ratio_equal<_R1, _R2>::value; -template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_not_equal_v +template <class _R1, class _R2> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value; -template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_v +template <class _R1, class _R2> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_less_v = ratio_less<_R1, _R2>::value; -template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_equal_v +template <class _R1, class _R2> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_less_equal_v = ratio_less_equal<_R1, _R2>::value; -template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_v +template <class _R1, class _R2> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_greater_v = ratio_greater<_R1, _R2>::value; -template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_equal_v +template <class _R1, class _R2> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool ratio_greater_equal_v = ratio_greater_equal<_R1, _R2>::value; #endif Modified: vendor/libc++/dist-release_60/include/system_error ============================================================================== --- vendor/libc++/dist-release_60/include/system_error Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/system_error Sat Jan 6 21:36:34 2018 (r327645) @@ -47,10 +47,10 @@ template <class T> struct is_error_condition_enum : public false_type {}; template <class _Tp> -constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17 +inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17 template <class _Tp> -constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17 +inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17 class error_code { @@ -246,7 +246,7 @@ struct _LIBCPP_TEMPLATE_VIS is_error_code_enum #if _LIBCPP_STD_VER > 14 template <class _Tp> -constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; +_LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; #endif // is_error_condition_enum @@ -257,7 +257,7 @@ struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum #if _LIBCPP_STD_VER > 14 template <class _Tp> -constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; +_LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; #endif // Some error codes are not present on all platforms, so we provide equivalents Modified: vendor/libc++/dist-release_60/include/tuple ============================================================================== --- vendor/libc++/dist-release_60/include/tuple Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/tuple Sat Jan 6 21:36:34 2018 (r327645) @@ -70,7 +70,7 @@ class tuple { (public) void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); }; -const unspecified ignore; +inline constexpr unspecified ignore; template <class... T> tuple<V...> make_tuple(T&&...); // constexpr in C++14 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14 @@ -87,7 +87,7 @@ template <class T, class Tuple> template <class T> class tuple_size; // undefined template <class... T> class tuple_size<tuple<T...>>; template <class T> - constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17 + inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17 template <size_t I, class T> class tuple_element; // undefined template <size_t I, class... T> class tuple_element<I, tuple<T...>>; template <size_t I, class T> @@ -1079,7 +1079,7 @@ struct __ignore_t }; namespace { - constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); + _LIBCPP_INLINE_VAR constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); } template <class _Tp> @@ -1368,7 +1368,7 @@ pair<_T1, _T2>::pair(piecewise_construct_t, #if _LIBCPP_STD_VER > 14 template <class _Tp> -constexpr size_t tuple_size_v = tuple_size<_Tp>::value; +_LIBCPP_INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Tp>::value; #define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; } Modified: vendor/libc++/dist-release_60/include/type_traits ============================================================================== --- vendor/libc++/dist-release_60/include/type_traits Sat Jan 6 21:36:11 2018 (r327644) +++ vendor/libc++/dist-release_60/include/type_traits Sat Jan 6 21:36:34 2018 (r327645) @@ -132,6 +132,8 @@ namespace std template <class T> struct has_virtual_destructor; + template<class T> struct has_unique_object_representations; // C++17 + // Relationships between types: template <class T, class U> struct is_same; template <class Base, class Derived> struct is_base_of; @@ -223,173 +225,175 @@ namespace std using void_t = void; // C++17 // See C++14 20.10.4.1, primary type categories - template <class T> constexpr bool is_void_v + template <class T> inline constexpr bool is_void_v = is_void<T>::value; // C++17 - template <class T> constexpr bool is_null_pointer_v + template <class T> inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value; // C++17 - template <class T> constexpr bool is_integral_v + template <class T> inline constexpr bool is_integral_v = is_integral<T>::value; // C++17 - template <class T> constexpr bool is_floating_point_v + template <class T> inline constexpr bool is_floating_point_v = is_floating_point<T>::value; // C++17 - template <class T> constexpr bool is_array_v + template <class T> inline constexpr bool is_array_v = is_array<T>::value; // C++17 - template <class T> constexpr bool is_pointer_v + template <class T> inline constexpr bool is_pointer_v = is_pointer<T>::value; // C++17 - template <class T> constexpr bool is_lvalue_reference_v + template <class T> inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value; // C++17 - template <class T> constexpr bool is_rvalue_reference_v + template <class T> inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value; // C++17 - template <class T> constexpr bool is_member_object_pointer_v + template <class T> inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value; // C++17 - template <class T> constexpr bool is_member_function_pointer_v + template <class T> inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value; // C++17 - template <class T> constexpr bool is_enum_v + template <class T> inline constexpr bool is_enum_v = is_enum<T>::value; // C++17 - template <class T> constexpr bool is_union_v + template <class T> inline constexpr bool is_union_v = is_union<T>::value; // C++17 - template <class T> constexpr bool is_class_v + template <class T> inline constexpr bool is_class_v = is_class<T>::value; // C++17 - template <class T> constexpr bool is_function_v + template <class T> inline constexpr bool is_function_v = is_function<T>::value; // C++17 // See C++14 20.10.4.2, composite type categories - template <class T> constexpr bool is_reference_v + template <class T> inline constexpr bool is_reference_v = is_reference<T>::value; // C++17 - template <class T> constexpr bool is_arithmetic_v + template <class T> inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value; // C++17 - template <class T> constexpr bool is_fundamental_v + template <class T> inline constexpr bool is_fundamental_v = is_fundamental<T>::value; // C++17 - template <class T> constexpr bool is_object_v + template <class T> inline constexpr bool is_object_v = is_object<T>::value; // C++17 - template <class T> constexpr bool is_scalar_v + template <class T> inline constexpr bool is_scalar_v = is_scalar<T>::value; // C++17 - template <class T> constexpr bool is_compound_v + template <class T> inline constexpr bool is_compound_v = is_compound<T>::value; // C++17 - template <class T> constexpr bool is_member_pointer_v + template <class T> inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value; // C++17 // See C++14 20.10.4.3, type properties - template <class T> constexpr bool is_const_v + template <class T> inline constexpr bool is_const_v = is_const<T>::value; // C++17 - template <class T> constexpr bool is_volatile_v + template <class T> inline constexpr bool is_volatile_v = is_volatile<T>::value; // C++17 - template <class T> constexpr bool is_trivial_v + template <class T> inline constexpr bool is_trivial_v = is_trivial<T>::value; // C++17 - template <class T> constexpr bool is_trivially_copyable_v + template <class T> inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value; // C++17 - template <class T> constexpr bool is_standard_layout_v + template <class T> inline constexpr bool is_standard_layout_v = is_standard_layout<T>::value; // C++17 - template <class T> constexpr bool is_pod_v + template <class T> inline constexpr bool is_pod_v = is_pod<T>::value; // C++17 - template <class T> constexpr bool is_literal_type_v + template <class T> inline constexpr bool is_literal_type_v = is_literal_type<T>::value; // C++17 - template <class T> constexpr bool is_empty_v + template <class T> inline constexpr bool is_empty_v = is_empty<T>::value; // C++17 - template <class T> constexpr bool is_polymorphic_v + template <class T> inline constexpr bool is_polymorphic_v = is_polymorphic<T>::value; // C++17 - template <class T> constexpr bool is_abstract_v + template <class T> inline constexpr bool is_abstract_v = is_abstract<T>::value; // C++17 - template <class T> constexpr bool is_final_v + template <class T> inline constexpr bool is_final_v = is_final<T>::value; // C++17 - template <class T> constexpr bool is_aggregate_v + template <class T> inline constexpr bool is_aggregate_v = is_aggregate<T>::value; // C++17 - template <class T> constexpr bool is_signed_v + template <class T> inline constexpr bool is_signed_v = is_signed<T>::value; // C++17 - template <class T> constexpr bool is_unsigned_v + template <class T> inline constexpr bool is_unsigned_v = is_unsigned<T>::value; // C++17 - template <class T, class... Args> constexpr bool is_constructible_v + template <class T, class... Args> inline constexpr bool is_constructible_v = is_constructible<T, Args...>::value; // C++17 - template <class T> constexpr bool is_default_constructible_v + template <class T> inline constexpr bool is_default_constructible_v = is_default_constructible<T>::value; // C++17 - template <class T> constexpr bool is_copy_constructible_v + template <class T> inline constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value; // C++17 - template <class T> constexpr bool is_move_constructible_v + template <class T> inline constexpr bool is_move_constructible_v = is_move_constructible<T>::value; // C++17 - template <class T, class U> constexpr bool is_assignable_v + template <class T, class U> inline constexpr bool is_assignable_v = is_assignable<T, U>::value; // C++17 - template <class T> constexpr bool is_copy_assignable_v + template <class T> inline constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value; // C++17 - template <class T> constexpr bool is_move_assignable_v + template <class T> inline constexpr bool is_move_assignable_v = is_move_assignable<T>::value; // C++17 - template <class T, class U> constexpr bool is_swappable_with_v + template <class T, class U> inline constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value; // C++17 - template <class T> constexpr bool is_swappable_v + template <class T> inline constexpr bool is_swappable_v = is_swappable<T>::value; // C++17 - template <class T> constexpr bool is_destructible_v + template <class T> inline constexpr bool is_destructible_v = is_destructible<T>::value; // C++17 - template <class T, class... Args> constexpr bool is_trivially_constructible_v + template <class T, class... Args> inline constexpr bool is_trivially_constructible_v = is_trivially_constructible<T, Args...>::value; // C++17 - template <class T> constexpr bool is_trivially_default_constructible_v + template <class T> inline constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<T>::value; // C++17 - template <class T> constexpr bool is_trivially_copy_constructible_v + template <class T> inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value; // C++17 - template <class T> constexpr bool is_trivially_move_constructible_v + template <class T> inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<T>::value; // C++17 - template <class T, class U> constexpr bool is_trivially_assignable_v + template <class T, class U> inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value; // C++17 - template <class T> constexpr bool is_trivially_copy_assignable_v + template <class T> inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<T>::value; // C++17 - template <class T> constexpr bool is_trivially_move_assignable_v + template <class T> inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value; // C++17 - template <class T> constexpr bool is_trivially_destructible_v + template <class T> inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value; // C++17 - template <class T, class... Args> constexpr bool is_nothrow_constructible_v + template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<T, Args...>::value; // C++17 - template <class T> constexpr bool is_nothrow_default_constructible_v + template <class T> inline constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<T>::value; // C++17 - template <class T> constexpr bool is_nothrow_copy_constructible_v + template <class T> inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value; // C++17 - template <class T> constexpr bool is_nothrow_move_constructible_v + template <class T> inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value; // C++17 - template <class T, class U> constexpr bool is_nothrow_assignable_v + template <class T, class U> inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value; // C++17 - template <class T> constexpr bool is_nothrow_copy_assignable_v + template <class T> inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value; // C++17 - template <class T> constexpr bool is_nothrow_move_assignable_v + template <class T> inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value; // C++17 - template <class T, class U> constexpr bool is_nothrow_swappable_with_v + template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value; // C++17 - template <class T> constexpr bool is_nothrow_swappable_v + template <class T> inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value; // C++17 - template <class T> constexpr bool is_nothrow_destructible_v + template <class T> inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value; // C++17 - template <class T> constexpr bool has_virtual_destructor_v + template <class T> inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value; // C++17 + template<class T> inline constexpr bool has_unique_object_representations_v // C++17 + = has_unique_object_representations<T>::value; // See C++14 20.10.5, type property queries - template <class T> constexpr size_t alignment_of_v + template <class T> inline constexpr size_t alignment_of_v = alignment_of<T>::value; // C++17 - template <class T> constexpr size_t rank_v + template <class T> inline constexpr size_t rank_v = rank<T>::value; // C++17 - template <class T, unsigned I = 0> constexpr size_t extent_v + template <class T, unsigned I = 0> inline constexpr size_t extent_v = extent<T, I>::value; // C++17 // See C++14 20.10.6, type relations - template <class T, class U> constexpr bool is_same_v + template <class T, class U> inline constexpr bool is_same_v = is_same<T, U>::value; // C++17 - template <class Base, class Derived> constexpr bool is_base_of_v + template <class Base, class Derived> inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value; // C++17 - template <class From, class To> constexpr bool is_convertible_v + template <class From, class To> inline constexpr bool is_convertible_v = is_convertible<From, To>::value; // C++17 - template <class Fn, class... ArgTypes> constexpr bool is_invocable_v + template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value; // C++17 - template <class R, class Fn, class... ArgTypes> constexpr bool is_invocable_r_v + template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value; // C++17 - template <class Fn, class... ArgTypes> constexpr bool is_nothrow_invocable_v + template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value; // C++17 - template <class R, class Fn, class... ArgTypes> constexpr bool is_nothrow_invocable_r_v + template <class R, class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value; // C++17 // [meta.logical], logical operator traits: template<class... B> struct conjunction; // C++17 template<class... B> - constexpr bool conjunction_v = conjunction<B...>::value; // C++17 + inline constexpr bool conjunction_v = conjunction<B...>::value; // C++17 template<class... B> struct disjunction; // C++17 template<class... B> - constexpr bool disjunction_v = disjunction<B...>::value; // C++17 + inline constexpr bool disjunction_v = disjunction<B...>::value; // C++17 template<class B> struct negation; // C++17 template<class B> - constexpr bool negation_v = negation<B>::value; // C++17 + inline constexpr bool negation_v = negation<B>::value; // C++17 } @@ -619,7 +623,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_co template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_const_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_const_v = is_const<_Tp>::value; #endif @@ -629,7 +634,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_vo template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_volatile_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_volatile_v = is_volatile<_Tp>::value; #endif @@ -666,7 +672,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_vo : public __libcpp_is_void<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_void_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_void_v = is_void<_Tp>::value; #endif @@ -683,7 +690,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nu : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_null_pointer_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_null_pointer_v = is_null_pointer<_Tp>::value; #endif #endif @@ -717,7 +725,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_in : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_integral_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v = is_integral<_Tp>::value; #endif @@ -732,7 +741,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fl : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_floating_point_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_floating_point_v = is_floating_point<_Tp>::value; #endif @@ -746,7 +756,8 @@ template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLA : public true_type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_array_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v = is_array<_Tp>::value; #endif @@ -759,7 +770,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_po : public __libcpp_is_pointer<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_pointer_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v = is_pointer<_Tp>::value; #endif @@ -780,13 +792,16 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_re #endif #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_reference_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_reference_v = is_reference<_Tp>::value; -template <class _Tp> _LIBCPP_CONSTEXPR bool is_lvalue_reference_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value; -template <class _Tp> _LIBCPP_CONSTEXPR bool is_rvalue_reference_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value; #endif // is_union @@ -805,7 +820,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_un #endif #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_union_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_union_v = is_union<_Tp>::value; #endif @@ -830,7 +846,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_cl #endif #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_class_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_class_v = is_class<_Tp>::value; #endif @@ -840,7 +857,8 @@ template <class _Tp, class _Up> struct _LIBCPP_TEMPLAT template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_same<_Tp, _Tp> : public true_type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_same_v +template <class _Tp, class _Up> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_same_v = is_same<_Tp, _Up>::value; #endif @@ -870,7 +888,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fu : public __libcpp_is_function<_Tp> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_function_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_function_v = is_function<_Tp>::value; #endif @@ -897,7 +916,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_me : public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type>::type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_function_pointer_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; #endif @@ -910,7 +930,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_me : public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_pointer_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v = is_member_pointer<_Tp>::value; #endif @@ -921,7 +942,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_me !is_member_function_pointer<_Tp>::value> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_object_pointer_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; #endif @@ -949,7 +971,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_en #endif #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_enum_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_enum_v = is_enum<_Tp>::value; #endif @@ -960,7 +983,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_ar is_floating_point<_Tp>::value> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_arithmetic_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_arithmetic_v = is_arithmetic<_Tp>::value; #endif @@ -972,7 +996,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fu is_arithmetic<_Tp>::value> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_fundamental_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v = is_fundamental<_Tp>::value; #endif @@ -988,7 +1013,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_sc template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_scalar_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scalar_v = is_scalar<_Tp>::value; #endif @@ -1001,7 +1027,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_ob is_class<_Tp>::value > {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_object_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_object_v = is_object<_Tp>::value; #endif @@ -1011,7 +1038,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_co : public integral_constant<bool, !is_fundamental<_Tp>::value> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_compound_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_compound_v = is_compound<_Tp>::value; #endif @@ -1210,7 +1238,8 @@ template <class _Tp> struct __libcpp_is_signed<_Tp, fa template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_signed_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v = is_signed<_Tp>::value; #endif @@ -1230,7 +1259,8 @@ template <class _Tp> struct __libcpp_is_unsigned<_Tp, template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_unsigned_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v = is_unsigned<_Tp>::value; #endif @@ -1244,7 +1274,8 @@ template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLA : public integral_constant<size_t, rank<_Tp>::value + 1> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR size_t rank_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t rank_v = rank<_Tp>::value; #endif @@ -1262,7 +1293,8 @@ template <class _Tp, size_t _Np, unsigned _Ip> struct : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp, unsigned _Ip = 0> _LIBCPP_CONSTEXPR size_t extent_v +template <class _Tp, unsigned _Ip = 0> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t extent_v = extent<_Tp, _Ip>::value; #endif @@ -1334,7 +1366,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_ab : public integral_constant<bool, __is_abstract(_Tp)> {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_abstract_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_abstract_v = is_abstract<_Tp>::value; #endif @@ -1354,7 +1387,8 @@ is_final : public integral_constant<bool, __is_final(_ #endif #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_final_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_final_v = is_final<_Tp>::value; #endif @@ -1366,7 +1400,8 @@ is_aggregate : public integral_constant<bool, __is_agg #if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) template <class _Tp> -constexpr bool is_aggregate_v = is_aggregate<_Tp>::value; +_LIBCPP_INLINE_VAR constexpr bool is_aggregate_v + = is_aggregate<_Tp>::value; #endif #endif // _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_IS_AGGREGATE) @@ -1407,7 +1442,8 @@ struct _LIBCPP_TEMPLATE_VIS is_base_of #endif // _LIBCPP_HAS_IS_BASE_OF #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Bp, class _Dp> _LIBCPP_CONSTEXPR bool is_base_of_v +template <class _Bp, class _Dp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_base_of_v = is_base_of<_Bp, _Dp>::value; #endif @@ -1497,7 +1533,8 @@ template <class _T1, class _T2> struct _LIBCPP_TEMPLAT #endif // __has_feature(is_convertible_to) #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _From, class _To> _LIBCPP_CONSTEXPR bool is_convertible_v +template <class _From, class _To> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_convertible_v = is_convertible<_From, _To>::value; #endif @@ -1533,7 +1570,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_em #endif // __has_feature(is_empty) #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_empty_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_empty_v = is_empty<_Tp>::value; #endif @@ -1558,7 +1596,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_po #endif // __has_feature(is_polymorphic) #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool is_polymorphic_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_polymorphic_v = is_polymorphic<_Tp>::value; #endif @@ -1577,17 +1616,35 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_v #endif #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) -template <class _Tp> _LIBCPP_CONSTEXPR bool has_virtual_destructor_v +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value; #endif +// has_unique_object_representations + +#if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS) + +template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations + : public integral_constant<bool, + __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {}; + +#if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) +template <class _Tp> +_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; +#endif + +#endif *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201801062136.w06LaYKc067475>