[libcxx] Update optional star operator to be noexcept.

[• Quuxplusone]

LGTM % comment, but it's major.

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp

40

Should use ASSERT_NOEXCEPT(*opt);
However, is this guaranteed by the Standard? or should this actually be a new test file in libcxx/test/libcxx/ because it's a conforming extension we're doing?
If new file, then I think one file (not four) would suffice: dereference_noexcept.compile.pass.cpp or something like that.

[zoecarver]

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp

40

LIBCPP_STATIC_ASSERT means it will only be checked for libc++. I think this is fine. I'd rather not add another file (putting it here also makes it far easier to find).

libcxx/include/optional

 #else
         return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
 #endif
     }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     const value_type&
-    operator*() const&
+    operator*() const& noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return this->__get();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     value_type&
-    operator*() &
+    operator*() & noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return this->__get();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     value_type&&
-    operator*() &&
+    operator*() && noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return _VSTD::move(this->__get());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr
     const value_type&&
-    operator*() const&&
+    operator*() const&& noexcept
     {
         _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
         return _VSTD::move(this->__get());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     constexpr explicit operator bool() const noexcept { return has_value(); }
 

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp

test()
     return (*opt).test();
 }
 
 int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*opt), X&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*opt);
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
         // (B) there is no path through the function that throws.
         // It's arguable if this is the correct behavior for the noexcept
         // operator.
         // Regardless this function should still be noexcept(false) because
         // it has a narrow contract.

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp

struct Y
     int test() const {return 2;}
 };
 
 int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*opt), X const&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*opt);
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
         // (B) there is no path through the function that throws.
         // It's arguable if this is the correct behavior for the noexcept
         // operator.
         // Regardless this function should still be noexcept(false) because
         // it has a narrow contract.

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp

struct Y
     int test() const && {return 2;}
 };
 
 int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*std::move(opt)), X const &&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*std::move(opt));
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
         // (B) there is no path through the function that throws.
         // It's arguable if this is the correct behavior for the noexcept
         // operator.
         // Regardless this function should still be noexcept(false) because
         // it has a narrow contract.

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp

test()
     return (*std::move(opt)).test();
 }
 
 int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
         ASSERT_SAME_TYPE(decltype(*std::move(opt)), X&&);
+        LIBCPP_STATIC_ASSERT(noexcept(*opt));
         // ASSERT_NOT_NOEXCEPT(*std::move(opt));
         // FIXME: This assertion fails with GCC because it can see that
         // (A) operator*() is constexpr, and
         // (B) there is no path through the function that throws.
         // It's arguable if this is the correct behavior for the noexcept
         // operator.
         // Regardless this function should still be noexcept(false) because
         // it has a narrow contract.