Address comments + Add some tests for function refs and array refs

Author: smallp-o-p

libcxx/include/optional

@@ -266,11 +266,6 @@ namespace std {
 _LIBCPP_PUSH_MACROS
 #  include <__undef_macros>
 
-#  if _LIBCPP_STD_VER >= 26
-#    define _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_TP, _UP)                                                            \
-      requires(is_lvalue_reference_v<_TP> && reference_constructs_from_temporary_v<_TP, _UP>)
-#  endif
-
 namespace std // purposefully not using versioning namespace
 {
 
@@ -702,6 +697,12 @@ private:
   static_assert(is_destructible_v<value_type>, "instantiation of optional with a non-destructible type is ill-formed");
   static_assert(!is_array_v<value_type>, "instantiation of optional with an array type is ill-formed");
 
+#    if _LIBCPP_STD_VER >= 26
+  template <class _Up>
+  constexpr static bool __libcpp_opt_ref_ctor_deleted =
+      is_lvalue_reference_v<_Tp> && reference_constructs_from_temporary_v<_Tp, _Up>;
+#    endif
+
   // LWG2756: conditionally explicit conversion from _Up
   struct _CheckOptionalArgsConstructor {
     template <class _Up>
@@ -818,33 +819,33 @@ public:
   template <class _Up,
             class... _Args,
             enable_if_t<is_constructible_v<value_type, initializer_list<_Up>&, _Args...>, int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) = delete;
 
   template <class _Up                                                                        = value_type,
             enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) = delete;
 
   template <class _Up                                                                        = remove_cv_t<_Tp>,
             enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) = delete;
 
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) = delete;
 
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) = delete;
 
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) = delete;
 
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
-  _LIBCPP_OPT_REF_DELETED_CONS_REQUIRES(_Tp, _Up)
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) = delete;
 #    endif
 

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

@@ -136,8 +136,8 @@ void test_reference_extension() {
   assert(T::alive == 0);
   assert(T::destroyed == 1);
   {
-    static_assert(!std::is_copy_constructible<std::optional<T&&>>::value, "");
-    static_assert(!std::is_copy_constructible<std::optional<T const&&>>::value, "");
+    static_assert(!std::is_copy_constructible_v<std::optional<T&&>>);
+    static_assert(!std::is_copy_constructible_v<std::optional<T const&&>>);
   }
 #  endif
 #endif

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ref_constructs_from_temporary.verify.cpp

@@ -32,4 +32,4 @@ int main(int, char**) {
   std::optional<const X&> o6{std::optional<int>(1)};   // optional(optional<U>&&)
   std::optional<const X&> o7{_co};                     // optional(const optional<U>&)
   std::optional<const X&> o8{_o};                      // optional(optional<U>&)
-}
+}

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

@@ -32,9 +32,44 @@ constexpr bool test() {
   return true;
 }
 
-int main(int, char**) {
-  static_assert((test<int&, 1>()));
-  static_assert((test<double&, 1.0>()));
+template <typename T>
+constexpr T foo(T val) {
+  return val;
+}
+
+template <typename T, T _Val>
+constexpr bool fn_ref_test() {
+  std::optional<T (&)(T)> opt{foo<T>};
+  assert(opt.has_value());
+  assert((*opt)(_Val) == _Val);
+
+  return true;
+}
+
+template <typename T, T _Val>
+constexpr bool array_ref_test() {
+  T arr[5]{};
+  std::optional<T(&)[5]> opt{arr};
+
+  assert(opt.has_value());
+  (*opt)[0] = _Val;
+  assert((*opt)[0] == _Val);
+  assert(arr[0] == _Val);
+
+  return true;
+}
+
+constexpr bool tests() {
   assert((test<int&, 1>()));
   assert((test<double&, 1.0>()));
+  assert((fn_ref_test<int, 1>()));
+  assert((array_ref_test<int, 1>()));
+  assert((fn_ref_test<double, 1.0>()));
+  assert((array_ref_test<double, 1.0>()));
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(tests());
+  tests();
 }

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

@@ -66,9 +66,21 @@ int main(int, char**)
     }
 #if TEST_STD_VER >= 26
     {
-      typedef int& T;
-      static_assert(std::is_trivially_destructible<T>::value, "");
-      static_assert(std::is_trivially_destructible<optional<T>>::value, "");
+      typedef X& T;
+      static_assert(std::is_trivially_destructible<T>::value);
+      static_assert(std::is_trivially_destructible<optional<T>>::value);
+    }
+    X::dtor_called = false;
+    X x;
+    {
+      optional<X&> opt{x};
+      assert(X::dtor_called == false);
+    }
+    assert(X::dtor_called == false);
+
+    {
+      static_assert(std::is_trivially_destructible<X (&)()>::value);
+      static_assert(std::is_trivially_destructible<optional<X (&)()>>::value);
     }
 #endif
     return 0;

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

@@ -37,7 +37,7 @@ int main(int, char**)
     {
       static constexpr int i = 0;
       constexpr optional<const int&> opt{i};
-      static_assert(opt.has_value(), "");
+      static_assert(opt.has_value());
     }
 #endif
 

libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.verify.cpp

@@ -29,12 +29,11 @@ int main(int, char**)
     {
 #if TEST_STD_VER >= 26
       // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
-      optional<int&&> opt2;
 #else
       // expected-error-re@optional:* 2 {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+#endif
       optional<int&> opt1;
       optional<int&&> opt2;
-#endif
     }
     {
         // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}