[libcxx][optional] adds missing constexpr operations

[cjdb]

Summary

Makes the following operations constexpr:

• std::swap(optional, optional)
• optional(optional<U> const&)
• optional(optional<U>&&)
• ~optional()
• operator=(nullopt_t)
• operator=(U&&)
• operator=(optional<U> const&)
• operator=(optional<U>&&)
• emplace(Args&&...)
• emplace(initializer_list<U>, Args&&...)
• swap(optional&)
• reset()

P2231 has been accepted by plenary, with the committee recommending
implementers retroactively apply to C++20. It's necessary for us to
implement _`semiregular-box`_ and _`non-propagating-cache`_, both of
which are required for ranges (otherwise we'll need to reimplement
std::optional with these members constexprified).

[cjdb]

replaces placement new with std::construct_at in C++20

[cjdb]

• Gets C++17 mode working.
• GCC 10 doesn't like this patch, but GCC 11 mostly does

[cjdb]

• disables GCC for constexpr tests (should this be temporary or permanent?)
• removes tests using is_literal_type since that was deprecated in C++17 and is to be removed in C++20

[cjdb]

updates C++2b status paper

[zoecarver]

This mostly looks good to me. A few comments, but mainly minor things.

The following two tests look like they still need to be updated:

• libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
• libcxx/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp

libcxx/docs/Cxx2bStatusPaperStatus.csv

13 ↗

(On Diff #343934)

Was this paper accepted yet?

libcxx/include/optional

106

This should be updated, too.

109

And these assignment operators.

326

Is this part of another paper? Should we add a test too?

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

71

This could just be constexpr, no?

85

Nit: checkY or testY (better, imho).

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

23

Want to update this comment?

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

43

We should still test this pre-c++20, I think. You could group them all together at the end, though.

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

137

I think the tests here are sufficient. But if you wanted, you could use the same dtor count trick as you did above (using a pointer) and then factor the existing tests out into check_swap and get rid of W.

As I said, either way is OK. I think there's sufficient set coverage here.

[cjdb]

libcxx/docs/Cxx2bStatusPaperStatus.csv

13 ↗

(On Diff #343934)

Please read my commit message.

libcxx/include/optional

326

This is necessary for GCC 11 to like this patch. It the two should be equivalent; but this one is permissible in a constant expression.

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

23

This is still relevant for C++17?

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

43

🤷 std::is_literal_type was deprecated in C++17 with the rationale

The traits had unreliable or awkward interfaces. The is_literal_type trait provided no way to detect which subset of constructors and member functions of a type were declared constexpr.

I'm not sure our tests should have something unreliable?

[tcanens]

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

43

The problem with is_literal_type is that it provides an answer to a mostly useless question - knowing that a type has some constexpr constructor tells you pretty much nothing about what you can do with it. The trait itself is perfectly reliable.

[ldionne]

libcxx/include/optional

72

Should be // constexpr in C++2b (in C++20 as an extension) or something along those lines, just to acknowledge that we're supporting that as an extension.

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

233

This should be:

#if TEST_STD_VER > 20 || (TEST_STD_VER >= 20 && defined(_LIBCPP_VER))

Basically, test it in C++2b, or in C++20 but only when testing libc++, since it is out own extension. Otherwise, a conforming implementation will fail the test suite in C++20 mode because they don't implement constexpr for std::optional. This applies everywhere.

Also, what's the deal with GCC? If it fails those tests, we should first report the issue to GCC and then use some XFAIL markup to disable it instead.

[cjdb]

libcxx/include/optional

72

Is it really an extension if LWG are recommending we backport it to C++20 as a "fix"?

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

233

Also, what's the deal with GCC? If it fails those tests, we should first report the issue to GCC and then use some XFAIL markup to disable it instead.

GCC 10 doesn't like our constexpr construct_at (GCC 11 is okay with it). I wasn't comfortable saying GCC couldn't test this file at all given it still works outside of constant expressions.

[zoecarver]

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

233

I think you should mark the whole file as UNSUPPORTED: gcc-10. IMO it's better to test everything on one version of GCC than some things on no versions of GCC.

Do we still support GCC 10? When does that change go through? And when it does, can/should we remove all this UNSUPPORTED cruft?

[cjdb]

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

233

Do we still support GCC 10?

We only support GCC 10.

And when it does, can/should we remove all this UNSUPPORTED cruft?

Why? It's not hurting anything to keep it there.

[ldionne]

libcxx/include/optional

72

You're right - if the Standard says to backport it, then it's not an extension.

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

233

I would prefer that we use UNSUPPORTED: gcc-10. The reason is that UNSUPPORTED annotations disable the test for the given version of GCC which we know doesn't support <some feature>, but it doesn't disable it forever. When we start testing on GCC 11, the test will not be considered as UNSUPPORTED. This is a great way to make sure that our tests don't become useless in a given configuration - it will automatically start breaking in the new version, and we'll have to re-acknowledge the failure by adjusting the UNSUPPORTED markup.

On the contrary, guarding with TEST_COMPILER_GCC means that we'll most likely forget about this in the future, and those bits will never be tested on GCC.

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

25

Why aren't we simply constexpr-ifying the tests like you did elsewhere?

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

43

I think Chris meant that our tests shouldn't be using a tool that we deprecated and removed. I agree with him, I don't think it's useful to check that optional<T> is a literal type (but my mind can easily be changed if you tell me why it would be useful to check this).

[cjdb]

• updates tests
• responds to @ldionne's feedback

[ldionne]

A few comments, and also CI should pass.

libcxx/docs/Cxx2bStatus.rst

42 ↗

(On Diff #350766)

I don't think this note is useful anymore.

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

100

#if TEST_STD_VER > 17 ? (here and below)

[cjdb]

• removes note
• makes C++20 test only available in C++20

[cjdb]

guards around C++20 test

[cjdb]

final update to remove C++20 tests from C++17 mode

[• Quuxplusone]

libcxx/test/support/archetypes.h

56

Style nit 1: static TEST_CONSTEXPR_CXX20 void
Correctness nit 2: None of these functions that touch static members like alive and constructed can actually be constexpr in C++20. Constexpr functions aren't allowed to modify (or even read) global data. Therefore, adding TEST_CONSTEXPR_CXX20 to all these functions is really just noise; you could remove it and simplify this patch.

[ldionne]

LGTM if CI passes, and the two nits applied.

libcxx/test/support/archetypes.h

56

Agree with both.

I didn't care about the placement of static vs TEST_CONSTEXPR_CXX20, but I grepped and it is more consistent with existing style to use static TEST_CONSTEXPR_CXX20 than the reverse.

libcxx/include/optional

namespace std {
   template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator>(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
 
   // 23.6.9, specialized algorithms
-  template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below );
+  template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20
   template <class T> constexpr optional<see below > make_optional(T&&);
   template <class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
   template <class T, class U, class... Args>
     constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
 
   // 23.6.10, hash support
   template <class T> struct hash;
public:
     optional(const optional &);
     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 optional(U &&);
     template <class U>
-      constexpr EXPLICIT optional(const optional<U> &);
+      EXPLICIT optional(const optional<U> &);   // constexpr in C++20
     template <class U>
-      constexpr EXPLICIT optional(optional<U> &&);
+      EXPLICIT optional(optional<U> &&);        // constexpr in C++20
 
     // 23.6.3.2, destructor
-    ~optional();
+    ~optional(); // constexpr in C++20
 
     // 23.6.3.3, assignment
     optional &operator=(nullopt_t) noexcept;
     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... Args> T& emplace(Args &&...);      // constexpr in C++20
     template <class U, class... Args>
-      T& emplace(initializer_list<U>, Args &&...);
+      T& emplace(initializer_list<U>, Args &&...);        // constexpr in C++20
 
     // 23.6.3.4, swap
-    void swap(optional &) noexcept(see below );
+    void swap(optional &) noexcept(see below ); // constexpr in C++20
 
     // 23.6.3.5, observers
     constexpr T const *operator->() const;
     constexpr T *operator->();
     constexpr T const &operator*() const &;
     constexpr T &operator*() &;
     constexpr T &&operator*() &&;
     constexpr const T &&operator*() const &&;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
     constexpr T const &value() const &;
     constexpr T &value() &;
     constexpr T &&value() &&;
     constexpr const T &&value() const &&;
     template <class U> constexpr T value_or(U &&) const &;
     template <class U> constexpr T value_or(U &&) &&;
 
     // 23.6.3.6, modifiers
-    void reset() noexcept;
+    void reset() noexcept; // constexpr in C++20
 
   private:
     T *val; // exposition only
   };
 
 template<class T>
   optional(T) -> optional<T>;
 
struct __optional_destruct_base<_Tp, false>
     union
     {
         char __null_state_;
         value_type __val_;
     };
     bool __engaged_;
 
     _LIBCPP_INLINE_VISIBILITY
-    ~__optional_destruct_base()
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 ~__optional_destruct_base()
     {
         if (__engaged_)
             __val_.~value_type();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr __optional_destruct_base() noexcept
         :  __null_state_(),
            __engaged_(false) {}
 
     template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
     constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
         :  __val_(_VSTD::forward<_Args>(__args)...),
            __engaged_(true) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    void reset() noexcept
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept
     {
         if (__engaged_)
         {
             __val_.~value_type();
             __engaged_ = false;
         }
     }
 };
struct __optional_destruct_base<_Tp, true>
 
     template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
     constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
         :  __val_(_VSTD::forward<_Args>(__args)...),
            __engaged_(true) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    void reset() noexcept
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept
     {
         if (__engaged_)
         {
             __engaged_ = false;
         }
     }
 };
 
struct __optional_storage_base : __optional_destruct_base<_Tp>
     _LIBCPP_INLINE_VISIBILITY
     constexpr const value_type&& __get() const&& noexcept
     {
         return _VSTD::move(this->__val_);
     }
 
     template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
-    void __construct(_Args&&... __args)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_Args&&... __args)
     {
         _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
+#if _LIBCPP_STD_VER > 17
+        _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...);
+#else
         ::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
+#endif
         this->__engaged_ = true;
     }
 
     template <class _That>
     _LIBCPP_INLINE_VISIBILITY
-    void __construct_from(_That&& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt)
     {
         if (__opt.has_value())
             __construct(_VSTD::forward<_That>(__opt).__get());
     }
 
     template <class _That>
     _LIBCPP_INLINE_VISIBILITY
-    void __assign_from(_That&& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt)
     {
         if (this->__engaged_ == __opt.has_value())
         {
             if (this->__engaged_)
                 this->__val_ = _VSTD::forward<_That>(__opt).__get();
         }
         else
         {
constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
         :  __value_(_VSTD::addressof(__uarg))
     {
       static_assert(__can_bind_reference<_UArg>(),
         "Attempted to construct a reference element in tuple from a "
         "possible temporary");
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    void reset() noexcept { __value_ = nullptr; }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept { __value_ = nullptr; }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr bool has_value() const noexcept
       { return __value_ != nullptr; }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr value_type& __get() const& noexcept
       { return *__value_; }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr value_type&& __get() const&& noexcept
       { return _VSTD::forward<value_type>(*__value_); }
 
     template <class _UArg>
     _LIBCPP_INLINE_VISIBILITY
-    void __construct(_UArg&& __val)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_UArg&& __val)
     {
         _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
         static_assert(__can_bind_reference<_UArg>(),
             "Attempted to construct a reference element in tuple from a "
             "possible temporary");
         __value_ = _VSTD::addressof(__val);
     }
 
     template <class _That>
     _LIBCPP_INLINE_VISIBILITY
-    void __construct_from(_That&& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt)
     {
         if (__opt.has_value())
             __construct(_VSTD::forward<_That>(__opt).__get());
     }
 
     template <class _That>
     _LIBCPP_INLINE_VISIBILITY
-    void __assign_from(_That&& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt)
     {
         if (has_value() == __opt.has_value())
         {
             if (has_value())
                 *__value_ = _VSTD::forward<_That>(__opt).__get();
         }
         else
         {

 struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
 {
     using __optional_storage_base<_Tp>::__optional_storage_base;
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_base() = default;
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base(const __optional_copy_base& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_base(const __optional_copy_base& __opt)
     {
         this->__construct_from(__opt);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_base(__optional_copy_base&&) = default;
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_base& operator=(const __optional_copy_base&) = default;
struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
     using __optional_copy_base<_Tp>::__optional_copy_base;
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_move_base() = default;
     _LIBCPP_INLINE_VISIBILITY
     __optional_move_base(const __optional_move_base&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base(__optional_move_base&& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_base(__optional_move_base&& __opt)
         noexcept(is_nothrow_move_constructible_v<value_type>)
     {
         this->__construct_from(_VSTD::move(__opt));
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_move_base& operator=(const __optional_move_base&) = default;
     _LIBCPP_INLINE_VISIBILITY
struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_assign_base() = default;
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
     {
         this->__assign_from(__opt);
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
 };
struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
     _LIBCPP_INLINE_VISIBILITY
     __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
     _LIBCPP_INLINE_VISIBILITY
     __optional_move_assign_base(__optional_move_assign_base&&) = default;
     _LIBCPP_INLINE_VISIBILITY
     __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
         noexcept(is_nothrow_move_assignable_v<value_type> &&
                  is_nothrow_move_constructible_v<value_type>)
     {
         this->__assign_from(_VSTD::move(__opt));
         return *this;
     }
 };
 
public:
     constexpr explicit optional(_Up&& __v)
         : __base(in_place, _VSTD::forward<_Up>(__v)) {}
 
     // LWG2756: conditionally explicit conversion from const optional<_Up>&
     template <class _Up, _EnableIf<
         _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>()
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    optional(const optional<_Up>& __v)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(const optional<_Up>& __v)
     {
         this->__construct_from(__v);
     }
     template <class _Up, _EnableIf<
         _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>()
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    explicit optional(const optional<_Up>& __v)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(const optional<_Up>& __v)
     {
         this->__construct_from(__v);
     }
 
     // LWG2756: conditionally explicit conversion from optional<_Up>&&
     template <class _Up, _EnableIf<
         _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    optional(optional<_Up>&& __v)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(optional<_Up>&& __v)
     {
         this->__construct_from(_VSTD::move(__v));
     }
     template <class _Up, _EnableIf<
         _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    explicit optional(optional<_Up>&& __v)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(optional<_Up>&& __v)
     {
         this->__construct_from(_VSTD::move(__v));
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    optional& operator=(nullopt_t) noexcept
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(nullopt_t) noexcept
     {
         reset();
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
     _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
 
     // LWG2756
     template <class _Up = value_type,
               class = _EnableIf<
                       _And<
                           _IsNotSame<__uncvref_t<_Up>, optional>,
                           _Or<
                               _IsNotSame<__uncvref_t<_Up>, value_type>,
                               _Not<is_scalar<value_type>>
                           >,
                           is_constructible<value_type, _Up>,
                           is_assignable<value_type&, _Up>
                       >::value>
              >
     _LIBCPP_INLINE_VISIBILITY
-    optional&
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional&
     operator=(_Up&& __v)
     {
         if (this->has_value())
             this->__get() = _VSTD::forward<_Up>(__v);
         else
             this->__construct(_VSTD::forward<_Up>(__v));
         return *this;
     }
 
     // LWG2756
     template <class _Up, _EnableIf<
         _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>()
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    optional&
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional&
     operator=(const optional<_Up>& __v)
     {
         this->__assign_from(__v);
         return *this;
     }
 
     // LWG2756
     template <class _Up, _EnableIf<
         _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    optional&
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional&
     operator=(optional<_Up>&& __v)
     {
         this->__assign_from(_VSTD::move(__v));
         return *this;
     }
 
     template <class... _Args,
               class = _EnableIf
                       <
                           is_constructible_v<value_type, _Args...>
                       >
              >
     _LIBCPP_INLINE_VISIBILITY
-    _Tp &
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp &
     emplace(_Args&&... __args)
     {
         reset();
         this->__construct(_VSTD::forward<_Args>(__args)...);
         return this->__get();
     }
 
     template <class _Up, class... _Args,
               class = _EnableIf
                       <
                           is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
                       >
              >
     _LIBCPP_INLINE_VISIBILITY
-    _Tp &
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp &
     emplace(initializer_list<_Up> __il, _Args&&... __args)
     {
         reset();
         this->__construct(__il, _VSTD::forward<_Args>(__args)...);
         return this->__get();
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(optional& __opt)
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(optional& __opt)
         noexcept(is_nothrow_move_constructible_v<value_type> &&
                  is_nothrow_swappable_v<value_type>)
     {
         if (this->has_value() == __opt.has_value())
         {
             using _VSTD::swap;
             if (this->has_value())
                 swap(this->__get(), __opt.__get());
constexpr value_type value_or(_Up&& __v) &&
                                   static_cast<value_type>(_VSTD::forward<_Up>(__v));
     }
 
     using __base::reset;
 
 private:
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY
-    static _Up*
+    static _LIBCPP_CONSTEXPR_AFTER_CXX17 _Up*
     __operator_arrow(true_type, _Up& __x)
     {
         return _VSTD::addressof(__x);
     }
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY
     static constexpr _Up*

 >
 operator>=(const _Tp& __v, const optional<_Up>& __x)
 {
     return static_cast<bool>(__x) ? __v >= *__x : true;
 }
 
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _EnableIf<
     is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
     void
 >
 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
 {
     __x.swap(__y);
 }

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

 
 using std::optional;
 
 class X
 {
     int i_;
     int j_ = 0;
 public:
-    X() : i_(0) {}
-    X(int i) : i_(i) {}
-    X(int i, int j) : i_(i), j_(j) {}
+    constexpr X() : i_(0) {}
+    constexpr X(int i) : i_(i) {}
+    constexpr X(int i, int j) : i_(i), j_(j) {}
 
-    friend bool operator==(const X& x, const X& y)
+    constexpr friend bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 class Y
 {
 public:
     static bool dtor_called;
     Y() = default;
     Y(int) { TEST_THROW(6);}
     ~Y() {dtor_called = true;}
 };
 
 bool Y::dtor_called = false;
 
 template <class T>
-void test_one_arg() {
+constexpr bool test_one_arg() {
     using Opt = std::optional<T>;
     {
         Opt opt;
         auto & v = opt.emplace();
         static_assert( std::is_same_v<T&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
         assert(*opt == T(0));
         assert(&v == &*opt);
constexpr bool test_one_arg() {
     {
         Opt opt(2);
         auto & v = opt.emplace(1);
         static_assert( std::is_same_v<T&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
         assert(*opt == T(1));
         assert(&v == &*opt);
     }
+    return true;
 }
 
 
 template <class T>
-void test_multi_arg()
+constexpr bool test_multi_arg()
 {
     test_one_arg<T>();
     using Opt = std::optional<T>;
     {
         Opt opt;
         auto &v = opt.emplace(101, 41);
         static_assert( std::is_same_v<T&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
constexpr bool test_multi_arg()
     {
         Opt opt;
         auto &v = opt.emplace({1, 2, 3, 4, 5}, 6);
         static_assert( std::is_same_v<T&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
         assert(  v == T(5)); // T sets its value to the size of the init list
         assert(*opt == T(5)); // T sets its value to the size of the init list
     }
+    return true;
 }
 
 template <class T>
 void test_on_test_type() {
 
     T::reset();
     optional<T> opt;
     assert(T::alive == 0);
assert(T::alive == 0);
         assert(T::value_constructed == 1);
         assert(T::destroyed == 1);
         assert(static_cast<bool>(opt) == true);
         assert(*opt == T(4)); // size of the initializer list
         assert(&v == &*opt);
     }
 }
 
-
+constexpr bool test_empty_emplace()
+{
+    optional<const int> opt;
+    auto &v = opt.emplace(42);
+    static_assert( std::is_same_v<const int&, decltype(v)>, "" );
+    assert(*opt == 42);
+    assert(   v == 42);
+    opt.emplace();
+    assert(*opt == 0);
+    return true;
+}
 
 int main(int, char**)
 {
     {
         test_on_test_type<TestTypes::TestType>();
         test_on_test_type<ExplicitTestTypes::TestType>();
     }
     {
         using T = int;
         test_one_arg<T>();
         test_one_arg<const T>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(test_one_arg<T>());
+        static_assert(test_one_arg<const T>());
+#endif
     }
     {
         using T = ConstexprTestTypes::TestType;
         test_multi_arg<T>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(test_multi_arg<T>());
+#endif
     }
     {
         using T = ExplicitConstexprTestTypes::TestType;
         test_multi_arg<T>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(test_multi_arg<T>());
+#endif
     }
     {
         using T = TrivialTestTypes::TestType;
         test_multi_arg<T>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(test_multi_arg<T>());
+#endif
     }
     {
         using T = ExplicitTrivialTestTypes::TestType;
         test_multi_arg<T>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(test_multi_arg<T>());
+#endif
     }
     {
-        optional<const int> opt;
-        auto &v = opt.emplace(42);
-        static_assert( std::is_same_v<const int&, decltype(v)>, "" );
-        assert(*opt == 42);
-        assert(   v == 42);
-        opt.emplace();
-        assert(*opt == 0);
+        test_empty_emplace();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(test_empty_emplace());
+#endif
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     Y::dtor_called = false;
     {
         Y y;
         optional<Y> opt(y);
         try
         {

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

 #include "test_macros.h"
 
 using std::optional;
 
 class X
 {
     int i_;
     int j_ = 0;
+    bool* dtor_called_;
 public:
-    static bool dtor_called;
-    constexpr X() : i_(0) {}
-    constexpr X(int i) : i_(i) {}
-    constexpr X(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {}
-    ~X() {dtor_called = true;}
+    constexpr X(bool& dtor_called) : i_(0), dtor_called_(&dtor_called) {}
+    constexpr X(int i, bool& dtor_called) : i_(i), dtor_called_(&dtor_called) {}
+    constexpr X(std::initializer_list<int> il, bool& dtor_called)
+    : i_(il.begin()[0]), j_(il.begin()[1]), dtor_called_(&dtor_called) {}
+    TEST_CONSTEXPR_CXX20 ~X() {*dtor_called_ = true;}
 
     friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
-bool X::dtor_called = false;
-
 class Y
 {
     int i_;
     int j_ = 0;
 public:
     constexpr Y() : i_(0) {}
     constexpr Y(int i) : i_(i) {}
     constexpr Y(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {}
public:
     ~Z() {dtor_called = true;}
 
     friend bool operator==(const Z& x, const Z& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 bool Z::dtor_called = false;
 
-int main(int, char**)
-{
-    {
-        X x;
-        optional<X> opt(x);
-        assert(X::dtor_called == false);
-        auto &v = opt.emplace({1, 2});
-        static_assert( std::is_same_v<X&, decltype(v)>, "" );
-        assert(X::dtor_called == true);
-        assert(*opt == X({1, 2}));
-        assert(&v == &*opt);
+TEST_CONSTEXPR_CXX20 bool check_X()
+    bool dtor_called = false;
+    X x(dtor_called);
+    assert(dtor_called == false);
+    auto &v = opt.emplace({1, 2}, dtor_called);
+    assert(dtor_called);
+    assert(*opt == X({1, 2}, dtor_called));
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool check_Y()
+{
+    optional<Y> opt;
+    auto &v = opt.emplace({1, 2});
+    static_assert( std::is_same_v<Y&, decltype(v)>, "" );
+    assert(static_cast<bool>(opt) == true);
+    assert(*opt == Y({1, 2}));
+    assert(&v == &*opt);
+    return true;
+}
+
+int main(int, char**)
+{
+    {
+        check_X();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(check_X());
+#endif
     }
     {
         optional<std::vector<int>> opt;
         auto &v = opt.emplace({1, 2, 3}, std::allocator<int>());
         static_assert( std::is_same_v<std::vector<int>&, decltype(v)>, "" );
         assert(static_cast<bool>(opt) == true);
         assert(*opt == std::vector<int>({1, 2, 3}));
         assert(&v == &*opt);
     }
     {
-        optional<Y> opt;
-        auto &v = opt.emplace({1, 2});
-        static_assert( std::is_same_v<Y&, decltype(v)>, "" );
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == Y({1, 2}));
-        assert(&v == &*opt);
+        check_Y();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+        static_assert(check_Y());
+#endif
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         Z z;
         optional<Z> opt(z);
         try
         {
             assert(static_cast<bool>(opt) == true);

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

 
 #include "test_macros.h"
 #include "archetypes.h"
 
 using std::optional;
 using std::nullopt_t;
 using std::nullopt;
 
+#if TEST_STD_VER >= 20
+consteval bool test_consteval()
+{
+    enum class State { inactive, constructed, destroyed };
+    State state = State::inactive;
+
+    struct StateTracker {
+      constexpr StateTracker(State& s)
+      : state_(&s)
+      {
+        s = State::constructed;
+      }
+      constexpr ~StateTracker() { *state_ = State::destroyed; }
+
+      State* state_;
+    };
+    {
+        optional<int> opt;
+        opt = nullopt;
+        assert(static_cast<bool>(opt) == false);
+    }
+    {
+        optional<int> opt(3);
+        opt = nullopt;
+        assert(static_cast<bool>(opt) == false);
+    }
+    {
+        optional<StateTracker> opt;
+        opt = nullopt;
+        assert(state == State::inactive);
+        assert(static_cast<bool>(opt) == false);
+    }
+    {
+        optional<StateTracker> opt(state);
+        assert(state == State::constructed);
+        opt = nullopt;
+        assert(state == State::destroyed);
+        assert(static_cast<bool>(opt) == false);
+    }
+    return true;
+}
+
+static_assert(test_consteval());
+#endif
+
 int main(int, char**)
 {
     {
         optional<int> opt;
         static_assert(noexcept(opt = nullopt) == true, "");
         opt = nullopt;
         assert(static_cast<bool>(opt) == false);
     }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp

 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 
 template <class T, class U>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const optional<U>& rhs, bool is_going_to_throw = false)
 {
     bool rhs_engaged = static_cast<bool>(rhs);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         optional<T> lhs = rhs;
         assert(is_going_to_throw == false);
if (rhs_engaged)
         assert(*lhs == *rhs);
 #endif
 }
 
 class X
 {
     int i_;
 public:
-    X(int i) : i_(i) {}
-    X(const X& x) : i_(x.i_) {}
-    ~X() {i_ = 0;}
-    friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
+    constexpr X(int i) : i_(i) {}
+    constexpr X(const X& x) : i_(x.i_) {}
+    TEST_CONSTEXPR_CXX20 ~X() {i_ = 0;}
+    friend constexpr bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
 };
 
 class Y
 {
     int i_;
 public:
-    Y(int i) : i_(i) {}
+    constexpr Y(int i) : i_(i) {}
 
     friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;}
 };
 
 int count = 0;
 
 class Z
 {
     int i_;
 public:
     Z(int i) : i_(i) {TEST_THROW(6);}
 
-    friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
+    friend bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 };
 
-
-int main(int, char**)
-{
-    {
-        typedef short U;
-        typedef int T;
-        optional<U> rhs;
-        test<T>(rhs);
-    }
-    {
-        typedef short U;
-        typedef int T;
-        optional<U> rhs(U{3});
-        test<T>(rhs);
-    }
-    {
-        typedef X T;
-        typedef int U;
-        optional<U> rhs;
-        test<T>(rhs);
-    }
-    {
-        typedef X T;
-        typedef int U;
-        optional<U> rhs(U{3});
-        test<T>(rhs);
-    }
-    {
-        typedef Y T;
-        typedef int U;
-        optional<U> rhs;
-        test<T>(rhs);
-    }
-    {
-        typedef Y T;
-        typedef int U;
-        optional<U> rhs(U{3});
-        test<T>(rhs);
-    }
+template<class T, class U>
+constexpr bool test_all()
+  return true;
+
+int main(int, char**)
+    test_all<int, short>();
+    test_all<X, int>();
+    test_all<Y, int>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+    static_assert(test_all<int, short>());
+    static_assert(test_all<X, int>());
+    static_assert(test_all<Y, int>());
+#endif
     {
         typedef Z T;
         typedef int U;
         optional<U> rhs;
         test<T>(rhs);
     }
     {
         typedef Z T;

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp

 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 
 template <class T, class U>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const optional<U>& rhs, bool is_going_to_throw = false)
 {
     static_assert(!(std::is_convertible<const optional<U>&, optional<T>>::value), "");
     bool rhs_engaged = static_cast<bool>(rhs);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         optional<T> lhs(rhs);
if (rhs_engaged)
         assert(*lhs == T(*rhs));
 #endif
 }
 
 class X
 {
     int i_;
 public:
-    explicit X(int i) : i_(i) {}
-    X(const X& x) : i_(x.i_) {}
-    ~X() {i_ = 0;}
-    friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
+    constexpr explicit X(int i) : i_(i) {}
+    constexpr X(const X& x) : i_(x.i_) {}
+    TEST_CONSTEXPR_CXX20 ~X() {i_ = 0;}
+    friend constexpr bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
 };
 
 class Y
 {
     int i_;
 public:
-    explicit Y(int i) : i_(i) {}
+    constexpr explicit Y(int i) : i_(i) {}
 
     friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;}
 };
 
 int count = 0;
 
 class Z
 {
     int i_;
 public:
-    explicit Z(int i) : i_(i) { TEST_THROW(6);}
+    constexpr explicit Z(int i) : i_(i) { TEST_THROW(6);}
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 };
 
-
-int main(int, char**)
+template<class T, class U>
+constexpr bool test_all()
 {
-    {
-        typedef X T;
-        typedef int U;
-        optional<U> rhs;
-        test<T>(rhs);
-    }
-    {
-        typedef X T;
-        typedef int U;
-        optional<U> rhs(3);
-        test<T>(rhs);
-    }
-    {
-        typedef Y T;
-        typedef int U;
-        optional<U> rhs;
-        test<T>(rhs);
-    }
-    {
-        typedef Y T;
-        typedef int U;
-        optional<U> rhs(3);
-        test<T>(rhs);
-    }
+  return true;
+
+
+int main(int, char**)
+    test_all<X, int>();
+    test_all<Y, int>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+    static_assert(test_all<X, int>());
+    static_assert(test_all<Y, int>());
+#endif
     {
         typedef Z T;
         typedef int U;
         optional<U> rhs;
         test<T>(rhs);
     }
     {
         typedef Z T;
         typedef int U;
         optional<U> rhs(3);
         test<T>(rhs, true);
     }
 
   return 0;
 }

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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// 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 {

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 
 template <class T, class U>
-void
+TEST_CONSTEXPR_CXX20 void
 test(optional<U>&& rhs, bool is_going_to_throw = false)
 {
     bool rhs_engaged = static_cast<bool>(rhs);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         optional<T> lhs = std::move(rhs);
         assert(is_going_to_throw == false);
#else
     assert(static_cast<bool>(lhs) == rhs_engaged);
 #endif
 }
 
 class X
 {
     int i_;
 public:
-    X(int i) : i_(i) {}
-    X(X&& x) : i_(std::exchange(x.i_, 0)) {}
-    ~X() {i_ = 0;}
-    friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
+    TEST_CONSTEXPR_CXX20 X(int i) : i_(i) {}
+    TEST_CONSTEXPR_CXX20 X(X&& x) : i_(std::exchange(x.i_, 0)) {}
+    TEST_CONSTEXPR_CXX20 ~X() {i_ = 0;}
+    friend constexpr bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
 };
 
-int count = 0;
-
 struct Z
 {
     Z(int) { TEST_THROW(6); }
 };
 
-int main(int, char**)
+template<class T, class U>
+TEST_CONSTEXPR_CXX20 bool test_all()
 {
     {
-        optional<short> rhs;
-        test<int>(std::move(rhs));
+        optional<T> rhs;
+        test<U>(std::move(rhs));
     }
     {
-        optional<short> rhs(short{3});
-        test<int>(std::move(rhs));
+        optional<T> rhs(short{3});
+        test<U>(std::move(rhs));
     }
-    {
-        optional<int> rhs;
-        test<X>(std::move(rhs));
-    }
-    {
-        optional<int> rhs(3);
-        test<X>(std::move(rhs));
-    }
+    return true;
+
+int main(int, char**)
+    test_all<short, int>();
+    test_all<int, X>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+    static_assert(test_all<short, int>());
+    static_assert(test_all<int, X>());
+#endif
     {
         optional<int> rhs;
         test<Z>(std::move(rhs));
     }
     {
         optional<int> rhs(3);
         test<Z>(std::move(rhs), true);
     }
 
     static_assert(!(std::is_constructible<optional<X>, optional<Z>>::value), "");
 
   return 0;
 }

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

 bool X::dtor_called = false;
 
 int main(int, char**)
 {
     {
         typedef int T;
         static_assert(std::is_trivially_destructible<T>::value, "");
         static_assert(std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(std::is_literal_type<optional<T>>::value, "");
     }
     {
         typedef double T;
         static_assert(std::is_trivially_destructible<T>::value, "");
         static_assert(std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(std::is_literal_type<optional<T>>::value, "");
     }
     {
         typedef PODType T;
         static_assert(std::is_trivially_destructible<T>::value, "");
         static_assert(std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(std::is_literal_type<optional<T>>::value, "");
     }
     {
         typedef X T;
         static_assert(!std::is_trivially_destructible<T>::value, "");
         static_assert(!std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(!std::is_literal_type<optional<T>>::value, "");
         {
             X x;
             optional<X> opt{x};
             assert(X::dtor_called == false);
         }
         assert(X::dtor_called == true);
     }
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp

 struct X
 {
     static bool dtor_called;
     ~X() {dtor_called = true;}
 };
 
 bool X::dtor_called = false;
 
-int main(int, char**)
+constexpr bool check_reset()
 {
     {
         optional<int> opt;
         static_assert(noexcept(opt.reset()) == true, "");
         opt.reset();
         assert(static_cast<bool>(opt) == false);
     }
     {
         optional<int> opt(3);
         opt.reset();
         assert(static_cast<bool>(opt) == false);
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    check_reset();
+#if TEST_STD_VER >= 20
+    static_assert(check_reset());
+#endif
     {
         optional<X> opt;
         static_assert(noexcept(opt.reset()) == true, "");
         assert(X::dtor_called == false);
         opt.reset();
         assert(X::dtor_called == false);
         assert(static_cast<bool>(opt) == false);
     }

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

 public:
     Z(int i) : i_(i) {}
     Z(Z&&) {TEST_THROW(7);}
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
     friend void swap(Z&, Z&) {TEST_THROW(6);}
 };
 
+class W
+{
+    int i_;
+public:
+    constexpr W(int i) : i_(i) {}
 
-int main(int, char**)
+    friend constexpr bool operator==(const W& x, const W& y) {return x.i_ == y.i_;}
+    friend TEST_CONSTEXPR_CXX20 void swap(W& x, W& y) noexcept {std::swap(x.i_, y.i_);}
+};
+
+template<class T>
+TEST_CONSTEXPR_CXX20 bool check_swap()
 {
     {
-        optional<int> opt1;
-        optional<int> opt2;
-        static_assert(noexcept(opt1.swap(opt2)) == true, "");
+        optional<T> opt1;
+        optional<T> opt2;
+        static_assert(noexcept(opt1.swap(opt2)) == true);
         assert(static_cast<bool>(opt1) == false);
         assert(static_cast<bool>(opt2) == false);
         opt1.swap(opt2);
         assert(static_cast<bool>(opt1) == false);
         assert(static_cast<bool>(opt2) == false);
     }
     {
-        optional<int> opt1(1);
-        optional<int> opt2;
-        static_assert(noexcept(opt1.swap(opt2)) == true, "");
+        optional<T> opt1(1);
+        optional<T> opt2;
+        static_assert(noexcept(opt1.swap(opt2)) == true);
         assert(static_cast<bool>(opt1) == true);
         assert(*opt1 == 1);
         assert(static_cast<bool>(opt2) == false);
         opt1.swap(opt2);
         assert(static_cast<bool>(opt1) == false);
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 1);
     }
     {
-        optional<int> opt1;
-        optional<int> opt2(2);
+        optional<T> opt1;
+        optional<T> opt2(2);
         static_assert(noexcept(opt1.swap(opt2)) == true, "");
         assert(static_cast<bool>(opt1) == false);
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 2);
         opt1.swap(opt2);
         assert(static_cast<bool>(opt1) == true);
         assert(*opt1 == 2);
         assert(static_cast<bool>(opt2) == false);
     }
     {
-        optional<int> opt1(1);
-        optional<int> opt2(2);
+        optional<T> opt1(1);
+        optional<T> opt2(2);
         static_assert(noexcept(opt1.swap(opt2)) == true, "");
         assert(static_cast<bool>(opt1) == true);
         assert(*opt1 == 1);
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 2);
         opt1.swap(opt2);
         assert(static_cast<bool>(opt1) == true);
         assert(*opt1 == 2);
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 1);
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    check_swap<int>();
+    check_swap<W>();
+#if TEST_STD_VER >= 20 && !defined(TEST_COMPILER_GCC)
+    static_assert(check_swap<int>());
+    static_assert(check_swap<W>());
+#endif
+
     {
         optional<X> opt1;
         optional<X> opt2;
         static_assert(noexcept(opt1.swap(opt2)) == true, "");
         assert(static_cast<bool>(opt1) == false);
         assert(static_cast<bool>(opt2) == false);
         opt1.swap(opt2);
         assert(static_cast<bool>(opt1) == false);

libcxx/test/support/archetypes.h

struct TestBase {
     static int copy_constructed;
     static int move_constructed;
     static int assigned;
     static int value_assigned;
     static int copy_assigned;
     static int move_assigned;
     static int destroyed;
 
-    static void reset() {
+    TEST_CONSTEXPR_CXX20 static void reset() {
         assert(alive == 0);
         alive = 0;
         reset_constructors();
     }
 
-    static void reset_constructors() {
+    TEST_CONSTEXPR_CXX20 static void reset_constructors() {
       constructed = value_constructed = default_constructed =
         copy_constructed = move_constructed = 0;
       assigned = value_assigned = copy_assigned = move_assigned = destroyed = 0;
     }
 
-    TestBase() noexcept : value(0) {
+    TEST_CONSTEXPR_CXX20 TestBase() noexcept : value(0) {
         ++alive; ++constructed; ++default_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit TestBase(int x) noexcept : value(x) {
+    TEST_CONSTEXPR_CXX20 explicit TestBase(int x) noexcept : value(x) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    TestBase(int x) noexcept : value(x) {
+    TEST_CONSTEXPR_CXX20 TestBase(int x) noexcept : value(x) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit TestBase(int, int y) noexcept : value(y) {
+    TEST_CONSTEXPR_CXX20 explicit TestBase(int, int y) noexcept : value(y) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    TestBase(int, int y) noexcept : value(y) {
+    TEST_CONSTEXPR_CXX20 TestBase(int, int y) noexcept : value(y) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
+    TEST_CONSTEXPR_CXX20 explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
       : value(static_cast<int>(il.size())) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
+    TEST_CONSTEXPR_CXX20 explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
         ++alive; ++constructed; ++value_constructed;
     }
-    TestBase& operator=(int xvalue) noexcept {
+    TEST_CONSTEXPR_CXX20 TestBase& operator=(int xvalue) noexcept {
       value = xvalue;
       ++assigned; ++value_assigned;
       return *this;
     }
 #ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
 protected:
 #endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
-    ~TestBase() {
+    TEST_CONSTEXPR_CXX20 ~TestBase() {
       assert(value != -999); assert(alive > 0);
       --alive; ++destroyed; value = -999;
     }
-    explicit TestBase(TestBase const& o) noexcept : value(o.value) {
+    TEST_CONSTEXPR_CXX20 explicit TestBase(TestBase const& o) noexcept : value(o.value) {
         assert(o.value != -1); assert(o.value != -999);
         ++alive; ++constructed; ++copy_constructed;
     }
-    explicit TestBase(TestBase && o) noexcept : value(o.value) {
+    TEST_CONSTEXPR_CXX20 explicit TestBase(TestBase && o) noexcept : value(o.value) {
         assert(o.value != -1); assert(o.value != -999);
         ++alive; ++constructed; ++move_constructed;
         o.value = -1;
     }
-    TestBase& operator=(TestBase const& o) noexcept {
+    TEST_CONSTEXPR_CXX20 TestBase& operator=(TestBase const& o) noexcept {
       assert(o.value != -1); assert(o.value != -999);
       ++assigned; ++copy_assigned;
       value = o.value;
       return *this;
     }
-    TestBase& operator=(TestBase&& o) noexcept {
+    TEST_CONSTEXPR_CXX20 TestBase& operator=(TestBase&& o) noexcept {
         assert(o.value != -1); assert(o.value != -999);
         ++assigned; ++move_assigned;
         value = o.value;
         o.value = -1;
         return *this;
     }
 public:
     int value;