[committed,1/3] libstdc++: Add noexcept to std::optional initialization (PR 96036)

Message ID 20200706210551.GA750840@redhat.com
State New
Headers show
Series
  • [committed,1/3] libstdc++: Add noexcept to std::optional initialization (PR 96036)
Related show

Commit Message

Peter Bergner via Gcc-patches July 6, 2020, 9:05 p.m.
libstdc++-v3/ChangeLog:

	PR libstdc++/96036
	* include/std/optional (optional): Add noexcept-specifier to
	every constructor, assignment operator, emplace function and
	dereference operator.
	* testsuite/20_util/optional/assignment/noexcept.cc: New test.
	* testsuite/20_util/optional/cons/noexcept.cc: New test.

Tested powerpc64le-linux, committed to trunk.
commit 8992cd1892df1adb352cf5d5b279a00686d1e88a
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Mon Jul 6 21:54:12 2020 +0100

    libstdc++: Add noexcept to std::optional initialization (PR 96036)
    
    libstdc++-v3/ChangeLog:
    
            PR libstdc++/96036
            * include/std/optional (optional): Add noexcept-specifier to
            every constructor, assignment operator, emplace function and
            dereference operator.
            * testsuite/20_util/optional/assignment/noexcept.cc: New test.
            * testsuite/20_util/optional/cons/noexcept.cc: New test.

Comments

Peter Bergner via Gcc-patches July 6, 2020, 9:06 p.m. | #1
The standard rquires that std::make_optional is constrained similarly to
the std::optional constructors, which our implementation fails to do.

As a conforming extension this also adds a noexcept-specifier to each
std::make_optional overload.

libstdc++-v3/ChangeLog:

         * include/std/optional (make_optional): Add enable_if
         constraints and noexcept-specifier to each overload.
         * testsuite/20_util/optional/make_optional-2.cc: New test.


Tested powerpc64le-linux, committed to trunk.
Peter Bergner via Gcc-patches July 6, 2020, 9:08 p.m. | #2
On 06/07/20 22:06 +0100, Jonathan Wakely wrote:
>The standard rquires that std::make_optional is constrained similarly to

>the std::optional constructors, which our implementation fails to do.

>

>As a conforming extension this also adds a noexcept-specifier to each

>std::make_optional overload.

>

>libstdc++-v3/ChangeLog:

>

>        * include/std/optional (make_optional): Add enable_if

>        constraints and noexcept-specifier to each overload.

>        * testsuite/20_util/optional/make_optional-2.cc: New test.

>

>

>Tested powerpc64le-linux, committed to trunk.


And with the patch attached this time ...
commit bcfe4681f9be68f96f0610f30356510ff518806b
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Mon Jul 6 21:54:12 2020 +0100

    libstdc++: Constrain std::make_optional
    
    The standard rquires that std::make_optional is constrained similarly to
    the std::optional constructors, which our implementation fails to do.
    
    As a conforming extension this also adds a noexcept-specifier to each
    std::make_optional overload.
    
    libstdc++-v3/ChangeLog:
    
            * include/std/optional (make_optional): Add enable_if
            constraints and noexcept-specifier to each overload.
            * testsuite/20_util/optional/make_optional-2.cc: New test.

diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index 785c434412d..24821f81d0f 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -1220,19 +1220,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     swap(optional<_Tp>&, optional<_Tp>&) = delete;
 
   template<typename _Tp>
-    constexpr optional<decay_t<_Tp>>
+    constexpr
+    enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
+		optional<decay_t<_Tp>>>
     make_optional(_Tp&& __t)
-    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
+    noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
+    { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }
 
-  template<typename _Tp, typename ..._Args>
-    constexpr optional<_Tp>
+  template<typename _Tp, typename... _Args>
+    constexpr
+    enable_if_t<is_constructible_v<_Tp, _Args...>,
+		optional<_Tp>>
     make_optional(_Args&&... __args)
-    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }
+    noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
+    { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }
 
-  template<typename _Tp, typename _Up, typename ..._Args>
-    constexpr optional<_Tp>
+  template<typename _Tp, typename _Up, typename... _Args>
+    constexpr
+    enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+		optional<_Tp>>
     make_optional(initializer_list<_Up> __il, _Args&&... __args)
-    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }
+    noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
+    { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }
 
   // Hash.
 
diff --git a/libstdc++-v3/testsuite/20_util/optional/make_optional-2.cc b/libstdc++-v3/testsuite/20_util/optional/make_optional-2.cc
new file mode 100644
index 00000000000..65a1fc78d80
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/optional/make_optional-2.cc
@@ -0,0 +1,94 @@
+// { dg-do compile { target c++17 }  }
+
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <optional>
+
+int i;
+
+struct Cont
+{
+  Cont() noexcept;
+  Cont(Cont&&) noexcept;
+  Cont(const Cont&);
+  Cont(int);
+  Cont(std::initializer_list<int>, int) noexcept;
+  Cont(std::initializer_list<int>, const char*);
+};
+const Cont c{};
+
+template<typename T, typename = void>
+  struct can_make_optional1
+  : std::false_type
+  { };
+
+template<typename T>
+  struct can_make_optional1<T,
+      std::void_t<decltype(std::make_optional(std::declval<T>()))>>
+  : std::true_type
+  { };
+
+static_assert( can_make_optional1<int>::value );
+static_assert( noexcept(std::make_optional(1)) );
+static_assert( can_make_optional1<int&>::value );
+static_assert( noexcept(std::make_optional(i)) );
+static_assert( ! can_make_optional1<void>::value );
+static_assert( can_make_optional1<Cont>::value );
+static_assert( noexcept(std::make_optional(Cont{})) );
+static_assert( can_make_optional1<Cont>::value );
+static_assert( ! noexcept(std::make_optional(c)) );
+
+template<typename T, typename Arg, typename = void>
+  struct can_make_optional2
+  : std::false_type
+  { };
+
+template<typename T, typename Arg>
+  struct can_make_optional2<T, Arg,
+      std::void_t<decltype(std::make_optional<T>(std::declval<Arg>()))>>
+  : std::true_type
+  { };
+
+static_assert( can_make_optional2<int, int>::value );
+static_assert( noexcept(std::make_optional<int>(1)) );
+static_assert( can_make_optional2<int, int&>::value );
+static_assert( noexcept(std::make_optional(i)) );
+static_assert( ! can_make_optional2<void, void>::value );
+static_assert( can_make_optional2<Cont, Cont>::value );
+static_assert( noexcept(std::make_optional<Cont>({})) );
+static_assert( can_make_optional2<Cont, const Cont&>::value );
+static_assert( ! noexcept(std::make_optional(c)) );
+static_assert( can_make_optional2<Cont, int>::value );
+static_assert( ! noexcept(std::make_optional<Cont>(1)) );
+
+template<typename T, typename Arg, typename = void>
+  struct can_make_optional3
+  : std::false_type
+  { };
+
+template<typename T, typename Arg>
+  struct can_make_optional3<T, Arg,
+      std::void_t<decltype(std::make_optional<T>({1,2}, std::declval<Arg>()))>>
+  : std::true_type
+  { };
+
+static_assert( can_make_optional3<Cont, int>::value );
+static_assert( noexcept(std::make_optional<Cont>({1,2}, 1)) );
+static_assert( can_make_optional3<Cont, char*>::value );
+static_assert( ! noexcept(std::make_optional<Cont>({1,2}, "")) );
+static_assert( !can_make_optional3<Cont, int*>::value );

Patch

diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index 923d45ae0e8..785c434412d 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -698,6 +698,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			 is_convertible<_Up&&, _Tp>> = true>
 	constexpr
 	optional(_Up&& __t)
+	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 	: _Base(std::in_place, std::forward<_Up>(__t)) { }
 
       template<typename _Up = _Tp,
@@ -706,6 +707,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			 __not_<is_convertible<_Up&&, _Tp>>> = false>
 	explicit constexpr
 	optional(_Up&& __t)
+	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
         : _Base(std::in_place, std::forward<_Up>(__t)) { }
 
       template<typename _Up,
@@ -715,6 +717,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			 __not_<__converts_from_optional<_Tp, _Up>>> = true>
 	constexpr
 	optional(const optional<_Up>& __t)
+	noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 	{
 	  if (__t)
 	    emplace(*__t);
@@ -727,6 +730,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			 __not_<__converts_from_optional<_Tp, _Up>>> = false>
 	explicit constexpr
 	optional(const optional<_Up>& __t)
+	noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 	{
 	  if (__t)
 	    emplace(*__t);
@@ -739,6 +743,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			  __not_<__converts_from_optional<_Tp, _Up>>> = true>
 	constexpr
 	optional(optional<_Up>&& __t)
+	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 	{
 	  if (__t)
 	    emplace(std::move(*__t));
@@ -751,6 +756,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			  __not_<__converts_from_optional<_Tp, _Up>>> = false>
 	explicit constexpr
 	optional(optional<_Up>&& __t)
+	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 	{
 	  if (__t)
 	    emplace(std::move(*__t));
@@ -760,6 +766,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	       _Requires<is_constructible<_Tp, _Args&&...>> = false>
 	explicit constexpr
 	optional(in_place_t, _Args&&... __args)
+	noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 	: _Base(std::in_place, std::forward<_Args>(__args)...) { }
 
       template<typename _Up, typename... _Args,
@@ -768,8 +775,11 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 					  _Args&&...>> = false>
 	explicit constexpr
 	optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+	noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
+					    _Args...>)
 	: _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
 
+
       // Assignment operators.
       optional&
       operator=(nullopt_t) noexcept
@@ -786,6 +796,8 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			    is_assignable<_Tp&, _Up>>,
 		    optional&>
 	operator=(_Up&& __u)
+	noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
+			 is_nothrow_assignable<_Tp&, _Up>>)
 	{
 	  if (this->_M_is_engaged())
 	    this->_M_get() = std::forward<_Up>(__u);
@@ -803,6 +815,8 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			    __not_<__assigns_from_optional<_Tp, _Up>>>,
 		    optional&>
 	operator=(const optional<_Up>& __u)
+	noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
+			 is_nothrow_assignable<_Tp&, const _Up&>>)
 	{
 	  if (__u)
 	    {
@@ -826,6 +840,8 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			    __not_<__assigns_from_optional<_Tp, _Up>>>,
 		    optional&>
 	operator=(optional<_Up>&& __u)
+	noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
+			 is_nothrow_assignable<_Tp&, _Up>>)
 	{
 	  if (__u)
 	    {
@@ -845,6 +861,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename... _Args>
 	enable_if_t<is_constructible_v<_Tp, _Args&&...>, _Tp&>
 	emplace(_Args&&... __args)
+	noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 	{
 	  this->_M_reset();
 	  this->_M_construct(std::forward<_Args>(__args)...);
@@ -855,6 +872,8 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&,
 				       _Args&&...>, _Tp&>
 	emplace(initializer_list<_Up> __il, _Args&&... __args)
+	noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
+					    _Args...>)
 	{
 	  this->_M_reset();
 	  this->_M_construct(__il, std::forward<_Args>(__args)...);
@@ -887,27 +906,27 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       // Observers.
       constexpr const _Tp*
-      operator->() const
+      operator->() const noexcept
       { return std::__addressof(this->_M_get()); }
 
       constexpr _Tp*
-      operator->()
+      operator->() noexcept
       { return std::__addressof(this->_M_get()); }
 
       constexpr const _Tp&
-      operator*() const&
+      operator*() const& noexcept
       { return this->_M_get(); }
 
       constexpr _Tp&
-      operator*()&
+      operator*()& noexcept
       { return this->_M_get(); }
 
       constexpr _Tp&&
-      operator*()&&
+      operator*()&& noexcept
       { return std::move(this->_M_get()); }
 
       constexpr const _Tp&&
-      operator*() const&&
+      operator*() const&& noexcept
       { return std::move(this->_M_get()); }
 
       constexpr explicit operator bool() const noexcept
diff --git a/libstdc++-v3/testsuite/20_util/optional/assignment/noexcept.cc b/libstdc++-v3/testsuite/20_util/optional/assignment/noexcept.cc
new file mode 100644
index 00000000000..45592b2a18c
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/optional/assignment/noexcept.cc
@@ -0,0 +1,81 @@ 
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-do compile { target c++17 } }
+
+#include <optional>
+
+template<bool B>
+struct X
+{
+  X() noexcept(B);
+
+  X(const X&) noexcept(B);
+  X& operator=(const X&) noexcept(B);
+
+  X(int) noexcept(B);
+  X& operator=(int) noexcept(false);
+
+  X(void*) noexcept(true);
+  X& operator=(void*) noexcept(B);
+
+  X(const X<!B>&) noexcept(B);
+  X& operator=(const X<!B>&) noexcept(B);
+
+  X(std::initializer_list<int>, int) noexcept(B);
+};
+
+using std::is_nothrow_assignable_v;
+
+using Xyes = X<true>;
+using Xno = X<false>;
+using Oyes = std::optional<Xyes>;
+using Ono = std::optional<Xno>;
+
+static_assert( is_nothrow_assignable_v<Oyes, std::nullopt_t> );
+static_assert( is_nothrow_assignable_v<Oyes, const Xyes&> );
+static_assert( is_nothrow_assignable_v<Oyes, Xyes> );
+static_assert( ! is_nothrow_assignable_v<Oyes, int> );
+static_assert( is_nothrow_assignable_v<Oyes, void*> );
+static_assert( is_nothrow_assignable_v<Oyes, const Ono&> );
+static_assert( is_nothrow_assignable_v<Oyes, Ono> );
+
+static_assert( is_nothrow_assignable_v<Ono, std::nullopt_t> );
+static_assert( ! is_nothrow_assignable_v<Ono, const Xno&> );
+static_assert( ! is_nothrow_assignable_v<Ono, Xno> );
+static_assert( ! is_nothrow_assignable_v<Ono, int> );
+static_assert( ! is_nothrow_assignable_v<Ono, void*> );
+static_assert( ! is_nothrow_assignable_v<Ono, const Xyes&> );
+static_assert( ! is_nothrow_assignable_v<Ono, Xyes> );
+
+Xyes xyes;
+Xno xno;
+Oyes oyes;
+Ono ono;
+static_assert( noexcept(oyes.emplace()) );
+static_assert( noexcept(oyes.emplace(xyes)) );
+static_assert( noexcept(oyes.emplace(1)) );
+static_assert( noexcept(oyes.emplace(nullptr)) );
+static_assert( noexcept(oyes.emplace(xno)) );
+static_assert( noexcept(oyes.emplace({1,2,3}, 1)) );
+
+static_assert( ! noexcept(ono.emplace()) );
+static_assert( ! noexcept(ono.emplace(xno)) );
+static_assert( ! noexcept(ono.emplace(1)) );
+static_assert( noexcept(ono.emplace(nullptr)) );
+static_assert( ! noexcept(ono.emplace(xyes)) );
+static_assert( ! noexcept(ono.emplace({1,2,3}, 1)) );
diff --git a/libstdc++-v3/testsuite/20_util/optional/cons/noexcept.cc b/libstdc++-v3/testsuite/20_util/optional/cons/noexcept.cc
new file mode 100644
index 00000000000..a529f5d39ad
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/optional/cons/noexcept.cc
@@ -0,0 +1,64 @@ 
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-do compile { target c++17 } }
+
+#include <optional>
+
+template<bool B>
+struct X
+{
+  X() noexcept(B);
+  X(const X&) noexcept(B);
+
+  X(int) noexcept(B);
+  X(std::initializer_list<int>, int) noexcept(B);
+
+  X(const X<!B>&) noexcept(B);
+
+  X& operator=(const X&) noexcept(false);
+};
+
+using std::is_nothrow_constructible_v;
+using std::in_place_t;
+
+using Xyes = X<true>;
+using Xno = X<false>;
+using Oyes = std::optional<Xyes>;
+using Ono = std::optional<Xno>;
+
+static_assert( is_nothrow_constructible_v<Oyes> );
+static_assert( is_nothrow_constructible_v<Oyes, std::nullopt_t> );
+static_assert( is_nothrow_constructible_v<Oyes, const Xyes&> );
+static_assert( is_nothrow_constructible_v<Oyes, Xyes> );
+static_assert( is_nothrow_constructible_v<Oyes, in_place_t, short> );
+static_assert( is_nothrow_constructible_v<Oyes, in_place_t,
+						std::initializer_list<int>,
+						long> );
+static_assert( is_nothrow_constructible_v<Oyes, const Ono&> );
+static_assert( is_nothrow_constructible_v<Oyes, Ono> );
+
+static_assert( is_nothrow_constructible_v<Ono> );
+static_assert( is_nothrow_constructible_v<Ono, std::nullopt_t> );
+static_assert( ! is_nothrow_constructible_v<Ono, const Xno&> );
+static_assert( ! is_nothrow_constructible_v<Ono, Xno> );
+static_assert( ! is_nothrow_constructible_v<Ono, in_place_t, short> );
+static_assert( ! is_nothrow_constructible_v<Ono, in_place_t,
+						 std::initializer_list<int>,
+						 long> );
+static_assert( ! is_nothrow_constructible_v<Ono, const Xyes&> );
+static_assert( ! is_nothrow_constructible_v<Ono, Xyes> );