libstdc++: Adjust static assertions in futures and promises [LWG 3466]

Add a static_assertions to check the result type is destructible, as in
the proposed resolution for LWG 3466 (which supersedes 3458).

libstdc++-v3/ChangeLog:

	* include/std/future (future, shared_future. promise): Add
	is_destructible assertion (LWG 3466). Adjust string-literal for
	!is_array and !is_function assertions.
	* testsuite/30_threads/future/requirements/lwg3458.cc: Check
	types with no accessible destructor. Adjust expected errors.
	* testsuite/30_threads/promise/requirements/lwg3466.cc:
	Likewise.
	* testsuite/30_threads/shared_future/requirements/lwg3458.cc:
	Likewise.

diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future
index e0816c2f5e1574417e25244bb52cb05e196ce0c9..a7466a32e03538dd2bc6dd67014e4cb028c0612d 100644 (file)
--- a/libstdc++-v3/include/std/future
+++ b/libstdc++-v3/include/std/future
@@ -757,8 +757,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 3458. Is shared_future intended to work with arrays or function types?
-      static_assert(!is_array<_Res>{}, "result type is not an array");
-      static_assert(!is_function<_Res>{}, "result type is not a function");
+      static_assert(!is_array<_Res>{}, "result type must not be an array");
+      static_assert(!is_function<_Res>{}, "result type must not be a function");
+      static_assert(is_destructible<_Res>{},
+                   "result type must be destructible");
 
       friend class promise<_Res>;
       template<typename> friend class packaged_task;
@@ -892,8 +894,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 3458. Is shared_future intended to work with arrays or function types?
-      static_assert(!is_array<_Res>{}, "result type is not an array");
-      static_assert(!is_function<_Res>{}, "result type is not a function");
+      static_assert(!is_array<_Res>{}, "result type must not be an array");
+      static_assert(!is_function<_Res>{}, "result type must not be a function");
+      static_assert(is_destructible<_Res>{},
+                   "result type must be destructible");
 
       typedef __basic_future<_Res> _Base_type;
 
@@ -1049,8 +1053,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 3466: Specify the requirements for promise/future/[...] consistently
-      static_assert(!is_array<_Res>{}, "result type is not an array");
-      static_assert(!is_function<_Res>{}, "result type is not a function");
+      static_assert(!is_array<_Res>{}, "result type must not be an array");
+      static_assert(!is_function<_Res>{}, "result type must not be a function");
+      static_assert(is_destructible<_Res>{},
+                   "result type must be destructible");
 
       typedef __future_base::_State_base       _State;
       typedef __future_base::_Result<_Res>     _Res_type;

diff --git a/libstdc++-v3/testsuite/30_threads/future/requirements/lwg3458.cc b/libstdc++-v3/testsuite/30_threads/future/requirements/lwg3458.cc
index 2bc206c94501413d6cdef792fa5ed0ddfa7ccb9b..f26e17bd799a658cbf03563a48f257f9aeb87f45 100644 (file)
--- a/libstdc++-v3/testsuite/30_threads/future/requirements/lwg3458.cc
+++ b/libstdc++-v3/testsuite/30_threads/future/requirements/lwg3458.cc
@@ -26,9 +26,18 @@ std::future<int(&)[1]> good;
 std::future<int(&)()> good2;
 
 std::future<int[1]> bad; // { dg-error "here" }
-// { dg-error "result type is not an array" "" { target *-*-* } 0 }
+// { dg-error "result type must not be an array" "" { target *-*-* } 0 }
 // { dg-prune-output "function returning an array" }
 
 std::future<int()> bad2; // { dg-error "here" }
-// { dg-error "result type is not a function" "" { target *-*-* } 0 }
+// { dg-error "result type must not be a function" "" { target *-*-* } 0 }
 // { dg-prune-output "function returning a function" }
+
+struct Indestructible { ~Indestructible() = delete; };
+std::future<Indestructible> bad3; // { dg-error "here" }
+// { dg-error "result type must be destructible" "" { target *-*-* } 0 }
+// { dg-prune-output {deleted function} }
+
+class PrivateDtor { public: PrivateDtor(); private: ~PrivateDtor(); };
+std::future<PrivateDtor> bad4; // { dg-error "here" }
+// { dg-prune-output {is private} }

diff --git a/libstdc++-v3/testsuite/30_threads/promise/requirements/lwg3466.cc b/libstdc++-v3/testsuite/30_threads/promise/requirements/lwg3466.cc
index 124c86c0392d5a7db891592ae014cd0187fede5f..71eb2603e83e0e21f016737249b67a100131806f 100644 (file)
--- a/libstdc++-v3/testsuite/30_threads/promise/requirements/lwg3466.cc
+++ b/libstdc++-v3/testsuite/30_threads/promise/requirements/lwg3466.cc
@@ -26,9 +26,18 @@ std::promise<int(&)[1]> good;
 std::promise<int(&)()> good2;
 
 std::promise<int[1]> bad; // { dg-error "here" }
-// { dg-error "result type is not an array" "" { target *-*-* } 0 }
+// { dg-error "result type must not be an array" "" { target *-*-* } 0 }
 // { dg-prune-output {request for member '~int \[1\]'} }
 
 std::promise<int()> bad2; // { dg-error "here" }
-// { dg-error "result type is not a function" "" { target *-*-* } 0 }
+// { dg-error "result type must not be a function" "" { target *-*-* } 0 }
 // { dg-prune-output {'sizeof \(int\(\)\)'} }
+
+struct Indestructible { ~Indestructible() = delete; };
+std::promise<Indestructible> bad3; // { dg-error "here" }
+// { dg-error "result type must be destructible" "" { target *-*-* } 0 }
+// { dg-prune-output {deleted function} }
+
+class PrivateDtor { public: PrivateDtor(); private: ~PrivateDtor(); };
+std::promise<PrivateDtor> bad4; // { dg-error "here" }
+// { dg-prune-output {is private} }

diff --git a/libstdc++-v3/testsuite/30_threads/shared_future/requirements/lwg3458.cc b/libstdc++-v3/testsuite/30_threads/shared_future/requirements/lwg3458.cc
index df5bfd2b976199bcf0742a8e2715adc1fc91f65c..cf767698f40980373ec69e059541618007390cf1 100644 (file)
--- a/libstdc++-v3/testsuite/30_threads/shared_future/requirements/lwg3458.cc
+++ b/libstdc++-v3/testsuite/30_threads/shared_future/requirements/lwg3458.cc
@@ -26,7 +26,16 @@ std::shared_future<int(&)[1]> good;
 std::shared_future<int(&)()> good2;
 
 std::shared_future<int[1]> bad; // { dg-error "here" }
-// { dg-error "result type is not an array" "" { target *-*-* } 0 }
+// { dg-error "result type must not be an array" "" { target *-*-* } 0 }
 
 std::shared_future<int()> bad2; // { dg-error "here" }
-// { dg-error "result type is not a function" "" { target *-*-* } 0 }
+// { dg-error "result type must not be a function" "" { target *-*-* } 0 }
+
+struct Indestructible { ~Indestructible() = delete; };
+std::shared_future<Indestructible> bad3; // { dg-error "here" }
+// { dg-error "result type must be destructible" "" { target *-*-* } 0 }
+// { dg-prune-output {deleted function} }
+
+class PrivateDtor { public: PrivateDtor(); private: ~PrivateDtor(); };
+std::shared_future<PrivateDtor> bad4; // { dg-error "here" }
+// { dg-prune-output {is private} }