[libc++] Applies P0602R4 retro-actively.

[Mordante]

Summary

While testing a test failure of C++17 with Clang ToT it was noticed the
paper

P0602R4 variant and optional should propagate copy/move triviality

was not applied as a DR in libc++.

This was discovered while investigating the issue "caused by" D131479.

[Mordante]

Polished test whether works with all Clang versions.

[Mordante]

Reenable the proper CI.

[Mordante]

The patch is tested with all Clang versions in this build https://buildkite.com/llvm-project/libcxx-ci/builds/13640

libcxx/include/optional

namespace std {
 
   template <class T> class optional {
   public:
     using value_type = T;
 
     // 23.6.3.1, constructors
     constexpr optional() noexcept;
     constexpr optional(nullopt_t) noexcept;
-    optional(const optional &);
-    optional(optional &&) noexcept(see below);
+    constexpr optional(const optional &);
+    constexpr optional(optional &&) noexcept(see below);
     template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
     template <class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
     template <class U = T>
       constexpr explicit(see-below) optional(U &&);
     template <class U>
       explicit(see-below) optional(const optional<U> &);         // constexpr in C++20
     template <class U>
       explicit(see-below) optional(optional<U> &&);              // constexpr in C++20
 
     // 23.6.3.2, destructor
     ~optional(); // constexpr in C++20
 
     // 23.6.3.3, assignment
     optional &operator=(nullopt_t) noexcept;                     // constexpr in C++20
-    optional &operator=(const optional &);                       // constexpr in C++20
-    optional &operator=(optional &&) noexcept(see below);        // constexpr in C++20
+    constexpr optional &operator=(const optional &);
+    constexpr optional &operator=(optional &&) noexcept(see below);
     template <class U = T> optional &operator=(U &&);            // constexpr in C++20
     template <class U> optional &operator=(const optional<U> &); // constexpr in C++20
     template <class U> optional &operator=(optional<U> &&);      // constexpr in C++20
     template <class... Args> T& emplace(Args &&...);             // constexpr in C++20
     template <class U, class... Args>
       T& emplace(initializer_list<U>, Args &&...);               // constexpr in C++20
 
     // 23.6.3.4, swap
#endif
 
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(nullopt_t) noexcept
     {
         reset();
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
-    _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
+    constexpr optional& operator=(const optional&) = default;
+    constexpr optional& operator=(optional&&) = default;
 
     // LWG2756
     template <class _Up = value_type,
               class = enable_if_t<
                       _And<
                           _IsNotSame<__remove_cvref_t<_Up>, optional>,
                           _Or<
                               _IsNotSame<__remove_cvref_t<_Up>, value_type>,

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&);                // constexpr in C++20
-    variant(variant&&) noexcept(see below); // constexpr in C++20
+    constexpr variant(const variant&);
+    constexpr variant(variant&&) noexcept(see below);
 
     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&);                // constexpr in C++20
-    variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
+    constexpr variant& operator=(const variant&);
+    constexpr variant& operator=(variant&&) noexcept(see below);
 
     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>
public:
   template <bool _Dummy = true,
             enable_if_t<__dependent_type<is_default_constructible<__first_type>,
                                          _Dummy>::value,
                         int> = 0>
   _LIBCPP_HIDE_FROM_ABI
   constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
       : __impl_(in_place_index<0>) {}
 
-  variant(const variant&) = default;
-  variant(variant&&) = default;
+  constexpr variant(const variant&) = default;
+  constexpr variant(variant&&) = default;
 
   template <
       class _Arg,
       enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
       enable_if_t<!__is_inplace_type<__remove_cvref_t<_Arg>>::value, int> = 0,
       enable_if_t<!__is_inplace_index<__remove_cvref_t<_Arg>>::value, int> = 0,
       class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
       size_t _Ip =
explicit constexpr variant(
       in_place_type_t<_Tp>,
       initializer_list<_Up> __il,
       _Args&&... __args) noexcept(
       is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
       : __impl_(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
 
   ~variant() = default;
 
-  variant& operator=(const variant&) = default;
-  variant& operator=(variant&&) = default;
+  constexpr variant& operator=(const variant&) = default;
+  constexpr variant& operator=(variant&&) = default;
 
   template <
       class _Arg,
       enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
       class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // <optional>
 
-// optional<T>& operator=(const optional<T>& rhs); // constexpr in C++20
+// constexpr optional<T>& operator=(const optional<T>& rhs);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "archetypes.h"
 
constexpr bool assign_value(optional<Tp>&& lhs) {
     lhs = rhs;
     return lhs.has_value() && rhs.has_value() && *lhs == *rhs;
 }
 
 int main(int, char**)
 {
     {
         using O = optional<int>;
-#if TEST_STD_VER > 17
-        LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
-        LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
-#endif
+        static_assert(assign_empty(O{42}));
+        static_assert(assign_value(O{42}));
         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
+        static_assert(assign_empty(O{42}));
+        static_assert(assign_value(O{42}));
         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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // <optional>
 
-// optional<T>& operator=(optional<T>&& rhs)
+// constexpr optional<T>& operator=(optional<T>&& rhs)
 //     noexcept(is_nothrow_move_assignable<T>::value &&
-//              is_nothrow_move_constructible<T>::value); // constexpr in C++20
+//              is_nothrow_move_constructible<T>::value);
 
 #include <optional>
 #include <cassert>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 #include "archetypes.h"
int main(int, char**)
         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
+        static_assert(assign_empty(O{42}));
+        static_assert(assign_value(O{42}));
         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
+        static_assert(assign_empty(O{42}));
+        static_assert(assign_value(O{42}));
         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;

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// REQUIRES: c++17
-// <optional>
-
-// constexpr optional(const optional<T>&& rhs);
-//  C++17 said:
-//   If is_trivially_move_constructible_v<T> is true,
-//    this constructor shall be a constexpr constructor.
-//
-//  P0602 changed this to:
-//     If is_trivially_move_constructible_v<T> is true, this constructor is trivial.
-//
-//  which means that it can't be constexpr if T is not trivially move-constructible,
-//    because you have to do a placement new to get the value into place.
-//    Except in the case where it is moving from an empty optional - that could be
-//    made to be constexpr (and libstdc++ does so).
-
-#include <optional>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-struct S {
-    constexpr S()   : v_(0) {}
-    S(int v)        : v_(v) {}
-    constexpr S(const S  &rhs) : v_(rhs.v_) {} // not trivially moveable
-    constexpr S(      S &&rhs) : v_(rhs.v_) {} // not trivially moveable
-    int v_;
-    };
-
-
-constexpr bool test() // expected-error {{constexpr function never produces a constant expression}}
-{
-    std::optional<S> o1{3};
-    std::optional<S> o2 = std::move(o1);
-    return o2.has_value();  // return -something-
-}
-
-
-int main(int, char**)
-{
-    static_assert (!std::is_trivially_move_constructible_v<S>, "" );
-    static_assert (test(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-    return 0;
-}

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

 
 // Throwing bad_variant_access is supported starting in macosx10.13
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant& operator=(variant const&); // constexpr in C++20
+// constexpr variant& operator=(variant const&);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 
void test_copy_assignment_sfinae() {
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
 
   // 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>);
using MET = MakeEmptyT;
     } catch (...) {
     }
     assert(v1.index() == 1);
     assert(&std::get<1>(v1) == &mref);
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
   // 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(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
     assert(v2.index() == 2);
     assert(std::get<2>(v2) == "hello");
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
   // 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_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() {
   // 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_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(int, char**) {
   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();
 
   return 0;
 }

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

 
 // Throwing bad_variant_access is supported starting in macosx10.13
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
+// constexpr variant& operator=(variant&&) noexcept(see below);
 
 #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, "");
   }
 
   // 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, "");
void test_move_assignment_sfinae() {
   {
     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>);
using MET = MakeEmptyT;
     } catch (...) {
     }
     assert(v1.index() == 1);
     assert(&std::get<1>(v1) == &mref);
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
   // 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 &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
   // 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_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() {
   // 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_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(int, char**) {
   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();
 
   return 0;
 }

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

 
 // Throwing bad_variant_access is supported starting in macosx10.13
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant(variant const&); // constexpr in C++20
+// constexpr variant(variant const&);
 
 #include <cassert>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
void test_copy_ctor_sfinae() {
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
 
   // 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);
   }
 
   // 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, "");
   }
   {
void test_copy_ctor_basic() {
   }
   {
     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_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() {
   // 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_MSVC_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_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
 #endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   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(int, char**) {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
   test_constexpr_copy_ctor();
 #if 0

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

 
 // Throwing bad_variant_access is supported starting in macosx10.13
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
 
 // <variant>
 
 // template <class ...Types> class variant;
 
-// variant(variant&&) noexcept(see below); // constexpr in C++20
+// constexpr variant(variant&&) noexcept(see below);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
void test_move_ctor_sfinae() {
     static_assert(std::is_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_move_constructible<V>::value, "");
   }
 
   // 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() {
     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);
   }
 
   // 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_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() {
   // 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_MSVC_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_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
 #endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   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(int, char**) {
   test_move_ctor_basic();
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
   test_constexpr_move_ctor();
 
   return 0;
 }