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

7 files changed, 0 insertions, 1432 deletions

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>>();
-}