OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

libstdc++: Support arrays in std::is_nothrow_constructible (PR 94149)

Browse Source 
The front end now supports parenthesized initialization for arrays in
C++20, so extend std::is_nothrow_constructible to support them too.

gcc/testsuite:

	PR c++/94149
	* g++.dg/cpp2a/paren-init24.C: Fix FIXMEs.

libstdc++-v3:

	PR c++/94149
	* include/std/type_traits (__is_nt_constructible_impl): Add partial
	specializations for bounded arrays with non-empty initializers.
	* testsuite/20_util/is_nothrow_constructible/value_c++20.cc: New test.
This commit is contained in:
Jonathan Wakely 2020-04-21 22:18:51 +01:00
parent 81e07d422c
commit d76925e46f
5 changed files with 95 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/testsuite/ChangeLog
View File

@ -67,6 +67,11 @@
* g++.dg/coroutines/ramp-return-b.C: New test.
* g++.dg/coroutines/ramp-return-c.C: New test.
2020-04-21 Jonathan Wakely <jwakely@redhat.com>
PR c++/94149
* g++.dg/cpp2a/paren-init24.C: Fix FIXMEs.
2020-04-17 Marek Polacek <polacek@redhat.com>
PR c++/94592

6
gcc/testsuite/g++.dg/cpp2a/paren-init24.C
View File

@ -11,8 +11,7 @@ int main()
static_assert(__is_constructible(T, int));
static_assert(!__is_constructible(T, int, int));
static_assert(std::is_constructible_v<T, int>);
//FIXME: libstdc++ problem?
//static_assert(std::is_nothrow_constructible_v<T, int>);
static_assert(std::is_nothrow_constructible_v<T, int>);
using T2 = int[2];
T2 t2(1);
@ -21,6 +20,5 @@ int main()
static_assert(__is_constructible(T2, int));
static_assert(__is_constructible(T2, int, int));
static_assert(std::is_constructible_v<T2, int, int>);
// FIXME libstdc++ problem?
//static_assert(std::is_nothrow_constructible_v<T2, int, int>);
static_assert(std::is_nothrow_constructible_v<T2, int, int>);
}

7
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,10 @@
2020-04-21 Jonathan Wakely <jwakely@redhat.com>
PR c++/94149
* include/std/type_traits (__is_nt_constructible_impl): Add partial
specializations for bounded arrays with non-empty initializers.
* testsuite/20_util/is_nothrow_constructible/value_c++20.cc: New test.
2020-04-20 Thomas Rodgers <trodgers@redhat.com>
* testsuite/lib/libstdc++.exp: Add additional_flags=

12
libstdc++-v3/include/std/type_traits
View File

@ -986,6 +986,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
{ };
#if __cpp_aggregate_paren_init
template<typename _Tp, size_t _Num, typename _Arg>
struct __is_nt_constructible_impl<true, _Tp[_Num], _Arg>
: public __is_nt_constructible_impl<true, _Tp, _Arg>
{ };
template<typename _Tp, size_t _Num, typename... _Args>
struct __is_nt_constructible_impl<true, _Tp[_Num], _Args...>
: public __and_<__is_nt_constructible_impl<true, _Tp, _Args>...>
{ };
#endif
template<typename _Tp, typename... _Args>
using __is_nothrow_constructible_impl
= __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),

69
libstdc++-v3/testsuite/20_util/is_nothrow_constructible/value_c++20.cc Normal file
View File

@ -0,0 +1,69 @@
// { dg-options "-std=gnu++2a" }
// { dg-do compile { target c++2a } }
// 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 <type_traits>
static_assert( std::is_nothrow_constructible_v<int[1]> );
static_assert( std::is_nothrow_constructible_v<int[1], int> );
static_assert( std::is_nothrow_constructible_v<int[2], int> );
static_assert( std::is_nothrow_constructible_v<int[2], int, int> );
static_assert( ! std::is_nothrow_constructible_v<int[1], int, int> );
static_assert( ! std::is_nothrow_constructible_v<int[]> );
static_assert( ! std::is_nothrow_constructible_v<int[], int> );
static_assert( ! std::is_nothrow_constructible_v<int[], int, int> );
struct X
{
X() = default;
X(int) noexcept { }
X(double) { }
};
static_assert( std::is_nothrow_constructible_v<X[2]> );
static_assert( std::is_nothrow_constructible_v<X[1], X> );
static_assert( std::is_nothrow_constructible_v<X[1], int> );
static_assert( ! std::is_nothrow_constructible_v<X[1], double> );
static_assert( ! std::is_nothrow_constructible_v<X[2], int, double> );
struct Y
{
int i;
X x;
};
static_assert( std::is_nothrow_constructible_v<Y> );
static_assert( std::is_nothrow_constructible_v<Y, Y> );
static_assert( std::is_nothrow_constructible_v<Y, int> );
static_assert( ! std::is_nothrow_constructible_v<Y, X> );
static_assert( std::is_nothrow_constructible_v<Y, int, X> );
static_assert( std::is_nothrow_constructible_v<Y, int, int> );
static_assert( ! std::is_nothrow_constructible_v<Y, int, double> );
struct Z : Y { };
static_assert( std::is_nothrow_constructible_v<Z> );
static_assert( std::is_nothrow_constructible_v<Z, Z> );
static_assert( std::is_nothrow_constructible_v<Z, Y> );
static_assert( ! std::is_nothrow_constructible_v<Z, int> );
static_assert( ! std::is_nothrow_constructible_v<Z, int, X> );
static_assert( ! std::is_nothrow_constructible_v<Z, int, int> );
static_assert( ! std::is_nothrow_constructible_v<Z, Y, double> );
static_assert( ! std::is_nothrow_constructible_v<Z, int, double> );
static_assert( ! std::is_nothrow_constructible_v<Z, X> );