Implement C++17 <variant>. Patch from Michael Park!

This patch was reviewed as https://reviews.llvm.org/D23263.

llvm-svn: 288547

5 files changed, 54 insertions, 51 deletions

diff --git a/libcxx/test/std/utilities/variant/variant.get/get_if_index.pass.cpp b/libcxx/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
index 2ea88e346ae..94cc08031fd 100644
--- a/libcxx/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
@@ -32,17 +32,17 @@ void test_const_get_if() {
     static_assert(std::get_if<0>(v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
     ASSERT_NOEXCEPT(std::get_if<0>(&v));
-    ASSERT_SAME_TYPE(decltype(std::get_if<0>(&v)), int const *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<0>(&v)), const int *);
     static_assert(*std::get_if<0>(&v) == 42, "");
     static_assert(std::get_if<1>(&v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), long const *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), const long *);
     static_assert(*std::get_if<1>(&v) == 42, "");
     static_assert(std::get_if<0>(&v) == nullptr, "");
   }
@@ -87,9 +87,9 @@ void test_get_if() {
     assert(std::get_if<1>(&v) == nullptr);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), long *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), const long *);
     assert(*std::get_if<1>(&v) == 42);
     assert(std::get_if<0>(&v) == nullptr);
   }
diff --git a/libcxx/test/std/utilities/variant/variant.get/get_if_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
index 59ddef3f9b3..a8cc664ef11 100644
--- a/libcxx/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
@@ -30,18 +30,18 @@ void test_const_get_if() {
     static_assert(std::get_if<int>(v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
     ASSERT_NOEXCEPT(std::get_if<int>(&v));
-    ASSERT_SAME_TYPE(decltype(std::get_if<int>(&v)), int const *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<int>(&v)), const int *);
     static_assert(*std::get_if<int>(&v) == 42, "");
-    static_assert(std::get_if<long>(&v) == nullptr, "");
+    static_assert(std::get_if<const long>(&v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<long>(&v)), long const *);
-    static_assert(*std::get_if<long>(&v) == 42, "");
+    ASSERT_SAME_TYPE(decltype(std::get_if<const long>(&v)), const long *);
+    static_assert(*std::get_if<const long>(&v) == 42, "");
     static_assert(std::get_if<int>(&v) == nullptr, "");
   }
 // FIXME: Remove these once reference support is reinstated
@@ -77,18 +77,18 @@ void test_get_if() {
     assert(std::get_if<int>(v) == nullptr);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOEXCEPT(std::get_if<int>(&v));
     ASSERT_SAME_TYPE(decltype(std::get_if<int>(&v)), int *);
     assert(*std::get_if<int>(&v) == 42);
-    assert(std::get_if<long>(&v) == nullptr);
+    assert(std::get_if<const long>(&v) == nullptr);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<long>(&v)), long *);
-    assert(*std::get_if<long>(&v) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get_if<const long>(&v)), const long *);
+    assert(*std::get_if<const long>(&v) == 42);
     assert(std::get_if<int>(&v) == nullptr);
   }
 // FIXME: Remove these once reference support is reinstated
diff --git a/libcxx/test/std/utilities/variant/variant.get/get_index.pass.cpp b/libcxx/test/std/utilities/variant/variant.get/get_index.pass.cpp
index 657db9b0933..669da5305bd 100644
--- a/libcxx/test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -34,16 +34,16 @@
 
 void test_const_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
-    // ASSERT_NOT_NOEXCEPT(std::get<0>(v));
-    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int const &);
+    ASSERT_NOT_NOEXCEPT(std::get<0>(v));
+    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     static_assert(std::get<0>(v) == 42, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), long const &);
+    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
     static_assert(std::get<1>(v) == 42, "");
   }
 // FIXME: Remove these once reference support is reinstated
@@ -74,16 +74,16 @@ void test_const_lvalue_get() {
 
 void test_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(v));
     ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
     assert(std::get<0>(v) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), long &);
+    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
     assert(std::get<1>(v) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
@@ -121,16 +121,16 @@ void test_lvalue_get() {
 
 void test_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &&);
     assert(std::get<0>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), long &&);
+    ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), const long &&);
     assert(std::get<1>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
@@ -170,14 +170,14 @@ void test_rvalue_get() {
 
 void test_const_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     const V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &&);
     assert(std::get<0>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     const V v(42l);
     ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), const long &&);
     assert(std::get<1>(std::move(v)) == 42);
@@ -234,7 +234,7 @@ void test_throws_for_all_value_categories() {
     using Idx = decltype(idx);
     try {
       std::get<Idx::value>(std::forward<decltype(v)>(v));
-    } catch (std::bad_variant_access const &) {
+    } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
     }
diff --git a/libcxx/test/std/utilities/variant/variant.get/get_type.pass.cpp b/libcxx/test/std/utilities/variant/variant.get/get_type.pass.cpp
index 11991dca5b6..497f0040133 100644
--- a/libcxx/test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -28,17 +28,17 @@
 
 void test_const_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
-    // ASSERT_NOT_NOEXCEPT(std::get<int>(v));
-    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int const &);
+    ASSERT_NOT_NOEXCEPT(std::get<int>(v));
+    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     static_assert(std::get<int>(v) == 42, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(v)), long const &);
-    static_assert(std::get<long>(v) == 42, "");
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(v)), const long &);
+    static_assert(std::get<const long>(v) == 42, "");
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
@@ -68,17 +68,17 @@ void test_const_lvalue_get() {
 
 void test_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(v));
     ASSERT_SAME_TYPE(decltype(std::get<int>(v)), int &);
     assert(std::get<int>(v) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(v)), long &);
-    assert(std::get<long>(v) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(v)), const long &);
+    assert(std::get<const long>(v) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
@@ -115,17 +115,18 @@ void test_lvalue_get() {
 
 void test_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<int>(std::move(v))), int &&);
     assert(std::get<int>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(std::move(v))), long &&);
-    assert(std::get<long>(std::move(v)) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(std::move(v))),
+                     const long &&);
+    assert(std::get<const long>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
@@ -166,17 +167,18 @@ void test_rvalue_get() {
 
 void test_const_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     const V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<int>(std::move(v))), const int &&);
     assert(std::get<int>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     const V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(std::move(v))), const long &&);
-    assert(std::get<long>(std::move(v)) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(std::move(v))),
+                     const long &&);
+    assert(std::get<const long>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
@@ -232,7 +234,7 @@ void test_throws_for_all_value_categories() {
     using Idx = decltype(idx);
     try {
       std::get<typename Idx::type>(std::forward<decltype(v)>(v));
-    } catch (std::bad_variant_access const &) {
+    } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
     }
diff --git a/libcxx/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp b/libcxx/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
index 34843869bb8..103b0498197 100644
--- a/libcxx/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
+++ b/libcxx/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
@@ -15,6 +15,7 @@
 // template <class T, class... Types>
 // constexpr bool holds_alternative(const variant<Types...>& v) noexcept;
 
+#include "test_macros.h"
 #include <variant>
 
 int main() {
@@ -32,6 +33,6 @@ int main() {
   { // noexcept test
     using V = std::variant<int>;
     const V v;
-    static_assert(noexcept(std::holds_alternative<int>(v)), "must be noexcept");
+    ASSERT_NOEXCEPT(std::holds_alternative<int>(v));
   }
 }