[libc++] Remove various C++03 feature test macros

[EricWF]

Summary

Libc++ still uses per-feature configuration macros when configuring for C++11. However libc++ requires a feature-complete C++11 compiler so there is no reason to check individual features. This patch starts the process of removing the feature specific macros and replacing their usage with _LIBCPP_CXX03_LANG.

This patch removes the __config macros:

• _LIBCPP_HAS_NO_TRAILING_RETURN
• _LIBCPP_HAS_NO_TEMPLATE_ALIASES
• _LIBCPP_HAS_NO_ADVANCED_SFINAE
• _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
• _LIBCPP_HAS_NO_STATIC_ASSERT

As a drive I also changed our C++03 static_assert to use _Static_assert if available.

I plan to commit this without review if nobody voices an objection.

[EricWF]

Actually remove _LIBCPP_HAS_NO_STATIC_ASSERT.

[EricWF]

Fix merge conflicts.

include/__config

 #if __has_feature(cxx_alignas)
 #  define _ALIGNAS_TYPE(x) alignas(x)
 #  define _ALIGNAS(x) alignas(x)
 #else
 #  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
 #  define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #endif
 
-#if !__has_feature(cxx_alias_templates)
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-#endif
-
 #if __cplusplus < 201103L
 typedef __char16_t char16_t;
 typedef __char32_t char32_t;
 #endif
 
 #if !(__has_feature(cxx_exceptions)) && !defined(_LIBCPP_NO_EXCEPTIONS)
 #define _LIBCPP_NO_EXCEPTIONS
 #endif

 #endif
 
 #if __has_feature(cxx_attributes)
 #  define _LIBCPP_NORETURN [[noreturn]]
 #else
 #  define _LIBCPP_NORETURN __attribute__ ((noreturn))
 #endif
 
-#if !(__has_feature(cxx_default_function_template_args))
-#define _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
-#endif
-
 #if !(__has_feature(cxx_defaulted_functions))
 #define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 #endif  // !(__has_feature(cxx_defaulted_functions))
 
 #if !(__has_feature(cxx_deleted_functions))
 #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 #endif  // !(__has_feature(cxx_deleted_functions))
 

 #if !(__has_feature(cxx_static_assert))
 #define _LIBCPP_HAS_NO_STATIC_ASSERT
 #endif
 
 #if !(__has_feature(cxx_auto_type))
 #define _LIBCPP_HAS_NO_AUTO_TYPE
 #endif
 
-#if !(__has_feature(cxx_access_control_sfinae)) || !__has_feature(cxx_trailing_return)
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#endif
-
 #if !(__has_feature(cxx_variadic_templates))
 #define _LIBCPP_HAS_NO_VARIADICS
 #endif
 
-#if !(__has_feature(cxx_trailing_return))
-#define _LIBCPP_HAS_NO_TRAILING_RETURN
-#endif
-
 #if !(__has_feature(cxx_generalized_initializers))
 #define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #endif
 
 #if __has_feature(is_base_of)
 #  define _LIBCPP_HAS_IS_BASE_OF
 #endif
 

 #endif
 
 // GCC 5 will support variable templates
 #if !defined(__cpp_variable_templates) || __cpp_variable_templates < 201304L
 #define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
 #endif
 
 #ifndef __GXX_EXPERIMENTAL_CXX0X__
-
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
 #define _LIBCPP_HAS_NO_DECLTYPE
-#define _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
 #define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 #define _LIBCPP_HAS_NO_NULLPTR
 #define _LIBCPP_HAS_NO_STATIC_ASSERT
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_VARIADICS
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #define _LIBCPP_HAS_NO_STRONG_ENUMS
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 #define _LIBCPP_HAS_NO_NOEXCEPT
 
 #else  // __GXX_EXPERIMENTAL_CXX0X__
 
 #if _GNUC_VER < 403
-#define _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#define _LIBCPP_HAS_NO_STATIC_ASSERT
 #endif
 
 
 #if _GNUC_VER < 404
 #define _LIBCPP_HAS_NO_DECLTYPE
 #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
-#define _LIBCPP_HAS_NO_TRAILING_RETURN
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_VARIADICS
 #define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #endif  // _GNUC_VER < 404
 
 #if _GNUC_VER < 406
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define _LIBCPP_HAS_NO_NULLPTR
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 #endif
 
 #if _GNUC_VER < 407
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
 #define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 #endif
 
 #endif  // __GXX_EXPERIMENTAL_CXX0X__
 
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
 #define _VSTD std::_LIBCPP_NAMESPACE
 
 namespace std {
 namespace _LIBCPP_NAMESPACE {
 }
 using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
 }
 
 #if !defined(_LIBCPP_HAS_NO_ASAN) && !defined(__SANITIZE_ADDRESS__)
 #define _LIBCPP_HAS_NO_ASAN
 #endif
 
 #elif defined(_LIBCPP_MSVC)
 
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 #define _LIBCPP_HAS_NO_CONSTEXPR
 #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
 #define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 #define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define __alignof__ __alignof

 
 #elif defined(__IBMCPP__)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
 #define _ATTRIBUTE(x) __attribute__((x))
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
-#define _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
 #define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define _LIBCPP_HAS_NO_NULLPTR
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_IS_BASE_OF
 #define _LIBCPP_HAS_IS_FINAL
 #define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
 

 typedef unsigned int   char32_t;
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 #ifndef __SIZEOF_INT128__
 #define _LIBCPP_HAS_NO_INT128
 #endif
 
 #ifdef _LIBCPP_HAS_NO_STATIC_ASSERT
-
+# if __has_extension(c_static_assert)
+#   define static_assert(__b, __m) _Static_assert(__b, __m)
+# else
 extern "C++" {
 template <bool> struct __static_assert_test;
 template <> struct __static_assert_test<true> {};
 template <unsigned> struct __static_assert_check {};
 }
 #define static_assert(__b, __m) \
     typedef __static_assert_check<sizeof(__static_assert_test<(__b)>)> \
     _LIBCPP_CONCAT(__t, __LINE__)
-
+# endif // __has_extension(c_static_assert)
 #endif  // _LIBCPP_HAS_NO_STATIC_ASSERT
 
 #ifdef _LIBCPP_HAS_NO_DECLTYPE
 // GCC 4.6 provides __decltype in all standard modes.
 #if !__is_identifier(__decltype) || _GNUC_VER >= 406
 #  define decltype(__x) __decltype(__x)
 #else
 #  define decltype(__x) __typeof__(__x)

include/iterator

 template <class _Tp, size_t _Np>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp*
 end(_Tp (&__array)[_Np])
 {
     return __array + _Np;
 }
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#if !defined(_LIBCPP_CXX03_LANG)
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 begin(_Cp& __c) -> decltype(__c.begin())
 {
     return __c.begin();
 }

 auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
 {
     return _VSTD::rend(__c);
 }
 
 #endif
 
 
-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#else  // defined(_LIBCPP_CXX03_LANG)
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename _Cp::iterator
 begin(_Cp& __c)
 {
     return __c.begin();
 }

 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename _Cp::const_iterator
 end(const _Cp& __c)
 {
     return __c.end();
 }
 
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#endif  // !defined(_LIBCPP_CXX03_LANG)
 
 #if _LIBCPP_STD_VER > 14
 template <class _Cont>
 constexpr auto size(const _Cont& __c) -> decltype(__c.size()) { return __c.size(); }
 
 template <class _Tp, size_t _Sz>
 constexpr size_t size(const _Tp (&__array)[_Sz]) noexcept { return _Sz; }
 

include/memory

private:
     template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
 public:
     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };
 
 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
 struct __pointer_traits_rebind
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Tp::template rebind<_Up> type;
 #else
     typedef typename _Tp::template rebind<_Up>::other type;
 #endif
 };
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
 {
     typedef _Sp<_Up, _Args...> type;
 };
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class> class _Sp, class _Tp, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class> class _Sp, class _Tp, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false>
 {
     typedef _Sp<_Up> type;
 };
 
 template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false>
 {
     typedef _Sp<_Up, _A0> type;
 };
 
 template <template <class, class, class> class _Sp, class _Tp, class _A0,
                                          class _A1, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class, class> class _Sp, class _Tp, class _A0,
                                          class _A1, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false>
 {
     typedef _Sp<_Up, _A0, _A1> type;
 };
 
 template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false>
 {
     typedef _Sp<_Up, _A0, _A1, _A2> type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Ptr>
 struct _LIBCPP_TYPE_VIS_ONLY pointer_traits
 {
     typedef _Ptr                                                     pointer;
     typedef typename __pointer_traits_element_type<pointer>::type    element_type;
     typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
 #else
     template <class _Up> struct rebind
         {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif  // _LIBCPP_CXX03_LANG
 
 private:
     struct __nat {};
 public:
     _LIBCPP_INLINE_VISIBILITY
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                            __nat, element_type>::type& __r)
         {return pointer::pointer_to(__r);}
 };
 
 template <class _Tp>
 struct _LIBCPP_TYPE_VIS_ONLY pointer_traits<_Tp*>
 {
     typedef _Tp*      pointer;
     typedef _Tp       element_type;
     typedef ptrdiff_t difference_type;
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     template <class _Up> using rebind = _Up*;
 #else
     template <class _Up> struct rebind {typedef _Up* other;};
 #endif
 
 private:
     struct __nat {};
 public:
     _LIBCPP_INLINE_VISIBILITY
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                       __nat, element_type>::type& __r) _NOEXCEPT
         {return _VSTD::addressof(__r);}
 };
 
 template <class _From, class _To>
 struct __rebind_pointer {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_From>::template rebind<_To>        type;
 #else
     typedef typename pointer_traits<_From>::template rebind<_To>::other type;
 #endif
 };
 
 // allocator_traits
 

 struct __const_pointer
 {
     typedef typename _Alloc::const_pointer type;
 };
 
 template <class _Tp, class _Ptr, class _Alloc>
 struct __const_pointer<_Tp, _Ptr, _Alloc, false>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type;
 #endif
 };
 
 template <class _Tp>
 struct __has_void_pointer

 struct __void_pointer
 {
     typedef typename _Alloc::void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __void_pointer<_Ptr, _Alloc, false>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_Ptr>::template rebind<void> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<void>::other type;
 #endif
 };
 
 template <class _Tp>
 struct __has_const_void_pointer

 struct __const_void_pointer
 {
     typedef typename _Alloc::const_void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __const_void_pointer<_Ptr, _Alloc, false>
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_Ptr>::template rebind<const void> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type;
 #endif
 };
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false>
 {
     typedef _Alloc<_Up, _A0, _A1, _A2> type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
     -> decltype(__a.allocate(__sz, __p), true_type());
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
     -> false_type;
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
     : integral_constant<bool,
         is_same<
             decltype(__has_allocate_hint_test(declval<_Alloc>(),
                                           declval<_SizeType>(),
                                           declval<_ConstVoidPtr>())),
             true_type>::value>
 {
 };
 
-#else  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
     : true_type
 {
 };
 
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif  // _LIBCPP_CXX03_LANG
 
-#if !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#if !defined(_LIBCPP_CXX03_LANG)
 
 template <class _Alloc, class _Tp, class ..._Args>
 decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),
                                            _VSTD::declval<_Args>()...),
                                            true_type())
 __has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);
 
 template <class _Alloc, class _Pointer, class ..._Args>

 struct __has_select_on_container_copy_construction
     : integral_constant<bool,
         is_same<
             decltype(__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
             true_type>::value>
 {
 };
 
-#else  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#else  // _LIBCPP_CXX03_LANG
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Alloc, class _Pointer, class ..._Args>
 struct __has_construct
     : false_type
 {
 };

 };
 
 template <class _Alloc>
 struct __has_select_on_container_copy_construction
     : false_type
 {
 };
 
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value>
 struct __alloc_traits_difference_type
 {
     typedef typename pointer_traits<_Ptr>::difference_type type;
 };
 
 template <class _Alloc, class _Ptr>
typedef typename __propagate_on_container_copy_assignment<allocator_type>::type
                      propagate_on_container_copy_assignment;
     typedef typename __propagate_on_container_move_assignment<allocator_type>::type
                      propagate_on_container_move_assignment;
     typedef typename __propagate_on_container_swap<allocator_type>::type
                      propagate_on_container_swap;
     typedef typename __is_always_equal<allocator_type>::type
                      is_always_equal;
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     template <class _Tp> using rebind_alloc =
                   typename __allocator_traits_rebind<allocator_type, _Tp>::type;
     template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#else  // _LIBCPP_CXX03_LANG
     template <class _Tp> struct rebind_alloc
         {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;};
     template <class _Tp> struct rebind_traits
         {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;};
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     static pointer allocate(allocator_type& __a, size_type __n)
         {return __a.allocate(__n);}
     _LIBCPP_INLINE_VISIBILITY
     static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
         {return allocate(__a, __n, __hint,
             __has_allocate_hint<allocator_type, size_type, const_void_pointer>());}
#endif  // _LIBCPP_HAS_NO_VARIADICS
     static allocator_type
         select_on_container_copy_construction(false_type, const allocator_type& __a)
             {return __a;}
 };
 
 template <class _Traits, class _Tp>
 struct __rebind_alloc_helper
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
     typedef typename _Traits::template rebind_alloc<_Tp>        type;
 #else
     typedef typename _Traits::template rebind_alloc<_Tp>::other type;
 #endif
 };
 
 // allocator
 

include/ratio

 public:
     typedef typename ratio
         <
             __ll_mul<_R1::num / __gcd_n1_d2, _R2::num / __gcd_d1_n2>::value,
             __ll_mul<_R2::den / __gcd_n1_d2, _R1::den / __gcd_d1_n2>::value
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2> using ratio_multiply
                                     = typename __ratio_multiply<_R1, _R2>::type;
 
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct _LIBCPP_TYPE_VIS_ONLY ratio_multiply
     : public __ratio_multiply<_R1, _R2>::type {};
 
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct __ratio_divide
 {
 private:
     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
     static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 public:
     typedef typename ratio
         <
             __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
             __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2> using ratio_divide
                                       = typename __ratio_divide<_R1, _R2>::type;
 
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct _LIBCPP_TYPE_VIS_ONLY ratio_divide
     : public __ratio_divide<_R1, _R2>::type {};
 
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct __ratio_add
 {
 private:
     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
     static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 public:
     typedef typename ratio_multiply
         <
             ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
             ratio
             <
                 __ll_add
                 <
                     __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
                     __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
                 >::value,
                 _R2::den
             >
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2> using ratio_add
                                          = typename __ratio_add<_R1, _R2>::type;
 
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct _LIBCPP_TYPE_VIS_ONLY ratio_add
     : public __ratio_add<_R1, _R2>::type {};
 
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct __ratio_subtract
 {
 private:
     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
     static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 public:
     typedef typename ratio_multiply
         <
             ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
             ratio
             <
                 __ll_sub
                 <
                     __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
                     __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
                 >::value,
                 _R2::den
             >
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2> using ratio_subtract
                                     = typename __ratio_subtract<_R1, _R2>::type;
 
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#else  // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
 struct _LIBCPP_TYPE_VIS_ONLY ratio_subtract
     : public __ratio_subtract<_R1, _R2>::type {};
 
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif  // _LIBCPP_CXX03_LANG
 
 // ratio_equal
 
 template <class _R1, class _R2>
 struct _LIBCPP_TYPE_VIS_ONLY ratio_equal
     : public _LIBCPP_BOOL_CONSTANT((_R1::num == _R2::num && _R1::den == _R2::den)) {};
 
 template <class _R1, class _R2>

include/scoped_allocator

 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
+#if !defined(_LIBCPP_CXX03_LANG)
 
 // scoped_allocator_adaptor
 
 template <class ..._Allocs>
 class scoped_allocator_adaptor;
 
 template <class ..._Allocs> struct __get_poc_copy_assignment;
 

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
            const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT
 {
     return !(__a == __b);
 }
 
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
+#endif  // !defined(_LIBCPP_CXX03_LANG)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SCOPED_ALLOCATOR

include/type_traits

 
 #endif  // !defined(_LIBCPP_CXX03_LANG)
 
 template <class _Tp> struct __is_swappable;
 template <class _Tp> struct __is_nothrow_swappable;
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#ifndef _LIBCPP_CXX03_LANG
 typename enable_if
 <
     is_move_constructible<_Tp>::value &&
     is_move_assignable<_Tp>::value
 >::type
 #else
 void
 #endif

 __uint128_t __convert_to_integral(__uint128_t __val) { return __val; }
 #endif
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __sfinae_underlying_type<_Tp>::__promoted_type
 __convert_to_integral(_Tp __val) { return __val; }
 
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 struct __has_operator_addressof_member_imp
 {
     template <class _Up>
         static auto __test(int)
             -> typename __select_2nd<decltype(_VSTD::declval<_Up>().operator&()), true_type>::type;
     template <class>

 };
 
 template <class _Tp>
 struct __has_operator_addressof
     : public integral_constant<bool, __has_operator_addressof_member_imp<_Tp>::value
                                   || __has_operator_addressof_free_imp<_Tp>::value>
 {};
 
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 14
 template <class...> using void_t = void;
 
 # ifndef _LIBCPP_HAS_NO_VARIADICS
 template <class... _Args>
 struct conjunction : __and_<_Args...> {};
 template<class... _Args> constexpr bool conjunction_v = conjunction<_Args...>::value;

test/std/containers/associative/map/map.cons/copy.pass.cpp

 
 // class map
 
 // map(const map& m);
 
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::pair<const int, double> V;
int main()
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
         assert(distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),
#if TEST_STD_VER >= 11
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
         assert(distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),

test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp

 
 // class multimap
 
 // multimap(const multimap& m);
 
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::pair<const int, double> V;
int main()
         std::multimap<int, double, C, A> m = mo;
         assert(m == mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),
#if TEST_STD_VER >= 11
         std::multimap<int, double, C, A> m = mo;
         assert(m == mo);
         assert(m.get_allocator() == A(-2));
         assert(m.key_comp() == C(5));
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),

test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp

 
 // class multiset
 
 // multiset(const multiset& m);
 
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
 int main()
 {
     {
         typedef int V;
         V ar[] =
int main()
         assert(*next(mo.begin(), 2) == 1);
         assert(*next(mo.begin(), 3) == 2);
         assert(*next(mo.begin(), 4) == 2);
         assert(*next(mo.begin(), 5) == 2);
         assert(*next(mo.begin(), 6) == 3);
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
#if TEST_STD_VER >= 11
         assert(*next(mo.begin(), 2) == 1);
         assert(*next(mo.begin(), 3) == 2);
         assert(*next(mo.begin(), 4) == 2);
         assert(*next(mo.begin(), 5) == 2);
         assert(*next(mo.begin(), 6) == 3);
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif
 }

test/std/containers/associative/set/set.cons/copy.pass.cpp

 
 // class set
 
 // set(const set& m);
 
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
 int main()
 {
     {
         typedef int V;
         V ar[] =
int main()
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
         assert(distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == 1);
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
#if TEST_STD_VER >= 11
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
         assert(distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == 1);
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif
 }

test/std/containers/sequences/deque/deque.cons/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(const deque&);
 
 #include <deque>
 #include <cassert>
+
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 void
 test(const C& x)
 {
     C c(x);
     assert(c == x);
 }
 
 int main()
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int>(ab, an));
     }
     {
         std::deque<int, test_allocator<int> > v(3, 2, test_allocator<int>(5));
         std::deque<int, test_allocator<int> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         std::deque<int, other_allocator<int> > v(3, 2, other_allocator<int>(5));
         std::deque<int, other_allocator<int> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == other_allocator<int>(-2));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, min_allocator<int>>(ab, an));
     }
     {
         std::deque<int, min_allocator<int> > v(3, 2, min_allocator<int>());
         std::deque<int, min_allocator<int> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
     }
 #endif
 }

test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp

 // <forward_list>
 
 // forward_list(const forward_list& x);
 
 #include <forward_list>
 #include <cassert>
 #include <iterator>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef int T;
         typedef test_allocator<int> A;
         typedef std::forward_list<T, A> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c0(std::begin(t), std::end(t), A(10));
         C c = c0;
         unsigned n = 0;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c == c0);
         assert(c.get_allocator() == A(10));
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef other_allocator<int> A;
         typedef std::forward_list<T, A> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c0(std::begin(t), std::end(t), A(10));
         C c = c0;
         unsigned n = 0;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c == c0);
         assert(c.get_allocator() == A(-2));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<int> A;
         typedef std::forward_list<T, A> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c0(std::begin(t), std::end(t), A());
         C c = c0;
         unsigned n = 0;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c == c0);
         assert(c.get_allocator() == A());
     }
 #endif
 }

test/std/containers/sequences/list/list.cons/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // list(const list& c);
 
 #include <list>
 #include <cassert>
+
+#include "test_macros.h"
 #include "DefaultOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         std::list<int> l(3, 2);
         std::list<int> l2 = l;
         assert(l2 == l);
     }
     {
         std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
         std::list<int, test_allocator<int> > l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == l.get_allocator());
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         std::list<int, other_allocator<int> > l(3, 2, other_allocator<int>(5));
         std::list<int, other_allocator<int> > l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(-2));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l(3, 2);
         std::list<int, min_allocator<int>> l2 = l;
         assert(l2 == l);
     }
     {
         std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::list<int, min_allocator<int> > l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == l.get_allocator());
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp

int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    other_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
         P a[] =
#if TEST_STD_VER >= 11
         assert(c.get_allocator() ==
                (other_allocator<std::pair<const int, std::string> >(-2)));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
         P a[] =

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp

int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    other_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
         P a[] =
#if TEST_STD_VER >= 11
         assert(c.get_allocator() ==
                (other_allocator<std::pair<const int, std::string> >(-2)));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         typedef std::pair<int, std::string> P;
         P a[] =

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp

int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    other_allocator<int>
                                    > C;
         typedef int P;
         P a[] =
#if TEST_STD_VER >= 11
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<int>
                                    > C;
         typedef int P;
         P a[] =

test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp

int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    other_allocator<int>
                                    > C;
         typedef int P;
         P a[] =
#if TEST_STD_VER >= 11
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
         assert(!c.empty());
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<int>
                                    > C;
         typedef int P;
         P a[] =

test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp

 //     static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
 //     ...
 // };
 
 #include <memory>
 #include <cstdint>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
     typedef T value_type;
 
     value_type* allocate(std::size_t n)
     {
         assert(n == 10);
value_type* allocate(std::size_t n, const void* p)
         assert(n == 11);
         assert(p == 0);
         return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xFEADBEEF));
     }
 };
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     A<int> a;
     assert(std::allocator_traits<A<int> >::allocate(a, 10, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif
     B<int> b;
     assert(std::allocator_traits<B<int> >::allocate(b, 11, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
 }

test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp

 //     ...
 // };
 
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
     typedef T value_type;
 
 };
 
 int b_construct = 0;
 
 template <class T>
 struct B
 {
     typedef T value_type;
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if TEST_STD_VER >= 11
     template <class U, class ...Args>
     void construct(U* p, Args&& ...args)
     {
         ++b_construct;
         ::new ((void*)p) U(std::forward<Args>(args)...);
     }
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 };
 
 struct A0
 {
     static int count;
     A0() {++count;}
 };
 
int main()
     {
         A2::count = 0;
         A<int> a;
         std::aligned_storage<sizeof(A2)>::type a2;
         assert(A2::count == 0);
         std::allocator_traits<A<int> >::construct(a, (A2*)&a2, 'd', 5);
         assert(A2::count == 1);
     }
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if TEST_STD_VER >= 11
     {
         A0::count = 0;
         b_construct = 0;
         B<int> b;
         std::aligned_storage<sizeof(A0)>::type a0;
         assert(A0::count == 0);
         assert(b_construct == 0);
         std::allocator_traits<B<int> >::construct(b, (A0*)&a0);
#if TEST_STD_VER >= 11
         B<int> b;
         std::aligned_storage<sizeof(A2)>::type a2;
         assert(A2::count == 0);
         assert(b_construct == 0);
         std::allocator_traits<B<int> >::construct(b, (A2*)&a2, 'd', 5);
         assert(A2::count == 1);
         assert(b_construct == 1);
     }
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 }

test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp

 //     ...
 // };
 
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
     typedef T value_type;
 
 };
 
 int b_destroy = 0;
int main()
         A0::count = 0;
         A<int> a;
         std::aligned_storage<sizeof(A0)>::type a0;
         std::allocator_traits<A<int> >::construct(a, (A0*)&a0);
         assert(A0::count == 0);
         std::allocator_traits<A<int> >::destroy(a, (A0*)&a0);
         assert(A0::count == 1);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         A0::count = 0;
         b_destroy = 0;
         B<int> b;
         std::aligned_storage<sizeof(A0)>::type a0;
         std::allocator_traits<B<int> >::construct(b, (A0*)&a0);
         assert(A0::count == 0);
         assert(b_destroy == 0);
         std::allocator_traits<B<int> >::destroy(b, (A0*)&a0);
         assert(A0::count == 1);
         assert(b_destroy == 1);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif
 }

test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp

struct B
     size_t max_size() const
     {
         return 100;
     }
 };
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+    {
+        B<int> b;
+        assert(std::allocator_traits<B<int> >::max_size(b) == 100);
+    }
+    {
+        const B<int> b = {};
+        assert(std::allocator_traits<B<int> >::max_size(b) == 100);
+    }
+#if TEST_STD_VER >= 11
     {
         A<int> a;
         assert(std::allocator_traits<A<int> >::max_size(a) ==
                std::numeric_limits<std::size_t>::max() / sizeof(int));
     }
     {
         const A<int> a = {};
         assert(std::allocator_traits<A<int> >::max_size(a) ==
                std::numeric_limits<std::size_t>::max() / sizeof(int));
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-    {
-        B<int> b;
-        assert(std::allocator_traits<B<int> >::max_size(b) == 100);
-    }
-    {
-        const B<int> b = {};
-        assert(std::allocator_traits<B<int> >::max_size(b) == 100);
-    }
-#if TEST_STD_VER >= 11
     {
         std::allocator<int> a;
         static_assert(noexcept(std::allocator_traits<std::allocator<int>>::max_size(a)) == true, "");
     }
 #endif
 }

test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp

 //     ...
 // };
 
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 struct A
 {
     typedef T value_type;
     int id;
     explicit A(int i = 0) : id(i) {}
 
 };
int main()
     {
         A<int> a;
         assert(std::allocator_traits<A<int> >::select_on_container_copy_construction(a).id == 0);
     }
     {
         const A<int> a(0);
         assert(std::allocator_traits<A<int> >::select_on_container_copy_construction(a).id == 0);
     }
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER >= 11
     {
         B<int> b;
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
     {
         const B<int> b(0);
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif
 }

test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp

 // {
 //     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
 //     ...
 // };
 
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 struct ReboundA {};
 
 template <class T>
 struct A
 {
     typedef T value_type;
 

 {
     typedef T value_type;
 
     template <class U> struct rebind {typedef ReboundA<U> otter;};
 };
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_traits<double>, std::allocator_traits<ReboundA<double> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_traits<double>, std::allocator_traits<ReboundB<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_traits<double>, std::allocator_traits<C<double> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_traits<double>, std::allocator_traits<D<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_traits<double>, std::allocator_traits<E<double> > >::value), "");
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#else
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_traits<double>::other, std::allocator_traits<ReboundA<double> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<int, char> >::rebind_traits<double>::other, std::allocator_traits<ReboundB<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<C<char> >::rebind_traits<double>::other, std::allocator_traits<C<double> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_traits<double>::other, std::allocator_traits<D<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_traits<double>::other, std::allocator_traits<E<double> > >::value), "");
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#endif
 }

test/std/utilities/memory/pointer.traits/rebind.pass.cpp

 // {
 //     template <class U> using rebind = U*;
 //     ...
 // };
 
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>, double*>::value), "");
 #else
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>::other, double*>::value), "");
 #endif
 }

test/support/test_allocator.h

template <class U> test_allocator(const test_allocator<U>& a) throw()
         : data_(a.data_) {++count;}
     ~test_allocator() throw() {assert(data_ >= 0); --count; data_ = -1;}
     pointer address(reference x) const {return &x;}
     const_pointer address(const_reference x) const {return &x;}
     pointer allocate(size_type n, const void* = 0)
         {
             assert(data_ >= 0);
             if (time_to_throw >= throw_after) {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#ifndef TEST_HAS_NO_EXCEPTIONS
                 throw std::bad_alloc();
 #else
                 std::terminate();
 #endif
             }
             ++time_to_throw;
             ++alloc_count;
             return (pointer)::operator new(n * sizeof(T));
template <class U> non_default_test_allocator(const non_default_test_allocator<U>& a) throw()
         : data_(a.data_) {++count;}
     ~non_default_test_allocator() throw() {assert(data_ >= 0); --count; data_ = -1;}
     pointer address(reference x) const {return &x;}
     const_pointer address(const_reference x) const {return &x;}
     pointer allocate(size_type n, const void* = 0)
         {
             assert(data_ >= 0);
             if (time_to_throw >= throw_after) {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#ifndef TEST_HAS_NO_EXCEPTIONS
                 throw std::bad_alloc();
 #else
                 std::terminate();
 #endif
             }
             ++time_to_throw;
             ++alloc_count;
             return (pointer)::operator new (n * sizeof(T));
friend bool operator==(const other_allocator& x, const other_allocator& y)
         {return x.data_ == y.data_;}
     friend bool operator!=(const other_allocator& x, const other_allocator& y)
         {return !(x == y);}
 
     typedef std::true_type propagate_on_container_copy_assignment;
     typedef std::true_type propagate_on_container_move_assignment;
     typedef std::true_type propagate_on_container_swap;
 
-#ifdef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if TEST_STD_VER < 11
     std::size_t max_size() const
         {return UINT_MAX / sizeof(T);}
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif
 
 };
 
 #if TEST_STD_VER >= 11
 
 struct Ctor_Tag {};
 
 template <typename T> class TaggingAllocator;