diff mbox

[v3] Implement LWG 2900, The copy and move constructors of optional are not constexpr.

Message ID CAFk2RUaaHyPNARiE32AhpbUE0Unv_5hptNvNmtxvyfURp=VSZg@mail.gmail.com
State New
Headers show

Commit Message

Ville Voutilainen March 17, 2017, 2:51 p.m. UTC 
Tested on Linux-x64.

2017-03-17  Ville Voutilainen  <ville.voutilainen@gmail.com>

    Implement LWG 2900, The copy and move constructors
    of optional are not constexpr.
    * include/std/optional (_Optional_payload): New.
    (_Optional_base): Remove the bool parameter.
    (_Optional_base<_Tp, false>): Remove.
    (_Optional_base()): Adjust.
    (_Optional_base(nullopt_t)): Likewise.
    (_Optional_base(in_place_t, _Args&&...)): Likewise.
    (_Optional_base(in_place_t, initializer_list<_Up>, _Args&&...)):
    Likewise.
    (_Optional_base(const _Optional_base&)): Likewise.
    (_Optional_base(_Optional_base&&)): Likewise.
    (operator=(const _Optional_base&)): Likewise.
    (operator=(_Optional_base&&)): Likewise.
    (~_Optional_base()): Remove.
    (_M_is_engaged()): Adjust.
    (_M_get()): Likewise.
    (_M_construct(_Args&&...)): Likewise.
    (_M_destruct()): Likewise.
    (_M_reset()): Likewise.
    (_Optional_base::_Empty_byte): Remove.
    (_Optional_base::_M_empty): Remove.
    (_Optional_base::_M_payload): Adjust.
    * testsuite/20_util/optional/cons/value_neg.cc: Adjust.
    * testsuite/20_util/optional/constexpr/cons/value.cc: Add tests.

Comments

Jonathan Wakely March 28, 2017, 10:06 a.m. UTC | #1 
On 17/03/17 16:51 +0200, Ville Voutilainen wrote:
>diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
>index 3f540ec..e67ba89 100644
>--- a/libstdc++-v3/include/std/optional
>+++ b/libstdc++-v3/include/std/optional
>@@ -95,125 +95,127 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>-      constexpr _Optional_base(nullopt_t) noexcept
>-      : _Optional_base{} { }
>+      template<typename _Up, typename... _Args>
>+      constexpr _Optional_payload(std::initializer_list<_Up> __il,
>+				  _Args&&... __args)
>+	: _M_payload(__il, std::forward<_Args>(__args)...),
>+	  _M_engaged(true) {}
>+
>+      template <class _Up> struct __ctor_tag {};

Newline here please, so it doesn't look like this template<...> is on
the constructor.

>+      constexpr _Optional_payload(__ctor_tag<bool>,
>+				  const _Tp& __other)
>+	: _M_payload(__other),
>+	  _M_engaged(true)
>+      {}
>+
>+      constexpr _Optional_payload(__ctor_tag<void>)
>+	: _M_empty()
>+      {}
>+
>+      constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
>+	: _M_payload(std::move(__other)),
>+	  _M_engaged(true)
>+      {}
>+
>+      constexpr _Optional_payload(bool __engaged,
>+				  const _Optional_payload&

Looks like we don't need a newline before the parameter name here:

>+				  __other)
>+	: _Optional_payload(__engaged ?
>+			    _Optional_payload(__ctor_tag<bool>{},
>+					      __other._M_payload) :
>+			    _Optional_payload(__ctor_tag<void>{}))
>+      {}
>+
>+      constexpr _Optional_payload(bool __engaged,
>+				  _Optional_payload&&

Nor here:

>+				  __other)
>+	: _Optional_payload(__engaged ?
>+			    _Optional_payload(__ctor_tag<bool>{},
>+					      std::move(__other._M_payload)) :
>+			    _Optional_payload(__ctor_tag<void>{}))
>+      {}

Hmm, I see we don't actually show a conditional expression in the
Coding Style docs, but I'd do that as:

	: _Optional_payload(__engaged
			    ? _Optional_payload(__ctor_tag<bool>{},
                                                std::move(__other._M_payload))
			    : _Optional_payload(__ctor_tag<void>{}))


>-      // Constructors for engaged optionals.
>-      template<typename... _Args,
>-	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
>-        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
>-        : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
>+      using _Stored_type = remove_const_t<_Tp>;
>+      struct _Empty_byte { };

I was going to ask whether std::byte would be better here, but I think
a valueless struct is better.

>+      union {
>+          _Empty_byte _M_empty;
>+          _Stored_type _M_payload;
>+      };
>+      bool _M_engaged = false;
>+    };


>+      template<typename... _Args>
>+        void
>+        _M_construct(_Args&&... __args)
>+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
>+        {
>+          ::new (std::__addressof(this->_M_payload))

I think we need (void*) here to ensure we use the reserved placement
form of operator new and not some other overload:

struct X { };
void* operator new(decltype(sizeof(0)) n, X*);

(We don't get this right everywhere that uses placement new with
arbitrary types).


>+            _Stored_type(std::forward<_Args>(__args)...);
>+          this->_M_engaged = true;
>+        }
>     };
>
>+      // The _M_construct operation has !_M_engaged as a precondition
>+      // while _M_destruct has _M_engaged as a precondition.
>       template<typename... _Args>
>         void
>         _M_construct(_Args&&... __args)
>         noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
>         {
>-          ::new (std::__addressof(this->_M_payload))
>+          ::new (std::__addressof(this->_M_payload._M_payload))

Here too.

>             _Stored_type(std::forward<_Args>(__args)...);
>-          this->_M_engaged = true;
>+          this->_M_payload._M_engaged = true;
>         }

OK for trunk with those adjustements, thanks.
diff mbox

Patch

diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index 3f540ec..e67ba89 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -95,125 +95,127 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   __throw_bad_optional_access()
   { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }
 
-  /**
-    * @brief Class template that holds the necessary state for @ref optional
-    * and that has the responsibility for construction and the special members.
-    *
-    * Such a separate base class template is necessary in order to
-    * conditionally enable the special members (e.g. copy/move constructors).
-    * Note that this means that @ref _Optional_base implements the
-    * functionality for copy and move assignment, but not for converting
-    * assignment.
-    *
-    * @see optional, _Enable_special_members
-    */
-  template<typename _Tp, bool _ShouldProvideDestructor =
-	   !is_trivially_destructible<_Tp>::value>
-    class _Optional_base
-    {
-    private:
-      // Remove const to avoid prohibition of reusing object storage for
-      // const-qualified types in [3.8/9]. This is strictly internal
-      // and even optional itself is oblivious to it.
-      using _Stored_type = remove_const_t<_Tp>;
 
-    public:
+  // Payload for constexpr optionals.
+  template <typename _Tp,
+	    bool /*_TrivialCopyMove*/ =
+	      is_trivially_copy_constructible<_Tp>::value
+	      && is_trivially_move_constructible<_Tp>::value,
+	    bool /*_ShouldProvideDestructor*/ =
+	      is_trivially_destructible<_Tp>::value>
+    struct _Optional_payload
+    {
+      constexpr _Optional_payload()
+	: _M_empty() {}
 
-      // Constructors for disengaged optionals.
-      constexpr _Optional_base() noexcept
-      : _M_empty{} { }
+      template<typename... _Args>
+      constexpr _Optional_payload(in_place_t, _Args&&... __args)
+	: _M_payload(std::forward<_Args>(__args)...),
+	  _M_engaged(true)
+      {}
 
-      constexpr _Optional_base(nullopt_t) noexcept
-      : _Optional_base{} { }
+      template<typename _Up, typename... _Args>
+      constexpr _Optional_payload(std::initializer_list<_Up> __il,
+				  _Args&&... __args)
+	: _M_payload(__il, std::forward<_Args>(__args)...),
+	  _M_engaged(true) {}
+
+      template <class _Up> struct __ctor_tag {};
+      constexpr _Optional_payload(__ctor_tag<bool>,
+				  const _Tp& __other)
+	: _M_payload(__other),
+	  _M_engaged(true)
+      {}
+
+      constexpr _Optional_payload(__ctor_tag<void>)
+	: _M_empty()
+      {}
+
+      constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
+	: _M_payload(std::move(__other)),
+	  _M_engaged(true)
+      {}
+
+      constexpr _Optional_payload(bool __engaged,
+				  const _Optional_payload&
+				  __other)
+	: _Optional_payload(__engaged ?
+			    _Optional_payload(__ctor_tag<bool>{},
+					      __other._M_payload) :
+			    _Optional_payload(__ctor_tag<void>{}))
+      {}
+
+      constexpr _Optional_payload(bool __engaged,
+				  _Optional_payload&&
+				  __other)
+	: _Optional_payload(__engaged ?
+			    _Optional_payload(__ctor_tag<bool>{},
+					      std::move(__other._M_payload)) :
+			    _Optional_payload(__ctor_tag<void>{}))
+      {}
 
-      // Constructors for engaged optionals.
-      template<typename... _Args,
-	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
-        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
-        : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged = false;
+    };
 
-      template<typename _Up, typename... _Args,
-               enable_if_t<is_constructible_v<_Tp,
-					      initializer_list<_Up>&,
-					      _Args&&...>, bool> = false>
-        constexpr explicit _Optional_base(in_place_t,
-                                          initializer_list<_Up> __il,
-                                          _Args&&... __args)
-        : _M_payload(__il, std::forward<_Args>(__args)...),
-          _M_engaged(true) { }
+  // Payload for non-constexpr optionals with non-trivial destructor.
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, false, false>
+    {
+      constexpr _Optional_payload()
+	: _M_empty() {}
 
-      // Copy and move constructors.
-      _Optional_base(const _Optional_base& __other)
-      {
-        if (__other._M_engaged)
-          this->_M_construct(__other._M_get());
-      }
+      template <typename... _Args>
+      constexpr _Optional_payload(in_place_t, _Args&&... __args)
+	: _M_payload(std::forward<_Args>(__args)...),
+	  _M_engaged(true) {}
 
-      _Optional_base(_Optional_base&& __other)
-      noexcept(is_nothrow_move_constructible<_Tp>())
+      template<typename _Up, typename... _Args>
+      constexpr _Optional_payload(std::initializer_list<_Up> __il,
+				  _Args&&... __args)
+	: _M_payload(__il, std::forward<_Args>(__args)...),
+	  _M_engaged(true) {}
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+	: _Optional_payload(__other)
+      {}
+
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+	: _Optional_payload(std::move(__other))
+      {}
+
+      constexpr _Optional_payload(const _Optional_payload& __other)
       {
-        if (__other._M_engaged)
-          this->_M_construct(std::move(__other._M_get()));
+	if (__other._M_engaged)
+	  this->_M_construct(__other._M_payload);
       }
 
-      // Assignment operators.
-      _Optional_base&
-      operator=(const _Optional_base& __other)
+      constexpr _Optional_payload(_Optional_payload&& __other)
       {
-        if (this->_M_engaged && __other._M_engaged)
-          this->_M_get() = __other._M_get();
-        else
-	  {
-	    if (__other._M_engaged)
-	      this->_M_construct(__other._M_get());
-	    else
-	      this->_M_reset();
-	  }
-
-        return *this;
+	if (__other._M_engaged)
+	  this->_M_construct(std::move(__other._M_payload));
       }
 
-      _Optional_base&
-      operator=(_Optional_base&& __other)
-      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
-		      is_nothrow_move_assignable<_Tp>>())
-      {
-	if (this->_M_engaged && __other._M_engaged)
-	  this->_M_get() = std::move(__other._M_get());
-	else
-	  {
-	    if (__other._M_engaged)
-	      this->_M_construct(std::move(__other._M_get()));
-	    else
-	      this->_M_reset();
-	  }
-	return *this;
-      }
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged = false;
 
-      // Destructor.
-      ~_Optional_base()
+      ~_Optional_payload()
       {
-        if (this->_M_engaged)
-          this->_M_payload.~_Stored_type();
+        if (_M_engaged)
+          _M_payload.~_Stored_type();
       }
 
-      // The following functionality is also needed by optional, hence the
-      // protected accessibility.
-    protected:
-      constexpr bool _M_is_engaged() const noexcept
-      { return this->_M_engaged; }
-
-      // The _M_get operations have _M_engaged as a precondition.
-      constexpr _Tp&
-      _M_get() noexcept
-      { return _M_payload; }
-
-      constexpr const _Tp&
-      _M_get() const noexcept
-      { return _M_payload; }
-
-      // The _M_construct operation has !_M_engaged as a precondition
-      // while _M_destruct has _M_engaged as a precondition.
       template<typename... _Args>
         void
         _M_construct(_Args&&... __args)
@@ -223,50 +225,102 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
             _Stored_type(std::forward<_Args>(__args)...);
           this->_M_engaged = true;
         }
+    };
 
-      void
-      _M_destruct()
+  // Payload for non-constexpr optionals with trivial destructor.
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, false, true>
+    {
+      constexpr _Optional_payload()
+	: _M_empty() {}
+
+      template <typename... _Args>
+      constexpr _Optional_payload(in_place_t, _Args&&... __args)
+	: _M_payload(std::forward<_Args>(__args)...),
+	  _M_engaged(true) {}
+
+      template<typename _Up, typename... _Args>
+      constexpr _Optional_payload(std::initializer_list<_Up> __il,
+				  _Args&&... __args)
+	: _M_payload(__il, std::forward<_Args>(__args)...),
+	  _M_engaged(true) {}
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+	: _Optional_payload(__other)
+      {}
+
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+	: _Optional_payload(std::move(__other))
+      {}
+
+      constexpr _Optional_payload(const _Optional_payload& __other)
       {
-        this->_M_engaged = false;
-        this->_M_payload.~_Stored_type();
+	if (__other._M_engaged)
+	  this->_M_construct(__other._M_payload);
       }
 
-      // _M_reset is a 'safe' operation with no precondition.
-      void
-      _M_reset()
+      constexpr _Optional_payload(_Optional_payload&& __other)
       {
-        if (this->_M_engaged)
-          this->_M_destruct();
+	if (__other._M_engaged)
+	  this->_M_construct(std::move(__other._M_payload));
       }
 
-    private:
+      using _Stored_type = remove_const_t<_Tp>;
       struct _Empty_byte { };
       union {
           _Empty_byte _M_empty;
           _Stored_type _M_payload;
       };
       bool _M_engaged = false;
+
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new (std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
     };
 
-  /// Partial specialization that is exactly identical to the primary template
-  /// save for not providing a destructor, to fulfill triviality requirements.
+  /**
+    * @brief Class template that holds the necessary state for @ref optional
+    * and that has the responsibility for construction and the special members.
+    *
+    * Such a separate base class template is necessary in order to
+    * conditionally enable the special members (e.g. copy/move constructors).
+    * Note that this means that @ref _Optional_base implements the
+    * functionality for copy and move assignment, but not for converting
+    * assignment.
+    *
+    * @see optional, _Enable_special_members
+    */
   template<typename _Tp>
-    class _Optional_base<_Tp, false>
+    class _Optional_base
     {
     private:
+      // Remove const to avoid prohibition of reusing object storage for
+      // const-qualified types in [3.8/9]. This is strictly internal
+      // and even optional itself is oblivious to it.
       using _Stored_type = remove_const_t<_Tp>;
 
     public:
+
+      // Constructors for disengaged optionals.
       constexpr _Optional_base() noexcept
-      : _M_empty{} { }
+      { }
 
       constexpr _Optional_base(nullopt_t) noexcept
-      : _Optional_base{} { }
+      { }
 
+      // Constructors for engaged optionals.
       template<typename... _Args,
 	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
         constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
-        : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
+        : _M_payload(in_place,
+		     std::forward<_Args>(__args)...) { }
 
       template<typename _Up, typename... _Args,
                enable_if_t<is_constructible_v<_Tp,
@@ -275,35 +329,37 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
         constexpr explicit _Optional_base(in_place_t,
                                           initializer_list<_Up> __il,
                                           _Args&&... __args)
-        : _M_payload(__il, std::forward<_Args>(__args)...),
-          _M_engaged(true) { }
+        : _M_payload(in_place,
+		     __il, std::forward<_Args>(__args)...)
+        { }
 
-      _Optional_base(const _Optional_base& __other)
-      {
-        if (__other._M_engaged)
-          this->_M_construct(__other._M_get());
-      }
+      // Copy and move constructors.
+      constexpr _Optional_base(const _Optional_base& __other)
+	: _M_payload(__other._M_payload._M_engaged,
+		     __other._M_payload)
+      { }
 
-      _Optional_base(_Optional_base&& __other)
+      constexpr _Optional_base(_Optional_base&& __other)
       noexcept(is_nothrow_move_constructible<_Tp>())
-      {
-        if (__other._M_engaged)
-          this->_M_construct(std::move(__other._M_get()));
-      }
+	: _M_payload(__other._M_payload._M_engaged,
+		     std::move(__other._M_payload))
+      { }
 
+      // Assignment operators.
       _Optional_base&
       operator=(const _Optional_base& __other)
       {
-	if (this->_M_engaged && __other._M_engaged)
-	  this->_M_get() = __other._M_get();
-	else
+        if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
+          this->_M_get() = __other._M_get();
+        else
 	  {
-	    if (__other._M_engaged)
+	    if (__other._M_payload._M_engaged)
 	      this->_M_construct(__other._M_get());
 	    else
 	      this->_M_reset();
 	  }
-	return *this;
+
+        return *this;
       }
 
       _Optional_base&
@@ -311,65 +367,61 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
       noexcept(__and_<is_nothrow_move_constructible<_Tp>,
 		      is_nothrow_move_assignable<_Tp>>())
       {
-	if (this->_M_engaged && __other._M_engaged)
+	if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
 	  this->_M_get() = std::move(__other._M_get());
 	else
 	  {
-	    if (__other._M_engaged)
+	    if (__other._M_payload._M_engaged)
 	      this->_M_construct(std::move(__other._M_get()));
 	    else
 	      this->_M_reset();
 	  }
 	return *this;
       }
-
-      // Sole difference
-      // ~_Optional_base() noexcept = default;
-
+      // The following functionality is also needed by optional, hence the
+      // protected accessibility.
     protected:
       constexpr bool _M_is_engaged() const noexcept
-      { return this->_M_engaged; }
+      { return this->_M_payload._M_engaged; }
 
+      // The _M_get operations have _M_engaged as a precondition.
       constexpr _Tp&
       _M_get() noexcept
-      { return _M_payload; }
+      { return this->_M_payload._M_payload; }
 
       constexpr const _Tp&
       _M_get() const noexcept
-      { return _M_payload; }
+      { return this->_M_payload._M_payload; }
 
+      // The _M_construct operation has !_M_engaged as a precondition
+      // while _M_destruct has _M_engaged as a precondition.
       template<typename... _Args>
         void
         _M_construct(_Args&&... __args)
         noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
         {
-          ::new (std::__addressof(this->_M_payload))
+          ::new (std::__addressof(this->_M_payload._M_payload))
             _Stored_type(std::forward<_Args>(__args)...);
-          this->_M_engaged = true;
+          this->_M_payload._M_engaged = true;
         }
 
       void
       _M_destruct()
       {
-        this->_M_engaged = false;
-        this->_M_payload.~_Stored_type();
+        this->_M_payload._M_engaged = false;
+        this->_M_payload._M_payload.~_Stored_type();
       }
 
+      // _M_reset is a 'safe' operation with no precondition.
       void
       _M_reset()
       {
-        if (this->_M_engaged)
+        if (this->_M_payload._M_engaged)
           this->_M_destruct();
       }
 
     private:
-      struct _Empty_byte { };
-      union
-      {
-	_Empty_byte _M_empty;
-	_Stored_type _M_payload;
-      };
-      bool _M_engaged = false;
+      _Optional_payload<_Tp> _M_payload;
     };
 
   template<typename _Tp>
diff --git a/libstdc++-v3/testsuite/20_util/optional/cons/value_neg.cc b/libstdc++-v3/testsuite/20_util/optional/cons/value_neg.cc
index 249f622..ff17b86 100644
--- a/libstdc++-v3/testsuite/20_util/optional/cons/value_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/optional/cons/value_neg.cc
@@ -37,8 +37,8 @@  int main()
     std::optional<std::unique_ptr<int>> oup2 = new int;  // { dg-error "conversion" }
     struct U { explicit U(std::in_place_t); };
     std::optional<U> ou(std::in_place); // { dg-error "no matching" }
-    // { dg-error "no type" "" { target { *-*-* } } 437 }
-    // { dg-error "no type" "" { target { *-*-* } } 447 }
-    // { dg-error "no type" "" { target { *-*-* } } 504 }
+    // { dg-error "no type" "" { target { *-*-* } } 489 }
+    // { dg-error "no type" "" { target { *-*-* } } 499 }
+    // { dg-error "no type" "" { target { *-*-* } } 556 }
   }
 }
diff --git a/libstdc++-v3/testsuite/20_util/optional/constexpr/cons/value.cc b/libstdc++-v3/testsuite/20_util/optional/constexpr/cons/value.cc
index b289f44..3b183f8 100644
--- a/libstdc++-v3/testsuite/20_util/optional/constexpr/cons/value.cc
+++ b/libstdc++-v3/testsuite/20_util/optional/constexpr/cons/value.cc
@@ -66,4 +66,21 @@  int main()
     static_assert( o, "" );
     static_assert( *o == 0x1234ABCD, "" );
   }
+  {
+    constexpr std::optional<long> o = 42;
+    constexpr std::optional<long> o2{o};
+    constexpr std::optional<long> o3(o);
+    constexpr std::optional<long> o4 = o;
+    constexpr std::optional<long> o5;
+    constexpr std::optional<long> o6{o5};
+    constexpr std::optional<long> o7(o5);
+    constexpr std::optional<long> o8 = o5;
+    constexpr std::optional<long> o9{std::move(o)};
+    constexpr std::optional<long> o10(std::move(o));
+    constexpr std::optional<long> o11 = std::move(o);
+    constexpr std::optional<long> o12;
+    constexpr std::optional<long> o13{std::move(o5)};
+    constexpr std::optional<long> o14(std::move(o5));
+    constexpr std::optional<long> o15 = std::move(o5);
+  }
 }