Move <optional> into include/experimental, and into the std::experimental namespace, since it's not part of C++14, but of an upcoming TS

llvm-svn: 194867

8 files changed, 110 insertions, 88 deletions

diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
index 2e69b30580a..071f5943b97 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -11,12 +11,14 @@
 
 // constexpr optional(const T& v);
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+
 class X
 {
     int i_;
@@ -52,12 +54,12 @@ int main()
     {
         typedef int T;
         constexpr T t(5);
-        constexpr std::optional<T> opt(t);
+        constexpr optional<T> opt(t);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 5, "");
 
         struct test_constexpr_ctor
-            : public std::optional<T>
+            : public optional<T>
         {
             constexpr test_constexpr_ctor(const T&) {}
         };
@@ -66,12 +68,12 @@ int main()
     {
         typedef double T;
         constexpr T t(3);
-        constexpr std::optional<T> opt(t);
+        constexpr optional<T> opt(t);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 3, "");
 
         struct test_constexpr_ctor
-            : public std::optional<T>
+            : public optional<T>
         {
             constexpr test_constexpr_ctor(const T&) {}
         };
@@ -80,19 +82,19 @@ int main()
     {
         typedef X T;
         const T t(3);
-        std::optional<T> opt(t);
+        optional<T> opt(t);
         assert(static_cast<bool>(opt) == true);
         assert(*opt == 3);
     }
     {
         typedef Y T;
         constexpr T t(3);
-        constexpr std::optional<T> opt(t);
+        constexpr optional<T> opt(t);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 3, "");
 
         struct test_constexpr_ctor
-            : public std::optional<T>
+            : public optional<T>
         {
             constexpr test_constexpr_ctor(const T&) {}
         };
@@ -103,7 +105,7 @@ int main()
         try
         {
             const T t(3);
-            std::optional<T> opt(t);
+            optional<T> opt(t);
             assert(false);
         }
         catch (int i)
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 84319ad15ea..8726f95a00c 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -11,20 +11,22 @@
 
 // optional(const optional<T>& rhs);
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+
 template <class T>
 void
-test(const std::optional<T>& rhs, bool is_going_to_throw = false)
+test(const optional<T>& rhs, bool is_going_to_throw = false)
 {
     bool rhs_engaged = static_cast<bool>(rhs);
     try
     {
-        std::optional<T> lhs = rhs;
+        optional<T> lhs = rhs;
         assert(is_going_to_throw == false);
         assert(static_cast<bool>(lhs) == rhs_engaged);
         if (rhs_engaged)
@@ -80,42 +82,42 @@ int main()
 #if _LIBCPP_STD_VER > 11
     {
         typedef int T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef int T;
-        std::optional<T> rhs(3);
+        optional<T> rhs(3);
         test(rhs);
     }
     {
         typedef X T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef X T;
-        std::optional<T> rhs(X(3));
+        optional<T> rhs(X(3));
         test(rhs);
     }
     {
         typedef Y T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef Y T;
-        std::optional<T> rhs(Y(3));
+        optional<T> rhs(Y(3));
         test(rhs);
     }
     {
         typedef Z T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef Z T;
-        std::optional<T> rhs(Z(3));
+        optional<T> rhs(Z(3));
         test(rhs, true);
     }
 #endif  // _LIBCPP_STD_VER > 11
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
index 5f9c5af5a29..6a1763de22b 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
@@ -11,12 +11,14 @@
 
 // constexpr optional() noexcept;
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+
 template <class Opt>
 void
 test_constexpr()
@@ -58,8 +60,8 @@ struct X
 int main()
 {
 #if _LIBCPP_STD_VER > 11
-    test_constexpr<std::optional<int>>();
-    test_constexpr<std::optional<int*>>();
-    test<std::optional<X>>();
+    test_constexpr<optional<int>>();
+    test_constexpr<optional<int*>>();
+    test<optional<X>>();
 #endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
index db1b62970b2..412c993ffbd 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
@@ -12,12 +12,16 @@
 // template <class... Args>
 //   constexpr explicit optional(in_place_t, Args&&... args);
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+using std::experimental::in_place_t;
+using std::experimental::in_place;
+
 class X
 {
     int i_;
@@ -60,76 +64,76 @@ int main()
 {
 #if _LIBCPP_STD_VER > 11
     {
-        constexpr std::optional<int> opt(std::in_place, 5);
+        constexpr optional<int> opt(in_place, 5);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 5, "");
 
         struct test_constexpr_ctor
-            : public std::optional<int>
+            : public optional<int>
         {
-            constexpr test_constexpr_ctor(std::in_place_t, int i) 
-                : std::optional<int>(std::in_place, i) {}
+            constexpr test_constexpr_ctor(in_place_t, int i) 
+                : optional<int>(in_place, i) {}
         };
 
     }
     {
-        const std::optional<X> opt(std::in_place);
+        const optional<X> opt(in_place);
         assert(static_cast<bool>(opt) == true);
         assert(*opt == X());
     }
     {
-        const std::optional<X> opt(std::in_place, 5);
+        const optional<X> opt(in_place, 5);
         assert(static_cast<bool>(opt) == true);
         assert(*opt == X(5));
     }
     {
-        const std::optional<X> opt(std::in_place, 5, 4);
+        const optional<X> opt(in_place, 5, 4);
         assert(static_cast<bool>(opt) == true);
         assert(*opt == X(5, 4));
     }
     {
-        constexpr std::optional<Y> opt(std::in_place);
+        constexpr optional<Y> opt(in_place);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == Y(), "");
 
         struct test_constexpr_ctor
-            : public std::optional<Y>
+            : public optional<Y>
         {
-            constexpr test_constexpr_ctor(std::in_place_t) 
-                : std::optional<Y>(std::in_place) {}
+            constexpr test_constexpr_ctor(in_place_t) 
+                : optional<Y>(in_place) {}
         };
 
     }
     {
-        constexpr std::optional<Y> opt(std::in_place, 5);
+        constexpr optional<Y> opt(in_place, 5);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == Y(5), "");
 
         struct test_constexpr_ctor
-            : public std::optional<Y>
+            : public optional<Y>
         {
-            constexpr test_constexpr_ctor(std::in_place_t, int i) 
-                : std::optional<Y>(std::in_place, i) {}
+            constexpr test_constexpr_ctor(in_place_t, int i) 
+                : optional<Y>(in_place, i) {}
         };
 
     }
     {
-        constexpr std::optional<Y> opt(std::in_place, 5, 4);
+        constexpr optional<Y> opt(in_place, 5, 4);
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == Y(5, 4), "");
 
         struct test_constexpr_ctor
-            : public std::optional<Y>
+            : public optional<Y>
         {
-            constexpr test_constexpr_ctor(std::in_place_t, int i, int j) 
-                : std::optional<Y>(std::in_place, i, j) {}
+            constexpr test_constexpr_ctor(in_place_t, int i, int j) 
+                : optional<Y>(in_place, i, j) {}
         };
 
     }
     {
         try
         {
-            const std::optional<Z> opt(std::in_place, 1);
+            const optional<Z> opt(in_place, 1);
             assert(false);
         }
         catch (int i)
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
index 076554a407d..98cb929dc51 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
@@ -13,13 +13,17 @@
 //     constexpr
 //     explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <vector>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+using std::experimental::in_place_t;
+using std::experimental::in_place;
+
 class X
 {
     int i_;
@@ -70,39 +74,39 @@ int main()
 #if _LIBCPP_STD_VER > 11
     {
         static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, "");
-        static_assert(!std::is_constructible<std::optional<X>, std::initializer_list<int>&>::value, "");
+        static_assert(!std::is_constructible<optional<X>, std::initializer_list<int>&>::value, "");
     }
     {
-        std::optional<std::vector<int>> opt(std::in_place, {3, 1});
+        optional<std::vector<int>> opt(in_place, {3, 1});
         assert(static_cast<bool>(opt) == true);
         assert((*opt == std::vector<int>{3, 1}));
         assert(opt->size() == 2);
     }
     {
-        std::optional<std::vector<int>> opt(std::in_place, {3, 1}, std::allocator<int>());
+        optional<std::vector<int>> opt(in_place, {3, 1}, std::allocator<int>());
         assert(static_cast<bool>(opt) == true);
         assert((*opt == std::vector<int>{3, 1}));
         assert(opt->size() == 2);
     }
     {
-        static_assert(std::is_constructible<std::optional<Y>, std::initializer_list<int>&>::value, "");
-        constexpr std::optional<Y> opt(std::in_place, {3, 1});
+        static_assert(std::is_constructible<optional<Y>, std::initializer_list<int>&>::value, "");
+        constexpr optional<Y> opt(in_place, {3, 1});
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == Y{3, 1}, "");
 
         struct test_constexpr_ctor
-            : public std::optional<Y>
+            : public optional<Y>
         {
-            constexpr test_constexpr_ctor(std::in_place_t, std::initializer_list<int> i) 
-                : std::optional<Y>(std::in_place, i) {}
+            constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) 
+                : optional<Y>(in_place, i) {}
         };
 
     }
     {
-        static_assert(std::is_constructible<std::optional<Z>, std::initializer_list<int>&>::value, "");
+        static_assert(std::is_constructible<optional<Z>, std::initializer_list<int>&>::value, "");
         try
         {
-            std::optional<Z> opt(std::in_place, {3, 1});
+            optional<Z> opt(in_place, {3, 1});
             assert(false);
         }
         catch (int i)
@@ -111,10 +115,10 @@ int main()
         }
 
         struct test_constexpr_ctor
-            : public std::optional<Z>
+            : public optional<Z>
         {
-            constexpr test_constexpr_ctor(std::in_place_t, std::initializer_list<int> i) 
-                : std::optional<Z>(std::in_place, i) {}
+            constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) 
+                : optional<Z>(in_place, i) {}
         };
 
     }
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index 70004fd8655..b320c95c582 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -11,22 +11,24 @@
 
 // optional(optional<T>&& rhs) noexcept(is_nothrow_move_constructible<T>::value);
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+
 template <class T>
 void
-test(std::optional<T>& rhs, bool is_going_to_throw = false)
+test(optional<T>& rhs, bool is_going_to_throw = false)
 {
-    static_assert(std::is_nothrow_move_constructible<std::optional<T>>::value ==
+    static_assert(std::is_nothrow_move_constructible<optional<T>>::value ==
                   std::is_nothrow_move_constructible<T>::value, "");
     bool rhs_engaged = static_cast<bool>(rhs);
     try
     {
-        std::optional<T> lhs = std::move(rhs);
+        optional<T> lhs = std::move(rhs);
         assert(is_going_to_throw == false);
         assert(static_cast<bool>(lhs) == rhs_engaged);
     }
@@ -80,42 +82,42 @@ int main()
 #if _LIBCPP_STD_VER > 11
     {
         typedef int T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef int T;
-        std::optional<T> rhs(3);
+        optional<T> rhs(3);
         test(rhs);
     }
     {
         typedef X T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef X T;
-        std::optional<T> rhs(X(3));
+        optional<T> rhs(X(3));
         test(rhs);
     }
     {
         typedef Y T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef Y T;
-        std::optional<T> rhs(Y(3));
+        optional<T> rhs(Y(3));
         test(rhs);
     }
     {
         typedef Z T;
-        std::optional<T> rhs;
+        optional<T> rhs;
         test(rhs);
     }
     {
         typedef Z T;
-        std::optional<T> rhs(Z(3));
+        optional<T> rhs(Z(3));
         test(rhs, true);
     }
 #endif  // _LIBCPP_STD_VER > 11
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
index 0d0f1e9a216..c307a2e1e25 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
@@ -11,18 +11,22 @@
 
 // constexpr optional(nullopt_t) noexcept;
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+using std::experimental::nullopt_t;
+using std::experimental::nullopt;
+
 template <class Opt>
 void
 test_constexpr()
 {
-    static_assert(noexcept(Opt(std::nullopt)), "");
-    constexpr Opt opt(std::nullopt);
+    static_assert(noexcept(Opt(nullopt)), "");
+    constexpr Opt opt(nullopt);
     static_assert(static_cast<bool>(opt) == false, "");
 
     struct test_constexpr_ctor
@@ -36,8 +40,8 @@ template <class Opt>
 void
 test()
 {
-    static_assert(noexcept(Opt(std::nullopt)), "");
-    Opt opt(std::nullopt);
+    static_assert(noexcept(Opt(nullopt)), "");
+    Opt opt(nullopt);
     assert(static_cast<bool>(opt) == false);
 
     struct test_constexpr_ctor
@@ -57,8 +61,8 @@ struct X
 int main()
 {
 #if _LIBCPP_STD_VER > 11
-    test_constexpr<std::optional<int>>();
-    test_constexpr<std::optional<int*>>();
-    test<std::optional<X>>();
+    test_constexpr<optional<int>>();
+    test_constexpr<optional<int*>>();
+    test<optional<X>>();
 #endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
index c07dd634398..ac52a42d595 100644
--- a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -11,12 +11,14 @@
 
 // constexpr optional(T&& v);
 
-#include <optional>
+#include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 #if _LIBCPP_STD_VER > 11
 
+using std::experimental::optional;
+
 class X
 {
     int i_;
@@ -52,42 +54,42 @@ int main()
 #if _LIBCPP_STD_VER > 11
     {
         typedef int T;
-        constexpr std::optional<T> opt(T(5));
+        constexpr optional<T> opt(T(5));
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 5, "");
 
         struct test_constexpr_ctor
-            : public std::optional<T>
+            : public optional<T>
         {
             constexpr test_constexpr_ctor(T&&) {}
         };
     }
     {
         typedef double T;
-        constexpr std::optional<T> opt(T(3));
+        constexpr optional<T> opt(T(3));
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 3, "");
 
         struct test_constexpr_ctor
-            : public std::optional<T>
+            : public optional<T>
         {
             constexpr test_constexpr_ctor(T&&) {}
         };
     }
     {
         typedef X T;
-        std::optional<T> opt(T(3));
+        optional<T> opt(T(3));
         assert(static_cast<bool>(opt) == true);
         assert(*opt == 3);
     }
     {
         typedef Y T;
-        constexpr std::optional<T> opt(T(3));
+        constexpr optional<T> opt(T(3));
         static_assert(static_cast<bool>(opt) == true, "");
         static_assert(*opt == 3, "");
 
         struct test_constexpr_ctor
-            : public std::optional<T>
+            : public optional<T>
         {
             constexpr test_constexpr_ctor(T&&) {}
         };
@@ -96,7 +98,7 @@ int main()
         typedef Z T;
         try
         {
-            std::optional<T> opt(T(3));
+            optional<T> opt(T(3));
             assert(false);
         }
         catch (int i)