From patchwork Thu Apr 30 15:15:23 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 1280521 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=gcc.gnu.org Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=NfR+2EYG; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49Cf8j5pTdz9sRY for ; Fri, 1 May 2020 01:15:49 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A0C88396E052; Thu, 30 Apr 2020 15:15:44 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A0C88396E052 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1588259744; bh=zmo2vvrkxE5JNBeQZDBmpvH9xO+3ypQYHQl3Wt1zzZg=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=NfR+2EYGrB/k02QzqHO8B/eThOhx+hpdL79bRy6R/ORzN7uiLVStk4Sfu8ZHzundl vhn5v8yLQ+4Zoc9sbuq7KmEkaEDPAedPVV/8SnjSEA78ZOXfm1uREjUFD2NAIUBsIp Pa1NztYo0D270Wy2/7FmdMXYTt3gXLEO7j7p0NjM= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-1.mimecast.com (us-smtp-1.mimecast.com [207.211.31.81]) by sourceware.org (Postfix) with ESMTP id C850A395CC9F for ; Thu, 30 Apr 2020 15:15:32 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org C850A395CC9F Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-407-OOu3cJakMo6nez-bcUVCTw-1; Thu, 30 Apr 2020 11:15:25 -0400 X-MC-Unique: OOu3cJakMo6nez-bcUVCTw-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 7A4C7107ACF5; Thu, 30 Apr 2020 15:15:24 +0000 (UTC) Received: from localhost (unknown [10.33.36.241]) by smtp.corp.redhat.com (Postfix) with ESMTP id 006DC67651; Thu, 30 Apr 2020 15:15:23 +0000 (UTC) Date: Thu, 30 Apr 2020 16:15:23 +0100 To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Subject: [committed] libstdc++: Avoid errors in allocator's noexcept-specifier (PR 89510) Message-ID: <20200430151523.GA239162@redhat.com> MIME-Version: 1.0 X-Clacks-Overhead: GNU Terry Pratchett X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-26.5 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, TXREP, URIBL_SBL, URIBL_SBL_A autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jonathan Wakely via Gcc-patches From: Jonathan Wakely Reply-To: Jonathan Wakely Errors-To: gcc-patches-bounces@gcc.gnu.org Sender: "Gcc-patches" This fixes a regression due to the conditional noexcept-specifier on std::allocator::construct and std::allocator::destroy, as well as the corresponding members of new_allocator, malloc_allocator, and allocator_traits. Those noexcept-specifiers were using expressions which might be ill-formed, which caused errors outside the immediate context when checking for the presence of construct and destroy in SFINAE contexts. The fix is to use the is_nothrow_constructible and is_nothrow_destructible type traits instead, because those traits are safe to use even when the construction/destruction itself is not valid. The is_nothrow_constructible trait will be false for a type that is not also nothrow-destructible, even if the new-expression used in the construct function body is actually noexcept. That's not the correct answer, but isn't a problem because providing a noexcept-specifier on these functions is not required by the standard anyway. If the answer is false when it should be true, that's suboptimal but OK (unlike giving errors for valid code, or giving a true answer when it should be false). PR libstdc++/89510 * include/bits/alloc_traits.h (allocator_traits::_S_construct) (allocator_traits::_S_destroy) (allocator_traits>::construct): Use traits in noexcept-specifiers. * include/bits/allocator.h (allocator::construct) (allocator::destroy): Likewise. * include/ext/malloc_allocator.h (malloc_allocator::construct) (malloc_allocator::destroy): Likewise. * include/ext/new_allocator.h (new_allocator::construct) (new_allocator::destroy): Likewise. * testsuite/20_util/allocator/89510.cc: New test. * testsuite/ext/malloc_allocator/89510.cc: New test. * testsuite/ext/new_allocator/89510.cc: New test. Tested powerpc64le-linux, committed to master. Backport to gcc-9 will follow soon too. commit b1983f4582bbe060b7da83578acb9ed653681fc8 Author: Jonathan Wakely Date: Thu Apr 30 15:47:52 2020 +0100 libstdc++: Avoid errors in allocator's noexcept-specifier (PR 89510) This fixes a regression due to the conditional noexcept-specifier on std::allocator::construct and std::allocator::destroy, as well as the corresponding members of new_allocator, malloc_allocator, and allocator_traits. Those noexcept-specifiers were using expressions which might be ill-formed, which caused errors outside the immediate context when checking for the presence of construct and destroy in SFINAE contexts. The fix is to use the is_nothrow_constructible and is_nothrow_destructible type traits instead, because those traits are safe to use even when the construction/destruction itself is not valid. The is_nothrow_constructible trait will be false for a type that is not also nothrow-destructible, even if the new-expression used in the construct function body is actually noexcept. That's not the correct answer, but isn't a problem because providing a noexcept-specifier on these functions is not required by the standard anyway. If the answer is false when it should be true, that's suboptimal but OK (unlike giving errors for valid code, or giving a true answer when it should be false). PR libstdc++/89510 * include/bits/alloc_traits.h (allocator_traits::_S_construct) (allocator_traits::_S_destroy) (allocator_traits>::construct): Use traits in noexcept-specifiers. * include/bits/allocator.h (allocator::construct) (allocator::destroy): Likewise. * include/ext/malloc_allocator.h (malloc_allocator::construct) (malloc_allocator::destroy): Likewise. * include/ext/new_allocator.h (new_allocator::construct) (new_allocator::destroy): Likewise. * testsuite/20_util/allocator/89510.cc: New test. * testsuite/ext/malloc_allocator/89510.cc: New test. * testsuite/ext/new_allocator/89510.cc: New test. diff --git a/libstdc++-v3/include/bits/alloc_traits.h b/libstdc++-v3/include/bits/alloc_traits.h index 6066f48d24c..86d8ed221ff 100644 --- a/libstdc++-v3/include/bits/alloc_traits.h +++ b/libstdc++-v3/include/bits/alloc_traits.h @@ -251,8 +251,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, is_constructible<_Tp, _Args...>>> _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) - noexcept(noexcept(::new((void*)__p) - _Tp(std::forward<_Args>(__args)...))) + noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) { #if __cplusplus <= 201703L ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); @@ -271,7 +270,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template static _GLIBCXX14_CONSTEXPR void _S_destroy(_Alloc2&, _Tp* __p, ...) - noexcept(noexcept(__p->~_Tp())) + noexcept(std::is_nothrow_destructible<_Tp>::value) { std::_Destroy(__p); } template @@ -507,7 +506,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX20_CONSTEXPR void construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, _Args&&... __args) - noexcept(noexcept(::new((void*)__p) _Up(std::declval<_Args>()...))) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) { #if __cplusplus <= 201703L __a.construct(__p, std::forward<_Args>(__args)...); diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h index dcca769938c..d224aa3ec5e 100644 --- a/libstdc++-v3/include/bits/allocator.h +++ b/libstdc++-v3/include/bits/allocator.h @@ -93,14 +93,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template void construct(_Up* __p, _Args&&... __args) - noexcept(noexcept(::new((void *)__p) - _Up(std::forward<_Args>(__args)...))) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } template void destroy(_Up* __p) - noexcept(noexcept(__p->~_Up())) + noexcept(std::is_nothrow_destructible<_Up>::value) { __p->~_Up(); } #endif // C++11 to C++17 }; diff --git a/libstdc++-v3/include/ext/malloc_allocator.h b/libstdc++-v3/include/ext/malloc_allocator.h index 1f41660fac7..366c766f25b 100644 --- a/libstdc++-v3/include/ext/malloc_allocator.h +++ b/libstdc++-v3/include/ext/malloc_allocator.h @@ -147,14 +147,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template void construct(_Up* __p, _Args&&... __args) - noexcept(noexcept(::new((void *)__p) - _Up(std::forward<_Args>(__args)...))) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } template void destroy(_Up* __p) - noexcept(noexcept(__p->~_Up())) + noexcept(std::is_nothrow_destructible<_Up>::value) { __p->~_Up(); } #else // _GLIBCXX_RESOLVE_LIB_DEFECTS diff --git a/libstdc++-v3/include/ext/new_allocator.h b/libstdc++-v3/include/ext/new_allocator.h index 959d6880276..131718b8b2f 100644 --- a/libstdc++-v3/include/ext/new_allocator.h +++ b/libstdc++-v3/include/ext/new_allocator.h @@ -146,14 +146,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template void construct(_Up* __p, _Args&&... __args) - noexcept(noexcept(::new((void *)__p) - _Up(std::forward<_Args>(__args)...))) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } template void destroy(_Up* __p) - noexcept(noexcept( __p->~_Up())) + noexcept(std::is_nothrow_destructible<_Up>::value) { __p->~_Up(); } #else // _GLIBCXX_RESOLVE_LIB_DEFECTS diff --git a/libstdc++-v3/testsuite/20_util/allocator/89510.cc b/libstdc++-v3/testsuite/20_util/allocator/89510.cc new file mode 100644 index 00000000000..a3100a2b062 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/allocator/89510.cc @@ -0,0 +1,147 @@ +// 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using AT = std::allocator_traits>; + +template using void_t = void; + +template +struct has_construct +: std::false_type +{ }; + +template +struct has_construct().construct(std::declval()))>> +: std::true_type +{ }; + +template +struct has_destroy +: std::false_type +{ }; + +template +struct has_destroy().destroy(std::declval()))>> +: std::true_type +{ }; + +template +struct has_traits_construct +: std::false_type +{ }; + +template +struct has_traits_construct(), std::declval()))>> +: std::true_type +{ }; + +template +struct has_traits_destroy +: std::false_type +{ }; + +template +struct has_traits_destroy(), std::declval()))>> +: std::true_type +{ }; + +struct NoDefault { NoDefault(int); }; +struct NoDest { private: ~NoDest(); }; + +// Whether true or false, this should not give an error: +constexpr bool c = has_construct, NoDefault>::value; +constexpr bool cv = has_construct, NoDefault>::value; +constexpr bool c2 = has_traits_construct, NoDefault>::value; +constexpr bool d = has_destroy, NoDest>::value; +constexpr bool d2 = has_traits_destroy, NoDest>::value; + +std::allocator a; + +long* lp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(lp)), "" ); +static_assert( noexcept(a.construct(lp, 1L)), "" ); +static_assert( noexcept(a.construct(lp, 2)), "" ); +static_assert( noexcept(a.construct(lp, 2U)), "" ); +static_assert( noexcept(a.destroy(lp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, lp)), "" ); +static_assert( noexcept(AT::construct(a, lp, 1L)), "" ); +static_assert( noexcept(AT::construct(a, lp, 2)), "" ); +static_assert( noexcept(AT::construct(a, lp, 2U)), "" ); +static_assert( noexcept(AT::destroy(a, lp)), "" ); + +struct X +{ + X() noexcept; + X(int) noexcept; + ~X() noexcept; +}; + +X* xp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(xp)), "" ); +static_assert( noexcept(a.construct(xp, 1)), "" ); +static_assert( noexcept(a.destroy(xp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, xp)), "" ); +static_assert( noexcept(AT::construct(a, xp, 1)), "" ); +static_assert( noexcept(AT::destroy(a, xp)), "" ); + +struct Y +{ + Y() noexcept; + Y(int) noexcept(false); + ~Y() noexcept; +}; + +Y* yp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(yp)), "" ); +static_assert( ! noexcept(a.construct(yp, 1)), "" ); +static_assert( noexcept(a.destroy(yp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, yp)), "" ); +static_assert( ! noexcept(AT::construct(a, yp, 1)), "" ); +static_assert( noexcept(AT::destroy(a, yp)), "" ); + +struct Z +{ + Z() noexcept; + Z(int) noexcept; + ~Z() noexcept(false); +}; + +Z* zp; +// These construct calls should be noexcept, but they are false because +// they use is_nothrow_constructible which depends on is_nothrow_destructible. +#if __cplusplus <= 201703L +static_assert( ! noexcept(a.construct(zp)), "wrong" ); +static_assert( ! noexcept(a.construct(zp, 1)), "wrong" ); +static_assert( ! noexcept(a.destroy(zp)), "" ); +#endif +static_assert( ! noexcept(AT::construct(a, zp)), "" ); +static_assert( ! noexcept(AT::construct(a, zp, 1)), "" ); +static_assert( ! noexcept(AT::destroy(a, zp)), "" ); diff --git a/libstdc++-v3/testsuite/ext/malloc_allocator/89510.cc b/libstdc++-v3/testsuite/ext/malloc_allocator/89510.cc new file mode 100644 index 00000000000..f2ab25adb74 --- /dev/null +++ b/libstdc++-v3/testsuite/ext/malloc_allocator/89510.cc @@ -0,0 +1,149 @@ +// 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 +// . + +// { dg-do compile { target c++11 } } + +#include +#include +#include + +using __gnu_cxx::malloc_allocator; +using AT = std::allocator_traits>; + +template using void_t = void; + +template +struct has_construct +: std::false_type +{ }; + +template +struct has_construct().construct(std::declval()))>> +: std::true_type +{ }; + +template +struct has_destroy +: std::false_type +{ }; + +template +struct has_destroy().destroy(std::declval()))>> +: std::true_type +{ }; + +template +struct has_traits_construct +: std::false_type +{ }; + +template +struct has_traits_construct(), std::declval()))>> +: std::true_type +{ }; + +template +struct has_traits_destroy +: std::false_type +{ }; + +template +struct has_traits_destroy(), std::declval()))>> +: std::true_type +{ }; + +struct NoDefault { NoDefault(int); }; +struct NoDest { private: ~NoDest(); }; + +// Whether true or false, these should not give errors: +constexpr bool c = has_construct, NoDefault>::value; +constexpr bool c2 = has_traits_construct, NoDefault>::value; +constexpr bool d = has_destroy, NoDest>::value; +constexpr bool b2 = has_traits_destroy, NoDest>::value; + +malloc_allocator a; + +long* lp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(lp)), "" ); +static_assert( noexcept(a.construct(lp, 1L)), "" ); +static_assert( noexcept(a.construct(lp, 2)), "" ); +static_assert( noexcept(a.construct(lp, 2U)), "" ); +static_assert( noexcept(a.destroy(lp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, lp)), "" ); +static_assert( noexcept(AT::construct(a, lp, 1L)), "" ); +static_assert( noexcept(AT::construct(a, lp, 2)), "" ); +static_assert( noexcept(AT::construct(a, lp, 2U)), "" ); +static_assert( noexcept(AT::destroy(a, lp)), "" ); + +struct X +{ + X() noexcept; + X(int) noexcept; + ~X() noexcept; +}; + +X* xp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(xp)), "" ); +static_assert( noexcept(a.construct(xp, 1)), "" ); +static_assert( noexcept(a.destroy(xp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, xp)), "" ); +static_assert( noexcept(AT::construct(a, xp, 1)), "" ); +static_assert( noexcept(AT::destroy(a, xp)), "" ); + +struct Y +{ + Y() noexcept; + Y(int) noexcept(false); + ~Y() noexcept; +}; + +Y* yp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(yp)), "" ); +static_assert( ! noexcept(a.construct(yp, 1)), "" ); +static_assert( noexcept(a.destroy(yp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, yp)), "" ); +static_assert( ! noexcept(AT::construct(a, yp, 1)), "" ); +static_assert( noexcept(AT::destroy(a, yp)), "" ); + +struct Z +{ + Z() noexcept; + Z(int) noexcept; + ~Z() noexcept(false); +}; + +Z* zp; +// These construct calls should be noexcept, but they are false because +// they use is_nothrow_constructible which depends on is_nothrow_destructible. +#if __cplusplus <= 201703L +static_assert( ! noexcept(a.construct(zp)), "wrong" ); +static_assert( ! noexcept(a.construct(zp, 1)), "wrong" ); +static_assert( ! noexcept(a.destroy(zp)), "" ); +#endif +static_assert( ! noexcept(AT::construct(a, zp)), "" ); +static_assert( ! noexcept(AT::construct(a, zp, 1)), "" ); +static_assert( ! noexcept(AT::destroy(a, zp)), "" ); diff --git a/libstdc++-v3/testsuite/ext/new_allocator/89510.cc b/libstdc++-v3/testsuite/ext/new_allocator/89510.cc new file mode 100644 index 00000000000..f684a9c157d --- /dev/null +++ b/libstdc++-v3/testsuite/ext/new_allocator/89510.cc @@ -0,0 +1,149 @@ +// 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 +// . + +// { dg-do compile { target c++11 } } + +#include +#include +#include + +using __gnu_cxx::new_allocator; +using AT = std::allocator_traits>; + +template using void_t = void; + +template +struct has_construct +: std::false_type +{ }; + +template +struct has_construct().construct(std::declval()))>> +: std::true_type +{ }; + +template +struct has_destroy +: std::false_type +{ }; + +template +struct has_destroy().destroy(std::declval()))>> +: std::true_type +{ }; + +template +struct has_traits_construct +: std::false_type +{ }; + +template +struct has_traits_construct(), std::declval()))>> +: std::true_type +{ }; + +template +struct has_traits_destroy +: std::false_type +{ }; + +template +struct has_traits_destroy(), std::declval()))>> +: std::true_type +{ }; + +struct NoDefault { NoDefault(int); }; +struct NoDest { private: ~NoDest(); }; + +// Whether true or false, these should not give errors: +constexpr bool c = has_construct, NoDefault>::value; +constexpr bool c2 = has_traits_construct, NoDefault>::value; +constexpr bool d = has_destroy, NoDest>::value; +constexpr bool d2 = has_traits_destroy, NoDest>::value; + +new_allocator a; + +long* lp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(lp)), "" ); +static_assert( noexcept(a.construct(lp, 1L)), "" ); +static_assert( noexcept(a.construct(lp, 2)), "" ); +static_assert( noexcept(a.construct(lp, 2U)), "" ); +static_assert( noexcept(a.destroy(lp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, lp)), "" ); +static_assert( noexcept(AT::construct(a, lp, 1L)), "" ); +static_assert( noexcept(AT::construct(a, lp, 2)), "" ); +static_assert( noexcept(AT::construct(a, lp, 2U)), "" ); +static_assert( noexcept(AT::destroy(a, lp)), "" ); + +struct X +{ + X() noexcept; + X(int) noexcept; + ~X() noexcept; +}; + +X* xp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(xp)), "" ); +static_assert( noexcept(a.construct(xp, 1)), "" ); +static_assert( noexcept(a.destroy(xp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, xp)), "" ); +static_assert( noexcept(AT::construct(a, xp, 1)), "" ); +static_assert( noexcept(AT::destroy(a, xp)), "" ); + +struct Y +{ + Y() noexcept; + Y(int) noexcept(false); + ~Y() noexcept; +}; + +Y* yp; +#if __cplusplus <= 201703L +static_assert( noexcept(a.construct(yp)), "" ); +static_assert( ! noexcept(a.construct(yp, 1)), "" ); +static_assert( noexcept(a.destroy(yp)), "" ); +#endif +static_assert( noexcept(AT::construct(a, yp)), "" ); +static_assert( ! noexcept(AT::construct(a, yp, 1)), "" ); +static_assert( noexcept(AT::destroy(a, yp)), "" ); + +struct Z +{ + Z() noexcept; + Z(int) noexcept; + ~Z() noexcept(false); +}; + +Z* zp; +// These construct calls should be noexcept, but they are false because +// they use is_nothrow_constructible which depends on is_nothrow_destructible. +#if __cplusplus <= 201703L +static_assert( ! noexcept(a.construct(zp)), "wrong" ); +static_assert( ! noexcept(a.construct(zp, 1)), "wrong" ); +static_assert( ! noexcept(a.destroy(zp)), "" ); +#endif +static_assert( ! noexcept(AT::construct(a, zp)), "" ); +static_assert( ! noexcept(AT::construct(a, zp, 1)), "" ); +static_assert( ! noexcept(AT::destroy(a, zp)), "" );