[libcxx] Reorganize tests since the application of P0602R4

[ldionne]

Summary

P0602R4 makes the special member functions of optional and variant
conditionally trivial based on the types in the optional/variant.
We already implemented that, but the tests were organized as if this
were a non-standard extension. This patch reorganizes the tests in a
way that makes more sense since this is not an extension anymore.

[mclow.lists]

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp

56

For future proofing, we never explicitly test for unreleased standard versions .
Instead, we say TEST_STD_VER > 17

libcxx/www/upcoming_meeting.html

53 ↗

(On Diff #174826)

You don't have to edit this file.

[ldionne]

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp

56

Ah, sorry, it feels like you've told me before. Eventually I'll remember.

[ldionne]

Address Marshall's comments

[mclow.lists]

Sorry this took me so long.

libcxx/include/optional

public:
     template <class U>
       constexpr EXPLICIT optional(optional<U> &&);
 
     // 23.6.3.2, destructor
     ~optional();
 
     // 23.6.3.3, assignment
     optional &operator=(nullopt_t) noexcept;
-    optional &operator=(const optional &);
-    optional &operator=(optional &&) noexcept(see below );
+    optional &operator=(const optional &);                // constexpr in C++20
+    optional &operator=(optional &&) noexcept(see below); // constexpr in C++20
     template <class U = T> optional &operator=(U &&);
     template <class U> optional &operator=(const optional<U> &);
     template <class U> optional &operator=(optional<U> &&);
     template <class... Args> T& emplace(Args &&...);
     template <class U, class... Args>
       T& emplace(initializer_list<U>, Args &&...);
 
     // 23.6.3.4, swap

libcxx/include/variant

namespace std {
 
   // 20.7.2, class template variant
   template <class... Types>
   class variant {
   public:
 
     // 20.7.2.1, constructors
     constexpr variant() noexcept(see below);
-    variant(const variant&);
-    variant(variant&&) noexcept(see below);
+    variant(const variant&);                // constexpr in C++20
+    variant(variant&&) noexcept(see below); // constexpr in C++20
 
     template <class T> constexpr variant(T&&) noexcept(see below);
 
     template <class T, class... Args>
     constexpr explicit variant(in_place_type_t<T>, Args&&...);
 
     template <class T, class U, class... Args>
     constexpr explicit variant(
         in_place_type_t<T>, initializer_list<U>, Args&&...);
 
     template <size_t I, class... Args>
     constexpr explicit variant(in_place_index_t<I>, Args&&...);
 
     template <size_t I, class U, class... Args>
     constexpr explicit variant(
         in_place_index_t<I>, initializer_list<U>, Args&&...);
 
     // 20.7.2.2, destructor
     ~variant();
 
     // 20.7.2.3, assignment
-    variant& operator=(const variant&);
-    variant& operator=(variant&&) noexcept(see below);
+    variant& operator=(const variant&);                // constexpr in C++20
+    variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
 
     template <class T> variant& operator=(T&&) noexcept(see below);
 
     // 20.7.2.4, modifiers
     template <class T, class... Args>
     T& emplace(Args&&...);
 
     template <class T, class U, class... Args>

libcxx/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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
+
 // <optional>
 
+// This test asserts the triviality of special member functions of optional<T>
+// whenever T has these special member functions trivial. The goal of this test
+// is to make sure that we do not change the triviality of those, since that
+// constitues an ABI break (small enough optionals would be passed by registers).
+//
+// constexpr optional(const optional& rhs);
+// constexpr optional(optional&& rhs) noexcept(see below);
+// constexpr optional<T>& operator=(const optional& rhs);
+// constexpr optional<T>& operator=(optional&& rhs) noexcept(see below);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "archetypes.hpp"
 
 template <class T>
 struct SpecialMemberTest {
     using O = std::optional<T>;
 
-    static_assert(std::is_default_constructible_v<O>,
-        "optional is always default constructible.");
-    static_assert(std::is_copy_constructible_v<O> == std::is_copy_constructible_v<T>,
-        "optional<T> is copy constructible if and only if T is copy constructible.");
-    static_assert(std::is_move_constructible_v<O> ==
-        (std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>),
-        "optional<T> is move constructible if and only if T is copy or move constructible.");
-    static_assert(std::is_copy_assignable_v<O> ==
-        (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>),
-        "optional<T> is copy assignable if and only if T is both copy "
-        "constructible and copy assignable.");
-    static_assert(std::is_move_assignable_v<O> ==
-        ((std::is_move_constructible_v<T> && std::is_move_assignable_v<T>) ||
-         (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>)),
-        "optional<T> is move assignable if and only if T is both move constructible and "
-        "move assignable, or both copy constructible and copy assignable.");
-
-    // The following tests are for not-yet-standardized behavior (P0602):
     static_assert(std::is_trivially_destructible_v<O> ==
         std::is_trivially_destructible_v<T>,
         "optional<T> is trivially destructible if and only if T is.");
+
     static_assert(std::is_trivially_copy_constructible_v<O> ==
         std::is_trivially_copy_constructible_v<T>,
         "optional<T> is trivially copy constructible if and only if T is.");
+
     static_assert(std::is_trivially_move_constructible_v<O> ==
         std::is_trivially_move_constructible_v<T> ||
         (!std::is_move_constructible_v<T> && std::is_trivially_copy_constructible_v<T>),
         "optional<T> is trivially move constructible if T is trivially move constructible, "
         "or if T is trivially copy constructible and is not move constructible.");
+
     static_assert(std::is_trivially_copy_assignable_v<O> ==
         (std::is_trivially_destructible_v<T> &&
          std::is_trivially_copy_constructible_v<T> &&
          std::is_trivially_copy_assignable_v<T>),
         "optional<T> is trivially copy assignable if and only if T is trivially destructible, "
         "trivially copy constructible, and trivially copy assignable.");
+
     static_assert(std::is_trivially_move_assignable_v<O> ==
         (std::is_trivially_destructible_v<T> &&
          ((std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T>) ||
           ((!std::is_move_constructible_v<T> || !std::is_move_assignable_v<T>) &&
            std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_assignable_v<T>))),
         "optional<T> is trivially move assignable if T is trivially destructible, and either "
         "(1) trivially move constructible and trivially move assignable, or "
         "(2) not move constructible or not move assignable, and "

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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
 // <optional>
 
-// optional<T>& operator=(const optional<T>& rhs);
+// optional<T>& operator=(const optional<T>& rhs); // constexpr in C++20
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "archetypes.hpp"
 
constexpr bool assign_value(optional<Tp>&& lhs) {
     lhs = rhs;
     return lhs.has_value() && rhs.has_value() && *lhs == *rhs;
 }
 
 int main()
 {
     {
         using O = optional<int>;
+#if TEST_STD_VER > 17
         LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
         LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
         assert(assign_empty(O{42}));
         assert(assign_value(O{42}));
     }
     {
         using O = optional<TrivialTestTypes::TestType>;
+#if TEST_STD_VER > 17
         LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
         LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
         assert(assign_empty(O{42}));
         assert(assign_value(O{42}));
     }
     {
         using O = optional<TestTypes::TestType>;
         assert(assign_empty(O{42}));
         assert(assign_value(O{42}));
     }

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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
 // <optional>
 
 // optional<T>& operator=(optional<T>&& rhs)
 //     noexcept(is_nothrow_move_assignable<T>::value &&
-//              is_nothrow_move_constructible<T>::value);
+//              is_nothrow_move_constructible<T>::value); // constexpr in C++20
 
 #include <optional>
-#include <type_traits>
 #include <cassert>
+#include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 #include "archetypes.hpp"
 
 using std::optional;
 
 struct X
 {
struct X
     ~X() { assert(alive > 0); --alive; }
 };
 
 struct Y {};
 
 bool X::throw_now = false;
 int X::alive = 0;
 
+
+template <class Tp>
+constexpr bool assign_empty(optional<Tp>&& lhs) {
+    optional<Tp> rhs;
+    lhs = std::move(rhs);
+    return !lhs.has_value() && !rhs.has_value();
+}
+
+template <class Tp>
+constexpr bool assign_value(optional<Tp>&& lhs) {
+    optional<Tp> rhs(101);
+    lhs = std::move(rhs);
+    return lhs.has_value() && rhs.has_value() && *lhs == Tp{101};
+}
+
 int main()
 {
     {
         static_assert(std::is_nothrow_move_assignable<optional<int>>::value, "");
         optional<int> opt;
         constexpr optional<int> opt2;
         opt = std::move(opt2);
         static_assert(static_cast<bool>(opt2) == false, "");
int main()
         optional<int> opt(3);
         constexpr optional<int> opt2(2);
         opt = std::move(opt2);
         static_assert(static_cast<bool>(opt2) == true, "");
         static_assert(*opt2 == 2, "");
         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
         assert(*opt == *opt2);
     }
+    {
+        using O = optional<int>;
+#if TEST_STD_VER > 17
+        LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
+        LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
+        assert(assign_empty(O{42}));
+        assert(assign_value(O{42}));
+    }
+    {
+        using O = optional<TrivialTestTypes::TestType>;
+#if TEST_STD_VER > 17
+        LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
+        LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
+        assert(assign_empty(O{42}));
+        assert(assign_value(O{42}));
+    }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         static_assert(!std::is_nothrow_move_assignable<optional<X>>::value, "");
         X::alive = 0;
         X::throw_now = false;
         optional<X> opt;
         optional<X> opt2(X{});
         assert(X::alive == 1);

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-//                     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
-// <optional>
-
-// constexpr optional(const optional<T>& rhs);
-//   If is_trivially_copy_constructible_v<T> is true,
-//    this constructor shall be a constexpr constructor.
-
-#include <optional>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-struct S {
-    constexpr S()   : v_(0) {}
-    S(int v)        : v_(v) {}
-    S(const S &rhs) : v_(rhs.v_) {}  // make it not trivially copyable
-    int v_;
-};
-
-
-int main()
-{
-    static_assert (!std::is_trivially_copy_constructible_v<S>, "" );
-    constexpr std::optional<S> o1;
-    constexpr std::optional<S> o2 = o1;  // not constexpr
-}

libcxx/test/std/utilities/optional/optional.object/special_members.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <optional>
+
+// Make sure we properly generate special member functions for optional<T>
+// based on the properties of T itself.
+
+#include <optional>
+#include <type_traits>
+
+#include "archetypes.hpp"
+
+
+template <class T>
+struct SpecialMemberTest {
+    using O = std::optional<T>;
+
+    static_assert(std::is_default_constructible_v<O>,
+        "optional is always default constructible.");
+
+    static_assert(std::is_copy_constructible_v<O> == std::is_copy_constructible_v<T>,
+        "optional<T> is copy constructible if and only if T is copy constructible.");
+
+    static_assert(std::is_move_constructible_v<O> ==
+        (std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>),
+        "optional<T> is move constructible if and only if T is copy or move constructible.");
+
+    static_assert(std::is_copy_assignable_v<O> ==
+        (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>),
+        "optional<T> is copy assignable if and only if T is both copy "
+        "constructible and copy assignable.");
+
+    static_assert(std::is_move_assignable_v<O> ==
+        ((std::is_move_constructible_v<T> && std::is_move_assignable_v<T>) ||
+         (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>)),
+        "optional<T> is move assignable if and only if T is both move constructible and "
+        "move assignable, or both copy constructible and copy assignable.");
+};
+
+template <class ...Args> static void sink(Args&&...) {}
+
+template <class ...TestTypes>
+struct DoTestsMetafunction {
+    DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
+};
+
+int main() {
+    sink(
+        ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{}
+    );
+}

libcxx/test/std/utilities/optional/optional.object/triviality.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     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, c++17
+
+// <optional>
+
+// The following special member functions should propagate the triviality of
+// the element held in the optional (see P0602R4):
+//
+// constexpr optional(const optional& rhs);
+// constexpr optional(optional&& rhs) noexcept(see below);
+// constexpr optional<T>& operator=(const optional& rhs);
+// constexpr optional<T>& operator=(optional&& rhs) noexcept(see below);
+
+
+#include <optional>
+#include <type_traits>
+
+#include "archetypes.hpp"
+
+
+constexpr bool implies(bool p, bool q) {
+    return !p || q;
+}
+
+template <class T>
+struct SpecialMemberTest {
+    using O = std::optional<T>;
+
+    static_assert(implies(std::is_trivially_copy_constructible_v<T>,
+                          std::is_trivially_copy_constructible_v<O>),
+        "optional<T> is trivially copy constructible if T is trivially copy constructible.");
+
+    static_assert(implies(std::is_trivially_move_constructible_v<T>,
+                          std::is_trivially_move_constructible_v<O>),
+        "optional<T> is trivially move constructible if T is trivially move constructible");
+
+    static_assert(implies(std::is_trivially_copy_constructible_v<T> &&
+                          std::is_trivially_copy_assignable_v<T> &&
+                          std::is_trivially_destructible_v<T>,
+
+                          std::is_trivially_copy_assignable_v<O>),
+        "optional<T> is trivially copy assignable if T is "
+        "trivially copy constructible, "
+        "trivially copy assignable, and "
+        "trivially destructible");
+
+    static_assert(implies(std::is_trivially_move_constructible_v<T> &&
+                          std::is_trivially_move_assignable_v<T> &&
+                          std::is_trivially_destructible_v<T>,
+
+                          std::is_trivially_move_assignable_v<O>),
+        "optional<T> is trivially move assignable if T is "
+        "trivially move constructible, "
+        "trivially move assignable, and"
+        "trivially destructible.");
+};
+
+template <class ...Args> static void sink(Args&&...) {}
+
+template <class ...TestTypes>
+struct DoTestsMetafunction {
+    DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
+};
+
+struct TrivialMoveNonTrivialCopy {
+    TrivialMoveNonTrivialCopy() = default;
+    TrivialMoveNonTrivialCopy(const TrivialMoveNonTrivialCopy&) {}
+    TrivialMoveNonTrivialCopy(TrivialMoveNonTrivialCopy&&) = default;
+    TrivialMoveNonTrivialCopy& operator=(const TrivialMoveNonTrivialCopy&) { return *this; }
+    TrivialMoveNonTrivialCopy& operator=(TrivialMoveNonTrivialCopy&&) = default;
+};
+
+struct TrivialCopyNonTrivialMove {
+    TrivialCopyNonTrivialMove() = default;
+    TrivialCopyNonTrivialMove(const TrivialCopyNonTrivialMove&) = default;
+    TrivialCopyNonTrivialMove(TrivialCopyNonTrivialMove&&) {}
+    TrivialCopyNonTrivialMove& operator=(const TrivialCopyNonTrivialMove&) = default;
+    TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
+};
+
+int main() {
+    sink(
+        ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
+        DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
+    );
+}

libcxx/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp

 // XFAIL: availability=macosx10.9
 // XFAIL: availability=macosx10.8
 // XFAIL: availability=macosx10.7
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant& operator=(variant const&);
+// variant& operator=(variant const&); // constexpr in C++20
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 
void test_copy_assignment_sfinae() {
     using V = std::variant<int, MoveOnly>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, NTCopyAssign>;
     static_assert(!std::is_trivially_copy_assignable<V>::value, "");
     static_assert(std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, TCopyAssign>;
     static_assert(std::is_trivially_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, TCopyAssignNTMoveAssign>;
     static_assert(std::is_trivially_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, CopyOnly>;
     static_assert(std::is_trivially_copy_assignable<V>::value, "");
   }
+#endif // > C++17
 }
 
 void test_copy_assignment_empty_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, long, MET>;
     V v1(std::in_place_index<0>);
try {
       assert(false);
     } catch (...) {
     }
     assert(v1.index() == 1);
     assert(&std::get<1>(v1) == &mref);
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<int> operator()() const {
         using V = std::variant<int>;
         V v(43);
         V v2(42);
         v = v2;
         return {v.index(), std::get<0>(v)};
struct {
         v = v2;
         return {v.index(), std::get<1>(v).value};
       }
     } test;
     constexpr auto result = test();
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_copy_assignment_different_index() {
   {
     using V = std::variant<int, long, unsigned>;
     V v1(43);
     V v2(42l);
     V &vref = (v1 = v2);
#ifndef TEST_HAS_NO_EXCEPTIONS
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
     assert(v2.index() == 2);
     assert(std::get<2>(v2) == "hello");
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<long> operator()() const {
         using V = std::variant<int, long, unsigned>;
         V v(43);
         V v2(42l);
         v = v2;
         return {v.index(), std::get<1>(v)};
struct {
         v = v2;
         return {v.index(), std::get<1>(v).value};
       }
     } test;
     constexpr auto result = test();
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 template <size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_extension_imp(
+constexpr bool test_constexpr_assign_imp(
     std::variant<long, void*, int>&& v, ValueType&& new_value)
 {
   const std::variant<long, void*, int> cp(
       std::forward<ValueType>(new_value));
   v = cp;
   return v.index() == NewIdx &&
         std::get<NewIdx>(v) == std::get<NewIdx>(cp);
 }
 
-void test_constexpr_copy_assignment_extension() {
-  // The following tests are for not-yet-standardized behavior (P0602):
+void test_constexpr_copy_assignment() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, int>;
   static_assert(std::is_trivially_copyable<V>::value, "");
   static_assert(std::is_trivially_copy_assignable<V>::value, "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
-  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
+  static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
+  static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
+  static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
+  static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
+#endif // > C++17
 }
 
 int main() {
   test_copy_assignment_empty_empty();
   test_copy_assignment_non_empty_empty();
   test_copy_assignment_empty_non_empty();
   test_copy_assignment_same_index();
   test_copy_assignment_different_index();
   test_copy_assignment_sfinae();
   test_copy_assignment_not_noexcept();
-  test_constexpr_copy_assignment_extension();
+  test_constexpr_copy_assignment();
 }

libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp

 // XFAIL: availability=macosx10.8
 // XFAIL: availability=macosx10.7
 
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant& operator=(variant&&) noexcept(see below);
+// variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <variant>
 
 #include "test_macros.h"
void test_move_assignment_sfinae() {
   }
   {
     // variant only provides move assignment when the types also provide
     // a move constructor.
     using V = std::variant<int, MoveAssignOnly>;
     static_assert(!std::is_move_assignable<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, NTMoveAssign>;
     static_assert(!std::is_trivially_move_assignable<V>::value, "");
     static_assert(std::is_move_assignable<V>::value, "");
#if TEST_STD_VER > 17
   {
     using V = std::variant<int, TrivialCopyNontrivialMove>;
     static_assert(!std::is_trivially_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, CopyOnly>;
     static_assert(std::is_trivially_move_assignable<V>::value, "");
   }
+#endif // > C++17
 }
 
 void test_move_assignment_empty_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, long, MET>;
     V v1(std::in_place_index<0>);
try {
       assert(false);
     } catch (...) {
     }
     assert(v1.index() == 1);
     assert(&std::get<1>(v1) == &mref);
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<int> operator()() const {
         using V = std::variant<int>;
         V v(43);
         V v2(42);
         v = std::move(v2);
         return {v.index(), std::get<0>(v)};
struct {
         v = std::move(v2);
         return {v.index(), std::get<1>(v).value};
       }
     } test;
     constexpr auto result = test();
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_move_assignment_different_index() {
   {
     using V = std::variant<int, long, unsigned>;
     V v1(43);
     V v2(42l);
     V &vref = (v1 = std::move(v2));
using MET = MakeEmptyT;
     V v2(std::in_place_type<std::string>, "hello");
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<long> operator()() const {
         using V = std::variant<int, long, unsigned>;
         V v(43);
         V v2(42l);
         v = std::move(v2);
         return {v.index(), std::get<1>(v)};
struct {
         v = std::move(v2);
         return {v.index(), std::get<1>(v).value};
       }
     } test;
     constexpr auto result = test();
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 template <size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_extension_imp(
+constexpr bool test_constexpr_assign_imp(
     std::variant<long, void*, int>&& v, ValueType&& new_value)
 {
   std::variant<long, void*, int> v2(
       std::forward<ValueType>(new_value));
   const auto cp = v2;
   v = std::move(v2);
   return v.index() == NewIdx &&
         std::get<NewIdx>(v) == std::get<NewIdx>(cp);
 }
 
-void test_constexpr_move_assignment_extension() {
-  // The following tests are for not-yet-standardized behavior (P0602):
+void test_constexpr_move_assignment() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, int>;
   static_assert(std::is_trivially_copyable<V>::value, "");
   static_assert(std::is_trivially_move_assignable<V>::value, "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
-  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
+  static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
+  static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
+  static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
+  static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
+#endif // > C++17
 }
 
 int main() {
   test_move_assignment_empty_empty();
   test_move_assignment_non_empty_empty();
   test_move_assignment_empty_non_empty();
   test_move_assignment_same_index();
   test_move_assignment_different_index();
   test_move_assignment_sfinae();
   test_move_assignment_noexcept();
-  test_constexpr_move_assignment_extension();
+  test_constexpr_move_assignment();
 }

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp

 // XFAIL: availability=macosx10.9
 // XFAIL: availability=macosx10.8
 // XFAIL: availability=macosx10.7
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant(variant const&);
+// variant(variant const&); // constexpr in C++20
 
 #include <cassert>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
void test_copy_ctor_sfinae() {
     using V = std::variant<int, MoveOnly>;
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, NTCopy>;
     static_assert(!std::is_trivially_copy_constructible<V>::value, "");
     static_assert(std::is_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, TCopy>;
     static_assert(std::is_trivially_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, TCopyNTMove>;
     static_assert(std::is_trivially_copy_constructible<V>::value, "");
   }
+#endif // > C++17
 }
 
 void test_copy_ctor_basic() {
   {
     std::variant<int> v(std::in_place_index<0>, 42);
     std::variant<int> v2 = v;
     assert(v2.index() == 0);
     assert(std::get<0>(v2) == 42);
void test_copy_ctor_basic() {
   {
     std::variant<int, NonT> v(std::in_place_index<1>, 42);
     assert(v.index() == 1);
     std::variant<int, NonT> v2(v);
     assert(v2.index() == 1);
     assert(std::get<1>(v2).value == 42);
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     constexpr std::variant<int> v(std::in_place_index<0>, 42);
     static_assert(v.index() == 0, "");
     constexpr std::variant<int> v2 = v;
     static_assert(v2.index() == 0, "");
     static_assert(std::get<0>(v2) == 42, "");
   }
   {
#if TEST_STD_VER > 17
   }
   {
     constexpr std::variant<int, TCopyNTMove> v(std::in_place_index<1>, 42);
     static_assert(v.index() == 1, "");
     constexpr std::variant<int, TCopyNTMove> v2(v);
     static_assert(v2.index() == 1, "");
     static_assert(std::get<1>(v2).value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_copy_ctor_valueless_by_exception() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using V = std::variant<int, MakeEmptyT>;
   V v1;
   makeEmpty(v1);
   const V &cv1 = v1;
   V v(cv1);
   assert(v.valueless_by_exception());
 #endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 template <size_t Idx>
-constexpr bool test_constexpr_copy_ctor_extension_imp(
-    std::variant<long, void*, const int> const& v)
-{
+constexpr bool test_constexpr_copy_ctor_imp(std::variant<long, void*, const int> const& v) {
   auto v2 = v;
   return v2.index() == v.index() &&
          v2.index() == Idx &&
          std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
-void test_constexpr_copy_ctor_extension() {
-  // NOTE: This test is for not yet standardized behavior. (P0602)
+void test_constexpr_copy_ctor() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, const int>;
 #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
   static_assert(std::is_trivially_copy_constructible<V>::value, "");
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(!std::is_copy_assignable<V>::value, "");
   static_assert(!std::is_move_assignable<V>::value, "");
 #else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
 #endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
-  static_assert(test_constexpr_copy_ctor_extension_imp<0>(V(42l)), "");
-  static_assert(test_constexpr_copy_ctor_extension_imp<1>(V(nullptr)), "");
-  static_assert(test_constexpr_copy_ctor_extension_imp<2>(V(101)), "");
+  static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
+  static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
+  static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
+#endif // > C++17
 }
 
 int main() {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
-  test_constexpr_copy_ctor_extension();
+  test_constexpr_copy_ctor();
 #if 0
 // disable this for the moment; it fails on older compilers.
 //  Need to figure out which compilers will support it.
 { // This is the motivating example from P0739R0
   std::variant<int, double> v1(3);
   std::variant v2 = v1;
   (void) v2;
 }
 #endif
 }

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp

 // XFAIL: availability=macosx10.9
 // XFAIL: availability=macosx10.8
 // XFAIL: availability=macosx10.7
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant(variant&&) noexcept(see below);
+// variant(variant&&) noexcept(see below); // constexpr in C++20
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
void test_move_ctor_sfinae() {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(std::is_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_move_constructible<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, NTMove>;
     static_assert(!std::is_trivially_move_constructible<V>::value, "");
     static_assert(std::is_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, TMove>;
     static_assert(std::is_trivially_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, TMoveNTCopy>;
     static_assert(std::is_trivially_move_constructible<V>::value, "");
   }
+#endif // > C++17
 }
 
 template <typename T>
 struct Result { size_t index; T value; };
 
 void test_move_ctor_basic() {
   {
     std::variant<int> v(std::in_place_index<0>, 42);
void test_move_ctor_basic() {
     std::variant<int, MoveOnlyNT> v(std::in_place_index<1>, 42);
     assert(v.index() == 1);
     std::variant<int, MoveOnlyNT> v2(std::move(v));
     assert(v2.index() == 1);
     assert(std::get<1>(v).value == -1);
     assert(std::get<1>(v2).value == 42);
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<int> operator()() const {
         std::variant<int> v(std::in_place_index<0>, 42);
         std::variant<int> v2 = std::move(v);
         return {v2.index(), std::get<0>(std::move(v2))};
       }
     } test;
struct {
         std::variant<int, TMoveNTCopy> v2(std::move(v));
         return {v2.index(), std::get<1>(std::move(v2))};
       }
     } test;
     constexpr auto result = test();
     static_assert(result.index == 1, "");
     static_assert(result.value.value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_move_ctor_valueless_by_exception() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using V = std::variant<int, MakeEmptyT>;
   V v1;
   makeEmpty(v1);
   V v(std::move(v1));
   assert(v.valueless_by_exception());
 #endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 template <size_t Idx>
-constexpr bool test_constexpr_ctor_extension_imp(
-    std::variant<long, void*, const int> const& v)
-{
+constexpr bool test_constexpr_ctor_imp(std::variant<long, void*, const int> const& v) {
   auto copy = v;
   auto v2 = std::move(copy);
   return v2.index() == v.index() &&
          v2.index() == Idx &&
         std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
-void test_constexpr_move_ctor_extension() {
-  // NOTE: This test is for not yet standardized behavior. (P0602)
+void test_constexpr_move_ctor() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, const int>;
 #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
   static_assert(std::is_trivially_copy_constructible<V>::value, "");
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(!std::is_copy_assignable<V>::value, "");
   static_assert(!std::is_move_assignable<V>::value, "");
 #else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
 #endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_move_constructible<V>::value, "");
-  static_assert(test_constexpr_ctor_extension_imp<0>(V(42l)), "");
-  static_assert(test_constexpr_ctor_extension_imp<1>(V(nullptr)), "");
-  static_assert(test_constexpr_ctor_extension_imp<2>(V(101)), "");
+  static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
+  static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
+  static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
+#endif // > C++17
 }
 
 int main() {
   test_move_ctor_basic();
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
-  test_constexpr_move_ctor_extension();
+  test_constexpr_move_ctor();
 }

libcxx/www/cxx2a_status.html

-->
    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0318R1">P0318R1</a></td><td>LWG</td><td>unwrap_ref_decay and unwrap_reference</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0356R5">P0356R5</a></td><td>LWG</td><td>Simplified partial function application</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0357R3">P0357R3</a></td><td>LWG</td><td>reference_wrapper for incomplete types</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0482R6">P0482R6</a></td><td>CWG</td><td>char8_t: A type for UTF-8 characters and strings</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0487R1">P0487R1</a></td><td>LWG</td><td>Fixing operator&gt;&gt;(basic_istream&amp;, CharT*) (LWG 2499)</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0591R4">P0591R4</a></td><td>LWG</td><td>Utility functions to implement uses-allocator construction</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0595R2">P0595R2</a></td><td>CWG</td><td>P0595R2 std::is_constant_evaluated()</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0608R3">P0608R3</a></td><td>LWG</td><td>A sane variant converting constructor</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0655R1">P0655R1</a></td><td>LWG</td><td>visit&lt;R&gt;: Explicit Return Type for visit</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0771R1">P0771R1</a></td><td>LWG</td><td>std::function move constructor should be noexcept</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0896R4">P0896R4</a></td><td>LWG</td><td>The One Ranges Proposal</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0899R1">P0899R1</a></td><td>LWG</td><td>P0899R1 - LWG 3016 is not a defect</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0919R3">P0919R3</a></td><td>LWG</td><td>Heterogeneous lookup for unordered containers</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0972R0">P0972R0</a></td><td>LWG</td><td>&lt;chrono&gt; <tt>zero()</tt>, <tt>min()</tt>, and <tt>max()</tt> should be noexcept</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1006R1">P1006R1</a></td><td>LWG</td><td>Constexpr in std::pointer_traits</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>