[libcxx] add missing constexpr to optional::value_or

[cpplearner]

Summary

See https://github.com/cplusplus/draft/pull/839 and https://github.com/cplusplus/fundamentals-ts/pull/73.

[EricWF]

Tests please! They should be somewhere under test/std/utilities/optional/optional.object/optional.object.observe

[cpplearner]

test updated

[EricWF]

The changes to <optional> LGTM but not the ones to <experimental/optional>

Unfortunately libc++'s <experimental/optional> doesn't yet implement LFTS v2 so all of the other non-const observers are also not constexpr in our implementation. I think updating <experimental/optional> to LFTS v2 should be done as a separate patch. Please back out the changes to <experimental/optional> before committing.

test/std/experimental/optional/optional.object/optional.object.observe/value_or.pass.cpp

48

This test doesn't compile since the non-const version of std::experimental::optional::operator*() isn't constexpr.

[cpplearner]

backed out the changes to <experimental/optional>

[EricWF]

@cpplearner Do you need somebody to commit this for you?

[cpplearner]

Yes, I do. Thank you.

include/experimental/optional

constexpr value_type value_or(_Up&& __v) const&
         static_assert(is_convertible<_Up, value_type>::value,
                       "optional<T>::value_or: U must be convertible to T");
         return this->__engaged_ ? this->__val_ :
                                   static_cast<value_type>(_VSTD::forward<_Up>(__v));
     }
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY
-    value_type value_or(_Up&& __v) &&
+    constexpr value_type value_or(_Up&& __v) &&
     {
         static_assert(is_move_constructible<value_type>::value,
                       "optional<T>::value_or: T must be move constructible");
         static_assert(is_convertible<_Up, value_type>::value,
                       "optional<T>::value_or: U must be convertible to T");
         return this->__engaged_ ? _VSTD::move(this->__val_) :
                                   static_cast<value_type>(_VSTD::forward<_Up>(__v));
     }

include/optional

constexpr value_type value_or(_Up&& __v) const&
         static_assert(is_convertible_v<_Up, value_type>,
                       "optional<T>::value_or: U must be convertible to T");
         return this->has_value() ? this->__get() :
                                   static_cast<value_type>(_VSTD::forward<_Up>(__v));
     }
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY
-    value_type value_or(_Up&& __v) &&
+    constexpr value_type value_or(_Up&& __v) &&
     {
         static_assert(is_move_constructible_v<value_type>,
                       "optional<T>::value_or: T must be move constructible");
         static_assert(is_convertible_v<_Up, value_type>,
                       "optional<T>::value_or: U must be convertible to T");
         return this->has_value() ? _VSTD::move(this->__get()) :
                                   static_cast<value_type>(_VSTD::forward<_Up>(__v));
     }

test/std/experimental/optional/optional.object/optional.object.observe/value_or.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
 // <optional>
 
-// template <class U> T optional<T>::value_or(U&& v) &&;
+// template <class U> constexpr T optional<T>::value_or(U&& v) &&;
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
 
 struct Y
 {
     int i_;
 
-    Y(int i) : i_(i) {}
+    constexpr Y(int i) : i_(i) {}
 };
 
 struct X
 {
     int i_;
 
-    X(int i) : i_(i) {}
-    X(X&& x) : i_(x.i_) {x.i_ = 0;}
-    X(const Y& y) : i_(y.i_) {}
-    X(Y&& y) : i_(y.i_+1) {}
+    constexpr X(int i) : i_(i) {}
+    constexpr X(X&& x) : i_(x.i_) {x.i_ = 0;}
+    constexpr X(const Y& y) : i_(y.i_) {}
+    constexpr X(Y&& y) : i_(y.i_+1) {}
     friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_;}
 };
 
-int main()
+constexpr int test()
 {
     {
         optional<X> opt(in_place, 2);
         Y y(3);
-        assert(std::move(opt).value_or(y) == 2);
-        assert(*opt == 0);
+        if (!(std::move(opt).value_or(y) == 2)) std::abort();
+        if (!(*opt == 0)) std::abort();
     }
     {
         optional<X> opt(in_place, 2);
-        assert(std::move(opt).value_or(Y(3)) == 2);
-        assert(*opt == 0);
+        if (!(std::move(opt).value_or(Y(3)) == 2)) std::abort();
+        if (!(*opt == 0)) std::abort();
     }
     {
         optional<X> opt;
         Y y(3);
-        assert(std::move(opt).value_or(y) == 3);
-        assert(!opt);
+        if (!(std::move(opt).value_or(y) == 3)) std::abort();
+        if (!(!opt)) std::abort();
     }
     {
         optional<X> opt;
-        assert(std::move(opt).value_or(Y(3)) == 4);
-        assert(!opt);
-    }
+        if (!(std::move(opt).value_or(Y(3)) == 4)) std::abort();
+        if (!(!opt)) std::abort();
+    }
+    return 0;
+
+int main()
+{
+    static_assert(test() == 0, "");
 }

test/std/utilities/optional/optional.object/optional.object.observe/value_or.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>
 
-// template <class U> T optional<T>::value_or(U&& v) &&;
+// template <class U> constexpr T optional<T>::value_or(U&& v) &&;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 using std::in_place_t;
 using std::in_place;
 
 struct Y
 {
     int i_;
 
-    Y(int i) : i_(i) {}
+    constexpr Y(int i) : i_(i) {}
 };
 
 struct X
 {
     int i_;
 
-    X(int i) : i_(i) {}
-    X(X&& x) : i_(x.i_) {x.i_ = 0;}
-    X(const Y& y) : i_(y.i_) {}
-    X(Y&& y) : i_(y.i_+1) {}
+    constexpr X(int i) : i_(i) {}
+    constexpr X(X&& x) : i_(x.i_) {x.i_ = 0;}
+    constexpr X(const Y& y) : i_(y.i_) {}
+    constexpr X(Y&& y) : i_(y.i_+1) {}
     friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_;}
 };
 
-int main()
+constexpr int test()
 {
     {
         optional<X> opt(in_place, 2);
         Y y(3);
         assert(std::move(opt).value_or(y) == 2);
         assert(*opt == 0);
     }
     {
         optional<X> opt(in_place, 2);
         assert(std::move(opt).value_or(Y(3)) == 2);
         assert(*opt == 0);
     }
     {
         optional<X> opt;
         Y y(3);
         assert(std::move(opt).value_or(y) == 3);
         assert(!opt);
     }
     {
         optional<X> opt;
         assert(std::move(opt).value_or(Y(3)) == 4);
         assert(!opt);
     }
+    return 0;
+}
+
+int main()
+{
+    static_assert(test() == 0);
 }