[libc++][test] LWG2857 test coverage for variant

[EricWF]

Summary

As the saying goes, "works on my machine."

NOTE: libc++ variant does not yet implement LWG2857 and will not pass these tests; MSVC variant does.

Changes under TEST_VARIANT_HAS_NO_REFERENCES are dry-coded; I figure that's better than nothing.

[EricWF]

Give me a day to implement this in variant and then this should be ready to land.

[CaseyCarter]

In D32107#727751, @EricWF wrote:

Give me a day to implement this in variant and then this should be ready to land.

No rush; the patch isn't going anywhere ;)

[EricWF]

LGTM, Thanks @CaseyCarter.

I committed these tests and the changes to libc++'s variant in r300403.

I'm hijacking this revision so I can close it.

test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp

 // -*- 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.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// template <size_t I, class ...Args> void emplace(Args&&... args);
+// template <size_t I, class ...Args>
+//   variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "archetypes.hpp"
 #include "test_convertible.hpp"
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   }
 #endif
 }
 
 void test_basic() {
   {
     using V = std::variant<int>;
     V v(42);
-    v.emplace<0>();
+    auto& ref1 = v.emplace<0>();
+    static_assert(std::is_same_v<int&, decltype(ref1)>, "");
     assert(std::get<0>(v) == 0);
-    v.emplace<0>(42);
+    assert(&ref1 == &std::get<0>(v));
+    auto& ref2 = v.emplace<0>(42);
+    static_assert(std::is_same_v<int&, decltype(ref2)>, "");
     assert(std::get<0>(v) == 42);
+    assert(&ref2 == &std::get<0>(v));
   }
   {
     using V =
         std::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
     const int x = 100;
     V v(std::in_place_index<0>, -1);
     // default emplace a value
-    v.emplace<1>();
+    auto& ref1 = v.emplace<1>();
+    static_assert(std::is_same_v<long&, decltype(ref1)>, "");
     assert(std::get<1>(v) == 0);
-    v.emplace<2>(&x);
+    assert(&ref1 == &std::get<1>(v));
+    auto& ref2 = v.emplace<2>(&x);
+    static_assert(std::is_same_v<const void*&, decltype(ref2)>, "");
     assert(std::get<2>(v) == &x);
+    assert(&ref2 == &std::get<2>(v));
     // emplace with multiple args
-    v.emplace<4>(3, 'a');
+    auto& ref3 = v.emplace<4>(3, 'a');
+    static_assert(std::is_same_v<std::string&, decltype(ref3)>, "");
     assert(std::get<4>(v) == "aaa");
+    assert(&ref3 == &std::get<4>(v));
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int, long, const int &, int &&, TestTypes::NoCtors,
                            std::string>;
     const int x = 100;
     int y = 42;
     int z = 43;
     V v(std::in_place_index<0>, -1);
     // default emplace a value
-    v.emplace<1>();
+    auto& ref1 = v.emplace<1>();
+    static_assert(std::is_same_v<long&, decltype(ref1)>, "");
     assert(std::get<1>(v) == 0);
+    assert(&ref1 == &std::get<1>(v));
     // emplace a reference
-    v.emplace<2>(x);
+    auto& ref2 = v.emplace<2>(x);
+    static_assert(std::is_same_v<&, decltype(ref)>, "");
     assert(&std::get<2>(v) == &x);
+    assert(&ref2 == &std::get<2>(v));
     // emplace an rvalue reference
-    v.emplace<3>(std::move(y));
+    auto& ref3 = v.emplace<3>(std::move(y));
+    static_assert(std::is_same_v<&, decltype(ref)>, "");
     assert(&std::get<3>(v) == &y);
+    assert(&ref3 == &std::get<3>(v));
     // re-emplace a new reference over the active member
-    v.emplace<3>(std::move(z));
+    auto& ref4 = v.emplace<3>(std::move(z));
+    static_assert(std::is_same_v<&, decltype(ref)>, "");
     assert(&std::get<3>(v) == &z);
+    assert(&ref4 == &std::get<3>(v));
     // emplace with multiple args
-    v.emplace<5>(3, 'a');
+    auto& ref5 = v.emplace<5>(3, 'a');
+    static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
     assert(std::get<5>(v) == "aaa");
+    assert(&ref5 == &std::get<5>(v));
   }
 #endif
 }
 
 int main() {
   test_basic();
   test_emplace_sfinae();
 }

test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp

 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <size_t I, class U, class ...Args>
-// void emplace(initializer_list<U> il,Args&&... args);
+//   variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il,Args&&... args);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "archetypes.hpp"
 #include "test_convertible.hpp"
void test_emplace_sfinae() {
   static_assert(!emplace_exists<V, 3, int>(), "args don't match");
   static_assert(!emplace_exists<V, 3, IL>(), "too few args");
   static_assert(!emplace_exists<V, 3, IL, int, int>(), "too many args");
 }
 
 void test_basic() {
   using V = std::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
   V v;
-  v.emplace<1>({1, 2, 3});
+  auto& ref1 = v.emplace<1>({1, 2, 3});
+  static_assert(std::is_same_v<InitList&, decltype(ref1)>, "");
   assert(std::get<1>(v).size == 3);
-  v.emplace<2>({1, 2, 3, 4}, 42);
+  assert(&ref1 == &std::get<1>(v));
+  auto& ref2 = v.emplace<2>({1, 2, 3, 4}, 42);
+  static_assert(std::is_same_v<InitListArg&, decltype(ref2)>, "");
   assert(std::get<2>(v).size == 4);
   assert(std::get<2>(v).value == 42);
-  v.emplace<1>({1});
+  assert(&ref2 == &std::get<2>(v));
+  auto& ref3 = v.emplace<1>({1});
+  static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
   assert(std::get<1>(v).size == 1);
+  assert(&ref3 == &std::get<1>(v));
 }
 
 int main() {
   test_basic();
   test_emplace_sfinae();
 }

test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp

 // -*- 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.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// template <class T, class ...Args> void emplace(Args&&... args);
+// template <class T, class ...Args> T& emplace(Args&&... args);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "archetypes.hpp"
 #include "test_convertible.hpp"
static_assert(!emplace_exists<V, TestTypes::NoCtors>(),
                 "cannot construct void");
 #endif
 }
 
 void test_basic() {
   {
     using V = std::variant<int>;
     V v(42);
-    v.emplace<int>();
+    auto& ref1 = v.emplace<int>();
+    static_assert(std::is_same_v<int&, decltype(ref1)>, "");
     assert(std::get<0>(v) == 0);
-    v.emplace<int>(42);
+    assert(&ref1 == &std::get<0>(v));
+    auto& ref2 = v.emplace<int>(42);
+    static_assert(std::is_same_v<int&, decltype(ref2)>, "");
     assert(std::get<0>(v) == 42);
+    assert(&ref2 == &std::get<0>(v));
   }
   {
     using V =
         std::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
     const int x = 100;
     V v(std::in_place_type<int>, -1);
     // default emplace a value
-    v.emplace<long>();
+    auto& ref1 = v.emplace<long>();
+    static_assert(std::is_same_v<long&, decltype(ref1)>, "");
     assert(std::get<1>(v) == 0);
-    v.emplace<const void *>(&x);
+    assert(&ref1 == &std::get<1>(v));
+    auto& ref2 = v.emplace<const void *>(&x);
+    static_assert(std::is_same_v<const void *&, decltype(ref2)>, "");
     assert(std::get<2>(v) == &x);
+    assert(&ref2 == &std::get<2>(v));
     // emplace with multiple args
-    v.emplace<std::string>(3, 'a');
+    auto& ref3 = v.emplace<std::string>(3, 'a');
+    static_assert(std::is_same_v<std::string&, decltype(ref3)>, "");
     assert(std::get<4>(v) == "aaa");
+    assert(&ref3 == &std::get<4>(v));
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int, long, const int &, int &&, TestTypes::NoCtors,
                            std::string>;
     const int x = 100;
     int y = 42;
     int z = 43;
     V v(std::in_place_index<0>, -1);
     // default emplace a value
-    v.emplace<long>();
+    auto& ref1 = v.emplace<long>();
+    static_assert(std::is_same_v<long&, decltype(ref1)>, "");
     assert(std::get<long>(v) == 0);
+    assert(&ref1 == &std::get<long>(v));
     // emplace a reference
-    v.emplace<const int &>(x);
+    auto& ref2 = v.emplace<const int &>(x);
+    static_assert(std::is_same_v<const int&, decltype(ref2)>, "");
     assert(&std::get<const int &>(v) == &x);
+    assert(&ref2 == &std::get<const int &>(v));
     // emplace an rvalue reference
-    v.emplace<int &&>(std::move(y));
+    auto& ref3 = v.emplace<int &&>(std::move(y));
+    static_assert(std::is_same_v<int &&, decltype(ref3)>, "");
     assert(&std::get<int &&>(v) == &y);
+    assert(&ref3 == &std::get<int &&>(v));
     // re-emplace a new reference over the active member
-    v.emplace<int &&>(std::move(z));
+    auto& ref4 = v.emplace<int &&>(std::move(z));
+    static_assert(std::is_same_v<int &, decltype(ref4)>, "");
     assert(&std::get<int &&>(v) == &z);
+    assert(&ref4 == &std::get<int &&>(v));
     // emplace with multiple args
-    v.emplace<std::string>(3, 'a');
+    auto& ref5 = v.emplace<std::string>(3, 'a');
+    static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
     assert(std::get<std::string>(v) == "aaa");
+    assert(&ref5 == &std::get<std::string>(v));
   }
 #endif
 }
 
 int main() {
   test_basic();
   test_emplace_sfinae();
 }

test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp

 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class T, class U, class ...Args>
-// void emplace(initializer_list<U> il,Args&&... args);
+//   T& emplace(initializer_list<U> il,Args&&... args);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "archetypes.hpp"
 #include "test_convertible.hpp"
void test_emplace_sfinae() {
   static_assert(!emplace_exists<V, InitListArg, IL>(), "too few args");
   static_assert(!emplace_exists<V, InitListArg, IL, int, int>(),
                 "too many args");
 }
 
 void test_basic() {
   using V = std::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
   V v;
-  v.emplace<InitList>({1, 2, 3});
+  auto& ref1 = v.emplace<InitList>({1, 2, 3});
+  static_assert(std::is_same_v<InitList&,decltype(ref1)>, "");
   assert(std::get<InitList>(v).size == 3);
-  v.emplace<InitListArg>({1, 2, 3, 4}, 42);
+  assert(&ref1 == &std::get<InitList>(v));
+  auto& ref2 = v.emplace<InitListArg>({1, 2, 3, 4}, 42);
+  static_assert(std::is_same_v<InitListArg&,decltype(ref2)>, "");
   assert(std::get<InitListArg>(v).size == 4);
   assert(std::get<InitListArg>(v).value == 42);
-  v.emplace<InitList>({1});
+  assert(&ref == &std::get<InitListArg>(v));
+  auto& ref3 = v.emplace<InitList>({1});
+  static_assert(std::is_same_v<InitList&,decltype(ref3)>, "");
   assert(std::get<InitList>(v).size == 1);
+  assert(&ref3 == &std::get<InitList>(v));
 }
 
 int main() {
   test_basic();
   test_emplace_sfinae();
 }