b1983f4582
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<allocator<T>>::construct): Use traits in noexcept-specifiers. * include/bits/allocator.h (allocator<void>::construct) (allocator<void>::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.
150 lines
4.4 KiB
C++
150 lines
4.4 KiB
C++
// 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++11 } }
|
|
|
|
#include <ext/new_allocator.h>
|
|
#include <memory>
|
|
#include <type_traits>
|
|
|
|
using __gnu_cxx::new_allocator;
|
|
using AT = std::allocator_traits<new_allocator<int>>;
|
|
|
|
template<typename...> using void_t = void;
|
|
|
|
template<typename T, typename U, typename = void>
|
|
struct has_construct
|
|
: std::false_type
|
|
{ };
|
|
|
|
template<typename T, typename U>
|
|
struct has_construct<T, U,
|
|
void_t<decltype(std::declval<T&>().construct(std::declval<U*>()))>>
|
|
: std::true_type
|
|
{ };
|
|
|
|
template<typename T, typename U, typename = void>
|
|
struct has_destroy
|
|
: std::false_type
|
|
{ };
|
|
|
|
template<typename T, typename U>
|
|
struct has_destroy<T, U,
|
|
void_t<decltype(std::declval<T&>().destroy(std::declval<U*>()))>>
|
|
: std::true_type
|
|
{ };
|
|
|
|
template<typename T, typename U, typename = void>
|
|
struct has_traits_construct
|
|
: std::false_type
|
|
{ };
|
|
|
|
template<typename T, typename U>
|
|
struct has_traits_construct<T, U,
|
|
void_t<decltype(AT::construct(std::declval<T&>(), std::declval<U*>()))>>
|
|
: std::true_type
|
|
{ };
|
|
|
|
template<typename T, typename U, typename = void>
|
|
struct has_traits_destroy
|
|
: std::false_type
|
|
{ };
|
|
|
|
template<typename T, typename U>
|
|
struct has_traits_destroy<T, U,
|
|
void_t<decltype(AT::destroy(std::declval<T&>(), std::declval<U*>()))>>
|
|
: 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<new_allocator<NoDefault>, NoDefault>::value;
|
|
constexpr bool c2 = has_traits_construct<new_allocator<int>, NoDefault>::value;
|
|
constexpr bool d = has_destroy<new_allocator<NoDest>, NoDest>::value;
|
|
constexpr bool d2 = has_traits_destroy<new_allocator<int>, NoDest>::value;
|
|
|
|
new_allocator<int> 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)), "" );
|