Remove more of the std::experimental bits that are now in std::. All the _v type aliases, conjunction/disjunction, apply, etc. See https://libcxx.llvm.org/TS_deprecation.html

llvm-svn: 324423

50 files changed, 4 insertions, 3997 deletions

diff --git a/libcxx/include/experimental/chrono b/libcxx/include/experimental/chrono
index ca9e5f852ea..591cf7160c1 100644
--- a/libcxx/include/experimental/chrono
+++ b/libcxx/include/experimental/chrono
@@ -8,52 +8,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP_EXPERIMENTAL_CHRONO
-#define _LIBCPP_EXPERIMENTAL_CHRONO
-
-/**
-    experimental/chrono synopsis
-
-// C++1y
-
-#include <chrono>
-
-namespace std {
-namespace chrono {
-namespace experimental {
-inline namespace fundamentals_v1 {
-
-  // See C++14 20.12.4, customization traits
-  template <class Rep> constexpr bool treat_as_floating_point_v
-    = treat_as_floating_point<Rep>::value;
-
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace chrono
-} // namespace std
-
- */
-
-#include <experimental/__config>
-#include <chrono>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-#if _LIBCPP_STD_VER > 11
-
-_LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS
-
-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
-
-template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
-    = treat_as_floating_point<_Rep>::value;
-
-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
-
-_LIBCPP_END_NAMESPACE_CHRONO_LFTS
-
-#endif /* _LIBCPP_STD_VER > 11 */
-
-#endif /* _LIBCPP_EXPERIMENTAL_CHRONO */
+#error "<experimental/chrono> has been removed. Use <chrono> instead."
diff --git a/libcxx/include/experimental/ratio b/libcxx/include/experimental/ratio
index 757f24e0861..9c2bf2e4624 100644
--- a/libcxx/include/experimental/ratio
+++ b/libcxx/include/experimental/ratio
@@ -8,70 +8,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP_EXPERIMENTAL_RATIO
-#define _LIBCPP_EXPERIMENTAL_RATIO
-
-/**
-    experimental/ratio synopsis
-    C++1y
-#include <ratio>
-
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-
-  // See C++14 20.11.5, ratio comparison
-  template <class R1, class R2> constexpr bool ratio_equal_v
-    = ratio_equal<R1, R2>::value;
-  template <class R1, class R2> constexpr bool ratio_not_equal_v
-    = ratio_not_equal<R1, R2>::value;
-  template <class R1, class R2> constexpr bool ratio_less_v
-    = ratio_less<R1, R2>::value;
-  template <class R1, class R2> constexpr bool ratio_less_equal_v
-    = ratio_less_equal<R1, R2>::value;
-  template <class R1, class R2> constexpr bool ratio_greater_v
-    = ratio_greater<R1, R2>::value;
-  template <class R1, class R2> constexpr bool ratio_greater_equal_v
-    = ratio_greater_equal<R1, R2>::value;
-
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
-*/
-
-#include <experimental/__config>
-
-#if _LIBCPP_STD_VER > 11
-
-#include <ratio>
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
-
-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_equal_v
-    = ratio_equal<_R1, _R2>::value;
-
-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_not_equal_v
-    = ratio_not_equal<_R1, _R2>::value;
-
-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_v
-    = ratio_less<_R1, _R2>::value;
-
-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_equal_v
-    = ratio_less_equal<_R1, _R2>::value;
-
-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_v
-    = ratio_greater<_R1, _R2>::value;
-
-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_equal_v
-    = ratio_greater_equal<_R1, _R2>::value;
-
-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
-
-_LIBCPP_END_NAMESPACE_LFTS
-
-#endif /* _LIBCPP_STD_VER > 11 */
-
-#endif // _LIBCPP_EXPERIMENTAL_RATIO
+#error "<experimental/ratio> has been removed. Use <ratio> instead."
diff --git a/libcxx/include/experimental/system_error b/libcxx/include/experimental/system_error
index 2ec23854461..7937357fa14 100644
--- a/libcxx/include/experimental/system_error
+++ b/libcxx/include/experimental/system_error
@@ -8,56 +8,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
-#define _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
-
-/**
-    experimental/system_error synopsis
-
-// C++1y
-
-#include <system_error>
-
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-
-  // See C++14 19.5, System error support
-  template <class T> constexpr bool is_error_code_enum_v
-    = is_error_code_enum<T>::value;
-  template <class T> constexpr bool is_error_condition_enum_v
-    = is_error_condition_enum<T>::value;
-
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
-*/
-
-#include <experimental/__config>
-
-#if _LIBCPP_STD_VER > 11
-
-#include <system_error>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_code_enum_v
-    = is_error_code_enum<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_condition_enum_v
-    = is_error_condition_enum<_Tp>::value;
-
-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
-
-_LIBCPP_END_NAMESPACE_LFTS
-
-#endif /* _LIBCPP_STD_VER > 11 */
-
-#endif /* _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR */
+#error "<experimental/system_error> has been removed. Use <system_error> instead."
diff --git a/libcxx/include/experimental/tuple b/libcxx/include/experimental/tuple
index e00d2ec1a92..1f37a6293ba 100644
--- a/libcxx/include/experimental/tuple
+++ b/libcxx/include/experimental/tuple
@@ -8,75 +8,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP_EXPERIMENTAL_TUPLE
-#define _LIBCPP_EXPERIMENTAL_TUPLE
-
-/*
-    experimental/tuple synopsis
-
-// C++1y
-
-#include <tuple>
-
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-
-  // See C++14 20.4.2.5, tuple helper classes
-  template <class T> constexpr size_t tuple_size_v
-    = tuple_size<T>::value;
-
-  // 3.2.2, Calling a function with a tuple of arguments
-  template <class F, class Tuple>
-  constexpr decltype(auto) apply(F&& f, Tuple&& t);
-
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-# include <experimental/__config>
-
-#if _LIBCPP_STD_VER > 11
-
-# include <tuple>
-# include <utility>
-# include <__functional_base>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
-template <class _Tp>
-_LIBCPP_CONSTEXPR size_t tuple_size_v = tuple_size<_Tp>::value;
-#endif
-
-template <class _Fn, class _Tuple, size_t ..._Id>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
-                                  integer_sequence<size_t, _Id...>) {
-    return _VSTD::__invoke_constexpr(
-        _VSTD::forward<_Fn>(__f),
-        _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...
-    );
-}
-
-template <class _Fn, class _Tuple>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-decltype(auto) apply(_Fn && __f, _Tuple && __t) {
-    return _VSTD_LFTS::__apply_tuple_impl(
-        _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
-        make_index_sequence<tuple_size<typename decay<_Tuple>::type>::value>()
-    );
-}
-
-_LIBCPP_END_NAMESPACE_LFTS
-
-#endif /* _LIBCPP_STD_VER > 11 */
-
-#endif /* _LIBCPP_EXPERIMENTAL_TUPLE */
+#error "<experimental/tuple> has been removed. Use <tuple> instead."
diff --git a/libcxx/include/experimental/type_traits b/libcxx/include/experimental/type_traits
index 3a7593620a7..afe491567ce 100644
--- a/libcxx/include/experimental/type_traits
+++ b/libcxx/include/experimental/type_traits
@@ -21,146 +21,6 @@ namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 
-  // See C++14 20.10.4.1, primary type categories
-  template <class T> constexpr bool is_void_v
-    = is_void<T>::value;
-  template <class T> constexpr bool is_null_pointer_v
-    = is_null_pointer<T>::value;
-  template <class T> constexpr bool is_integral_v
-    = is_integral<T>::value;
-  template <class T> constexpr bool is_floating_point_v
-    = is_floating_point<T>::value;
-  template <class T> constexpr bool is_array_v
-    = is_array<T>::value;
-  template <class T> constexpr bool is_pointer_v
-    = is_pointer<T>::value;
-  template <class T> constexpr bool is_lvalue_reference_v
-    = is_lvalue_reference<T>::value;
-  template <class T> constexpr bool is_rvalue_reference_v
-    = is_rvalue_reference<T>::value;
-  template <class T> constexpr bool is_member_object_pointer_v
-    = is_member_object_pointer<T>::value;
-  template <class T> constexpr bool is_member_function_pointer_v
-    = is_member_function_pointer<T>::value;
-  template <class T> constexpr bool is_enum_v
-    = is_enum<T>::value;
-  template <class T> constexpr bool is_union_v
-    = is_union<T>::value;
-  template <class T> constexpr bool is_class_v
-    = is_class<T>::value;
-  template <class T> constexpr bool is_function_v
-    = is_function<T>::value;
-
-  // See C++14 20.10.4.2, composite type categories
-  template <class T> constexpr bool is_reference_v
-    = is_reference<T>::value;
-  template <class T> constexpr bool is_arithmetic_v
-    = is_arithmetic<T>::value;
-  template <class T> constexpr bool is_fundamental_v
-    = is_fundamental<T>::value;
-  template <class T> constexpr bool is_object_v
-    = is_object<T>::value;
-  template <class T> constexpr bool is_scalar_v
-    = is_scalar<T>::value;
-  template <class T> constexpr bool is_compound_v
-    = is_compound<T>::value;
-  template <class T> constexpr bool is_member_pointer_v
-    = is_member_pointer<T>::value;
-
-  // See C++14 20.10.4.3, type properties
-  template <class T> constexpr bool is_const_v
-    = is_const<T>::value;
-  template <class T> constexpr bool is_volatile_v
-    = is_volatile<T>::value;
-  template <class T> constexpr bool is_trivial_v
-    = is_trivial<T>::value;
-  template <class T> constexpr bool is_trivially_copyable_v
-    = is_trivially_copyable<T>::value;
-  template <class T> constexpr bool is_standard_layout_v
-    = is_standard_layout<T>::value;
-  template <class T> constexpr bool is_pod_v
-    = is_pod<T>::value;
-  template <class T> constexpr bool is_literal_type_v
-    = is_literal_type<T>::value;
-  template <class T> constexpr bool is_empty_v
-    = is_empty<T>::value;
-  template <class T> constexpr bool is_polymorphic_v
-    = is_polymorphic<T>::value;
-  template <class T> constexpr bool is_abstract_v
-    = is_abstract<T>::value;
-  template <class T> constexpr bool is_final_v
-    = is_final<T>::value;
-  template <class T> constexpr bool is_signed_v
-    = is_signed<T>::value;
-  template <class T> constexpr bool is_unsigned_v
-    = is_unsigned<T>::value;
-  template <class T, class... Args> constexpr bool is_constructible_v
-    = is_constructible<T, Args...>::value;
-  template <class T> constexpr bool is_default_constructible_v
-    = is_default_constructible<T>::value;
-  template <class T> constexpr bool is_copy_constructible_v
-    = is_copy_constructible<T>::value;
-  template <class T> constexpr bool is_move_constructible_v
-    = is_move_constructible<T>::value;
-  template <class T, class U> constexpr bool is_assignable_v
-    = is_assignable<T, U>::value;
-  template <class T> constexpr bool is_copy_assignable_v
-    = is_copy_assignable<T>::value;
-  template <class T> constexpr bool is_move_assignable_v
-    = is_move_assignable<T>::value;
-  template <class T> constexpr bool is_destructible_v
-    = is_destructible<T>::value;
-  template <class T, class... Args> constexpr bool is_trivially_constructible_v
-    = is_trivially_constructible<T, Args...>::value;
-  template <class T> constexpr bool is_trivially_default_constructible_v
-    = is_trivially_default_constructible<T>::value;
-  template <class T> constexpr bool is_trivially_copy_constructible_v
-    = is_trivially_copy_constructible<T>::value;
-  template <class T> constexpr bool is_trivially_move_constructible_v
-    = is_trivially_move_constructible<T>::value;
-  template <class T, class U> constexpr bool is_trivially_assignable_v
-    = is_trivially_assignable<T, U>::value;
-  template <class T> constexpr bool is_trivially_copy_assignable_v
-    = is_trivially_copy_assignable<T>::value;
-  template <class T> constexpr bool is_trivially_move_assignable_v
-    = is_trivially_move_assignable<T>::value;
-  template <class T> constexpr bool is_trivially_destructible_v
-    = is_trivially_destructible<T>::value;
-  template <class T, class... Args> constexpr bool is_nothrow_constructible_v
-    = is_nothrow_constructible<T, Args...>::value;
-  template <class T> constexpr bool is_nothrow_default_constructible_v
-    = is_nothrow_default_constructible<T>::value;
-  template <class T> constexpr bool is_nothrow_copy_constructible_v
-    = is_nothrow_copy_constructible<T>::value;
-  template <class T> constexpr bool is_nothrow_move_constructible_v
-    = is_nothrow_move_constructible<T>::value;
-  template <class T, class U> constexpr bool is_nothrow_assignable_v
-    = is_nothrow_assignable<T, U>::value;
-  template <class T> constexpr bool is_nothrow_copy_assignable_v
-    = is_nothrow_copy_assignable<T>::value;
-  template <class T> constexpr bool is_nothrow_move_assignable_v
-    = is_nothrow_move_assignable<T>::value;
-  template <class T> constexpr bool is_nothrow_destructible_v
-    = is_nothrow_destructible<T>::value;
-  template <class T> constexpr bool has_virtual_destructor_v
-    = has_virtual_destructor<T>::value;
-
-  // See C++14 20.10.5, type property queries
-  template <class T> constexpr size_t alignment_of_v
-    = alignment_of<T>::value;
-  template <class T> constexpr size_t rank_v
-    = rank<T>::value;
-  template <class T, unsigned I = 0> constexpr size_t extent_v
-    = extent<T, I>::value;
-
-  // See C++14 20.10.6, type relations
-  template <class T, class U> constexpr bool is_same_v
-    = is_same<T, U>::value;
-  template <class Base, class Derived> constexpr bool is_base_of_v
-    = is_base_of<Base, Derived>::value;
-  template <class From, class To> constexpr bool is_convertible_v
-    = is_convertible<From, To>::value;
-
   // 3.3.2, Other type transformations
   template <class> class invocation_type; // not defined
   template <class F, class... ArgTypes> class invocation_type<F(ArgTypes...)>;
@@ -172,14 +32,6 @@ inline namespace fundamentals_v1 {
   template <class T>
     using raw_invocation_type_t = typename raw_invocation_type<T>::type;
 
-  // 3.3.3, Logical operator traits
-  template<class... B> struct conjunction;
-  template<class... B> constexpr bool conjunction_v = conjunction<B...>::value;
-  template<class... B> struct disjunction;
-  template<class... B> constexpr bool disjunction_v = disjunction<B...>::value;
-  template<class B> struct negation;
-  template<class B> constexpr bool negation_v = negation<B>::value;
-
   // 3.3.4, Detection idiom
   template <class...> using void_t = void;
 
@@ -229,215 +81,6 @@ inline namespace fundamentals_v1 {
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
-
-// C++14 20.10.4.1, primary type categories
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_void_v
-    = is_void<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_null_pointer_v
-    = is_null_pointer<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_integral_v
-    = is_integral<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_floating_point_v
-    = is_floating_point<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_array_v
-    = is_array<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_pointer_v
-    = is_pointer<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_lvalue_reference_v
-    = is_lvalue_reference<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
-    = is_rvalue_reference<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
-    = is_member_object_pointer<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
-    = is_member_function_pointer<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_enum_v
-    = is_enum<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_union_v
-    = is_union<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_class_v
-    = is_class<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_function_v
-    = is_function<_Tp>::value;
-
-// C++14 20.10.4.2,  composite type categories
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_reference_v
-    = is_reference<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_arithmetic_v
-    = is_arithmetic<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_fundamental_v
-    = is_fundamental<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_object_v
-    = is_object<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_scalar_v
-    = is_scalar<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_compound_v
-    = is_compound<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_pointer_v
-    = is_member_pointer<_Tp>::value;
-
-// C++14 20.10.4.3, type properties
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_const_v
-    = is_const<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_volatile_v
-    = is_volatile<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivial_v
-    = is_trivial<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copyable_v
-    = is_trivially_copyable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_standard_layout_v
-    = is_standard_layout<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_pod_v
-    = is_pod<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_literal_type_v
-    = is_literal_type<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_empty_v
-    = is_empty<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_polymorphic_v
-    = is_polymorphic<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_abstract_v
-    = is_abstract<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_final_v
-    = is_final<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_signed_v
-    = is_signed<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_unsigned_v
-    = is_unsigned<_Tp>::value;
-
-template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_constructible_v
-    = is_constructible<_Tp, _Ts...>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_default_constructible_v
-    = is_default_constructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_copy_constructible_v
-    = is_copy_constructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_move_constructible_v
-    = is_move_constructible<_Tp>::value;
-
-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_assignable_v
-    = is_assignable<_Tp, _Up>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_copy_assignable_v
-    = is_copy_assignable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_move_assignable_v
-    = is_move_assignable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_destructible_v
-    = is_destructible<_Tp>::value;
-
-template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_trivially_constructible_v
-    = is_trivially_constructible<_Tp, _Ts...>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_default_constructible_v
-    = is_trivially_default_constructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copy_constructible_v
-    = is_trivially_copy_constructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_move_constructible_v
-    = is_trivially_move_constructible<_Tp>::value;
-
-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_trivially_assignable_v
-    = is_trivially_assignable<_Tp, _Up>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copy_assignable_v
-    = is_trivially_copy_assignable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_move_assignable_v
-    = is_trivially_move_assignable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_destructible_v
-    = is_trivially_destructible<_Tp>::value;
-
-template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_nothrow_constructible_v
-    = is_nothrow_constructible<_Tp, _Ts...>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_default_constructible_v
-    = is_nothrow_default_constructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_copy_constructible_v
-    = is_nothrow_copy_constructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_move_constructible_v
-    = is_nothrow_move_constructible<_Tp>::value;
-
-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_nothrow_assignable_v
-    = is_nothrow_assignable<_Tp, _Up>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_copy_assignable_v
-    = is_nothrow_copy_assignable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_move_assignable_v
-    = is_nothrow_move_assignable<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_destructible_v
-    = is_nothrow_destructible<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR bool has_virtual_destructor_v
-    = has_virtual_destructor<_Tp>::value;
-
-// C++14 20.10.5, type properties queries
-
-template <class _Tp> _LIBCPP_CONSTEXPR size_t alignment_of_v
-    = alignment_of<_Tp>::value;
-
-template <class _Tp> _LIBCPP_CONSTEXPR size_t rank_v
-    = rank<_Tp>::value;
-
-template <class _Tp, unsigned _Id = 0> _LIBCPP_CONSTEXPR size_t extent_v
-    = extent<_Tp, _Id>::value;
-
-// C++14 20.10.6, type relations
-
-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_same_v
-    = is_same<_Tp, _Up>::value;
-
-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_base_of_v
-    = is_base_of<_Tp, _Up>::value;
-
-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_convertible_v
-    = is_convertible<_Tp, _Up>::value;
-
-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
-
 // 3.3.2, Other type transformations
 /*
 template <class>
@@ -459,24 +102,6 @@ template <class _Tp>
 using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
 */
 
-// 3.3.3, Logical operator traits
-template <class...> using void_t = void;
-
-template <class... _Args>
-struct conjunction : _VSTD::__and_<_Args...> {};
-template <class... _Args>
-_LIBCPP_CONSTEXPR bool conjunction_v = conjunction<_Args...>::value;
-
-template <class... _Args>
-struct disjunction : _VSTD::__or_<_Args...> {};
-template <class... _Args>
-_LIBCPP_CONSTEXPR bool disjunction_v = disjunction<_Args...>::value;
-
-template <class _Tp>
-struct negation : _VSTD::__not_<_Tp> {};
-template<class _Tp>
-_LIBCPP_CONSTEXPR bool negation_v = negation<_Tp>::value;
-
 // 3.3.4, Detection idiom
 template <class...> using void_t = void;
 
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 9775447ec60..076ef2334b8 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -493,10 +493,6 @@ module std [system] {
       header "experimental/algorithm"
       export *
     }
-    module chrono {
-      header "experimental/chrono"
-      export *
-    }
      module coroutine {
       requires coroutines
       header "experimental/coroutine"
@@ -542,10 +538,6 @@ module std [system] {
       header "experimental/propagate_const"
       export *
     }
-    module ratio {
-      header "experimental/ratio"
-      export *
-    }
     module regex {
       header "experimental/regex"
       export *
@@ -558,14 +550,6 @@ module std [system] {
       header "experimental/string"
       export *
     }
-    module system_error {
-      header "experimental/system_error"
-      export *
-    }
-    module tuple {
-      header "experimental/tuple"
-      export *
-    }
     module type_traits {
       header "experimental/type_traits"
       export *
diff --git a/libcxx/test/libcxx/double_include.sh.cpp b/libcxx/test/libcxx/double_include.sh.cpp
index d10849eb4c6..462c685e553 100644
--- a/libcxx/test/libcxx/double_include.sh.cpp
+++ b/libcxx/test/libcxx/double_include.sh.cpp
@@ -135,7 +135,6 @@
 // experimental headers
 #if __cplusplus >= 201103L
 #include <experimental/algorithm>
-#include <experimental/chrono>
 #if defined(__cpp_coroutines)
 #include <experimental/coroutine>
 #endif
@@ -149,12 +148,9 @@
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
-#include <experimental/ratio>
 #include <experimental/regex>
 #include <experimental/set>
 #include <experimental/string>
-#include <experimental/system_error>
-#include <experimental/tuple>
 #include <experimental/type_traits>
 #include <experimental/unordered_map>
 #include <experimental/unordered_set>
diff --git a/libcxx/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp b/libcxx/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
deleted file mode 100644
index ea7ef6cbc10..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/ratio>
-
-// Test that <ratio> is included.
-
-#include <experimental/ratio>
-
-#ifndef _LIBCPP_RATIO
-#  error " <experimental/ratio> must include <ratio>"
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/ratio/version.pass.cpp b/libcxx/test/libcxx/experimental/utilities/ratio/version.pass.cpp
deleted file mode 100644
index 8bc583fb6d9..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/ratio/version.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/ratio>
-
-#include <experimental/ratio>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp b/libcxx/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
deleted file mode 100644
index be3aacdc362..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/system_error>
-
-#include <experimental/system_error>
-
-#ifndef _LIBCPP_SYSTEM_ERROR
-#  error "<experimental/system_error> must include <system_error>"
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/syserror/version.pass.cpp b/libcxx/test/libcxx/experimental/utilities/syserror/version.pass.cpp
deleted file mode 100644
index 35f6a59c387..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/syserror/version.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/system_error>
-
-#include <experimental/system_error>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp b/libcxx/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
deleted file mode 100644
index e91068c742e..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/chrono>
-
-#include <experimental/chrono>
-
-#ifndef _LIBCPP_CHRONO
-#  error "<experimental/chrono> must include <chrono>"
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/time/version.pass.cpp b/libcxx/test/libcxx/experimental/utilities/time/version.pass.cpp
deleted file mode 100644
index be97466f37c..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/time/version.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/chrono>
-
-#include <experimental/chrono>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp b/libcxx/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
deleted file mode 100644
index defa454d68f..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/tuple>
-
-#include <experimental/tuple>
-
-int main()
-{
-#ifndef _LIBCPP_TUPLE
-#  error "<experimental/tuple> must include <tuple>"
-#endif
-}
diff --git a/libcxx/test/libcxx/experimental/utilities/tuple/version.pass.cpp b/libcxx/test/libcxx/experimental/utilities/tuple/version.pass.cpp
deleted file mode 100644
index 5a3fd2e3964..00000000000
--- a/libcxx/test/libcxx/experimental/utilities/tuple/version.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/tuple>
-
-#include <experimental/tuple>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/libcxx/min_max_macros.sh.cpp b/libcxx/test/libcxx/min_max_macros.sh.cpp
index f245d35c469..087aa3645a5 100644
--- a/libcxx/test/libcxx/min_max_macros.sh.cpp
+++ b/libcxx/test/libcxx/min_max_macros.sh.cpp
@@ -237,8 +237,6 @@ TEST_MACROS();
 #if __cplusplus >= 201103L
 #include <experimental/algorithm>
 TEST_MACROS();
-#include <experimental/chrono>
-TEST_MACROS();
 #include <experimental/deque>
 TEST_MACROS();
 #include <experimental/dynarray>
@@ -259,18 +257,12 @@ TEST_MACROS();
 TEST_MACROS();
 #include <experimental/propagate_const>
 TEST_MACROS();
-#include <experimental/ratio>
-TEST_MACROS();
 #include <experimental/regex>
 TEST_MACROS();
 #include <experimental/set>
 TEST_MACROS();
 #include <experimental/string>
 TEST_MACROS();
-#include <experimental/system_error>
-TEST_MACROS();
-#include <experimental/tuple>
-TEST_MACROS();
 #include <experimental/type_traits>
 TEST_MACROS();
 #include <experimental/unordered_map>
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.logical/conjunction.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.logical/conjunction.pass.cpp
deleted file mode 100644
index cb8db1febd2..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.logical/conjunction.pass.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-// template<class... B> struct conjunction;                           // C++17
-// template<class... B>
-//   constexpr bool conjunction_v = conjunction<B...>::value;         // C++17
-
-#include <experimental/type_traits>
-#include <cassert>
-
-namespace ex = std::experimental;
-
-struct True  { static constexpr bool value = true; };
-struct False { static constexpr bool value = false; };
-
-int main()
-{
-    static_assert ( ex::conjunction<>::value, "" );
-    static_assert ( ex::conjunction<std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::false_type>::value, "" );
-
-    static_assert ( ex::conjunction_v<>, "" );
-    static_assert ( ex::conjunction_v<std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::false_type>, "" );
-
-    static_assert ( ex::conjunction<std::true_type,  std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::true_type,  std::false_type>::value, "" );
-    static_assert (!ex::conjunction<std::false_type, std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::false_type, std::false_type>::value, "" );
-
-    static_assert ( ex::conjunction_v<std::true_type,  std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::true_type,  std::false_type>, "" );
-    static_assert (!ex::conjunction_v<std::false_type, std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::false_type, std::false_type>, "" );
-
-    static_assert ( ex::conjunction<std::true_type,  std::true_type,  std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::true_type,  std::false_type, std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::false_type, std::true_type,  std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::false_type, std::false_type, std::true_type >::value, "" );
-    static_assert (!ex::conjunction<std::true_type,  std::true_type,  std::false_type>::value, "" );
-    static_assert (!ex::conjunction<std::true_type,  std::false_type, std::false_type>::value, "" );
-    static_assert (!ex::conjunction<std::false_type, std::true_type,  std::false_type>::value, "" );
-    static_assert (!ex::conjunction<std::false_type, std::false_type, std::false_type>::value, "" );
-
-    static_assert ( ex::conjunction_v<std::true_type,  std::true_type,  std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::true_type,  std::false_type, std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::false_type, std::true_type,  std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::false_type, std::false_type, std::true_type >, "" );
-    static_assert (!ex::conjunction_v<std::true_type,  std::true_type,  std::false_type>, "" );
-    static_assert (!ex::conjunction_v<std::true_type,  std::false_type, std::false_type>, "" );
-    static_assert (!ex::conjunction_v<std::false_type, std::true_type,  std::false_type>, "" );
-    static_assert (!ex::conjunction_v<std::false_type, std::false_type, std::false_type>, "" );
-
-    static_assert ( ex::conjunction<True >::value, "" );
-    static_assert (!ex::conjunction<False>::value, "" );
-
-    static_assert ( ex::conjunction_v<True >, "" );
-    static_assert (!ex::conjunction_v<False>, "" );
-}
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.logical/disjunction.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.logical/disjunction.pass.cpp
deleted file mode 100644
index dcdbf09fb09..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.logical/disjunction.pass.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-// template<class... B> struct disjunction;
-// template<class... B>
-//   constexpr bool disjunction_v = disjunction<B...>::value;
-
-#include <experimental/type_traits>
-#include <cassert>
-
-namespace ex = std::experimental;
-
-struct True  { static constexpr bool value = true; };
-struct False { static constexpr bool value = false; };
-
-int main()
-{
-    static_assert (!ex::disjunction<>::value, "" );
-    static_assert ( ex::disjunction<std::true_type >::value, "" );
-    static_assert (!ex::disjunction<std::false_type>::value, "" );
-
-    static_assert (!ex::disjunction_v<>, "" );
-    static_assert ( ex::disjunction_v<std::true_type >, "" );
-    static_assert (!ex::disjunction_v<std::false_type>, "" );
-
-    static_assert ( ex::disjunction<std::true_type,  std::true_type >::value, "" );
-    static_assert ( ex::disjunction<std::true_type,  std::false_type>::value, "" );
-    static_assert ( ex::disjunction<std::false_type, std::true_type >::value, "" );
-    static_assert (!ex::disjunction<std::false_type, std::false_type>::value, "" );
-
-    static_assert ( ex::disjunction_v<std::true_type,  std::true_type >, "" );
-    static_assert ( ex::disjunction_v<std::true_type,  std::false_type>, "" );
-    static_assert ( ex::disjunction_v<std::false_type, std::true_type >, "" );
-    static_assert (!ex::disjunction_v<std::false_type, std::false_type>, "" );
-
-    static_assert ( ex::disjunction<std::true_type,  std::true_type,  std::true_type >::value, "" );
-    static_assert ( ex::disjunction<std::true_type,  std::false_type, std::true_type >::value, "" );
-    static_assert ( ex::disjunction<std::false_type, std::true_type,  std::true_type >::value, "" );
-    static_assert ( ex::disjunction<std::false_type, std::false_type, std::true_type >::value, "" );
-    static_assert ( ex::disjunction<std::true_type,  std::true_type,  std::false_type>::value, "" );
-    static_assert ( ex::disjunction<std::true_type,  std::false_type, std::false_type>::value, "" );
-    static_assert ( ex::disjunction<std::false_type, std::true_type,  std::false_type>::value, "" );
-    static_assert (!ex::disjunction<std::false_type, std::false_type, std::false_type>::value, "" );
-
-    static_assert ( ex::disjunction_v<std::true_type,  std::true_type,  std::true_type >, "" );
-    static_assert ( ex::disjunction_v<std::true_type,  std::false_type, std::true_type >, "" );
-    static_assert ( ex::disjunction_v<std::false_type, std::true_type,  std::true_type >, "" );
-    static_assert ( ex::disjunction_v<std::false_type, std::false_type, std::true_type >, "" );
-    static_assert ( ex::disjunction_v<std::true_type,  std::true_type,  std::false_type>, "" );
-    static_assert ( ex::disjunction_v<std::true_type,  std::false_type, std::false_type>, "" );
-    static_assert ( ex::disjunction_v<std::false_type, std::true_type,  std::false_type>, "" );
-    static_assert (!ex::disjunction_v<std::false_type, std::false_type, std::false_type>, "" );
-
-    static_assert ( ex::disjunction<True >::value, "" );
-    static_assert (!ex::disjunction<False>::value, "" );
-
-    static_assert ( ex::disjunction_v<True >, "" );
-    static_assert (!ex::disjunction_v<False>, "" );
-}
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.logical/negation.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.logical/negation.pass.cpp
deleted file mode 100644
index b0d43d7e512..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.logical/negation.pass.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-// template<class B> struct negation;
-// template<class B>
-//   constexpr bool negation_v = negation<B>::value;
-
-#include <experimental/type_traits>
-#include <cassert>
-
-namespace ex = std::experimental;
-
-struct True  { static constexpr bool value = true; };
-struct False { static constexpr bool value = false; };
-
-int main()
-{
-    static_assert (!ex::negation<std::true_type >::value, "" );
-    static_assert ( ex::negation<std::false_type>::value, "" );
-
-    static_assert (!ex::negation_v<std::true_type >, "" );
-    static_assert ( ex::negation_v<std::false_type>, "" );
-
-    static_assert (!ex::negation<True >::value, "" );
-    static_assert ( ex::negation<False>::value, "" );
-
-    static_assert (!ex::negation_v<True >, "" );
-    static_assert ( ex::negation_v<False>, "" );
-
-    static_assert ( ex::negation<ex::negation<std::true_type >>::value, "" );
-    static_assert (!ex::negation<ex::negation<std::false_type>>::value, "" );
-}
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
deleted file mode 100644
index ddc82cb5482..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-#include <experimental/type_traits>
-
-#ifndef _LIBCPP_TYPE_TRAITS
-#  error "<experimental/type_traits> must include <type_traits>"
-#endif
-
-int main()
-{
-}
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
deleted file mode 100644
index 8edc917303a..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-#include <experimental/type_traits>
-
-namespace ex = std::experimental;
-
-struct base_type {};
-struct derived_type : base_type {};
-
-int main()
-{
-    {
-        typedef int T;
-        typedef int U;
-        static_assert(ex::is_same_v<T, U>, "");
-        static_assert(std::is_same<decltype(ex::is_same_v<T, U>), const bool>::value, "");
-        static_assert(ex::is_same_v<T, U> == std::is_same<T, U>::value, "");
-    }
-    {
-        typedef int T;
-        typedef long U;
-        static_assert(!ex::is_same_v<T, U>, "");
-        static_assert(ex::is_same_v<T, U> == std::is_same<T, U>::value, "");
-    }
-    {
-        typedef base_type T;
-        typedef derived_type U;
-        static_assert(ex::is_base_of_v<T, U>, "");
-        static_assert(std::is_same<decltype(ex::is_base_of_v<T, U>), const bool>::value, "");
-        static_assert(ex::is_base_of_v<T, U> == std::is_base_of<T, U>::value, "");
-    }
-    {
-        typedef int T;
-        typedef int U;
-        static_assert(!ex::is_base_of_v<T, U>, "");
-        static_assert(ex::is_base_of_v<T, U> == std::is_base_of<T, U>::value, "");
-    }
-    {
-        typedef int T;
-        typedef long U;
-        static_assert(ex::is_convertible_v<T, U>, "");
-        static_assert(std::is_same<decltype(ex::is_convertible_v<T, U>), const bool>::value, "");
-        static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
-    }
-    {
-        typedef void T;
-        typedef int U;
-        static_assert(!ex::is_convertible_v<T, U>, "");
-        static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
-    }
-}
-
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
deleted file mode 100644
index a4a91c13692..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-#include <experimental/type_traits>
-
-namespace ex = std::experimental;
-
-struct class_type {};
-enum enum_type {};
-union union_type {};
-
-int main()
-{
-    {
-        typedef void T;
-        static_assert(ex::is_void_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_void_v<T>), const bool>::value, "");
-        static_assert(ex::is_void_v<T> == std::is_void<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_void_v<T>, "");
-        static_assert(ex::is_void_v<T> == std::is_void<T>::value, "");
-    }
-    {
-        typedef decltype(nullptr) T;
-        static_assert(ex::is_null_pointer_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_null_pointer_v<T>), const bool>::value, "");
-        static_assert(ex::is_null_pointer_v<T> == std::is_null_pointer<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_null_pointer_v<T>, "");
-        static_assert(ex::is_null_pointer_v<T> == std::is_null_pointer<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_integral_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_integral_v<T>), const bool>::value, "");
-        static_assert(ex::is_integral_v<T> == std::is_integral<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_integral_v<T>, "");
-        static_assert(ex::is_integral_v<T> == std::is_integral<T>::value, "");
-    }
-    {
-        typedef float T;
-        static_assert(ex::is_floating_point_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_floating_point_v<T>), const bool>::value, "");
-        static_assert(ex::is_floating_point_v<T> == std::is_floating_point<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_floating_point_v<T>, "");
-        static_assert(ex::is_floating_point_v<T> == std::is_floating_point<T>::value, "");
-    }
-    {
-        typedef int(T)[42];
-        static_assert(ex::is_array_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_array_v<T>), const bool>::value, "");
-        static_assert(ex::is_array_v<T> == std::is_array<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_array_v<T>, "");
-        static_assert(ex::is_array_v<T> == std::is_array<T>::value, "");
-    }
-    {
-        typedef void* T;
-        static_assert(ex::is_pointer_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_pointer_v<T>), const bool>::value, "");
-        static_assert(ex::is_pointer_v<T> == std::is_pointer<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_pointer_v<T>, "");
-        static_assert(ex::is_pointer_v<T> == std::is_pointer<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(ex::is_lvalue_reference_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_lvalue_reference_v<T>), const bool>::value, "");
-        static_assert(ex::is_lvalue_reference_v<T> == std::is_lvalue_reference<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_lvalue_reference_v<T>, "");
-        static_assert(ex::is_lvalue_reference_v<T> == std::is_lvalue_reference<T>::value, "");
-    }
-    {
-        typedef int && T;
-        static_assert(ex::is_rvalue_reference_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_rvalue_reference_v<T>), const bool>::value, "");
-        static_assert(ex::is_rvalue_reference_v<T> == std::is_rvalue_reference<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_rvalue_reference_v<T>, "");
-        static_assert(ex::is_rvalue_reference_v<T> == std::is_rvalue_reference<T>::value, "");
-    }
-    {
-        typedef int class_type::*T;
-        static_assert(ex::is_member_object_pointer_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_member_object_pointer_v<T>), const bool>::value, "");
-        static_assert(ex::is_member_object_pointer_v<T> == std::is_member_object_pointer<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_member_object_pointer_v<T>, "");
-        static_assert(ex::is_member_object_pointer_v<T> == std::is_member_object_pointer<T>::value, "");
-    }
-    {
-        typedef void(class_type::*T)();
-        static_assert(ex::is_member_function_pointer_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_member_function_pointer_v<T>), const bool>::value, "");
-        static_assert(ex::is_member_function_pointer_v<T> == std::is_member_function_pointer<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_member_function_pointer_v<T>, "");
-        static_assert(ex::is_member_function_pointer_v<T> == std::is_member_function_pointer<T>::value, "");
-    }
-    {
-        typedef enum_type T;
-        static_assert(ex::is_enum_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_enum_v<T>), const bool>::value, "");
-        static_assert(ex::is_enum_v<T> == std::is_enum<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_enum_v<T>, "");
-        static_assert(ex::is_enum_v<T> == std::is_enum<T>::value, "");
-    }
-    {
-        typedef union_type T;
-        static_assert(ex::is_union_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_union_v<T>), const bool>::value, "");
-        static_assert(ex::is_union_v<T> == std::is_union<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_union_v<T>, "");
-        static_assert(ex::is_union_v<T> == std::is_union<T>::value, "");
-    }
-    {
-        typedef class_type T;
-        static_assert(ex::is_class_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_class_v<T>), const bool>::value, "");
-        static_assert(ex::is_class_v<T> == std::is_class<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_class_v<T>, "");
-        static_assert(ex::is_class_v<T> == std::is_class<T>::value, "");
-    }
-    {
-        typedef void(T)();
-        static_assert(ex::is_function_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_function_v<T>), const bool>::value, "");
-        static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_function_v<T>, "");
-        static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
-    }
-}
-
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
deleted file mode 100644
index b3927b12095..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-#include <experimental/type_traits>
-
-namespace ex = std::experimental;
-
-struct class_type {};
-
-int main()
-{
-    {
-        typedef int & T;
-        static_assert(ex::is_reference_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_reference_v<T>), const bool>::value, "");
-        static_assert(ex::is_reference_v<T> == std::is_reference<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_reference_v<T>, "");
-        static_assert(ex::is_reference_v<T> == std::is_reference<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_arithmetic_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_arithmetic_v<T>), const bool>::value, "");
-        static_assert(ex::is_arithmetic_v<T> == std::is_arithmetic<T>::value, "");
-    }
-    {
-        typedef void* T;
-        static_assert(!ex::is_arithmetic_v<T>, "");
-        static_assert(ex::is_arithmetic_v<T> == std::is_arithmetic<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_fundamental_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_fundamental_v<T>), const bool>::value, "");
-        static_assert(ex::is_fundamental_v<T> == std::is_fundamental<T>::value, "");
-    }
-    {
-        typedef class_type T;
-        static_assert(!ex::is_fundamental_v<T>, "");
-        static_assert(ex::is_fundamental_v<T> == std::is_fundamental<T>::value, "");
-    }
-    {
-        typedef class_type T;
-        static_assert(ex::is_object_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_object_v<T>), const bool>::value, "");
-        static_assert(ex::is_object_v<T> == std::is_object<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_object_v<T>, "");
-        static_assert(ex::is_object_v<T> == std::is_object<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_scalar_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_scalar_v<T>), const bool>::value, "");
-        static_assert(ex::is_scalar_v<T> == std::is_scalar<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_scalar_v<T>, "");
-        static_assert(ex::is_scalar_v<T> == std::is_scalar<T>::value, "");
-    }
-    {
-        typedef void* T;
-        static_assert(ex::is_compound_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_compound_v<T>), const bool>::value, "");
-        static_assert(ex::is_compound_v<T> == std::is_compound<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_compound_v<T>, "");
-        static_assert(ex::is_compound_v<T> == std::is_compound<T>::value, "");
-    }
-    {
-        typedef int class_type::*T;
-        static_assert(ex::is_member_pointer_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_member_pointer_v<T>), const bool>::value, "");
-        static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_member_pointer_v<T>, "");
-        static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
-    }
-}
-
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
deleted file mode 100644
index bfd385a1b8e..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp
+++ /dev/null
@@ -1,492 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// GCC returns true for __is_trivially_constructible(void, int)
-// See gcc.gnu.org/PR80682
-// NOTE: This has been fixed in trunk and will be backported soon.
-// XFAIL: gcc-7, gcc-6, gcc-5, gcc-4
-
-// <experimental/type_traits>
-
-#include <experimental/type_traits>
-
-namespace ex = std::experimental;
-
-struct non_literal_type { non_literal_type() {} };
-struct empty_type {};
-
-struct polymorphic_type
-{
-    virtual void foo() {}
-};
-
-struct abstract_type
-{
-    virtual void foo() = 0;
-};
-
-struct final_type final {};
-
-struct virtual_dtor_type
-{
-    virtual ~virtual_dtor_type() {}
-};
-
-void type_properties_test()
-{
-    {
-        typedef const int T;
-        static_assert(ex::is_const_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_const_v<T>), const bool>::value, "");
-        static_assert(ex::is_const_v<T> == std::is_const<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_const_v<T>, "");
-        static_assert(ex::is_const_v<T> == std::is_const<T>::value, "");
-    }
-    {
-        typedef volatile int T;
-        static_assert(ex::is_volatile_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_volatile_v<T>), const bool>::value, "");
-        static_assert(ex::is_volatile_v<T> == std::is_volatile<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_volatile_v<T>, "");
-        static_assert(ex::is_volatile_v<T> == std::is_volatile<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivial_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivial_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivial_v<T> == std::is_trivial<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_trivial_v<T>, "");
-        static_assert(ex::is_trivial_v<T> == std::is_trivial<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_copyable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_copyable_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_copyable_v<T> == std::is_trivially_copyable<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_trivially_copyable_v<T>, "");
-        static_assert(ex::is_trivially_copyable_v<T> == std::is_trivially_copyable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_standard_layout_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_standard_layout_v<T>), const bool>::value, "");
-        static_assert(ex::is_standard_layout_v<T> == std::is_standard_layout<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_standard_layout_v<T>, "");
-        static_assert(ex::is_standard_layout_v<T> == std::is_standard_layout<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_pod_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_pod_v<T>), const bool>::value, "");
-        static_assert(ex::is_pod_v<T> == std::is_pod<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_pod_v<T>, "");
-        static_assert(ex::is_pod_v<T> == std::is_pod<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_literal_type_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_literal_type_v<T>), const bool>::value, "");
-        static_assert(ex::is_literal_type_v<T> == std::is_literal_type<T>::value, "");
-    }
-    {
-        typedef non_literal_type T;
-        static_assert(!ex::is_literal_type_v<T>, "");
-        static_assert(ex::is_literal_type_v<T> == std::is_literal_type<T>::value, "");
-    }
-    {
-        typedef empty_type T;
-        static_assert(ex::is_empty_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_empty_v<T>), const bool>::value, "");
-        static_assert(ex::is_empty_v<T> == std::is_empty<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_empty_v<T>, "");
-        static_assert(ex::is_empty_v<T> == std::is_empty<T>::value, "");
-    }
-    {
-        typedef polymorphic_type T;
-        static_assert(ex::is_polymorphic_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_polymorphic_v<T>), const bool>::value, "");
-        static_assert(ex::is_polymorphic_v<T> == std::is_polymorphic<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_polymorphic_v<T>, "");
-        static_assert(ex::is_polymorphic_v<T> == std::is_polymorphic<T>::value, "");
-    }
-    {
-        typedef abstract_type T;
-        static_assert(ex::is_abstract_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_abstract_v<T>), const bool>::value, "");
-        static_assert(ex::is_abstract_v<T> == std::is_abstract<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_abstract_v<T>, "");
-        static_assert(ex::is_abstract_v<T> == std::is_abstract<T>::value, "");
-    }
-    {
-        typedef final_type T;
-        static_assert(ex::is_final_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_final_v<T>), const bool>::value, "");
-        static_assert(ex::is_final_v<T> == std::is_final<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_final_v<T>, "");
-        static_assert(ex::is_final_v<T> == std::is_final<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_signed_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_signed_v<T>), const bool>::value, "");
-        static_assert(ex::is_signed_v<T> == std::is_signed<T>::value, "");
-    }
-    {
-        typedef unsigned T;
-        static_assert(!ex::is_signed_v<T>, "");
-        static_assert(ex::is_signed_v<T> == std::is_signed<T>::value, "");
-    }
-    {
-        typedef unsigned T;
-        static_assert(ex::is_unsigned_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_unsigned_v<T>), const bool>::value, "");
-        static_assert(ex::is_unsigned_v<T> == std::is_unsigned<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::is_unsigned_v<T>, "");
-        static_assert(ex::is_unsigned_v<T> == std::is_unsigned<T>::value, "");
-    }
-}
-
-void is_constructible_and_assignable_test()
-{
-    {
-        typedef int T;
-        static_assert(ex::is_constructible_v<T, int>, "");
-        static_assert(std::is_same<decltype(ex::is_constructible_v<T, int>), const bool>::value, "");
-        static_assert(ex::is_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_constructible_v<T, int>, "");
-        static_assert(ex::is_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_default_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_default_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_default_constructible_v<T>, "");
-        static_assert(ex::is_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_copy_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_copy_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_copy_constructible_v<T>, "");
-        static_assert(ex::is_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_move_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_move_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_move_constructible_v<T>, "");
-        static_assert(ex::is_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
-    }
-    {
-        typedef int & T;
-        typedef int U;
-        static_assert(ex::is_assignable_v<T, U>, "");
-        static_assert(std::is_same<decltype(ex::is_assignable_v<T, U>), const bool>::value, "");
-        static_assert(ex::is_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
-    }
-    {
-        typedef int & T;
-        typedef void U;
-        static_assert(!ex::is_assignable_v<T, U>, "");
-        static_assert(ex::is_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_copy_assignable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_copy_assignable_v<T>), const bool>::value, "");
-        static_assert(ex::is_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_copy_assignable_v<T>, "");
-        static_assert(ex::is_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_move_assignable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_move_assignable_v<T>), const bool>::value, "");
-        static_assert(ex::is_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_move_assignable_v<T>, "");
-        static_assert(ex::is_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_destructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_destructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_destructible_v<T> == std::is_destructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_destructible_v<T>, "");
-        static_assert(ex::is_destructible_v<T> == std::is_destructible<T>::value, "");
-    }
-}
-
-void is_trivially_constructible_and_assignable_test()
-{
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_constructible_v<T, int>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_constructible_v<T, int>), const bool>::value, "");
-        static_assert(ex::is_trivially_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_trivially_constructible_v<T, int>, "");
-        static_assert(ex::is_trivially_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_default_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_default_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_trivially_default_constructible_v<T>, "");
-        static_assert(ex::is_trivially_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_copy_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_copy_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_trivially_copy_constructible_v<T>, "");
-        static_assert(ex::is_trivially_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_move_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_move_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_trivially_move_constructible_v<T>, "");
-        static_assert(ex::is_trivially_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
-    }
-    {
-        typedef int & T;
-        typedef int U;
-        static_assert(ex::is_trivially_assignable_v<T, U>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_assignable_v<T, U>), const bool>::value, "");
-        static_assert(ex::is_trivially_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
-    }
-    {
-        typedef int & T;
-        typedef void U;
-        static_assert(!ex::is_trivially_assignable_v<T, U>, "");
-        static_assert(ex::is_trivially_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_copy_assignable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_copy_assignable_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_trivially_copy_assignable_v<T>, "");
-        static_assert(ex::is_trivially_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_move_assignable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_move_assignable_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_trivially_move_assignable_v<T>, "");
-        static_assert(ex::is_trivially_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_trivially_destructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_trivially_destructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_trivially_destructible_v<T> == std::is_destructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_trivially_destructible_v<T>, "");
-        static_assert(ex::is_trivially_destructible_v<T> == std::is_destructible<T>::value, "");
-    }
-}
-
-
-
-void is_nothrow_constructible_and_assignable_test()
-{
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_constructible_v<T, int>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_constructible_v<T, int>), const bool>::value, "");
-        static_assert(ex::is_nothrow_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_nothrow_constructible_v<T, int>, "");
-        static_assert(ex::is_nothrow_constructible_v<T, int> == std::is_constructible<T, int>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_default_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_default_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_nothrow_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
-    }
-    {
-        typedef int & T;
-        static_assert(!ex::is_nothrow_default_constructible_v<T>, "");
-        static_assert(ex::is_nothrow_default_constructible_v<T> == std::is_default_constructible<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_copy_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_copy_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_nothrow_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_nothrow_copy_constructible_v<T>, "");
-        static_assert(ex::is_nothrow_copy_constructible_v<T> == std::is_copy_constructible<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_move_constructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_move_constructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_nothrow_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_nothrow_move_constructible_v<T>, "");
-        static_assert(ex::is_nothrow_move_constructible_v<T> == std::is_move_constructible<T>::value, "");
-    }
-    {
-        typedef int & T;
-        typedef int U;
-        static_assert(ex::is_nothrow_assignable_v<T, U>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_assignable_v<T, U>), const bool>::value, "");
-        static_assert(ex::is_nothrow_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
-    }
-    {
-        typedef int & T;
-        typedef void U;
-        static_assert(!ex::is_nothrow_assignable_v<T, U>, "");
-        static_assert(ex::is_nothrow_assignable_v<T, U> == std::is_assignable<T, U>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_copy_assignable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_copy_assignable_v<T>), const bool>::value, "");
-        static_assert(ex::is_nothrow_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_nothrow_copy_assignable_v<T>, "");
-        static_assert(ex::is_nothrow_copy_assignable_v<T> == std::is_copy_assignable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_move_assignable_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_move_assignable_v<T>), const bool>::value, "");
-        static_assert(ex::is_nothrow_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_nothrow_move_assignable_v<T>, "");
-        static_assert(ex::is_nothrow_move_assignable_v<T> == std::is_move_assignable<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(ex::is_nothrow_destructible_v<T>, "");
-        static_assert(std::is_same<decltype(ex::is_nothrow_destructible_v<T>), const bool>::value, "");
-        static_assert(ex::is_nothrow_destructible_v<T> == std::is_destructible<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(!ex::is_nothrow_destructible_v<T>, "");
-        static_assert(ex::is_nothrow_destructible_v<T> == std::is_destructible<T>::value, "");
-    }
-}
-
-int main()
-{
-    type_properties_test();
-    is_constructible_and_assignable_test();
-    is_trivially_constructible_and_assignable_test();
-    is_nothrow_constructible_and_assignable_test();
-    {
-        typedef virtual_dtor_type T;
-        static_assert(ex::has_virtual_destructor_v<T>, "");
-        static_assert(std::is_same<decltype(ex::has_virtual_destructor_v<T>), const bool>::value, "");
-        static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
-    }
-    {
-        typedef int T;
-        static_assert(!ex::has_virtual_destructor_v<T>, "");
-        static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
-    }
-}
-
diff --git a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp b/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
deleted file mode 100644
index f91667da523..00000000000
--- a/libcxx/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-// <experimental/type_traits>
-
-#include <experimental/type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef char T;
-        static_assert(ex::alignment_of_v<T> == 1, "");
-        static_assert(std::is_same<decltype(ex::alignment_of_v<T>), const std::size_t>::value, "");
-        static_assert(ex::alignment_of_v<T> == std::alignment_of<T>::value, "");
-    }
-    {
-        typedef char(T)[1][1][1];
-        static_assert(ex::rank_v<T> == 3, "");
-        static_assert(std::is_same<decltype(ex::rank_v<T>), const std::size_t>::value, "");
-        static_assert(ex::rank_v<T> == std::rank<T>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(ex::rank_v<T> == 0, "");
-        static_assert(ex::rank_v<T> == std::rank<T>::value, "");
-    }
-    {
-        typedef char(T)[2][3][4];
-        static_assert(ex::extent_v<T> == 2, "");
-        static_assert(std::is_same<decltype(ex::extent_v<T>), const std::size_t>::value, "");
-        static_assert(ex::extent_v<T> == std::extent<T>::value, "");
-    }
-    {
-        typedef char(T)[2][3][4];
-        static_assert(ex::extent_v<T, 0> == 2, "");
-        static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
-    }
-    {
-        typedef char(T)[2][3][4];
-        static_assert(ex::extent_v<T, 1> == 3, "");
-        static_assert(ex::extent_v<T, 1> == std::extent<T, 1>::value, "");
-    }
-    {
-        typedef char(T)[2][3][4];
-        static_assert(ex::extent_v<T, 5> == 0, "");
-        static_assert(ex::extent_v<T, 5> == std::extent<T, 5>::value, "");
-    }
-    {
-        typedef void T;
-        static_assert(ex::extent_v<T, 0> == 0, "");
-        static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
deleted file mode 100644
index 485da33cdec..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// Test that <ratio> is included.
-
-#include <experimental/ratio>
-
-int main()
-{
-  std::ratio<100> x;
-  ((void)x);
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_equal_v.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_equal_v.pass.cpp
deleted file mode 100644
index 641e6ae22cc..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_equal_v.pass.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// template <class R1, class R2> constexpr bool ratio_equal_v;
-
-#include <experimental/ratio>
-#include <type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_equal_v<R1, R2> == std::ratio_equal<R1, R2>::value, ""
-          );
-        static_assert(
-            std::is_same<decltype(ex::ratio_equal_v<R1, R2>), const bool>::value
-          , ""
-          );
-    }
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, -1> R2;
-        static_assert(
-            !ex::ratio_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_equal_v<R1, R2> == std::ratio_equal<R1, R2>::value, ""
-          );
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_equal_v.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_equal_v.pass.cpp
deleted file mode 100644
index 3896d0ac64d..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_equal_v.pass.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// template <class R1, class R2> constexpr bool ratio_greater_equal_v;
-
-#include <experimental/ratio>
-#include <type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef std::ratio<1, 2> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_greater_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_greater_equal_v<R1, R2>
-            == std::ratio_greater_equal<R1, R2>::value, ""
-          );
-        static_assert(
-            std::is_same<
-              decltype(ex::ratio_greater_equal_v<R1, R2>), const bool>::value
-          , ""
-          );
-    }
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_greater_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_greater_equal_v<R1, R2>
-            == std::ratio_greater_equal<R1, R2>::value, ""
-          );
-    }
-    {
-        typedef std::ratio<2, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_greater_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_greater_equal_v<R1, R2>
-            == std::ratio_greater_equal<R1, R2>::value, ""
-          );
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_v.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_v.pass.cpp
deleted file mode 100644
index bdc54515f62..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_greater_v.pass.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// template <class R1, class R2> constexpr bool ratio_greater_v;
-
-#include <experimental/ratio>
-#include <type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef std::ratio<1, 2> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_greater_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_greater_v<R1, R2> == std::ratio_greater<R1, R2>::value, ""
-          );
-        static_assert(
-            std::is_same<decltype(ex::ratio_greater_v<R1, R2>), const bool>::value
-          , ""
-          );
-    }
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_greater_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_greater_v<R1, R2> == std::ratio_greater<R1, R2>::value, ""
-          );
-    }
-    {
-        typedef std::ratio<2, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_greater_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_greater_v<R1, R2> == std::ratio_greater<R1, R2>::value, ""
-          );
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_equal_v.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_equal_v.pass.cpp
deleted file mode 100644
index 50f213b0133..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_equal_v.pass.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// template <class R1, class R2> constexpr bool ratio_less_equal_v;
-
-#include <experimental/ratio>
-#include <type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef std::ratio<1, 2> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_less_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_less_equal_v<R1, R2> == std::ratio_less_equal<R1, R2>::value, ""
-          );
-        static_assert(
-            std::is_same<decltype(ex::ratio_less_equal_v<R1, R2>), const bool>::value
-          , ""
-          );
-    }
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_less_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_less_equal_v<R1, R2> == std::ratio_less_equal<R1, R2>::value, ""
-          );
-    }
-    {
-        typedef std::ratio<2, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_less_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_less_equal_v<R1, R2> == std::ratio_less_equal<R1, R2>::value, ""
-          );
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_v.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_v.pass.cpp
deleted file mode 100644
index 7a6d7738bd9..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_less_v.pass.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// template <class R1, class R2> constexpr bool ratio_less_v;
-
-#include <experimental/ratio>
-#include <type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef std::ratio<1, 2> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            ex::ratio_less_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_less_v<R1, R2> == std::ratio_less<R1, R2>::value, ""
-          );
-        static_assert(
-            std::is_same<decltype(ex::ratio_less_v<R1, R2>), const bool>::value
-          , ""
-          );
-    }
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_less_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_less_v<R1, R2> == std::ratio_less<R1, R2>::value, ""
-          );
-    }
-    {
-        typedef std::ratio<2, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_less_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_less_v<R1, R2> == std::ratio_less<R1, R2>::value, ""
-          );
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_not_equal_v.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_not_equal_v.pass.cpp
deleted file mode 100644
index b5296ff24ef..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/header.ratio.synop/ratio_not_equal_v.pass.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/ratio>
-
-// template <class R1, class R2> constexpr bool ratio_not_equal_v;
-
-#include <experimental/ratio>
-#include <type_traits>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, -1> R2;
-        static_assert(
-            ex::ratio_not_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_not_equal_v<R1, R2> == std::ratio_not_equal<R1, R2>::value, ""
-          );
-        static_assert(
-            std::is_same<decltype(ex::ratio_not_equal_v<R1, R2>), const bool>::value
-          , ""
-          );
-    }
-    {
-        typedef std::ratio<1, 1> R1;
-        typedef std::ratio<1, 1> R2;
-        static_assert(
-            !ex::ratio_not_equal_v<R1, R2>, ""
-          );
-        static_assert(
-            ex::ratio_not_equal_v<R1, R2> == std::ratio_not_equal<R1, R2>::value, ""
-          );
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/ratio/nothing_to_do.pass.cpp b/libcxx/test/std/experimental/utilities/ratio/nothing_to_do.pass.cpp
deleted file mode 100644
index 9a59227abdd..00000000000
--- a/libcxx/test/std/experimental/utilities/ratio/nothing_to_do.pass.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-int main()
-{
-}
diff --git a/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
deleted file mode 100644
index de813925f21..00000000000
--- a/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/system_error>
-
-#include <experimental/system_error>
-
-int main()
-{
-  // Check that <system_error> has been included
-  std::error_code ec;
-  ((void)ec);
-}
diff --git a/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/is_error_code_enum_v.pass.cpp b/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/is_error_code_enum_v.pass.cpp
deleted file mode 100644
index f944123ebc0..00000000000
--- a/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/is_error_code_enum_v.pass.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/system_error>
-
-// template <class T> constexpr bool is_error_code_enum_v;
-
-#include <experimental/system_error>
-#include <ios> /* for std::io_errc */
-
-namespace ex = std::experimental;
-
-int main() {
-  {
-    static_assert(ex::is_error_code_enum_v<std::io_errc>, "");
-
-    static_assert(ex::is_error_code_enum_v<std::io_errc> ==
-                  std::is_error_code_enum <std::io_errc>::value, "");
-
-    static_assert(std::is_same<decltype(ex::is_error_code_enum_v<std::io_errc>),
-                               const bool>::value, "");
-  }
-  {
-    static_assert(!ex::is_error_code_enum_v<int>, "");
-
-    static_assert(ex::is_error_code_enum_v<int> ==
-                  std::is_error_code_enum <int>::value, "");
-  }
-}
diff --git a/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/is_error_condition_enum.pass.cpp b/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/is_error_condition_enum.pass.cpp
deleted file mode 100644
index ee8dc57aa9d..00000000000
--- a/libcxx/test/std/experimental/utilities/syserror/header.system_error.synop/is_error_condition_enum.pass.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/system_error>
-
-// template <class T> constexpr bool is_error_condition_enum_v;
-
-#include <experimental/system_error>
-#include <type_traits>
-namespace ex = std::experimental;
-
-int main() {
-  {
-    static_assert(ex::is_error_condition_enum_v<std::errc>, "");
-
-    static_assert(ex::is_error_condition_enum_v<std::errc> ==
-                  std::is_error_condition_enum <std::errc>::value, "");
-
-    static_assert(
-        std::is_same<decltype(ex::is_error_condition_enum_v<std::errc>),
-                     const bool>::value,
-        "");
-  }
-  {
-    static_assert(!ex::is_error_condition_enum_v<int>, "");
-
-    static_assert(ex::is_error_condition_enum_v<int> ==
-                  std::is_error_condition_enum <int>::value, "");
-  }
-}
diff --git a/libcxx/test/std/experimental/utilities/time/header.chrono.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
deleted file mode 100644
index f6ad37f9ee3..00000000000
--- a/libcxx/test/std/experimental/utilities/time/header.chrono.synop/includes.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/chrono>
-
-#include <experimental/chrono>
-
-int main()
-{
-  // Check that <chrono> has been included.
-  std::chrono::seconds s;
-  ((void)s);
-}
diff --git a/libcxx/test/std/experimental/utilities/time/header.chrono.synop/treat_as_floating_point_v.pass.cpp b/libcxx/test/std/experimental/utilities/time/header.chrono.synop/treat_as_floating_point_v.pass.cpp
deleted file mode 100644
index 9ac9a2ed1c8..00000000000
--- a/libcxx/test/std/experimental/utilities/time/header.chrono.synop/treat_as_floating_point_v.pass.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/chrono>
-
-// template <class Rep> constexpr bool treat_as_floating_point_v;
-
-#include <experimental/chrono>
-#include <type_traits>
-
-namespace ex = std::chrono::experimental;
-namespace cr = std::chrono;
-
-template <class T, bool Expect>
-void test()
-{
-  static_assert(
-    ex::treat_as_floating_point_v<T> == Expect, ""
-  );
-  static_assert(
-    ex::treat_as_floating_point_v<T> == cr::treat_as_floating_point<T>::value, ""
-  );
-}
-
-int main()
-{
-  {
-    static_assert(
-      std::is_same<
-        decltype(ex::treat_as_floating_point_v<float>), const bool
-      >::value, ""
-    );
-  }
-  test<int, false>();
-  test<unsigned, false>();
-  test<char, false>();
-  test<bool, false>();
-  test<float, true>();
-  test<double, true>();
-  test<long double, true>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
deleted file mode 100644
index 5cfb15e3df2..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-#include <experimental/tuple>
-
-int main()
-{
-  std::tuple<int> x(1);
-  (void)x;
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/arg_type.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/arg_type.pass.cpp
deleted file mode 100644
index cb44707fa7e..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/arg_type.pass.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Test with different ref/ptr/cv qualified argument types.
-
-#include <experimental/tuple>
-#include <array>
-#include <utility>
-#include <cassert>
-
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-
-namespace ex = std::experimental;
-
-int call_with_value(int x, int y) { return (x + y); }
-int call_with_ref(int & x, int & y) { return (x + y); }
-int call_with_const_ref(int const & x, int const & y) { return (x + y); }
-int call_with_rvalue_ref(int && x, int && y) { return (x + y); }
-int call_with_pointer(int * x, int * y) { return (*x + *y); }
-int call_with_const_pointer(int const* x, int const * y) { return (*x + *y); }
-
-
-template <class Tuple>
-void test_values()
-{
-    {
-        Tuple t{1, 2};
-        assert(3 == ex::apply(call_with_value, t));
-    }
-    {
-        Tuple t{2, 2};
-        assert(4 == ex::apply(call_with_ref, t));
-    }
-    {
-        Tuple t{2, 3};
-        assert(5 == ex::apply(call_with_const_ref, t));
-    }
-    {
-        Tuple t{3, 3};
-        assert(6 == ex::apply(call_with_rvalue_ref, static_cast<Tuple &&>(t)));
-    }
-    {
-        Tuple const t{4, 4};
-        assert(8 == ex::apply(call_with_value, t));
-    }
-    {
-        Tuple const t{4, 5};
-        assert(9 == ex::apply(call_with_const_ref, t));
-    }
-}
-
-template <class Tuple>
-void test_refs()
-{
-    int x = 0;
-    int y = 0;
-    {
-        x = 1; y = 2;
-        Tuple t{x, y};
-        assert(3 == ex::apply(call_with_value, t));
-    }
-    {
-        x = 2; y = 2;
-        Tuple t{x, y};
-        assert(4 == ex::apply(call_with_ref, t));
-    }
-    {
-        x = 2; y = 3;
-        Tuple t{x, y};
-        assert(5 == ex::apply(call_with_const_ref, t));
-    }
-    {
-        x = 3; y = 3;
-        Tuple const t{x, y};
-        assert(6 == ex::apply(call_with_value, t));
-    }
-    {
-        x = 3; y = 4;
-        Tuple const t{x, y};
-        assert(7 == ex::apply(call_with_const_ref, t));
-    }
-}
-
-template <class Tuple>
-void test_const_refs()
-{
-    int x = 0;
-    int y = 0;
-    {
-        x = 1; y = 2;
-        Tuple t{x, y};
-        assert(3 == ex::apply(call_with_value, t));
-    }
-    {
-        x = 2; y = 3;
-        Tuple t{x, y};
-        assert(5 == ex::apply(call_with_const_ref, t));
-    }
-    {
-        x = 3; y = 3;
-        Tuple const t{x, y};
-        assert(6 == ex::apply(call_with_value, t));
-    }
-    {
-        x = 3; y = 4;
-        Tuple const t{x, y};
-        assert(7 == ex::apply(call_with_const_ref, t));
-    }
-}
-
-
-template <class Tuple>
-void test_pointer()
-{
-    int x = 0;
-    int y = 0;
-    {
-        x = 2; y = 2;
-        Tuple t{&x, &y};
-        assert(4 == ex::apply(call_with_pointer, t));
-    }
-    {
-        x = 2; y = 3;
-        Tuple t{&x, &y};
-        assert(5 == ex::apply(call_with_const_pointer, t));
-    }
-    {
-        x = 3; y = 4;
-        Tuple const t{&x, &y};
-        assert(7 == ex::apply(call_with_const_pointer, t));
-    }
-}
-
-
-template <class Tuple>
-void test_const_pointer()
-{
-    int x = 0;
-    int y = 0;
-    {
-        x = 2; y = 3;
-        Tuple t{&x, &y};
-        assert(5 == ex::apply(call_with_const_pointer, t));
-    }
-    {
-        x = 3; y = 4;
-        Tuple const t{&x, &y};
-        assert(7 == ex::apply(call_with_const_pointer, t));
-    }
-}
-
-
-int main()
-{
-    test_values<std::tuple<int, int>>();
-    test_values<std::pair<int, int>>();
-    test_values<std::array<int, 2>>();
-
-    test_refs<std::tuple<int &, int &>>();
-    test_refs<std::pair<int &, int &>>();
-
-    test_const_refs<std::tuple<int const &, int const &>>();
-    test_const_refs<std::pair<int const &, int const &>>();
-
-    test_pointer<std::tuple<int *, int *>>();
-    test_pointer<std::pair<int *, int *>>();
-    test_pointer<std::array<int *, 2>>();
-
-    test_const_pointer<std::tuple<int const *, int const *>>();
-    test_const_pointer<std::pair<int const *, int const *>>();
-    test_const_pointer<std::array<int const *, 2>>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp
deleted file mode 100644
index 5b8a8f09d1e..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Testing constexpr evaluation
-
-#include <experimental/tuple>
-#include <utility>
-#include <cassert>
-
-constexpr int f_int_0() { return 1; }
-constexpr int f_int_1(int x) { return  x; }
-constexpr int f_int_2(int x, int y) { return (x + y); }
-
-struct A_int_0
-{
-    constexpr A_int_0() {}
-    constexpr int operator()() const { return 1; }
-};
-
-struct A_int_1
-{
-    constexpr A_int_1() {}
-    constexpr int operator()(int x) const { return x; }
-};
-
-struct A_int_2
-{
-    constexpr A_int_2() {}
-    constexpr int operator()(int x, int y) const { return (x + y); }
-};
-
-namespace ex = std::experimental;
-
-template <class Tuple>
-void test_0()
-{
-    // function
-    {
-        constexpr Tuple t{};
-        static_assert(1 == ex::apply(f_int_0, t), "");
-    }
-    // function pointer
-    {
-        constexpr Tuple t{};
-        constexpr auto fp = &f_int_0;
-        static_assert(1 == ex::apply(fp, t), "");
-    }
-    // functor
-    {
-        constexpr Tuple t{};
-        constexpr A_int_0 a;
-        static_assert(1 == ex::apply(a, t), "");
-    }
-}
-
-template <class Tuple>
-void test_1()
-{
-    // function
-    {
-        constexpr Tuple t{1};
-        static_assert(1 == ex::apply(f_int_1, t), "");
-    }
-    // function pointer
-    {
-        constexpr Tuple t{2};
-        constexpr int (*fp)(int) = f_int_1;
-        static_assert(2 == ex::apply(fp, t), "");
-    }
-    // functor
-    {
-        constexpr Tuple t{3};
-        constexpr A_int_1 fn;
-        static_assert(3 == ex::apply(fn, t), "");
-    }
-}
-
-template <class Tuple>
-void test_2()
-{
-    // function
-    {
-        constexpr Tuple t{1, 2};
-        static_assert(3 == ex::apply(f_int_2, t), "");
-    }
-        // function pointer
-    {
-        constexpr Tuple t{2, 3};
-        constexpr auto fp = &f_int_2;
-        static_assert(5 == ex::apply(fp, t), "");
-    }
-    // functor
-    {
-        constexpr Tuple t{3, 4};
-        constexpr A_int_2 a;
-        static_assert(7 == ex::apply(a, t), "");
-    }
-}
-
-int main()
-{
-    test_0<std::tuple<>>();
-    test_1<std::tuple<int>>();
-    test_2<std::tuple<int, int>>();
-    test_2<std::pair<int, int>>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/extended_types.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/extended_types.pass.cpp
deleted file mode 100644
index 57dff44976b..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/extended_types.pass.cpp
+++ /dev/null
@@ -1,427 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Testing extended function types. The extended function types are those
-// named by INVOKE but that are not actual callable objects. These include
-// bullets 1-4 of invoke.
-
-#include <experimental/tuple>
-#include <array>
-#include <utility>
-#include <cassert>
-
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-int count = 0;
-
-struct A_int_0
-{
-    A_int_0() : obj1(0){}
-    A_int_0(int x) : obj1(x) {}
-    int mem1() { return ++count; }
-    int mem2() const { return ++count; }
-    int const obj1;
-};
-
-struct A_int_1
-{
-    A_int_1() {}
-    A_int_1(int) {}
-    int mem1(int x) { return count += x; }
-    int mem2(int x) const { return count += x; }
-};
-
-struct A_int_2
-{
-    A_int_2() {}
-    A_int_2(int) {}
-    int mem1(int x, int y) { return count += (x + y); }
-    int mem2(int x, int y) const { return count += (x + y); }
-};
-
-template <class A>
-struct A_wrap
-{
-    A_wrap() {}
-    A_wrap(int x) : m_a(x) {}
-    A & operator*() { return m_a; }
-    A const & operator*() const { return m_a; }
-    A m_a;
-};
-
-typedef A_wrap<A_int_0> A_wrap_0;
-typedef A_wrap<A_int_1> A_wrap_1;
-typedef A_wrap<A_int_2> A_wrap_2;
-
-
-template <class A>
-struct A_base : public A
-{
-    A_base() : A() {}
-    A_base(int x) : A(x) {}
-};
-
-typedef A_base<A_int_0> A_base_0;
-typedef A_base<A_int_1> A_base_1;
-typedef A_base<A_int_2> A_base_2;
-
-namespace ex = std::experimental;
-
-template <
-    class Tuple, class ConstTuple
-  , class TuplePtr, class ConstTuplePtr
-  , class TupleWrap, class ConstTupleWrap
-  , class TupleBase, class ConstTupleBase
-  >
-void test_ext_int_0()
-{
-    count = 0;
-    typedef A_int_0 T;
-    typedef A_wrap_0 Wrap;
-    typedef A_base_0 Base;
-
-    typedef int(T::*mem1_t)();
-    mem1_t mem1 = &T::mem1;
-
-    typedef int(T::*mem2_t)() const;
-    mem2_t mem2 = &T::mem2;
-
-    typedef int const T::*obj1_t;
-    obj1_t obj1 = &T::obj1;
-
-    // member function w/ref
-    {
-        T a;
-        Tuple t{a};
-        assert(1 == ex::apply(mem1, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // member function w/pointer
-    {
-        T a;
-        TuplePtr t{&a};
-        assert(1 == ex::apply(mem1, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // member function w/base
-    {
-        Base a;
-        TupleBase t{a};
-        assert(1 == ex::apply(mem1, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // member function w/wrap
-    {
-        Wrap a;
-        TupleWrap t{a};
-        assert(1 == ex::apply(mem1, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // const member function w/ref
-    {
-        T const a;
-        ConstTuple t{a};
-        assert(1 == ex::apply(mem2, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // const member function w/pointer
-    {
-        T const a;
-        ConstTuplePtr t{&a};
-        assert(1 == ex::apply(mem2, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // const member function w/base
-    {
-        Base const a;
-        ConstTupleBase t{a};
-        assert(1 == ex::apply(mem2, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // const member function w/wrapper
-    {
-        Wrap const a;
-        ConstTupleWrap t{a};
-        assert(1 == ex::apply(mem2, t));
-        assert(1 == count);
-    }
-    // member object w/ref
-    {
-        T a{42};
-        Tuple t{a};
-        assert(42 == ex::apply(obj1, t));
-    }
-    // member object w/pointer
-    {
-        T a{42};
-        TuplePtr t{&a};
-        assert(42 == ex::apply(obj1, t));
-    }
-    // member object w/base
-    {
-        Base a{42};
-        TupleBase t{a};
-        assert(42 == ex::apply(obj1, t));
-    }
-    // member object w/wrapper
-    {
-        Wrap a{42};
-        TupleWrap t{a};
-        assert(42 == ex::apply(obj1, t));
-    }
-}
-
-
-template <
-    class Tuple, class ConstTuple
-  , class TuplePtr, class ConstTuplePtr
-  , class TupleWrap, class ConstTupleWrap
-  , class TupleBase, class ConstTupleBase
-  >
-void test_ext_int_1()
-{
-    count = 0;
-    typedef A_int_1 T;
-    typedef A_wrap_1 Wrap;
-    typedef A_base_1 Base;
-
-    typedef int(T::*mem1_t)(int);
-    mem1_t mem1 = &T::mem1;
-
-    typedef int(T::*mem2_t)(int) const;
-    mem2_t mem2 = &T::mem2;
-
-    // member function w/ref
-    {
-        T a;
-        Tuple t{a, 2};
-        assert(2 == ex::apply(mem1, t));
-        assert(count == 2);
-    }
-    count = 0;
-    // member function w/pointer
-    {
-        T a;
-        TuplePtr t{&a, 3};
-        assert(3 == ex::apply(mem1, t));
-        assert(count == 3);
-    }
-    count = 0;
-    // member function w/base
-    {
-        Base a;
-        TupleBase t{a, 4};
-        assert(4 == ex::apply(mem1, t));
-        assert(count == 4);
-    }
-    count = 0;
-    // member function w/wrap
-    {
-        Wrap a;
-        TupleWrap t{a, 5};
-        assert(5 == ex::apply(mem1, t));
-        assert(count == 5);
-    }
-    count = 0;
-    // const member function w/ref
-    {
-        T const a;
-        ConstTuple t{a, 6};
-        assert(6 == ex::apply(mem2, t));
-        assert(count == 6);
-    }
-    count = 0;
-    // const member function w/pointer
-    {
-        T const a;
-        ConstTuplePtr t{&a, 7};
-        assert(7 == ex::apply(mem2, t));
-        assert(count == 7);
-    }
-    count = 0;
-    // const member function w/base
-    {
-        Base const a;
-        ConstTupleBase t{a, 8};
-        assert(8 == ex::apply(mem2, t));
-        assert(count == 8);
-    }
-    count = 0;
-    // const member function w/wrapper
-    {
-        Wrap const a;
-        ConstTupleWrap t{a, 9};
-        assert(9 == ex::apply(mem2, t));
-        assert(9 == count);
-    }
-}
-
-
-template <
-    class Tuple, class ConstTuple
-  , class TuplePtr, class ConstTuplePtr
-  , class TupleWrap, class ConstTupleWrap
-  , class TupleBase, class ConstTupleBase
-  >
-void test_ext_int_2()
-{
-    count = 0;
-    typedef A_int_2 T;
-    typedef A_wrap_2 Wrap;
-    typedef A_base_2 Base;
-
-    typedef int(T::*mem1_t)(int, int);
-    mem1_t mem1 = &T::mem1;
-
-    typedef int(T::*mem2_t)(int, int) const;
-    mem2_t mem2 = &T::mem2;
-
-    // member function w/ref
-    {
-        T a;
-        Tuple t{a, 1, 1};
-        assert(2 == ex::apply(mem1, t));
-        assert(count == 2);
-    }
-    count = 0;
-    // member function w/pointer
-    {
-        T a;
-        TuplePtr t{&a, 1, 2};
-        assert(3 == ex::apply(mem1, t));
-        assert(count == 3);
-    }
-    count = 0;
-    // member function w/base
-    {
-        Base a;
-        TupleBase t{a, 2, 2};
-        assert(4 == ex::apply(mem1, t));
-        assert(count == 4);
-    }
-    count = 0;
-    // member function w/wrap
-    {
-        Wrap a;
-        TupleWrap t{a, 2, 3};
-        assert(5 == ex::apply(mem1, t));
-        assert(count == 5);
-    }
-    count = 0;
-    // const member function w/ref
-    {
-        T const a;
-        ConstTuple t{a, 3, 3};
-        assert(6 == ex::apply(mem2, t));
-        assert(count == 6);
-    }
-    count = 0;
-    // const member function w/pointer
-    {
-        T const a;
-        ConstTuplePtr t{&a, 3, 4};
-        assert(7 == ex::apply(mem2, t));
-        assert(count == 7);
-    }
-    count = 0;
-    // const member function w/base
-    {
-        Base const a;
-        ConstTupleBase t{a, 4, 4};
-        assert(8 == ex::apply(mem2, t));
-        assert(count == 8);
-    }
-    count = 0;
-    // const member function w/wrapper
-    {
-        Wrap const a;
-        ConstTupleWrap t{a, 4, 5};
-        assert(9 == ex::apply(mem2, t));
-        assert(9 == count);
-    }
-}
-
-int main()
-{
-    {
-        test_ext_int_0<
-            std::tuple<A_int_0 &>, std::tuple<A_int_0 const &>
-          , std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
-          , std::tuple<A_wrap_0 &>, std::tuple<A_wrap_0 const &>
-          , std::tuple<A_base_0 &>, std::tuple<A_base_0 const &>
-          >();
-        test_ext_int_0<
-            std::tuple<A_int_0>, std::tuple<A_int_0 const>
-          , std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
-          , std::tuple<A_wrap_0>, std::tuple<A_wrap_0 const>
-          , std::tuple<A_base_0>, std::tuple<A_base_0 const>
-          >();
-        test_ext_int_0<
-            std::array<A_int_0, 1>, std::array<A_int_0 const, 1>
-          , std::array<A_int_0*, 1>, std::array<A_int_0 const*, 1>
-          , std::array<A_wrap_0, 1>, std::array<A_wrap_0 const, 1>
-          , std::array<A_base_0, 1>, std::array<A_base_0 const, 1>
-          >();
-    }
-    {
-        test_ext_int_1<
-            std::tuple<A_int_1 &, int>, std::tuple<A_int_1 const &, int>
-          , std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
-          , std::tuple<A_wrap_1 &, int>, std::tuple<A_wrap_1 const &, int>
-          , std::tuple<A_base_1 &, int>, std::tuple<A_base_1 const &, int>
-          >();
-        test_ext_int_1<
-            std::tuple<A_int_1, int>, std::tuple<A_int_1 const, int>
-          , std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
-          , std::tuple<A_wrap_1, int>, std::tuple<A_wrap_1 const, int>
-          , std::tuple<A_base_1, int>, std::tuple<A_base_1 const, int>
-          >();
-        test_ext_int_1<
-            std::pair<A_int_1 &, int>, std::pair<A_int_1 const &, int>
-          , std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
-          , std::pair<A_wrap_1 &, int>, std::pair<A_wrap_1 const &, int>
-          , std::pair<A_base_1 &, int>, std::pair<A_base_1 const &, int>
-          >();
-        test_ext_int_1<
-            std::pair<A_int_1, int>, std::pair<A_int_1 const, int>
-          , std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
-          , std::pair<A_wrap_1, int>, std::pair<A_wrap_1 const, int>
-          , std::pair<A_base_1, int>, std::pair<A_base_1 const, int>
-          >();
-    }
-    {
-        test_ext_int_2<
-            std::tuple<A_int_2 &, int, int>, std::tuple<A_int_2 const &, int, int>
-          , std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
-          , std::tuple<A_wrap_2 &, int, int>, std::tuple<A_wrap_2 const &, int, int>
-          , std::tuple<A_base_2 &, int, int>, std::tuple<A_base_2 const &, int, int>
-          >();
-        test_ext_int_2<
-            std::tuple<A_int_2, int, int>, std::tuple<A_int_2 const, int, int>
-          , std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
-          , std::tuple<A_wrap_2, int, int>, std::tuple<A_wrap_2 const, int, int>
-          , std::tuple<A_base_2, int, int>, std::tuple<A_base_2 const, int, int>
-          >();
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/large_arity.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/large_arity.pass.cpp
deleted file mode 100644
index 027258ad8d1..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/large_arity.pass.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Stress testing large arities with tuple and array.
-
-#include <experimental/tuple>
-#include <array>
-#include <utility>
-#include <cassert>
-
-////////////////////////////////////////////////////////////////////////////////
-template <class T, std::size_t Dummy = 0>
-struct always_imp
-{
-    typedef T type;
-};
-
-template <class T, std::size_t Dummy = 0>
-using always_t = typename always_imp<T, Dummy>::type;
-
-////////////////////////////////////////////////////////////////////////////////
-template <class Tuple, class Idx>
-struct make_function;
-
-template <class Tp, std::size_t ...Idx>
-struct make_function<Tp, std::integer_sequence<std::size_t, Idx...>>
-{
-    using type = bool (*)(always_t<Tp, Idx>...);
-};
-
-template <class Tp, std::size_t Size>
-using make_function_t = typename make_function<Tp, std::make_index_sequence<Size>>::type;
-
-////////////////////////////////////////////////////////////////////////////////
-template <class Tp, class Idx>
-struct make_tuple_imp;
-
-////////////////////////////////////////////////////////////////////////////////
-template <class Tp, std::size_t ...Idx>
-struct make_tuple_imp<Tp, std::integer_sequence<std::size_t, Idx...>>
-{
-    using type = std::tuple<always_t<Tp, Idx>...>;
-};
-
-template <class Tp, std::size_t Size>
-using make_tuple_t = typename make_tuple_imp<Tp, std::make_index_sequence<Size>>::type;
-
-template <class ...Types>
-bool test_apply_fn(Types...) { return true; }
-
-namespace ex = std::experimental;
-
-template <std::size_t Size>
-void test_all()
-{
-
-    using A = std::array<int, Size>;
-    using ConstA = std::array<int const, Size>;
-
-    using Tuple = make_tuple_t<int, Size>;
-    using CTuple = make_tuple_t<const int, Size>;
-
-    using ValFn  = make_function_t<int, Size>;
-    ValFn val_fn = &test_apply_fn;
-
-    using RefFn  = make_function_t<int &, Size>;
-    RefFn ref_fn = &test_apply_fn;
-
-    using CRefFn = make_function_t<int const &, Size>;
-    CRefFn cref_fn = &test_apply_fn;
-
-    using RRefFn = make_function_t<int &&, Size>;
-    RRefFn rref_fn = &test_apply_fn;
-
-    {
-        A a{};
-        assert(ex::apply(val_fn, a));
-        assert(ex::apply(ref_fn, a));
-        assert(ex::apply(cref_fn, a));
-        assert(ex::apply(rref_fn, std::move(a)));
-    }
-    {
-        ConstA a{};
-        assert(ex::apply(val_fn, a));
-        assert(ex::apply(cref_fn, a));
-    }
-    {
-        Tuple a{};
-        assert(ex::apply(val_fn, a));
-        assert(ex::apply(ref_fn, a));
-        assert(ex::apply(cref_fn, a));
-        assert(ex::apply(rref_fn, std::move(a)));
-    }
-    {
-        CTuple a{};
-        assert(ex::apply(val_fn, a));
-        assert(ex::apply(cref_fn, a));
-    }
-
-}
-
-
-template <std::size_t Size>
-void test_one()
-{
-    using A = std::array<int, Size>;
-    using Tuple = make_tuple_t<int, Size>;
-
-    using ValFn  = make_function_t<int, Size>;
-    ValFn val_fn = &test_apply_fn;
-
-    {
-        A a{};
-        assert(ex::apply(val_fn, a));
-    }
-    {
-        Tuple a{};
-        assert(ex::apply(val_fn, a));
-    }
-}
-
-int main()
-{
-    // Instantiate with 1-5 arguments.
-    test_all<1>();
-    test_all<2>();
-    test_all<3>();
-    test_all<4>();
-    test_all<5>();
-
-    // Stress test with 128.
-    test_one<128>();
-    //test_one<256>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/ref_qualifiers.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/ref_qualifiers.pass.cpp
deleted file mode 100644
index 3cf259f531c..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/ref_qualifiers.pass.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Testing ref qualified functions
-
-#include <experimental/tuple>
-#include <cassert>
-
-struct func_obj
-{
-    constexpr func_obj() {}
-
-    constexpr int operator()() const & { return 1; }
-    constexpr int operator()() const && { return 2; }
-    constexpr int operator()() & { return 3; }
-    constexpr int operator()() && { return 4; }
-};
-
-namespace ex = std::experimental;
-
-int main()
-{
-// TODO(ericwf): Re-enable constexpr support
-/*
-    {
-        constexpr func_obj f;
-        constexpr std::tuple<> tp;
-
-        static_assert(1 == ex::apply(static_cast<func_obj const &>(f), tp), "");
-        static_assert(2 == ex::apply(static_cast<func_obj const &&>(f), tp), "");
-    }
-*/
-    {
-        func_obj f;
-        std::tuple<> tp;
-        assert(1 == ex::apply(static_cast<func_obj const &>(f), tp));
-        assert(2 == ex::apply(static_cast<func_obj const &&>(f), tp));
-        assert(3 == ex::apply(static_cast<func_obj &>(f), tp));
-        assert(4 == ex::apply(static_cast<func_obj &&>(f), tp));
-    }
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp
deleted file mode 100644
index 01d36637e1c..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Test the return type deduction.
-
-#include <experimental/tuple>
-#include <cassert>
-
-static int my_int = 42;
-
-template <int N> struct index_t {};
-
-void f(index_t<0>) {}
-
-int f(index_t<1>) { return 0; }
-
-int & f(index_t<2>) { return static_cast<int &>(my_int); }
-int const & f(index_t<3>) { return static_cast<int const &>(my_int); }
-int volatile & f(index_t<4>) { return static_cast<int volatile &>(my_int); }
-int const volatile & f(index_t<5>) { return static_cast<int const volatile &>(my_int); }
-
-int && f(index_t<6>) { return static_cast<int &&>(my_int); }
-int const && f(index_t<7>) { return static_cast<int const &&>(my_int); }
-int volatile && f(index_t<8>) { return static_cast<int volatile &&>(my_int); }
-int const volatile && f(index_t<9>) { return static_cast<int const volatile &&>(my_int); }
-
-int * f(index_t<10>) { return static_cast<int *>(&my_int); }
-int const * f(index_t<11>) { return static_cast<int const *>(&my_int); }
-int volatile * f(index_t<12>) { return static_cast<int volatile *>(&my_int); }
-int const volatile * f(index_t<13>) { return static_cast<int const volatile *>(&my_int); }
-
-
-template <int Func, class Expect>
-void test()
-{
-    using F = decltype(f(index_t<Func>{}));
-    static_assert(std::is_same<F, Expect>::value, "");
-}
-
-namespace ex = std::experimental;
-
-int main()
-{
-    test<0, void>();
-    test<1, int>();
-    test<2, int &>();
-    test<3, int const &>();
-    test<4, int volatile &>();
-    test<5, int const volatile &>();
-    test<6, int &&>();
-    test<7, int const &&>();
-    test<8, int volatile &&>();
-    test<9, int const volatile &&>();
-    test<10, int *>();
-    test<11, int const *>();
-    test<12, int volatile *>();
-    test<13, int const volatile *>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/types.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple.apply/types.pass.cpp
deleted file mode 100644
index 52eec276394..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple.apply/types.pass.cpp
+++ /dev/null
@@ -1,431 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
-
-// Test function types.
-
-#include <experimental/tuple>
-#include <array>
-#include <utility>
-#include <cassert>
-
-// std::array is explicitly allowed to be initialized with A a = { init-list };.
-// Disable the missing braces warning for this reason.
-#include "disable_missing_braces_warning.h"
-
-namespace ex = std::experimental;
-
-int count = 0;
-
-void f_void_0() { ++count; }
-void f_void_1(int i) { count += i; }
-void f_void_2(int x, int y) { count += (x + y); }
-void f_void_3(int x, int y, int z) { count += (x + y + z); }
-
-int f_int_0() { return ++count; }
-int f_int_1(int x) { return count += x; }
-int f_int_2(int x, int y) { return count += (x + y); }
-int f_int_3(int x, int y, int z) { return count += (x + y + z); }
-
-struct A_void_0
-{
-    A_void_0() {}
-    void operator()() { ++count; }
-    void operator()() const { ++count; ++count; }
-};
-
-struct A_void_1
-{
-    A_void_1() {}
-    void operator()(int x) { count += x; }
-    void operator()(int x) const { count += x + 1; }
-};
-
-struct A_void_2
-{
-    A_void_2() {}
-    void operator()(int x, int y) { count += (x + y); }
-    void operator()(int x, int y) const { count += (x + y) + 1; }
-};
-
-struct A_void_3
-{
-    A_void_3() {}
-    void operator()(int x, int y, int z) { count += (x + y + z); }
-    void operator()(int x, int y, int z) const { count += (x + y + z) + 1; }
-};
-
-
-struct A_int_0
-{
-    A_int_0() {}
-    int operator()() { return ++count; }
-    int operator()() const { ++count; return ++count; }
-};
-
-struct A_int_1
-{
-    A_int_1() {}
-    int operator()(int x) { return count += x; }
-    int operator()(int x) const { return count += (x + 1); }
-
-};
-
-struct A_int_2
-{
-    A_int_2() {}
-    int operator()(int x, int y) { return count += (x + y); }
-    int operator()(int x, int y) const { return count += (x + y + 1); }
-};
-
-struct A_int_3
-{
-    A_int_3() {}
-    int operator()(int x, int y, int z) { return count += (x + y + z); }
-    int operator()(int x, int y, int z) const { return count += (x + y + z + 1); }
-};
-
-
-template <class Tuple>
-void test_void_0()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{};
-        ex::apply(f_void_0, t);
-        assert(count == 1);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{};
-        auto fp = &f_void_0;
-        ex::apply(fp, t);
-        assert(count == 1);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{};
-        A_void_0 a;
-        ex::apply(a, t);
-        assert(count == 1);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{};
-        A_void_0 const a;
-        ex::apply(a, t);
-        assert(count == 2);
-    }
-}
-
-template <class Tuple>
-void test_void_1()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{1};
-        ex::apply(f_void_1, t);
-        assert(count == 1);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{2};
-        void (*fp)(int) = f_void_1;
-        ex::apply(fp, t);
-        assert(count == 2);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{3};
-        A_void_1 fn;
-        ex::apply(fn, t);
-        assert(count == 3);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{4};
-        A_void_1 const a;
-        ex::apply(a, t);
-        assert(count == 5);
-    }
-}
-
-template <class Tuple>
-void test_void_2()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{1, 2};
-        ex::apply(f_void_2, t);
-        assert(count == 3);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{2, 3};
-        auto fp = &f_void_2;
-        ex::apply(fp, t);
-        assert(count == 5);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{3, 4};
-        A_void_2 a;
-        ex::apply(a, t);
-        assert(count == 7);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{4, 5};
-        A_void_2 const a;
-        ex::apply(a, t);
-        assert(count == 10);
-    }
-}
-
-template <class Tuple>
-void test_void_3()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{1, 2, 3};
-        ex::apply(f_void_3, t);
-        assert(count == 6);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{2, 3, 4};
-        auto fp = &f_void_3;
-        ex::apply(fp, t);
-        assert(count == 9);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{3, 4, 5};
-        A_void_3 a;
-        ex::apply(a, t);
-        assert(count == 12);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{4, 5, 6};
-        A_void_3 const a;
-        ex::apply(a, t);
-        assert(count == 16);
-    }
-}
-
-
-
-template <class Tuple>
-void test_int_0()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{};
-        assert(1 == ex::apply(f_int_0, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{};
-        auto fp = &f_int_0;
-        assert(1 == ex::apply(fp, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{};
-        A_int_0 a;
-        assert(1 == ex::apply(a, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{};
-        A_int_0 const a;
-        assert(2 == ex::apply(a, t));
-        assert(count == 2);
-    }
-}
-
-template <class Tuple>
-void test_int_1()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{1};
-        assert(1 == ex::apply(f_int_1, t));
-        assert(count == 1);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{2};
-        int (*fp)(int) = f_int_1;
-        assert(2 == ex::apply(fp, t));
-        assert(count == 2);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{3};
-        A_int_1 fn;
-        assert(3 == ex::apply(fn, t));
-        assert(count == 3);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{4};
-        A_int_1 const a;
-        assert(5 == ex::apply(a, t));
-        assert(count == 5);
-    }
-}
-
-template <class Tuple>
-void test_int_2()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{1, 2};
-        assert(3 == ex::apply(f_int_2, t));
-        assert(count == 3);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{2, 3};
-        auto fp = &f_int_2;
-        assert(5 == ex::apply(fp, t));
-        assert(count == 5);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{3, 4};
-        A_int_2 a;
-        assert(7 == ex::apply(a, t));
-        assert(count == 7);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{4, 5};
-        A_int_2 const a;
-        assert(10 == ex::apply(a, t));
-        assert(count == 10);
-    }
-}
-
-template <class Tuple>
-void test_int_3()
-{
-    count = 0;
-    // function
-    {
-        Tuple t{1, 2, 3};
-        assert(6 == ex::apply(f_int_3, t));
-        assert(count == 6);
-    }
-    count = 0;
-    // function pointer
-    {
-        Tuple t{2, 3, 4};
-        auto fp = &f_int_3;
-        assert(9 == ex::apply(fp, t));
-        assert(count == 9);
-    }
-    count = 0;
-    // functor
-    {
-        Tuple t{3, 4, 5};
-        A_int_3 a;
-        assert(12 == ex::apply(a, t));
-        assert(count == 12);
-    }
-    count = 0;
-    // const functor
-    {
-        Tuple t{4, 5, 6};
-        A_int_3 const a;
-        assert(16 == ex::apply(a, t));
-        assert(count == 16);
-    }
-}
-
-template <class Tuple>
-void test_0()
-{
-    test_void_0<Tuple>();
-    test_int_0<Tuple>();
-}
-
-template <class Tuple>
-void test_1()
-{
-    test_void_1<Tuple>();
-    test_int_1<Tuple>();
-}
-
-template <class Tuple>
-void test_2()
-{
-    test_void_2<Tuple>();
-    test_int_2<Tuple>();
-}
-
-template <class Tuple>
-void test_3()
-{
-    test_void_3<Tuple>();
-    test_int_3<Tuple>();
-}
-
-int main()
-{
-    test_0<std::tuple<>>();
-
-    test_1<std::tuple<int>>();
-    test_1<std::array<int, 1>>();
-
-    test_2<std::tuple<int, int>>();
-    test_2<std::pair<int, int>>();
-    test_2<std::array<int, 2>>();
-
-    test_3<std::tuple<int, int, int>>();
-    test_3<std::array<int, 3>>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v.fail.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple_size_v.fail.cpp
deleted file mode 100644
index a25b18cf538..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v.fail.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
-
-// Test with reference
-
-#include <experimental/tuple>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    auto x = ex::tuple_size_v<std::tuple<> &>;
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v.pass.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple_size_v.pass.cpp
deleted file mode 100644
index d7a5aa679fc..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v.pass.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
-
-#include <experimental/tuple>
-#include <utility>
-#include <array>
-
-namespace ex = std::experimental;
-
-template <class Tuple, int Expect>
-void test()
-{
-    static_assert(ex::tuple_size_v<Tuple> == Expect, "");
-    static_assert(ex::tuple_size_v<Tuple> == std::tuple_size<Tuple>::value, "");
-    static_assert(ex::tuple_size_v<Tuple const> == std::tuple_size<Tuple>::value, "");
-    static_assert(ex::tuple_size_v<Tuple volatile> == std::tuple_size<Tuple>::value, "");
-    static_assert(ex::tuple_size_v<Tuple const volatile> == std::tuple_size<Tuple>::value, "");
-}
-
-int main()
-{
-    test<std::tuple<>, 0>();
-
-    test<std::tuple<int>, 1>();
-    test<std::array<int, 1>, 1>();
-
-    test<std::tuple<int, int>, 2>();
-    test<std::pair<int, int>, 2>();
-    test<std::array<int, 2>, 2>();
-
-    test<std::tuple<int, int, int>, 3>();
-    test<std::array<int, 3>, 3>();
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v_2.fail.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple_size_v_2.fail.cpp
deleted file mode 100644
index a95ac49ff45..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v_2.fail.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
-
-// Test with non tuple type
-
-#include <experimental/tuple>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    auto x = ex::tuple_size_v<int>;
-}
diff --git a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v_3.fail.cpp b/libcxx/test/std/experimental/utilities/tuple/tuple_size_v_3.fail.cpp
deleted file mode 100644
index 7c2f0cc236f..00000000000
--- a/libcxx/test/std/experimental/utilities/tuple/tuple_size_v_3.fail.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11
-
-// <experimental/tuple>
-
-// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
-
-// Test with pointer
-
-#include <experimental/tuple>
-
-namespace ex = std::experimental;
-
-int main()
-{
-    auto x = ex::tuple_size_v<std::tuple<>*>;
-}