git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

functional (_Require): Move to ... 

* include/std/functional (_Require): Move to ...
	* include/std/type_traits (_Require): ... here.
	* include/bits/shared_ptr_base.h (__shared_count::_S_create_from_up):
	Handle unique_ptr for arrays or with custom pointer types.
	(__shared_ptr::__shared_ptr(unique_ptr<_Tp1, _Del>&&): Likewise.
	* include/bits/unique_ptr.h (unique_ptr<_Tp[], _Dp>): Use
	_Dp::pointer if defined. Implement proposed resolution of LWG 2118.
	* testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc: New.
	* testsuite/20_util/unique_ptr/assign/cv_qual.cc: New.
	* testsuite/20_util/unique_ptr/cons/array_convertible_neg.cc: New.
	* testsuite/20_util/unique_ptr/cons/convertible_neg.cc: New.
	* testsuite/20_util/unique_ptr/cons/cv_qual.cc: New.
	* testsuite/20_util/unique_ptr/modifiers/cv_qual.cc: New.
	* testsuite/20_util/unique_ptr/requirements/pointer_type_array.cc: New.
	* testsuite/20_util/shared_ptr/cons/unique_ptr.cc: Adjust comments.
	* testsuite/20_util/unique_ptr/cons/pointer_array_convertible_neg.cc:
	Likewise.
	* testsuite/20_util/unique_ptr/requirements/pointer_type.cc: Likewise.
	* testsuite/20_util/bind/ref_neg.cc: Adjust dg-error line number.
	* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
	* testsuite/20_util/default_delete/48631_neg.cc: Likewise.
	* testsuite/20_util/shared_ptr/cons/43820_neg.cc: Likewise.
	* testsuite/20_util/unique_ptr/assign/48635_neg.cc: Likewise.
	* testsuite/20_util/unique_ptr/modifiers/reset_neg.cc: Adjust
	dg-error text.
	* testsuite/20_util/unique_ptr/cons/ptr_deleter_neg.cc: Use
	different instantiations so static_assert fails for each.

From-SVN: r194651
This commit is contained in:
Jonathan Wakely 2012-12-20 21:02:33 +00:00 committed by Jonathan Wakely
parent d89da9dbda
commit 23df853421
22 changed files with 668 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,33 @@
2012-12-20 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/std/functional (_Require): Move to ...
* include/std/type_traits (_Require): ... here.
* include/bits/shared_ptr_base.h (__shared_count::_S_create_from_up):
Handle unique_ptr for arrays or with custom pointer types.
(__shared_ptr::__shared_ptr(unique_ptr<_Tp1, _Del>&&): Likewise.
* include/bits/unique_ptr.h (unique_ptr<_Tp[], _Dp>): Use
_Dp::pointer if defined. Implement proposed resolution of LWG 2118.
* testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc: New.
* testsuite/20_util/unique_ptr/assign/cv_qual.cc: New.
* testsuite/20_util/unique_ptr/cons/array_convertible_neg.cc: New.
* testsuite/20_util/unique_ptr/cons/convertible_neg.cc: New.
* testsuite/20_util/unique_ptr/cons/cv_qual.cc: New.
* testsuite/20_util/unique_ptr/modifiers/cv_qual.cc: New.
* testsuite/20_util/unique_ptr/requirements/pointer_type_array.cc: New.
* testsuite/20_util/shared_ptr/cons/unique_ptr.cc: Adjust comments.
* testsuite/20_util/unique_ptr/cons/pointer_array_convertible_neg.cc:
Likewise.
* testsuite/20_util/unique_ptr/requirements/pointer_type.cc: Likewise.
* testsuite/20_util/bind/ref_neg.cc: Adjust dg-error line number.
* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
* testsuite/20_util/default_delete/48631_neg.cc: Likewise.
* testsuite/20_util/shared_ptr/cons/43820_neg.cc: Likewise.
* testsuite/20_util/unique_ptr/assign/48635_neg.cc: Likewise.
* testsuite/20_util/unique_ptr/modifiers/reset_neg.cc: Adjust
dg-error text.
* testsuite/20_util/unique_ptr/cons/ptr_deleter_neg.cc: Use
different instantiations so static_assert fails for each.
2012-12-20 Jonathan Wakely <jwakely.gcc@gmail.com> 2012-12-20 Jonathan Wakely <jwakely.gcc@gmail.com>
PR libstdc++/55741 PR libstdc++/55741

8
libstdc++-v3/include/bits/shared_ptr_base.h
View File

@ -616,7 +616,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r, _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0) typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0)
{ {
return new _Sp_counted_deleter<_Tp*, _Del, std::allocator<void>, typedef typename unique_ptr<_Tp, _Del>::pointer _Ptr;
return new _Sp_counted_deleter<_Ptr, _Del, std::allocator<void>,
_Lp>(__r.get(), __r.get_deleter()); _Lp>(__r.get(), __r.get_deleter());
} }
@ -625,9 +626,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r, _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
typename std::enable_if<std::is_reference<_Del>::value>::type* = 0) typename std::enable_if<std::is_reference<_Del>::value>::type* = 0)
{ {
typedef typename unique_ptr<_Tp, _Del>::pointer _Ptr;
typedef typename std::remove_reference<_Del>::type _Del1; typedef typename std::remove_reference<_Del>::type _Del1;
typedef std::reference_wrapper<_Del1> _Del2; typedef std::reference_wrapper<_Del1> _Del2;
return new _Sp_counted_deleter<_Tp*, _Del2, std::allocator<void>, return new _Sp_counted_deleter<_Ptr, _Del2, std::allocator<void>,
_Lp>(__r.get(), std::ref(__r.get_deleter())); _Lp>(__r.get(), std::ref(__r.get_deleter()));
} }
@ -846,7 +848,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: _M_ptr(__r.get()), _M_refcount() : _M_ptr(__r.get()), _M_refcount()
{ {
__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
_Tp1* __tmp = __r.get(); auto __tmp = std::__addressof(*__r.get());
_M_refcount = __shared_count<_Lp>(std::move(__r)); _M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
} }

194
libstdc++-v3/include/bits/unique_ptr.h
View File

@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr default_delete() noexcept = default; constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename template<typename _Up, typename = typename
std::enable_if<std::is_convertible<_Up*, _Tp*>::value>::type> enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { } default_delete(const default_delete<_Up>&) noexcept { }
void void
@ -74,8 +74,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
struct default_delete<_Tp[]> struct default_delete<_Tp[]>
{ {
private:
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
// Like is_base_of<_Tp, _Up> but false if unqualified types are the same
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
public:
constexpr default_delete() noexcept = default; constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<!__is_derived_Tp<_Up>::value>::type>
default_delete(const default_delete<_Up[]>&) noexcept { }
void void
operator()(_Tp* __ptr) const operator()(_Tp* __ptr) const
{ {
@ -84,7 +99,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
delete [] __ptr; delete [] __ptr;
} }
template<typename _Up> void operator()(_Up*) const = delete; template<typename _Up>
typename enable_if<__is_derived_Tp<_Up>::value>::type
operator()(_Up*) const = delete;
}; };
/// 20.7.1.2 unique_ptr for single objects. /// 20.7.1.2 unique_ptr for single objects.
@ -103,7 +120,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef typename remove_reference<_Dp>::type _Del; typedef typename remove_reference<_Dp>::type _Del;
public: public:
typedef decltype( __test<_Del>(0)) type; typedef decltype(__test<_Del>(0)) type;
}; };
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type; typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
@ -117,54 +134,45 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Constructors. // Constructors.
constexpr unique_ptr() noexcept constexpr unique_ptr() noexcept
: _M_t() : _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value, { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); } "constructed with null function pointer deleter"); }
explicit explicit
unique_ptr(pointer __p) noexcept unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type()) : _M_t(__p, deleter_type())
{ static_assert(!std::is_pointer<deleter_type>::value, { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); } "constructed with null function pointer deleter"); }
unique_ptr(pointer __p, unique_ptr(pointer __p,
typename std::conditional<std::is_reference<deleter_type>::value, typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { } : _M_t(__p, __d) { }
unique_ptr(pointer __p, unique_ptr(pointer __p,
typename std::remove_reference<deleter_type>::type&& __d) noexcept typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d)) : _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value, { static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); } "rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
// Move constructors. // Move constructors.
unique_ptr(unique_ptr&& __u) noexcept unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep, typename = typename template<typename _Up, typename _Ep, typename = _Require<
std::enable_if is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
<std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer, __not_<is_array<_Up>>,
pointer>::value typename conditional<is_reference<_Dp>::value,
&& !std::is_array<_Up>::value is_same<_Ep, _Dp>,
&& ((std::is_reference<_Dp>::value is_convertible<_Ep, _Dp>>::type>>
&& std::is_same<_Ep, _Dp>::value)
|| (!std::is_reference<_Dp>::value
&& std::is_convertible<_Ep, _Dp>::value))>
::type>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ } { }
#if _GLIBCXX_USE_DEPRECATED #if _GLIBCXX_USE_DEPRECATED
template<typename _Up, typename = typename template<typename _Up, typename = _Require<
std::enable_if<std::is_convertible<_Up*, _Tp*>::value is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
&& std::is_same<_Dp,
default_delete<_Tp>>::value>::type>
unique_ptr(auto_ptr<_Up>&& __u) noexcept; unique_ptr(auto_ptr<_Up>&& __u) noexcept;
#endif #endif
@ -186,12 +194,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return *this; return *this;
} }
template<typename _Up, typename _Ep, typename = typename template<typename _Up, typename _Ep>
std::enable_if typename enable_if< __and_<
<std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer, is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
pointer>::value __not_<is_array<_Up>>
&& !std::is_array<_Up>::value>::type> >::value,
unique_ptr& unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{ {
reset(__u.release()); reset(__u.release());
@ -207,7 +215,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
// Observers. // Observers.
typename std::add_lvalue_reference<element_type>::type typename add_lvalue_reference<element_type>::type
operator*() const operator*() const
{ {
_GLIBCXX_DEBUG_ASSERT(get() != pointer()); _GLIBCXX_DEBUG_ASSERT(get() != pointer());
@ -273,11 +281,47 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Dp> template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp> class unique_ptr<_Tp[], _Dp>
{ {
typedef std::tuple<_Tp*, _Dp> __tuple_type; // use SFINAE to determine whether _Del::pointer exists
__tuple_type _M_t; class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
// like is_base_of<_Tp, _Up> but false if unqualified types are the same
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
template<typename _Up, typename _Ep,
typename _Tp_pointer = typename _Pointer::type,
typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
using __safe_conversion = __and_<
is_convertible<_Up_pointer, _Tp_pointer>,
is_array<_Up>,
__or_<__not_<is_pointer<_Up_pointer>>,
__not_<is_pointer<_Tp_pointer>>,
__not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
>
>;
public: public:
typedef _Tp* pointer; typedef typename _Pointer::type pointer;
typedef _Tp element_type; typedef _Tp element_type;
typedef _Dp deleter_type; typedef _Dp deleter_type;
@ -285,35 +329,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr unique_ptr() noexcept constexpr unique_ptr() noexcept
: _M_t() : _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value, { static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); } "constructed with null function pointer deleter"); }
explicit explicit
unique_ptr(pointer __p) noexcept unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type()) : _M_t(__p, deleter_type())
{ static_assert(!std::is_pointer<deleter_type>::value, { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); } "constructed with null function pointer deleter"); }
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
explicit
unique_ptr(_Up* __p) = delete;
unique_ptr(pointer __p, unique_ptr(pointer __p,
typename std::conditional<std::is_reference<deleter_type>::value, typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { } : _M_t(__p, __d) { }
unique_ptr(pointer __p, typename unique_ptr(pointer __p, typename
std::remove_reference<deleter_type>::type && __d) noexcept remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d)) : _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value, { static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); } "rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept // Move constructor.
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
// Move constructors.
unique_ptr(unique_ptr&& __u) noexcept unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep> constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
template<typename _Up, typename _Ep,
typename = _Require<__safe_conversion<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type
>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ } { }
@ -337,7 +388,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
template<typename _Up, typename _Ep> template<typename _Up, typename _Ep>
unique_ptr& typename
enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{ {
reset(__u.release()); reset(__u.release());
@ -385,7 +437,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
void void
reset(pointer __p = pointer()) noexcept reset() noexcept
{ reset(pointer()); }
void
reset(pointer __p) noexcept
{ {
using std::swap; using std::swap;
swap(std::get<0>(_M_t), __p); swap(std::get<0>(_M_t), __p);
@ -393,18 +449,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
get_deleter()(__p); get_deleter()(__p);
} }
void template<typename _Up, typename = _Require<is_pointer<pointer>,
reset(nullptr_t) noexcept is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
{ void reset(_Up*) = delete;
pointer __p = get();
std::get<0>(_M_t) = pointer();
if (__p != nullptr)
get_deleter()(__p);
}
// DR 821.
template<typename _Up>
void reset(_Up) = delete;
void void
swap(unique_ptr& __u) noexcept swap(unique_ptr& __u) noexcept
@ -418,23 +465,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
unique_ptr& operator=(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete;
// Disable construction from convertible pointer types. // Disable construction from convertible pointer types.
// (N2315 - 20.7.1.3.1) template<typename _Up, typename = _Require<is_pointer<pointer>,
template<typename _Up> is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename unique_ptr(_Up*, typename
std::conditional<std::is_reference<deleter_type>::value, conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type, deleter_type, const deleter_type&>::type) = delete;
typename std::enable_if<std::is_convertible<_Up*,
pointer>::value>::type* = 0) = delete;
template<typename _Up> template<typename _Up, typename = _Require<is_pointer<pointer>,
unique_ptr(_Up*, typename std::remove_reference<deleter_type>::type&&, is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
typename std::enable_if<std::is_convertible<_Up*, unique_ptr(_Up*, typename
pointer>::value>::type* = 0) = delete; remove_reference<deleter_type>::type&&) = delete;
template<typename _Up>
explicit
unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*,
pointer>::value>::type* = 0) = delete;
}; };
template<typename _Tp, typename _Dp> template<typename _Tp, typename _Dp>

3
libstdc++-v3/include/std/functional
View File

@ -501,9 +501,6 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
// @} group functors // @} group functors
template<typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
template<typename... _Types> template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)> struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ }; { };

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

@ -1771,6 +1771,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct enable_if<true, _Tp> struct enable_if<true, _Tp>
{ typedef _Tp type; }; { typedef _Tp type; };
template<typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
// Primary template. // Primary template.
/// Define a member typedef @c type to one of two argument types. /// Define a member typedef @c type to one of two argument types.

8
libstdc++-v3/testsuite/20_util/bind/ref_neg.cc
View File

@ -30,10 +30,10 @@ void test01()
{ {
const int dummy = 0; const int dummy = 0;
std::bind(&inc, _1)(0); // { dg-error "no match" } std::bind(&inc, _1)(0); // { dg-error "no match" }
// { dg-error "rvalue|const" "" { target *-*-* } 1349 } // { dg-error "rvalue|const" "" { target *-*-* } 1346 }
// { dg-error "rvalue|const" "" { target *-*-* } 1363 } // { dg-error "rvalue|const" "" { target *-*-* } 1360 }
// { dg-error "rvalue|const" "" { target *-*-* } 1377 } // { dg-error "rvalue|const" "" { target *-*-* } 1374 }
// { dg-error "rvalue|const" "" { target *-*-* } 1391 } // { dg-error "rvalue|const" "" { target *-*-* } 1388 }
std::bind(&inc, std::ref(dummy))(); // { dg-error "no match" } std::bind(&inc, std::ref(dummy))(); // { dg-error "no match" }
} }

2
libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc
View File

@ -19,7 +19,7 @@
// with this library; see the file COPYING3. If not see // with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>. // <http://www.gnu.org/licenses/>.
// { dg-error "static assertion failed" "" { target *-*-* } 1869 } // { dg-error "static assertion failed" "" { target *-*-* } 1871 }
#include <utility> #include <utility>

2
libstdc++-v3/testsuite/20_util/default_delete/48631_neg.cc
View File

@ -27,4 +27,4 @@ struct D : B { };
D d; D d;
std::default_delete<B[]> db; std::default_delete<B[]> db;
typedef decltype(db(&d)) type; // { dg-error "use of deleted function" } typedef decltype(db(&d)) type; // { dg-error "use of deleted function" }
// { dg-error "declared here" "" { target *-*-* } 87 } // { dg-error "declared here" "" { target *-*-* } 104 }

2
libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc
View File

@ -32,7 +32,7 @@ void test01()
{ {
X* px = 0; X* px = 0;
std::shared_ptr<X> p1(px); // { dg-error "here" } std::shared_ptr<X> p1(px); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 769 } // { dg-error "incomplete" "" { target *-*-* } 771 }
std::shared_ptr<X> p9(ap()); // { dg-error "here" } std::shared_ptr<X> p9(ap()); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 307 } // { dg-error "incomplete" "" { target *-*-* } 307 }

8
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr.cc
View File

@ -1,6 +1,6 @@
// { dg-options "-std=gnu++0x" } // { dg-options "-std=gnu++11" }
// Copyright (C) 2008, 2009 Free Software Foundation // Copyright (C) 2008-2012 Free Software Foundation
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -17,14 +17,14 @@
// with this library; see the file COPYING3. If not see // with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>. // <http://www.gnu.org/licenses/>.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared] // 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
#include <memory> #include <memory>
#include <testsuite_hooks.h> #include <testsuite_hooks.h>
struct A { }; struct A { };
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const] // 20.7.2.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr // Construction from unique_ptr
int int

59
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc Normal file
View File

@ -0,0 +1,59 @@
// { dg-options "-std=gnu++11" }
// Copyright (C) 2012 Free Software Foundation
//
// 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/>.
// 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
int destroyed = 0;
struct A : std::enable_shared_from_this<A>
{
~A() { ++destroyed; }
};
// 20.7.2.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr<A[]>
int
test01()
{
bool test __attribute__((unused)) = true;
std::unique_ptr<A[]> up(new A[2]);
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
VERIFY( sp->shared_from_this() != nullptr );
sp.reset();
VERIFY( destroyed == 2 );
return 0;
}
int
main()
{
test01();
return 0;
}

4
libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc
View File

@ -41,10 +41,10 @@ void f()
std::unique_ptr<int, B&> ub(nullptr, b); std::unique_ptr<int, B&> ub(nullptr, b);
std::unique_ptr<int, D&> ud(nullptr, d); std::unique_ptr<int, D&> ud(nullptr, d);
ub = std::move(ud); ub = std::move(ud);
// { dg-error "use of deleted function" "" { target *-*-* } 198 } // { dg-error "use of deleted function" "" { target *-*-* } 206 }
std::unique_ptr<int[], B&> uba(nullptr, b); std::unique_ptr<int[], B&> uba(nullptr, b);
std::unique_ptr<int[], D&> uda(nullptr, d); std::unique_ptr<int[], D&> uda(nullptr, d);
uba = std::move(uda); uba = std::move(uda);
// { dg-error "use of deleted function" "" { target *-*-* } 344 } // { dg-error "use of deleted function" "" { target *-*-* } 396 }
} }

89
libstdc++-v3/testsuite/20_util/unique_ptr/assign/cv_qual.cc Normal file
View File

@ -0,0 +1,89 @@
// { dg-options "-std=gnu++11" }
// { dg-do compile }
// Copyright (C) 2012 Free Software Foundation
//
// 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/>.
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
struct A { virtual ~A() = default; };
struct B : A { };
// Assignment from objects with different cv-qualification
void
test01()
{
std::unique_ptr<A> upA;
std::unique_ptr<const A> cA;
cA = std::move(upA);
std::unique_ptr<volatile A> vA;
vA = std::move(upA);
std::unique_ptr<const volatile A> cvA;
cvA = std::move(upA);
}
void
test02()
{
std::unique_ptr<B> upB;
std::unique_ptr<const A> cA;
cA = std::move(upB);
std::unique_ptr<volatile A> vA;
vA = std::move(upB);
std::unique_ptr<const volatile A> cvA;
cvA = std::move(upB);
}
void
test03()
{
std::unique_ptr<A[]> upA;
std::unique_ptr<const A[]> cA;
cA = std::move(upA);
std::unique_ptr<volatile A[]> vA;
vA = std::move(upA);
std::unique_ptr<const volatile A[]> cvA;
cvA = std::move(upA);
}
struct A_pointer { operator A*() const { return nullptr; } };
template<typename T>
struct deleter
{
deleter() = default;
template<typename U>
deleter(const deleter<U>) { }
typedef T pointer;
void operator()(T) const { }
};
void
test04()
{
// Allow conversions from user-defined pointer-like types
std::unique_ptr<B[], deleter<A_pointer>> p;
std::unique_ptr<A[], deleter<A*>> upA;
upA = std::move(p);
}

58
libstdc++-v3/testsuite/20_util/unique_ptr/cons/array_convertible_neg.cc Normal file
View File

@ -0,0 +1,58 @@
// { dg-do compile }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2012 Free Software Foundation
//
// 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 <memory>
struct A
{
};
struct B : A
{
virtual ~B() { }
};
// 20.7.1.3 unique_ptr for array objects [unique.ptr.runtime]
struct D
{
template<typename T>
void operator()(const T* p) const { delete[] p; }
};
// Conversion from different type of unique_ptr<T[], D>
void
test01()
{
std::unique_ptr<B[], D> b(new B[1]);
std::unique_ptr<A[], D> a(std::move(b)); //{ dg-error "no matching function" }
a = std::move(b); //{ dg-error "no match" }
}
// Conversion from non-array form of unique_ptr
void
test02()
{
std::unique_ptr<A> nonarray(new A);
std::unique_ptr<A[]> array(std::move(nonarray)); //{ dg-error "no matching function" }
array = std::move(nonarray); //{ dg-error "no match" }
}
// { dg-prune-output "include" }

38
libstdc++-v3/testsuite/20_util/unique_ptr/cons/convertible_neg.cc Normal file
View File

@ -0,0 +1,38 @@
// { dg-do compile }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2012 Free Software Foundation
//
// 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 <memory>
struct A
{
};
// 20.7.1.3 unique_ptr for array objects [unique.ptr.runtime]
// Conversion to non-array form of unique_ptr
void
test01()
{
std::unique_ptr<A[]> array(new A[1]);
std::unique_ptr<A> nonarray(std::move(array)); //{ dg-error "no matching function" }
nonarray = std::move(array); //{ dg-error "no match" }
}
// { dg-prune-output "include" }

115
libstdc++-v3/testsuite/20_util/unique_ptr/cons/cv_qual.cc Normal file
View File

@ -0,0 +1,115 @@
// { dg-options "-std=gnu++11" }
// { dg-do compile }
// Copyright (C) 2012 Free Software Foundation
//
// 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/>.
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
struct A { virtual ~A() = default; };
struct B : A { };
// Construction from objects with different cv-qualification
void
test01()
{
std::unique_ptr<const A> cA(new A);
std::unique_ptr<volatile A> vA(new A);
std::unique_ptr<const volatile A> cvA(new A);
}
void
test02()
{
std::unique_ptr<const A> cB(new B);
std::unique_ptr<volatile A> vB(new B);
std::unique_ptr<const volatile A> cvB(new B);
}
void
test03()
{
std::unique_ptr<A> upA;
std::unique_ptr<const A> cA(std::move(upA));
std::unique_ptr<volatile A> vA(std::move(upA));
std::unique_ptr<const volatile A> cvA(std::move(upA));
}
void
test04()
{
std::unique_ptr<B> upB;
std::unique_ptr<const A> cA(std::move(upB));
std::unique_ptr<volatile A> vA(std::move(upB));
std::unique_ptr<const volatile A> cvA(std::move(upB));
}
void
test05()
{
std::unique_ptr<const A[]> cA(new A[1]);
std::unique_ptr<volatile A[]> vA(new A[1]);
std::unique_ptr<const volatile A[]> cvA(new A[1]);
}
void
test06()
{
std::unique_ptr<A[]> upA;
std::unique_ptr<const A[]> cA(std::move(upA));
std::unique_ptr<volatile A[]> vA(std::move(upA));
std::unique_ptr<const volatile A[]> cvA(std::move(upA));
}
struct A_pointer { operator A*() const { return nullptr; } };
void
test07()
{
// Allow conversions from user-defined pointer-like types
A_pointer p;
std::unique_ptr<A[]> upA(p);
std::unique_ptr<const A[]> cA(p);
std::unique_ptr<volatile A[]> vA(p);
std::unique_ptr<const volatile A[]> cvA(p);
}
template<typename T>
struct deleter
{
deleter() = default;
template<typename U>
deleter(const deleter<U>) { }
typedef T pointer;
void operator()(T) const { }
};
void
test08()
{
// Allow conversions from user-defined pointer-like types
std::unique_ptr<B[], deleter<A_pointer>> p;
std::unique_ptr<A[], deleter<A*>> upA(std::move(p));
}

6
libstdc++-v3/testsuite/20_util/unique_ptr/cons/pointer_array_convertible_neg.cc
View File

@ -1,7 +1,7 @@
// { dg-do compile } // { dg-do compile }
// { dg-options "-std=gnu++0x" } // { dg-options "-std=gnu++11" }
// Copyright (C) 2008, 2009 Free Software Foundation // Copyright (C) 2008-2012 Free Software Foundation
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -29,7 +29,7 @@ struct B : A
virtual ~B() { } virtual ~B() { }
}; };
// 20.4.5.1 unique_ptr constructors [unique.ptr.cons] // 20.7.1.3.1 unique_ptr constructors [unique.ptr.runtime.ctor]
// Construction from pointer of derived type // Construction from pointer of derived type
void void

13
libstdc++-v3/testsuite/20_util/unique_ptr/cons/ptr_deleter_neg.cc
View File

@ -1,7 +1,7 @@
// { dg-options "-std=gnu++0x" } // { dg-options "-std=gnu++0x" }
// { dg-do compile } // { dg-do compile }
// Copyright (C) 2010 Free Software Foundation // Copyright (C) 2010-2012 Free Software Foundation
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -18,10 +18,9 @@
// with this library; see the file COPYING3. If not see // with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>. // <http://www.gnu.org/licenses/>.
// 20.6.11 Template class unique_ptr [unique.ptr] // 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory> #include <memory>
#include <testsuite_hooks.h>
using std::unique_ptr; using std::unique_ptr;
@ -30,9 +29,9 @@ using std::unique_ptr;
void void
test01() test01()
{ {
unique_ptr<int, void(*)(int*)> p1; // { dg-error "here" } unique_ptr<long, void(*)(long*)> p1; // { dg-error "here" }
unique_ptr<int, void(*)(int*)> p2(nullptr); // { dg-error "here" } unique_ptr<short, void(*)(short*)> p2(nullptr); // { dg-error "here" }
unique_ptr<int, void(*)(int*)> p3(new int); // { dg-error "here" } unique_ptr<int, void(*)(int*)> p3(new int); // { dg-error "here" }
} }
@ -40,9 +39,9 @@ test01()
void void
test02() test02()
{ {
unique_ptr<int[], void(*)(int*)> p1; // { dg-error "here" } unique_ptr<long[], void(*)(long*)> p1; // { dg-error "here" }
unique_ptr<int[], void(*)(int*)> p2(nullptr); // { dg-error "here" } unique_ptr<short[], void(*)(short*)> p2(nullptr); // { dg-error "here" }
unique_ptr<int[], void(*)(int*)> p3(new int[1]); // { dg-error "here" } unique_ptr<int[], void(*)(int*)> p3(new int[1]); // { dg-error "here" }
} }

79
libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/cv_qual.cc Normal file
View File

@ -0,0 +1,79 @@
// { dg-options "-std=gnu++11" }
// { dg-do compile }
// Copyright (C) 2012 Free Software Foundation
//
// 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/>.
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
struct A { virtual ~A() = default; };
struct B : A { };
// Construction from objects with different cv-qualification
void
test01()
{
std::unique_ptr<const A> cA;
cA.reset(new A);
std::unique_ptr<volatile A> vA;
vA.reset(new A);
std::unique_ptr<const volatile A> cvA;
cvA.reset(new A);
}
void
test02()
{
std::unique_ptr<const A> cB;
cB.reset(new B);
std::unique_ptr<volatile A> vB;
vB.reset(new B);
std::unique_ptr<const volatile A> cvB;
cvB.reset(new B);
}
void
test03()
{
std::unique_ptr<const A[]> cA;
cA.reset(new A[1]);
std::unique_ptr<volatile A[]> vA;
vA.reset(new A[1]);
std::unique_ptr<const volatile A[]> cvA;
cvA.reset(new A[1]);
}
struct A_pointer { operator A*() const { return nullptr; } };
void
test07()
{
// Allow conversions from user-defined pointer-like types
A_pointer p;
std::unique_ptr<A[]> upA;
upA.reset(p);
std::unique_ptr<const A[]> cA;
cA.reset(p);
std::unique_ptr<volatile A[]> vA;
vA.reset(p);
std::unique_ptr<const volatile A[]> cvA;
cvA.reset(p);
}

4
libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/reset_neg.cc
View File

@ -1,7 +1,7 @@
// { dg-do compile } // { dg-do compile }
// { dg-options "-std=gnu++0x" } // { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009, 2010 Free Software Foundation // Copyright (C) 2008-2012 Free Software Foundation
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -32,7 +32,7 @@ struct B : A
void test01() void test01()
{ {
std::unique_ptr<B[]> up; std::unique_ptr<B[]> up;
up.reset(new A[3]); // { dg-error "deleted" } up.reset(new A[3]); // { dg-error "invalid conversion" }
} }
// { dg-prune-output "include" } // { dg-prune-output "include" }

7
libstdc++-v3/testsuite/20_util/unique_ptr/requirements/pointer_type.cc
View File

@ -1,7 +1,7 @@
// { dg-do compile } // { dg-do compile }
// { dg-options "-std=gnu++0x" } // { dg-options "-std=gnu++11" }
// Copyright (C) 2010, 2011 Free Software Foundation // Copyright (C) 2010-2012 Free Software Foundation
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -18,10 +18,9 @@
// with this library; see the file COPYING3. If not see // with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>. // <http://www.gnu.org/licenses/>.
// 20.6.11 Template class unique_ptr [unique.ptr.single] // 20.7.1.2 unique_ptr for single objects [unique.ptr.single]
#include <memory> #include <memory>
#include <testsuite_hooks.h>
struct A struct A
{ {

49
libstdc++-v3/testsuite/20_util/unique_ptr/requirements/pointer_type_array.cc Normal file
View File

@ -0,0 +1,49 @@
// { dg-do compile }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2010-2012 Free Software Foundation
//
// 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/>.
// 20.7.1.3 unique_ptr for array objects [unique.ptr.runtime]
#include <memory>
struct A
{
void operator()(void*) const { }
};
struct B
{
typedef char* pointer;
void operator()(pointer) const { }
};
int main()
{
typedef std::unique_ptr<int[]> up;
typedef std::unique_ptr<int[], A> upA;
typedef std::unique_ptr<int[], B> upB;
typedef std::unique_ptr<int[], A&> upAr;
typedef std::unique_ptr<int[], B&> upBr;
static_assert( std::is_same< up::pointer, int*>::value, "" );
static_assert( std::is_same< upA::pointer, int*>::value, "" );
static_assert( std::is_same< upB::pointer, char*>::value, "" );
static_assert( std::is_same< upAr::pointer, int*>::value, "" );
static_assert( std::is_same< upBr::pointer, char*>::value, "" );
}