This is an archive of the discontinued LLVM Phabricator instance.

Differential D70117

[libc++][P0174] Deprecated/removed parts of default allocator.
ClosedPublic

Authored by mpark on Nov 12 2019, 3:40 AM.

Details

Reviewers
ldionne
EricWF
mclow.lists
Group Reviewers
Restricted Project
Commits
rG5b1e5b4338d1: [libc++][P0174] Deprecated/removed parts of default allocator.

Diff Detail

Event Timeline

mpark created this revision.Nov 12 2019, 3:40 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 12 2019, 3:40 AM
Herald added subscribers: libcxx-commits, dexonsmith, christof. · View Herald Transcript
Harbormaster completed remote builds in B40798: Diff 228848.Nov 12 2019, 3:41 AM
mpark updated this revision to Diff 228853.Nov 12 2019, 3:59 AM

Updated to use allocator_traits<>::max_size().

mpark updated this revision to Diff 228855.Nov 12 2019, 4:03 AM

Fixed the static_cast result out of allocator<const T>.

Harbormaster completed remote builds in B40799: Diff 228853.Nov 12 2019, 4:05 AM
Harbormaster completed remote builds in B40801: Diff 228855.
mpark mentioned this in D69132: [libc++][P0784] Marked the default allocator constexpr..Nov 12 2019, 4:16 AM
mpark updated this revision to Diff 228858.Nov 12 2019, 4:20 AM

Added a new test allocate.depr_in_cxx17.fail.cpp.

Harbormaster completed remote builds in B40804: Diff 228858.Nov 12 2019, 4:27 AM
mpark updated this revision to Diff 228864.Nov 12 2019, 4:32 AM

Fixed the allocate.depr_in_cxx17.fail.cpp test.

Harbormaster completed remote builds in B40807: Diff 228864.Nov 12 2019, 4:37 AM
mpark updated this revision to Diff 228975.EditedNov 12 2019, 3:31 PM
  • Replaced use of allocator_traits::max_size with implementation of max_size(). This will be replaced to allocator_traits::max_size once allocator::max_size and allocator_traits::max_size are both marked constexpr.
  • Removed deprecated attributes from C++03 codepaths.
  • Moved/added more tests.
Harbormaster completed remote builds in B40850: Diff 228975.Nov 12 2019, 3:38 PM
mpark updated this revision to Diff 229007.Nov 12 2019, 10:24 PM

Refined the tests.

Harbormaster completed remote builds in B40865: Diff 229007.Nov 12 2019, 10:25 PM
ldionne requested changes to this revision.Nov 13 2019, 8:57 AM
ldionne added inline comments.
libcxx/include/memory
118–125

Woooh, thanks for the cleanup.

1361

What! I didn't know you could surround literally any piece of code with these pragmas! It does make sense though, since it's a preprocessor thing. Clang will really take the pragma into account when parsing just that part of the declaration?

1394

If the return type of __a.construct(...) somehow hijacks operator,, this won't work. But I don't care, don't change it.

An Allocator's construct method is supposed to return void -- if someone's that clever, they deserve to be taught better.

1871

I'm OK with this TODO since I saw you fixed it in a subsequent patch.

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp
15–16

Wait, you shouldn't get rid of this test pre-C++17. You should mark it as REQUIRES: c++03, ..., c++14. Or did I miss something and you did not actually remove this test?

This revision now requires changes to proceed.Nov 13 2019, 8:57 AM
mpark marked 8 inline comments as done.Feb 13 2020, 5:23 AM
mpark added inline comments.
libcxx/include/memory
1361

I believe so!

1394

+1

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp
15–16

This test has been moved to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.cxx2a.pass.cpp, following the pattern for auto_ptr which have auto_ptr.cxx1z.pass.cpp and auto_ptr.depr_in_cxx11.fail.cpp.

mpark marked 4 inline comments as done.Feb 13 2020, 5:25 AM
mpark added inline comments.
libcxx/include/memory
1361

Never mind, You were right. I can't do this 😅

mpark updated this revision to Diff 244577.Feb 14 2020, 12:35 AM

Fixed build error.

Harbormaster completed remote builds in B46477: Diff 244577.Feb 14 2020, 12:41 AM
ldionne accepted this revision.Mar 4 2020, 8:58 AM
ldionne added inline comments.
libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.depr_in_cxx17.fail.cpp
35

I'll admit I'm not the biggest fan of those escape hatches. Let's leave it here to avoid a discussion, but in the future we may want to have a discussion about whether we want to be less forgiving about those.

This revision is now accepted and ready to land.Mar 4 2020, 8:58 AM
Closed by commit rG5b1e5b4338d1: [libc++][P0174] Deprecated/removed parts of default allocator. (authored by mpark, committed by ldionne). · Explain WhyMar 4 2020, 9:34 AM
This revision was automatically updated to reflect the committed changes.
ldionne added inline comments.Mar 4 2020, 1:08 PM
libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.depr_in_cxx17.fail.cpp
17 ↗(On Diff #248217)

Just as a statement of how tricky it is to get things right the first time in libc++ (cause we're talking about it elsewhere), this broke the GCC-trunk C++17 bot on Ubuntu, and only that one. Finding it required firing my docker image with a similar configuration to the bot and running another test that we'd expect to fail, but was instead skipped. That hinted me that this test should be unsupported too, and I found the typo.

dblaikie added a subscriber: dblaikie.May 11 2021, 9:11 AM
dblaikie added inline comments.
libcxx/include/memory
717

https://bugs.llvm.org/show_bug.cgi?id=50299 might be of interest

Herald added a reviewer: Restricted Project. · View Herald TranscriptMay 11 2021, 9:11 AM
ldionne added a subscriber: jwakely.Jun 15 2021, 12:55 PM
ldionne added inline comments.
libcxx/include/memory
717

Thanks for the heads up, indeed we need to fix this. I'm doing that now.

Thanks @jwakely for the report BTW.

Revision Contents

PathSize
libcxx/
include/
268 lines
test/
libcxx/
depr/
depr.default.allocator/
std/
utilities/
memory/
allocator.members/
default.allocator/
allocator.members/
address.cxx2a.pass.cpp
address.pass.cpp
9 lines
31 lines
allocate.cxx2a.fail.cpp
allocate.fail.cpp
16 lines
construct.cxx2a.pass.cpp
construct.pass.cpp
9 lines
max_size.cxx2a.pass.cpp
max_size.pass.cpp
9 lines
allocator_types.cxx2a.pass.cpp/
default.allocator/
allocator_types.pass.cpp
11 lines
allocator_void.cxx2a.pass.cpp/
default.allocator/
allocator_void.pass.cpp
5 lines
allocator_void.depr_in_cxx17.fail.cpp/
default.allocator/
allocator_void.pass.cpp
23 lines
libcxx/
depr/
depr.default.allocator/
56 lines
utilities/
tuple/
tuple.tuple/
tuple.cnstr/
2 lines
std/
containers/
sequences/
deque/
3 lines
list/
3 lines
vector/
3 lines
experimental/
memory/
memory.resource.adaptor/
memory.resource.adaptor.overview/
2 lines
utilities/
function.objects/
func.wrap/
func.wrap.func/
func.wrap.func.con/
4 lines
memory/
default.allocator/
allocator.members/
9 lines
23 lines
11 lines
25 lines
tuple/
tuple.tuple/
tuple.cnstr/
2 lines
8 lines
2 lines
4 lines
6 lines
4 lines
4 lines
2 lines
4 lines
2 lines

Diff 228855

libcxx/include/memory

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines typedef Alloc::propagate_on_container_copy_assignment
| false_type propagate_on_container_copy_assignment; | false_type propagate_on_container_copy_assignment;
typedef Alloc::propagate_on_container_move_assignment typedef Alloc::propagate_on_container_move_assignment
| false_type propagate_on_container_move_assignment; | false_type propagate_on_container_move_assignment;
typedef Alloc::propagate_on_container_swap typedef Alloc::propagate_on_container_swap
| false_type propagate_on_container_swap; | false_type propagate_on_container_swap;
typedef Alloc::is_always_equal typedef Alloc::is_always_equal
| is_empty is_always_equal; | is_empty is_always_equal;
template <class T> using rebind_alloc = Alloc::rebind<U>::other | Alloc<T, Args...>; template <class T> using rebind_alloc = Alloc::rebind<T>::other | Alloc<T, Args...>;
template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
static pointer allocate(allocator_type& a, size_type n); // [[nodiscard]] in C++20 static pointer allocate(allocator_type& a, size_type n); // [[nodiscard]] in C++20
static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // [[nodiscard]] in C++20 static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // [[nodiscard]] in C++20
static void deallocate(allocator_type& a, pointer p, size_type n) noexcept; static void deallocate(allocator_type& a, pointer p, size_type n) noexcept;
template <class T, class... Args> template <class T, class... Args>
static void construct(allocator_type& a, T* p, Args&&... args); static void construct(allocator_type& a, T* p, Args&&... args);
template <class T> template <class T>
static void destroy(allocator_type& a, T* p); static void destroy(allocator_type& a, T* p);
static size_type max_size(const allocator_type& a); // noexcept in C++14 static size_type max_size(const allocator_type& a); // noexcept in C++14
static allocator_type static allocator_type
select_on_container_copy_construction(const allocator_type& a); select_on_container_copy_construction(const allocator_type& a);
}; };
template <> template <>
class allocator<void> class allocator<void> // deprecated in C++17, removed in C++20
{ {
public: public:
typedef void* pointer; typedef void* pointer;
typedef const void* const_pointer; typedef const void* const_pointer;
typedef void value_type; typedef void value_type;
template <class _Up> struct rebind {typedef allocator<_Up> other;}; template <class _Up> struct rebind {typedef allocator<_Up> other;};
}; };
template <class T> template <class T>
class allocator class allocator
{ {
public: public:
typedef size_t size_type; typedef size_t size_type; // deprecated in C++17, removed in C++20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type; // deprecated in C++17, removed in C++20
typedef T* pointer; typedef T* pointer; // deprecated in C++17, removed in C++20
typedef const T* const_pointer; typedef const T* const_pointer; // deprecated in C++17, removed in C++20
typedef typename add_lvalue_reference<T>::type reference; typedef typename add_lvalue_reference<T>::type
typedef typename add_lvalue_reference<const T>::type const_reference; reference; // deprecated in C++17, removed in C++20
typedef typename add_lvalue_reference<const T>::type
const_reference; // deprecated in C++17, removed in C++20
ldionneUnsubmitted
Done
ReplyInline Actions

Woooh, thanks for the cleanup.

ldionne: Woooh, thanks for the cleanup.
typedef T value_type; typedef T value_type;
template <class U> struct rebind {typedef allocator<U> other;}; template <class U> struct rebind {typedef allocator<U> other;}; // deprecated in C++17, removed in C++20
typedef true_type propagate_on_container_move_assignment;
typedef true_type is_always_equal;
constexpr allocator() noexcept; // constexpr in C++20 constexpr allocator() noexcept; // constexpr in C++20
constexpr allocator(const allocator&) noexcept; // constexpr in C++20 constexpr allocator(const allocator&) noexcept; // constexpr in C++20
template <class U> template <class U>
constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20 constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20
~allocator(); ~allocator();
pointer address(reference x) const noexcept; pointer address(reference x) const noexcept; // deprecated in C++17, removed in C++20
const_pointer address(const_reference x) const noexcept; const_pointer address(const_reference x) const noexcept; // deprecated in C++17, removed in C++20
pointer allocate(size_type, allocator<void>::const_pointer hint = 0); T* allocate(size_t n, const void* hint); // deprecated in C++17, removed in C++20
void deallocate(pointer p, size_type n) noexcept; T* allocate(size_t n);
size_type max_size() const noexcept; void deallocate(T* p, size_t n) noexcept;
size_type max_size() const noexcept; // deprecated in C++17, removed in C++20
template<class U, class... Args> template<class U, class... Args>
void construct(U* p, Args&&... args); void construct(U* p, Args&&... args); // deprecated in C++17, removed in C++20
template <class U> template <class U>
void destroy(U* p); void destroy(U* p); // deprecated in C++17, removed in C++20
}; };
template <class T, class U> template <class T, class U>
bool operator==(const allocator<T>&, const allocator<U>&) noexcept; bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
template <class T, class U> template <class T, class U>
bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
▲ Show 20 Lines • Show All 550 Lines • ▼ Show 20 Lines#else
return *__value; return *__value;
#endif #endif
} }
// addressof moved to <type_traits> // addressof moved to <type_traits>
template <class _Tp> class allocator; template <class _Tp> class allocator;
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
template <> template <>
class _LIBCPP_TEMPLATE_VIS allocator<void> class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<void>
dblaikieUnsubmitted
Not Done
ReplyInline Actions

https://bugs.llvm.org/show_bug.cgi?id=50299 might be of interest

dblaikie: https://bugs.llvm.org/show_bug.cgi?id=50299 might be of interest
ldionneUnsubmitted
Done
ReplyInline Actions

Thanks for the heads up, indeed we need to fix this. I'm doing that now.

Thanks @jwakely for the report BTW.

ldionne: Thanks for the heads up, indeed we need to fix this. I'm doing that now. Thanks @jwakely for…
{ {
public: public:
typedef void* pointer; typedef void* pointer;
typedef const void* const_pointer; typedef const void* const_pointer;
typedef void value_type; typedef void value_type;
template <class _Up> struct rebind {typedef allocator<_Up> other;}; template <class _Up> struct rebind {typedef allocator<_Up> other;};
}; };
template <> template <>
class _LIBCPP_TEMPLATE_VIS allocator<const void> class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<const void>
{ {
public: public:
typedef const void* pointer; typedef const void* pointer;
typedef const void* const_pointer; typedef const void* const_pointer;
typedef const void value_type; typedef const void value_type;
template <class _Up> struct rebind {typedef allocator<_Up> other;}; template <class _Up> struct rebind {typedef allocator<_Up> other;};
}; };
#endif
// pointer_traits // pointer_traits
template <class _Tp, class = void> template <class _Tp, class = void>
struct __has_element_type : false_type {}; struct __has_element_type : false_type {};
template <class _Tp> template <class _Tp>
struct __has_element_type<_Tp, struct __has_element_type<_Tp,
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
}; };
template <class _Ptr> template <class _Ptr>
struct __pointer_traits_difference_type<_Ptr, true> struct __pointer_traits_difference_type<_Ptr, true>
{ {
typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::difference_type type; typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::difference_type type;
}; };
template <class _Tp, class _Up, class = void>
struct __has_rebind : false_type {};
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __has_rebind struct __has_rebind<_Tp, _Up,
{ typename __void_t<typename _Tp::template rebind<_Up> >::type> : true_type {};
private:
struct __two {char __lx; char __lxx;};
template <class _Xp> static __two __test(...);
template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
public:
static const bool value = sizeof(__test<_Tp>(0)) == 1;
};
template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
struct __pointer_traits_rebind struct __pointer_traits_rebind
{ {
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up> type; typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up> type;
#else #else
typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type; typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
▲ Show 20 Lines • Show All 397 Lines • ▼ Show 20 Lines
}; };
template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
struct __has_rebind_other struct __has_rebind_other
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
template <class _Xp> static __two __test(...); template <class _Xp> static __two __test(...);
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0); template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);
_LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
static const bool value = sizeof(__test<_Tp>(0)) == 1; static const bool value = sizeof(__test<_Tp>(0)) == 1;
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __has_rebind_other<_Tp, _Up, false> struct __has_rebind_other<_Tp, _Up, false>
{ {
static const bool value = false; static const bool value = false;
}; };
template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value> template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
struct __allocator_traits_rebind struct __allocator_traits_rebind
{ {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type; typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
_LIBCPP_SUPPRESS_DEPRECATED_POP
}; };
#ifndef _LIBCPP_HAS_NO_VARIADICS #ifndef _LIBCPP_HAS_NO_VARIADICS
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
{ {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type; typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;
_LIBCPP_SUPPRESS_DEPRECATED_POP
}; };
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
{ {
typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type; typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type;
}; };
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
#endif // _LIBCPP_HAS_NO_VARIADICS #endif // _LIBCPP_HAS_NO_VARIADICS
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Alloc, class _SizeType, class _ConstVoidPtr> template <class _Alloc, class _SizeType, class _ConstVoidPtr>
auto auto
__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
ldionneUnsubmitted
Done
ReplyInline Actions

What! I didn't know you could surround literally any piece of code with these pragmas! It does make sense though, since it's a preprocessor thing. Clang will really take the pragma into account when parsing just that part of the declaration?

ldionne: What! I didn't know you could surround literally any piece of code with these pragmas! It does…
mparkAuthorUnsubmitted
Done
ReplyInline Actions

I believe so!

mpark: I believe so!
mparkAuthorUnsubmitted
Done
ReplyInline Actions

Never mind, You were right. I can't do this 😅

mpark: Never mind, You were right. I can't do this 😅
-> decltype((void)__a.allocate(__sz, __p), true_type()); -> decltype((void)__a.allocate(__sz, __p), true_type());
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Alloc, class _SizeType, class _ConstVoidPtr> template <class _Alloc, class _SizeType, class _ConstVoidPtr>
auto auto
__has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
-> false_type; -> false_type;
template <class _Alloc, class _SizeType, class _ConstVoidPtr> template <class _Alloc, class _SizeType, class _ConstVoidPtr>
struct __has_allocate_hint struct __has_allocate_hint
: integral_constant<bool, : decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
is_same<
decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
declval<_SizeType>(), declval<_SizeType>(),
declval<_ConstVoidPtr>())), declval<_ConstVoidPtr>()))
true_type>::value>
{ {
}; };
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _Alloc, class _SizeType, class _ConstVoidPtr> template <class _Alloc, class _SizeType, class _ConstVoidPtr>
struct __has_allocate_hint struct __has_allocate_hint
: true_type : true_type
{ {
}; };
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if !defined(_LIBCPP_CXX03_LANG) #if !defined(_LIBCPP_CXX03_LANG)
template <class _Alloc, class _Tp, class ..._Args> template <class _Alloc, class _Tp, class... _Args>
decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(), auto
_VSTD::declval<_Args>()...), __has_construct_test(_Alloc&& __a, _Tp* __p, _Args&&... __args)
true_type()) _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args); -> decltype(__a.construct(__p, _VSTD::forward<_Args>(__args)...), true_type());
ldionneUnsubmitted
Done
ReplyInline Actions

If the return type of __a.construct(...) somehow hijacks operator,, this won't work. But I don't care, don't change it.

An Allocator's construct method is supposed to return void -- if someone's that clever, they deserve to be taught better.

ldionne: If the return type of `__a.construct(...)` somehow hijacks `operator,`, this won't work. But I…
mparkAuthorUnsubmitted
Done
ReplyInline Actions

+1

mpark: +1
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Alloc, class _Pointer, class ..._Args> template <class _Alloc, class _Pointer, class ..._Args>
false_type auto
__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args); __has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args)
-> false_type;
template <class _Alloc, class _Pointer, class ..._Args> template <class _Alloc, class _Pointer, class ..._Args>
struct __has_construct struct __has_construct
: integral_constant<bool, : decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
is_same<
decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
declval<_Pointer>(), declval<_Pointer>(),
declval<_Args>()...)), declval<_Args>()...))
true_type>::value>
{ {
}; };
template <class _Alloc, class _Pointer> template <class _Alloc, class _Pointer>
auto auto
__has_destroy_test(_Alloc&& __a, _Pointer&& __p) __has_destroy_test(_Alloc&& __a, _Pointer&& __p)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-> decltype(__a.destroy(__p), true_type()); -> decltype(__a.destroy(__p), true_type());
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Alloc, class _Pointer> template <class _Alloc, class _Pointer>
auto auto
__has_destroy_test(const _Alloc& __a, _Pointer&& __p) __has_destroy_test(const _Alloc& __a, _Pointer&& __p)
-> false_type; -> false_type;
template <class _Alloc, class _Pointer> template <class _Alloc, class _Pointer>
struct __has_destroy struct __has_destroy
: integral_constant<bool, : decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
is_same< declval<_Pointer>()))
decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
declval<_Pointer>())),
true_type>::value>
{ {
}; };
template <class _Alloc> template <class _Alloc>
auto auto
__has_max_size_test(_Alloc&& __a) __has_max_size_test(_Alloc&& __a)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-> decltype(__a.max_size(), true_type()); -> decltype(__a.max_size(), true_type());
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Alloc> template <class _Alloc>
auto auto
__has_max_size_test(const volatile _Alloc& __a) __has_max_size_test(const volatile _Alloc& __a)
-> false_type; -> false_type;
template <class _Alloc> template <class _Alloc>
struct __has_max_size struct __has_max_size
: integral_constant<bool, : decltype(_VSTD::__has_max_size_test(declval<_Alloc&>()))
is_same<
decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
true_type>::value>
{ {
}; };
template <class _Alloc> template <class _Alloc>
auto auto
__has_select_on_container_copy_construction_test(_Alloc&& __a) __has_select_on_container_copy_construction_test(_Alloc&& __a)
-> decltype(__a.select_on_container_copy_construction(), true_type()); -> decltype(__a.select_on_container_copy_construction(), true_type());
template <class _Alloc> template <class _Alloc>
auto auto
__has_select_on_container_copy_construction_test(const volatile _Alloc& __a) __has_select_on_container_copy_construction_test(const volatile _Alloc& __a)
-> false_type; -> false_type;
template <class _Alloc> template <class _Alloc>
struct __has_select_on_container_copy_construction struct __has_select_on_container_copy_construction
: integral_constant<bool, : decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>()))
is_same<
decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
true_type>::value>
{ {
}; };
#else // _LIBCPP_CXX03_LANG #else // _LIBCPP_CXX03_LANG
template <class _Alloc, class _Pointer, class _Tp, class = void> template <class _Alloc, class _Pointer, class _Tp, class = void>
struct __has_construct : std::false_type {}; struct __has_construct : std::false_type {};
▲ Show 20 Lines • Show All 275 Lines • ▼ Show 20 Lines template <class _Tp>
_VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
} }
private: private:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static pointer __allocate(allocator_type& __a, size_type __n, static pointer __allocate(allocator_type& __a, size_type __n,
const_void_pointer __hint, true_type) const_void_pointer __hint, true_type)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
{return __a.allocate(__n, __hint);} {return __a.allocate(__n, __hint);}
_LIBCPP_SUPPRESS_DEPRECATED_POP
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static pointer __allocate(allocator_type& __a, size_type __n, static pointer __allocate(allocator_type& __a, size_type __n,
const_void_pointer, false_type) const_void_pointer, false_type)
{return __a.allocate(__n);} {return __a.allocate(__n);}
#ifndef _LIBCPP_HAS_NO_VARIADICS #ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args) static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
{__a.construct(__p, _VSTD::forward<_Args>(__args)...);} {__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args) static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
{ {
::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
} }
#else // _LIBCPP_HAS_NO_VARIADICS #else // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _A0> template <class _Tp, class _A0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void __construct(true_type, allocator_type& __a, _Tp* __p, static void __construct(true_type, allocator_type& __a, _Tp* __p,
const _A0& __a0) const _A0& __a0)
{__a.construct(__p, __a0);} {__a.construct(__p, __a0);}
template <class _Tp, class _A0> template <class _Tp, class _A0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void __construct(false_type, allocator_type&, _Tp* __p, static void __construct(false_type, allocator_type&, _Tp* __p,
const _A0& __a0) const _A0& __a0)
{ {
::new ((void*)__p) _Tp(__a0); ::new ((void*)__p) _Tp(__a0);
} }
#endif // _LIBCPP_HAS_NO_VARIADICS #endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void __destroy(true_type, allocator_type& __a, _Tp* __p) static void __destroy(true_type, allocator_type& __a, _Tp* __p)
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
{__a.destroy(__p);} {__a.destroy(__p);}
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static void __destroy(false_type, allocator_type&, _Tp* __p) static void __destroy(false_type, allocator_type&, _Tp* __p)
{ {
__p->~_Tp(); __p->~_Tp();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
{return __a.max_size();} {return __a.max_size();}
_LIBCPP_SUPPRESS_DEPRECATED_POP
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT
{return numeric_limits<size_type>::max() / sizeof(value_type);} {return numeric_limits<size_type>::max() / sizeof(value_type);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
static allocator_type static allocator_type
__select_on_container_copy_construction(true_type, const allocator_type& __a) __select_on_container_copy_construction(true_type, const allocator_type& __a)
{return __a.select_on_container_copy_construction();} {return __a.select_on_container_copy_construction();}
Show All 14 Lines
}; };
// allocator // allocator
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS allocator class _LIBCPP_TEMPLATE_VIS allocator
{ {
public: public:
typedef size_t size_type; #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
typedef ptrdiff_t difference_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t size_type;
typedef _Tp* pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef ptrdiff_t difference_type;
typedef const _Tp* const_pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp* pointer;
typedef _Tp& reference; _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
typedef const _Tp& const_reference; _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp& reference;
_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
#endif
typedef _Tp value_type; typedef _Tp value_type;
typedef true_type propagate_on_container_move_assignment; typedef true_type propagate_on_container_move_assignment;
typedef true_type is_always_equal; typedef true_type is_always_equal;
template <class _Up> struct rebind {typedef allocator<_Up> other;};
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
allocator() _NOEXCEPT {} allocator() _NOEXCEPT {}
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
allocator(const allocator<_Up>&) _NOEXCEPT {} allocator(const allocator<_Up>&) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
pointer address(reference __x) const _NOEXCEPT
{return _VSTD::addressof(__x);} {return _VSTD::addressof(__x);}
_LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
const_pointer address(const_reference __x) const _NOEXCEPT
{return _VSTD::addressof(__x);} {return _VSTD::addressof(__x);}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY #endif
pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _Tp* allocate(size_t __n)
{ {
if (__n > max_size()) if (__n > allocator_traits<allocator>::max_size(*this))
ldionneUnsubmitted
Done
ReplyInline Actions

I'm OK with this TODO since I saw you fixed it in a subsequent patch.

ldionne: I'm OK with this TODO since I saw you fixed it in a subsequent patch.
__throw_length_error("allocator<T>::allocate(size_t n)" __throw_length_error("allocator<T>::allocate(size_t n)"
" 'n' exceeds maximum supported size"); " 'n' exceeds maximum supported size");
return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
} }
_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
_Tp* allocate(size_t __n, const void*) { return allocate(__n); }
#endif
_LIBCPP_INLINE_VISIBILITY void deallocate(_Tp* __p, size_t __n) _NOEXCEPT
{_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));} {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
{return size_type(~0) / sizeof(_Tp);} {return size_type(~0) / sizeof(_Tp);}
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
template <class _Up, class... _Args> template <class _Up, class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(_Up* __p, _Args&&... __args) construct(_Up* __p, _Args&&... __args)
{ {
::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
} }
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) #else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p) construct(pointer __p)
{ {
::new((void*)__p) _Tp(); ::new((void*)__p) _Tp();
} }
# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
template <class _A0> template <class _A0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, _A0& __a0) _LIBCPP_DEPRECATED_IN_CXX17 construct(pointer __p, _A0& __a0)
{ {
::new((void*)__p) _Tp(__a0); ::new((void*)__p) _Tp(__a0);
} }
template <class _A0> template <class _A0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, const _A0& __a0) construct(pointer __p, const _A0& __a0)
{ {
::new((void*)__p) _Tp(__a0); ::new((void*)__p) _Tp(__a0);
} }
# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) # endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, _A0& __a0, _A1& __a1) construct(pointer __p, _A0& __a0, _A1& __a1)
{ {
::new((void*)__p) _Tp(__a0, __a1); ::new((void*)__p) _Tp(__a0, __a1);
} }
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, const _A0& __a0, _A1& __a1) construct(pointer __p, const _A0& __a0, _A1& __a1)
{ {
::new((void*)__p) _Tp(__a0, __a1); ::new((void*)__p) _Tp(__a0, __a1);
} }
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, _A0& __a0, const _A1& __a1) construct(pointer __p, _A0& __a0, const _A1& __a1)
{ {
::new((void*)__p) _Tp(__a0, __a1); ::new((void*)__p) _Tp(__a0, __a1);
} }
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, const _A0& __a0, const _A1& __a1) construct(pointer __p, const _A0& __a0, const _A1& __a1)
{ {
::new((void*)__p) _Tp(__a0, __a1); ::new((void*)__p) _Tp(__a0, __a1);
} }
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
#endif
}; };
template <class _Tp> template <class _Tp>
class _LIBCPP_TEMPLATE_VIS allocator<const _Tp> class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
{ {
public: public:
typedef size_t size_type; #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
typedef ptrdiff_t difference_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t size_type;
typedef const _Tp* pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef ptrdiff_t difference_type;
typedef const _Tp* const_pointer; _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
typedef const _Tp& reference; _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
typedef const _Tp& const_reference; _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference;
_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
#endif
typedef const _Tp value_type; typedef const _Tp value_type;
typedef true_type propagate_on_container_move_assignment; typedef true_type propagate_on_container_move_assignment;
typedef true_type is_always_equal; typedef true_type is_always_equal;
template <class _Up> struct rebind {typedef allocator<_Up> other;};
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
allocator() _NOEXCEPT {} allocator() _NOEXCEPT {}
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
allocator(const allocator<_Up>&) _NOEXCEPT {} allocator(const allocator<_Up>&) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
const_pointer address(const_reference __x) const _NOEXCEPT
{return _VSTD::addressof(__x);} {return _VSTD::addressof(__x);}
_LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0) #endif
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const _Tp* allocate(size_t __n)
{ {
if (__n > max_size()) if (__n > allocator_traits<allocator>::max_size(*this))
__throw_length_error("allocator<const T>::allocate(size_t n)" __throw_length_error("allocator<const T>::allocate(size_t n)"
" 'n' exceeds maximum supported size"); " 'n' exceeds maximum supported size");
return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
} }
_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
const _Tp* allocate(size_t __n, const void*) { return allocate(__n); }
#endif
_LIBCPP_INLINE_VISIBILITY void deallocate(const _Tp* __p, size_t __n)
{_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));} {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
{return size_type(~0) / sizeof(_Tp);} {return size_type(~0) / sizeof(_Tp);}
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
template <class _Up, class... _Args> template <class _Up, class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(_Up* __p, _Args&&... __args) construct(_Up* __p, _Args&&... __args)
{ {
::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
} }
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) #else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p) construct(pointer __p)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(); ::new((void*) const_cast<_Tp *>(__p)) _Tp();
} }
# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
template <class _A0> template <class _A0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, _A0& __a0) construct(pointer __p, _A0& __a0)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0); ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0);
} }
template <class _A0> template <class _A0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, const _A0& __a0) construct(pointer __p, const _A0& __a0)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0); ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0);
} }
# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) # endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, _A0& __a0, _A1& __a1) construct(pointer __p, _A0& __a0, _A1& __a1)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
} }
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, const _A0& __a0, _A1& __a1) construct(pointer __p, const _A0& __a0, _A1& __a1)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
} }
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, _A0& __a0, const _A1& __a1) construct(pointer __p, _A0& __a0, const _A1& __a1)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
} }
template <class _A0, class _A1> template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
void void
construct(pointer __p, const _A0& __a0, const _A1& __a1) construct(pointer __p, const _A0& __a0, const _A1& __a1)
{ {
::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
} }
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
#endif
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;} bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 3,341 Lines • Show Last 20 Lines

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.cxx2a.pass.cpp

  • This file was copied from libcxx/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// allocator: // allocator:
// pointer address(reference x) const; // pointer address(reference x) const;
// const_pointer address(const_reference x) const; // const_pointer address(const_reference x) const;
// In C++20, parts of std::allocator<T> have been removed.
// However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// is defined before including <memory>, then removed members will be restored.
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
void test_address() void test_address()
{ {
Show All 20 Lines

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp

  • This file was moved from libcxx/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// allocator: // allocator:
// pointer address(reference x) const; // pointer address(reference x) const;
// const_pointer address(const_reference x) const; // const_pointer address(const_reference x) const;
#include <memory> // Deprecated in C++17
#include <cassert>
ldionneUnsubmitted
Done
ReplyInline Actions

Wait, you shouldn't get rid of this test pre-C++17. You should mark it as REQUIRES: c++03, ..., c++14. Or did I miss something and you did not actually remove this test?

ldionne: Wait, you shouldn't get rid of this test pre-C++17. You should mark it as `REQUIRES: c++03, ...
mparkAuthorUnsubmitted
Done
ReplyInline Actions

This test has been moved to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.cxx2a.pass.cpp, following the pattern for auto_ptr which have auto_ptr.cxx1z.pass.cpp and auto_ptr.depr_in_cxx11.fail.cpp.

mpark: This test has been moved to `libcxx/test/libcxx/depr/depr.default.allocator/allocator.
#include "test_macros.h" // UNSUPPORTED: c++98, c++03, c++11, c++14
// REQUIRES: verify-support
template <class T> // MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
void test_address() #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
{
T* tp = new T();
const T* ctp = tp;
const std::allocator<T> a;
assert(a.address(*tp) == tp);
assert(a.address(*ctp) == tp);
delete tp;
}
struct A #include <memory>
{ #include "test_macros.h"
void operator&() const {}
};
int main(int, char**) int main(int, char**)
{ {
test_address<int>(); int x = 0;
test_address<A>(); std::allocator<int> a;
int* p = a.address(x); // expected-error{{'address' is deprecated}}
(void)p;
return 0; return 0;
} }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.cxx2a.fail.cpp

  • This file was copied from libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
// <memory> // <memory>
// allocator: // allocator:
// pointer allocate(size_type n, allocator<void>::const_pointer hint=0); // T* allocate(size_t n, const void* hint);
// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 // In C++20, parts of std::allocator<T> have been removed.
// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8 // However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// is defined before including <memory>, then removed members will be restored.
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::allocator<int> a; std::allocator<int> a;
a.allocate(3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}} a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
return 0; return 0;
} }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/construct.cxx2a.pass.cpp

  • This file was moved from libcxx/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// allocator: // allocator:
// template <class... Args> void construct(pointer p, Args&&... args); // template <class... Args> void construct(pointer p, Args&&... args);
// In C++20, parts of std::allocator<T> have been removed.
// However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// is defined before including <memory>, then removed members will be restored.
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.h" #include "count_new.h"
int A_constructed = 0; int A_constructed = 0;
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/max_size.cxx2a.pass.cpp

  • This file was moved from libcxx/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// allocator: // allocator:
// size_type max_size() const throw(); // size_type max_size() const throw();
// In C++20, parts of std::allocator<T> have been removed.
// However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// is defined before including <memory>, then removed members will be restored.
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <limits> #include <limits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int new_called = 0; int new_called = 0;
Show All 9 Lines

libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.cxx2a.pass.cpp

  • This file was copied from libcxx/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp.
Show All 14 Lines
// { // {
// public: // public:
// typedef size_t size_type; // typedef size_t size_type;
// typedef ptrdiff_t difference_type; // typedef ptrdiff_t difference_type;
// typedef T* pointer; // typedef T* pointer;
// typedef const T* const_pointer; // typedef const T* const_pointer;
// typedef typename add_lvalue_reference<T>::type reference; // typedef typename add_lvalue_reference<T>::type reference;
// typedef typename add_lvalue_reference<const T>::type const_reference; // typedef typename add_lvalue_reference<const T>::type const_reference;
// typedef T value_type;
// typedef true_type is_always_equal;
// //
// template <class U> struct rebind {typedef allocator<U> other;}; // template <class U> struct rebind {typedef allocator<U> other;};
// ... // ...
// }; // };
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), ""); static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), ""); static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
static_assert((std::is_same<std::allocator<char>::pointer, char*>::value), ""); static_assert((std::is_same<std::allocator<char>::pointer, char*>::value), "");
static_assert((std::is_same<std::allocator<char>::const_pointer, const char*>::value), ""); static_assert((std::is_same<std::allocator<char>::const_pointer, const char*>::value), "");
static_assert((std::is_same<std::allocator<char>::value_type, char>::value), "");
static_assert((std::is_same<std::allocator<char>::reference, char&>::value), ""); static_assert((std::is_same<std::allocator<char>::reference, char&>::value), "");
static_assert((std::is_same<std::allocator<char>::const_reference, const char&>::value), ""); static_assert((std::is_same<std::allocator<char>::const_reference, const char&>::value), "");
static_assert((std::is_same<std::allocator<char>::rebind<int>::other, static_assert((std::is_same<std::allocator<char>::rebind<int>::other,
std::allocator<int> >::value), ""); std::allocator<int> >::value), "");
static_assert((std::is_same<std::allocator< char>::is_always_equal, std::true_type>::value), "");
LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::is_always_equal, std::true_type>::value), "");
std::allocator<char> a; std::allocator<char> a;
std::allocator<char> a2 = a; std::allocator<char> a2 = a;
a2 = a; a2 = a;
std::allocator<int> a3 = a2; std::allocator<int> a3 = a2;
((void)a3); ((void)a3);
return 0; return 0;
} }

libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.depr_in_cxx17.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <memory>
// check nested types:
// template <class T>
// class allocator
// {
// public:
// typedef size_t size_type;
// typedef ptrdiff_t difference_type;
// typedef T* pointer;
// typedef const T* const_pointer;
// typedef typename add_lvalue_reference<T>::type reference;
// typedef typename add_lvalue_reference<const T>::type const_reference;
//
// template <class U> struct rebind {typedef allocator<U> other;};
// ...
// };
// Deprecated in C++17
// UNSUPPORTED: c++98, c++03, c++11, c++14
// REQUIRES: verify-support
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
ldionneUnsubmitted
Not Done
ReplyInline Actions

I'll admit I'm not the biggest fan of those escape hatches. Let's leave it here to avoid a discussion, but in the future we may want to have a discussion about whether we want to be less forgiving about those.

ldionne: I'll admit I'm not the biggest fan of those escape hatches. Let's leave it here to avoid a…
#include <memory>
#include "test_macros.h"
int main(int, char**)
{
typedef std::allocator<char>::size_type AST; // expected-error{{'size_type' is deprecated}}
typedef std::allocator<char>::difference_type ADT; // expected-error{{'difference_type' is deprecated}}
typedef std::allocator<char>::pointer AP; // expected-error{{'pointer' is deprecated}}
typedef std::allocator<char>::const_pointer ACP; // expected-error{{'const_pointer' is deprecated}}
typedef std::allocator<char>::reference AR; // expected-error{{'reference' is deprecated}}
typedef std::allocator<char>::const_reference ACR; // expected-error{{'const_reference' is deprecated}}
typedef std::allocator<char>::rebind<int>::other ARO; // expected-error{{'rebind<int>' is deprecated}}
std::allocator<char> a;
std::allocator<char> a2 = a;
a2 = a;
std::allocator<int> a3 = a2;
((void)a3);
return 0;
}

libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.cxx2a.pass.cpp

  • This file was copied from libcxx/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp.
Show All 13 Lines
// public: // public:
// typedef void* pointer; // typedef void* pointer;
// typedef const void* const_pointer; // typedef const void* const_pointer;
// typedef void value_type; // typedef void value_type;
// //
// template <class _Up> struct rebind {typedef allocator<_Up> other;}; // template <class _Up> struct rebind {typedef allocator<_Up> other;};
// }; // };
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), ""); static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");
Show All 10 Lines

libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.depr_in_cxx17.fail.cpp

  • This file was moved from libcxx/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
//
// template <> // template <>
// class allocator<void> // class allocator<void>
// { // {
// public: // public:
// typedef void* pointer; // typedef void* pointer;
// typedef const void* const_pointer; // typedef const void* const_pointer;
// typedef void value_type; // typedef void value_type;
// //
// template <class _Up> struct rebind {typedef allocator<_Up> other;}; // template <class _Up> struct rebind {typedef allocator<_Up> other;};
// }; // };
//
// Deprecated in C++17
#include <memory> // UNSUPPORTED: c++98, c++03, c++11, c++14
#include <type_traits> // REQUIRES: verify-support
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#include <memory>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), ""); typedef std::allocator<void>::pointer AP; // expected-error{{'allocator<void>' is deprecated}}
static_assert((std::is_same<std::allocator<void>::const_pointer, const void*>::value), ""); typedef std::allocator<void>::const_pointer ACP; // expected-error{{'allocator<void>' is deprecated}}
static_assert((std::is_same<std::allocator<void>::value_type, void>::value), ""); typedef std::allocator<void>::rebind<int>::other ARO; // expected-error{{'allocator<void>' is deprecated}}
static_assert((std::is_same<std::allocator<void>::rebind<int>::other,
std::allocator<int> >::value), "");
std::allocator<void> a;
std::allocator<void> a2 = a;
a2 = a;
return 0; return 0;
} }

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines // expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
ConvertsTo<int> ct; ConvertsTo<int> ct;
std::tuple<int const&, void*> t(ct, nullptr); // expected-note {{requested here}} std::tuple<int const&, void*> t(ct, nullptr); // expected-note {{requested here}}
} }
{ {
ConvertsTo<Derived> ct; ConvertsTo<Derived> ct;
std::tuple<Base const&, int> t(ct, 42); // expected-note {{requested here}} std::tuple<Base const&, int> t(ct, 42); // expected-note {{requested here}}
} }
{ {
std::allocator<void> alloc; std::allocator<int> alloc;
std::tuple<std::string &&> t2("hello"); // expected-note {{requested here}} std::tuple<std::string &&> t2("hello"); // expected-note {{requested here}}
std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-note {{requested here}} std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-note {{requested here}}
} }
#else #else
#error force failure #error force failure
// expected-error@-1 {{force failure}} // expected-error@-1 {{force failure}}
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/sequences/deque/types.pass.cpp

Show All 22 Lines
// typedef typename allocator_type::size_type size_type; // typedef typename allocator_type::size_type size_type;
// typedef typename allocator_type::difference_type difference_type; // typedef typename allocator_type::difference_type difference_type;
// typedef typename allocator_type::pointer pointer; // typedef typename allocator_type::pointer pointer;
// typedef typename allocator_type::const_pointer const_pointer; // typedef typename allocator_type::const_pointer const_pointer;
// typedef std::reverse_iterator<iterator> reverse_iterator; // typedef std::reverse_iterator<iterator> reverse_iterator;
// typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// }; // };
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <deque> #include <deque>
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "../../Copyable.h" #include "../../Copyable.h"
#include "min_allocator.h" #include "min_allocator.h"
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/containers/sequences/list/types.pass.cpp

Show All 15 Lines
// // types: // // types:
// typedef T value_type; // typedef T value_type;
// typedef Alloc allocator_type; // typedef Alloc allocator_type;
// typedef typename allocator_type::reference reference; // typedef typename allocator_type::reference reference;
// typedef typename allocator_type::const_reference const_reference; // typedef typename allocator_type::const_reference const_reference;
// typedef typename allocator_type::pointer pointer; // typedef typename allocator_type::pointer pointer;
// typedef typename allocator_type::const_pointer const_pointer; // typedef typename allocator_type::const_pointer const_pointer;
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <list> #include <list>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
struct A { std::list<A> v; }; // incomplete type support struct A { std::list<A> v; }; // incomplete type support
Show All 40 Lines

libcxx/test/std/containers/sequences/vector/types.pass.cpp

Show All 22 Lines
// typedef typename allocator_type::size_type size_type; // typedef typename allocator_type::size_type size_type;
// typedef typename allocator_type::difference_type difference_type; // typedef typename allocator_type::difference_type difference_type;
// typedef typename allocator_type::pointer pointer; // typedef typename allocator_type::pointer pointer;
// typedef typename allocator_type::const_pointer const_pointer; // typedef typename allocator_type::const_pointer const_pointer;
// typedef std::reverse_iterator<iterator> reverse_iterator; // typedef std::reverse_iterator<iterator> reverse_iterator;
// typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// }; // };
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <vector> #include <vector>
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "../../Copyable.h" #include "../../Copyable.h"
#include "min_allocator.h" #include "min_allocator.h"
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp

Show All 17 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef ex::resource_adaptor<std::allocator<void>> R; typedef ex::resource_adaptor<std::allocator<int>> R;
typedef ex::resource_adaptor<std::allocator<long>> R2; typedef ex::resource_adaptor<std::allocator<long>> R2;
static_assert(std::is_same<R, R2>::value, ""); static_assert(std::is_same<R, R2>::value, "");
{ {
static_assert(std::is_base_of<ex::memory_resource, R>::value, ""); static_assert(std::is_base_of<ex::memory_resource, R>::value, "");
static_assert(std::is_same<R::allocator_type, std::allocator<char>>::value, ""); static_assert(std::is_same<R::allocator_type, std::allocator<char>>::value, "");
} }
{ {
static_assert(std::is_default_constructible<R>::value, ""); static_assert(std::is_default_constructible<R>::value, "");
static_assert(std::is_copy_constructible<R>::value, ""); static_assert(std::is_copy_constructible<R>::value, "");
static_assert(std::is_move_constructible<R>::value, ""); static_assert(std::is_move_constructible<R>::value, "");
static_assert(std::is_copy_assignable<R>::value, ""); static_assert(std::is_copy_assignable<R>::value, "");
static_assert(std::is_move_assignable<R>::value, ""); static_assert(std::is_move_assignable<R>::value, "");
} }
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines assert(globalMemCounter.checkOutstandingNewEq(0));
DisableAllocationGuard g; DisableAllocationGuard g;
using Ref = std::reference_wrapper<A>; using Ref = std::reference_wrapper<A>;
A a; A a;
Ref aref(a); Ref aref(a);
std::function<int(int)> f(aref); std::function<int(int)> f(aref);
assert(A::count == 1); assert(A::count == 1);
assert(f.target<A>() == nullptr); assert(f.target<A>() == nullptr);
assert(f.target<Ref>()); assert(f.target<Ref>());
std::function<int(int)> f2(std::allocator_arg, std::allocator<void>{}, std::function<int(int)> f2(std::allocator_arg, std::allocator<int>{},
std::move(f)); std::move(f));
assert(A::count == 1); assert(A::count == 1);
assert(f2.target<A>() == nullptr); assert(f2.target<A>() == nullptr);
assert(f2.target<Ref>()); assert(f2.target<Ref>());
assert(f.target<Ref>()); // f is unchanged because the target is small assert(f.target<Ref>()); // f is unchanged because the target is small
} }
{ {
// Test that moving a function constructed from a function pointer // Test that moving a function constructed from a function pointer
// is done without allocating // is done without allocating
DisableAllocationGuard guard; DisableAllocationGuard guard;
using Ptr = int(*)(int); using Ptr = int(*)(int);
Ptr p = g; Ptr p = g;
std::function<int(int)> f(p); std::function<int(int)> f(p);
assert(f.target<A>() == nullptr); assert(f.target<A>() == nullptr);
assert(f.target<Ptr>()); assert(f.target<Ptr>());
std::function<int(int)> f2(std::allocator_arg, std::allocator<void>(), std::function<int(int)> f2(std::allocator_arg, std::allocator<int>(),
std::move(f)); std::move(f));
assert(f2.target<A>() == nullptr); assert(f2.target<A>() == nullptr);
assert(f2.target<Ptr>()); assert(f2.target<Ptr>());
assert(f.target<Ptr>()); // f is unchanged because the target is small assert(f.target<Ptr>()); // f is unchanged because the target is small
} }
return 0; return 0;
} }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp

  • This file was deleted after being copied to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.cxx2a.pass.cpp, libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp.

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp

  • This file was copied to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.cxx2a.fail.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
// <memory> // <memory>
// allocator: // allocator:
// pointer allocate(size_type n, allocator<void>::const_pointer hint=0); // T* allocate(size_t);
// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::allocator<int> a; std::allocator<int> a;
a.allocate(3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}} a.allocate(3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
return 0; return 0;
} }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// allocator: // allocator:
// pointer allocate(size_type n, allocator<void>::const_pointer hint=0); // T* allocate(size_t);
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <cstddef> // for std::max_align_t #include <cstddef> // for std::max_align_t
#include "test_macros.h" #include "test_macros.h"
#include "count_new.h" #include "count_new.h"
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines const bool ExpectAligned = IsOverAlignedType && UsingAlignedNew;
globalMemCounter.last_delete_align = 0; globalMemCounter.last_delete_align = 0;
a.deallocate(ap, 3); a.deallocate(ap, 3);
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
assert(globalMemCounter.checkDeleteCalledEq(1)); assert(globalMemCounter.checkDeleteCalledEq(1));
assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned)); assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0)); assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0));
assert(T::constructed == 0); assert(T::constructed == 0);
} }
globalMemCounter.reset();
{
globalMemCounter.last_new_size = 0;
globalMemCounter.last_new_align = 0;
T* volatile ap2 = a.allocate(11, (const void*)5);
DoNotOptimize(ap2);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.checkAlignedNewCalledEq(ExpectAligned));
assert(globalMemCounter.checkLastNewSizeEq(11 * sizeof(T)));
assert(globalMemCounter.checkLastNewAlignEq(ExpectAligned ? Align : 0));
assert(T::constructed == 0);
globalMemCounter.last_delete_align = 0;
a.deallocate(ap2, 11);
DoNotOptimize(ap2);
assert(globalMemCounter.checkOutstandingNewEq(0));
assert(globalMemCounter.checkDeleteCalledEq(1));
assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0));
assert(T::constructed == 0);
}
} }
int main(int, char**) { int main(int, char**) {
test_aligned<1>(); test_aligned<1>();
test_aligned<2>(); test_aligned<2>();
test_aligned<4>(); test_aligned<4>();
test_aligned<8>(); test_aligned<8>();
test_aligned<16>(); test_aligned<16>();
test_aligned<MaxAligned>(); test_aligned<MaxAligned>();
test_aligned<OverAligned>(); test_aligned<OverAligned>();
test_aligned<OverAligned * 2>(); test_aligned<OverAligned * 2>();
return 0; return 0;
} }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: libcpp-no-exceptions // UNSUPPORTED: libcpp-no-exceptions
// <memory> // <memory>
// allocator: // allocator:
// pointer allocate(size_type n, allocator<void>::const_pointer hint=0); // T* allocate(size_t);
// When back-deploying to macosx10.7, the RTTI for exception classes // When back-deploying to macosx10.7, the RTTI for exception classes
// incorrectly provided by libc++.dylib is mixed with the one in // incorrectly provided by libc++.dylib is mixed with the one in
// libc++abi.dylib and exceptions are not caught properly. // libc++abi.dylib and exceptions are not caught properly.
// XFAIL: with_system_cxx_lib=macosx10.7 // XFAIL: with_system_cxx_lib=macosx10.7
#include <memory> #include <memory>
#include <cassert> #include <cassert>
Show All 10 Linesvoid test_max(size_t count)
} catch (const std::exception &) { } catch (const std::exception &) {
} }
} }
template <typename T> template <typename T>
void test() void test()
{ {
// Bug 26812 -- allocating too large // Bug 26812 -- allocating too large
std::allocator<T> a; typedef std::allocator<T> A;
test_max<T> (a.max_size() + 1); // just barely too large typedef std::allocator_traits<A> AT;
test_max<T> (a.max_size() * 2); // significantly too large A a;
test_max<T> (AT::max_size(a) + 1); // just barely too large
test_max<T> (AT::max_size(a) * 2); // significantly too large
test_max<T> (((size_t) -1) / sizeof(T) + 1); // multiply will overflow test_max<T> (((size_t) -1) / sizeof(T) + 1); // multiply will overflow
test_max<T> ((size_t) -1); // way too large test_max<T> ((size_t) -1); // way too large
} }
int main(int, char**) int main(int, char**)
{ {
test<double>(); test<double>();
LIBCPP_ONLY(test<const double>()); LIBCPP_ONLY(test<const double>());
return 0; return 0;
} }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp

  • This file was moved to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/construct.cxx2a.pass.cpp.

libcxx/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp

  • This file was moved to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/max_size.cxx2a.pass.cpp.

libcxx/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp

  • This file was copied to libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.cxx2a.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// check nested types: // check nested types:
// template <class T> // template <class T>
// class allocator // class allocator
// { // {
// public: // public:
// typedef size_t size_type;
// typedef ptrdiff_t difference_type;
// typedef T* pointer;
// typedef const T* const_pointer;
// typedef typename add_lvalue_reference<T>::type reference;
// typedef typename add_lvalue_reference<const T>::type const_reference;
// typedef T value_type; // typedef T value_type;
// typedef true_type is_always_equal;
// //
// template <class U> struct rebind {typedef allocator<U> other;}; // typedef true_type propagate_on_container_move_assignment;
// typedef true_type is_always_equal;
// ... // ...
// }; // };
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
static_assert((std::is_same<std::allocator<char>::pointer, char*>::value), "");
static_assert((std::is_same<std::allocator<char>::const_pointer, const char*>::value), "");
static_assert((std::is_same<std::allocator<char>::value_type, char>::value), ""); static_assert((std::is_same<std::allocator<char>::value_type, char>::value), "");
static_assert((std::is_same<std::allocator<char>::reference, char&>::value), "");
static_assert((std::is_same<std::allocator<char>::const_reference, const char&>::value), ""); static_assert((std::is_same<std::allocator<char>::propagate_on_container_move_assignment, std::true_type>::value), "");
static_assert((std::is_same<std::allocator<char>::rebind<int>::other, LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::propagate_on_container_move_assignment, std::true_type>::value), "");
std::allocator<int> >::value), "");
static_assert((std::is_same<std::allocator< char>::is_always_equal, std::true_type>::value), ""); static_assert((std::is_same<std::allocator<char>::is_always_equal, std::true_type>::value), "");
LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::is_always_equal, std::true_type>::value), ""); LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::is_always_equal, std::true_type>::value), "");
std::allocator<char> a; std::allocator<char> a;
std::allocator<char> a2 = a; std::allocator<char> a2 = a;
a2 = a; a2 = a;
std::allocator<int> a3 = a2; std::allocator<int> a3 = a2;
((void)a3); ((void)a3);
return 0; return 0;
} }

libcxx/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp

  • This file was deleted after being copied to libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.cxx2a.pass.cpp, libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.depr_in_cxx17.fail.cpp.
The contents of this file were not changed.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Linesvoid compile_tests() {
} }
{ {
ConvertsTo<int&> ct; ConvertsTo<int&> ct;
std::tuple<int, int&> t(42, ct); std::tuple<int, int&> t(42, ct);
} }
} }
void allocator_tests() { void allocator_tests() {
std::allocator<void> alloc; std::allocator<int> alloc;
int x = 42; int x = 42;
{ {
std::tuple<int&> t(std::ref(x)); std::tuple<int&> t(std::ref(x));
assert(&std::get<0>(t) == &x); assert(&std::get<0>(t) == &x);
std::tuple<int&> t1(std::allocator_arg, alloc, std::ref(x)); std::tuple<int&> t1(std::allocator_arg, alloc, std::ref(x));
assert(&std::get<0>(t1) == &x); assert(&std::get<0>(t1) == &x);
} }
{ {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines typedef ExplicitUnconstrainedCtor ExplicitA;
static_assert(std::is_copy_constructible<std::tuple<A>>::value, ""); static_assert(std::is_copy_constructible<std::tuple<A>>::value, "");
static_assert(std::is_move_constructible<std::tuple<A>>::value, ""); static_assert(std::is_move_constructible<std::tuple<A>>::value, "");
static_assert(std::is_copy_constructible<std::tuple<ExplicitA>>::value, ""); static_assert(std::is_copy_constructible<std::tuple<ExplicitA>>::value, "");
static_assert(std::is_move_constructible<std::tuple<ExplicitA>>::value, ""); static_assert(std::is_move_constructible<std::tuple<ExplicitA>>::value, "");
} }
{ {
static_assert(std::is_constructible< static_assert(std::is_constructible<
std::tuple<A>, std::tuple<A>,
std::allocator_arg_t, std::allocator<void>, std::allocator_arg_t, std::allocator<int>,
std::tuple<A> const& std::tuple<A> const&
>::value, ""); >::value, "");
static_assert(std::is_constructible< static_assert(std::is_constructible<
std::tuple<A>, std::tuple<A>,
std::allocator_arg_t, std::allocator<void>, std::allocator_arg_t, std::allocator<int>,
std::tuple<A> && std::tuple<A> &&
>::value, ""); >::value, "");
static_assert(std::is_constructible< static_assert(std::is_constructible<
std::tuple<ExplicitA>, std::tuple<ExplicitA>,
std::allocator_arg_t, std::allocator<void>, std::allocator_arg_t, std::allocator<int>,
std::tuple<ExplicitA> const& std::tuple<ExplicitA> const&
>::value, ""); >::value, "");
static_assert(std::is_constructible< static_assert(std::is_constructible<
std::tuple<ExplicitA>, std::tuple<ExplicitA>,
std::allocator_arg_t, std::allocator<void>, std::allocator_arg_t, std::allocator<int>,
std::tuple<ExplicitA> && std::tuple<ExplicitA> &&
>::value, ""); >::value, "");
} }
{ {
std::tuple<A&&> t(std::forward_as_tuple(A{})); std::tuple<A&&> t(std::forward_as_tuple(A{}));
((void)t); ((void)t);
std::tuple<ExplicitA&&> t2(std::forward_as_tuple(ExplicitA{})); std::tuple<ExplicitA&&> t2(std::forward_as_tuple(ExplicitA{}));
((void)t2); ((void)t2);
} }
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
struct Explicit { struct Explicit {
int value; int value;
explicit Explicit(int x) : value(x) {} explicit Explicit(int x) : value(x) {}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::tuple<Explicit> t{std::allocator_arg, std::allocator<void>{}, 42}; std::tuple<Explicit> t{std::allocator_arg, std::allocator<int>{}, 42};
assert(std::get<0>(t).value == 42); assert(std::get<0>(t).value == 42);
} }
{ {
std::tuple<MoveOnly> t(std::allocator_arg, A1<int>(), MoveOnly(0)); std::tuple<MoveOnly> t(std::allocator_arg, A1<int>(), MoveOnly(0));
assert(std::get<0>(t) == 0); assert(std::get<0>(t) == 0);
} }
{ {
using T = DefaultCtorBlowsUp<>; using T = DefaultCtorBlowsUp<>;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp

Show All 20 Lines
struct ExplicitCopy { struct ExplicitCopy {
explicit ExplicitCopy(ExplicitCopy const&) {} explicit ExplicitCopy(ExplicitCopy const&) {}
explicit ExplicitCopy(int) {} explicit ExplicitCopy(int) {}
}; };
std::tuple<ExplicitCopy> const_explicit_copy_test() { std::tuple<ExplicitCopy> const_explicit_copy_test() {
const ExplicitCopy e(42); const ExplicitCopy e(42);
return {std::allocator_arg, std::allocator<void>{}, e}; return {std::allocator_arg, std::allocator<int>{}, e};
// expected-error@-1 {{chosen constructor is explicit in copy-initialization}} // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
} }
std::tuple<ExplicitCopy> non_const_explicity_copy_test() { std::tuple<ExplicitCopy> non_const_explicity_copy_test() {
ExplicitCopy e(42); ExplicitCopy e(42);
return {std::allocator_arg, std::allocator<void>{}, e}; return {std::allocator_arg, std::allocator<int>{}, e};
// expected-error@-1 {{chosen constructor is explicit in copy-initialization}} // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
} }
int main(int, char**) int main(int, char**)
{ {
const_explicit_copy_test(); const_explicit_copy_test();
non_const_explicity_copy_test(); non_const_explicity_copy_test();
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp

Show All 27 Linesstruct ImplicitCopy {
explicit ImplicitCopy(int) {} explicit ImplicitCopy(int) {}
ImplicitCopy(ImplicitCopy const&) {} ImplicitCopy(ImplicitCopy const&) {}
}; };
// Test that tuple(std::allocator_arg, Alloc, Types const&...) allows implicit // Test that tuple(std::allocator_arg, Alloc, Types const&...) allows implicit
// copy conversions in return value expressions. // copy conversions in return value expressions.
std::tuple<ImplicitCopy> testImplicitCopy1() { std::tuple<ImplicitCopy> testImplicitCopy1() {
ImplicitCopy i(42); ImplicitCopy i(42);
return {std::allocator_arg, std::allocator<void>{}, i}; return {std::allocator_arg, std::allocator<int>{}, i};
} }
std::tuple<ImplicitCopy> testImplicitCopy2() { std::tuple<ImplicitCopy> testImplicitCopy2() {
const ImplicitCopy i(42); const ImplicitCopy i(42);
return {std::allocator_arg, std::allocator<void>{}, i}; return {std::allocator_arg, std::allocator<int>{}, i};
} }
int main(int, char**) int main(int, char**)
{ {
{ {
// check that the literal '0' can implicitly initialize a stored pointer. // check that the literal '0' can implicitly initialize a stored pointer.
std::tuple<int*> t = {std::allocator_arg, std::allocator<void>{}, 0}; std::tuple<int*> t = {std::allocator_arg, std::allocator<int>{}, 0};
} }
{ {
std::tuple<int> t(std::allocator_arg, A1<int>(), 3); std::tuple<int> t(std::allocator_arg, A1<int>(), 3);
assert(std::get<0>(t) == 3); assert(std::get<0>(t) == 3);
} }
{ {
assert(!alloc_first::allocator_constructed); assert(!alloc_first::allocator_constructed);
std::tuple<alloc_first> t(std::allocator_arg, A1<int>(5), alloc_first(3)); std::tuple<alloc_first> t(std::allocator_arg, A1<int>(5), alloc_first(3));
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp

Show All 20 Lines
struct ExplicitCopy { struct ExplicitCopy {
explicit ExplicitCopy(int) {} explicit ExplicitCopy(int) {}
explicit ExplicitCopy(ExplicitCopy const&) {} explicit ExplicitCopy(ExplicitCopy const&) {}
}; };
std::tuple<ExplicitCopy> const_explicit_copy_test() { std::tuple<ExplicitCopy> const_explicit_copy_test() {
const std::tuple<int> t1(42); const std::tuple<int> t1(42);
return {std::allocator_arg, std::allocator<void>{}, t1}; return {std::allocator_arg, std::allocator<int>{}, t1};
// expected-error@-1 {{chosen constructor is explicit in copy-initialization}} // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
} }
std::tuple<ExplicitCopy> non_const_explicit_copy_test() { std::tuple<ExplicitCopy> non_const_explicit_copy_test() {
std::tuple<int> t1(42); std::tuple<int> t1(42);
return {std::allocator_arg, std::allocator<void>{}, t1}; return {std::allocator_arg, std::allocator<int>{}, t1};
// expected-error@-1 {{chosen constructor is explicit in copy-initialization}} // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
} }
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linesint main(int, char**)
assert(alloc_first::allocator_constructed); assert(alloc_first::allocator_constructed);
assert(alloc_last::allocator_constructed); assert(alloc_last::allocator_constructed);
assert(std::get<0>(t1) == 1); assert(std::get<0>(t1) == 1);
assert(std::get<1>(t1) == 2); assert(std::get<1>(t1) == 2);
assert(std::get<2>(t1) == 3); assert(std::get<2>(t1) == 3);
} }
{ {
const std::tuple<int> t1(42); const std::tuple<int> t1(42);
std::tuple<Explicit> t2{std::allocator_arg, std::allocator<void>{}, t1}; std::tuple<Explicit> t2{std::allocator_arg, std::allocator<int>{}, t1};
assert(std::get<0>(t2).value == 42); assert(std::get<0>(t2).value == 42);
} }
{ {
const std::tuple<int> t1(42); const std::tuple<int> t1(42);
std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, t1}; std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<int>{}, t1};
assert(std::get<0>(t2).value == 42); assert(std::get<0>(t2).value == 42);
} }
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp

Show All 19 Lines
struct ExplicitCopy { struct ExplicitCopy {
explicit ExplicitCopy(int) {} explicit ExplicitCopy(int) {}
explicit ExplicitCopy(ExplicitCopy const&) {} explicit ExplicitCopy(ExplicitCopy const&) {}
}; };
std::tuple<ExplicitCopy> explicit_move_test() { std::tuple<ExplicitCopy> explicit_move_test() {
std::tuple<int> t1(42); std::tuple<int> t1(42);
return {std::allocator_arg, std::allocator<void>{}, std::move(t1)}; return {std::allocator_arg, std::allocator<int>{}, std::move(t1)};
// expected-error@-1 {{chosen constructor is explicit in copy-initialization}} // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
} }
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Linesint main(int, char**)
assert(alloc_first::allocator_constructed); assert(alloc_first::allocator_constructed);
assert(alloc_last::allocator_constructed); assert(alloc_last::allocator_constructed);
assert(std::get<0>(t1) == 1); assert(std::get<0>(t1) == 1);
assert(std::get<1>(t1) == 2); assert(std::get<1>(t1) == 2);
assert(std::get<2>(t1)->id_ == 3); assert(std::get<2>(t1)->id_ == 3);
} }
{ {
std::tuple<int> t1(42); std::tuple<int> t1(42);
std::tuple<Explicit> t2{std::allocator_arg, std::allocator<void>{}, std::move(t1)}; std::tuple<Explicit> t2{std::allocator_arg, std::allocator<int>{}, std::move(t1)};
assert(std::get<0>(t2).value == 42); assert(std::get<0>(t2).value == 42);
} }
{ {
std::tuple<int> t1(42); std::tuple<int> t1(42);
std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, std::move(t1)}; std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<int>{}, std::move(t1)};
assert(std::get<0>(t2).value == 42); assert(std::get<0>(t2).value == 42);
} }
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesstruct move_only_large final {
move_only_large() : value(42) {} move_only_large() : value(42) {}
move_only_large(move_only_large&&) = default; move_only_large(move_only_large&&) = default;
int value; int value;
}; };
template <class Elem> template <class Elem>
void test_sfinae() { void test_sfinae() {
using Tup = std::tuple<Elem>; using Tup = std::tuple<Elem>;
using Alloc = std::allocator<void>; using Alloc = std::allocator<int>;
using Tag = std::allocator_arg_t; using Tag = std::allocator_arg_t;
// special members // special members
{ {
static_assert(std::is_default_constructible<Tup>::value, ""); static_assert(std::is_default_constructible<Tup>::value, "");
static_assert(std::is_move_constructible<Tup>::value, ""); static_assert(std::is_move_constructible<Tup>::value, "");
static_assert(!std::is_copy_constructible<Tup>::value, ""); static_assert(!std::is_copy_constructible<Tup>::value, "");
static_assert(!std::is_constructible<Tup, Tup&>::value, ""); static_assert(!std::is_constructible<Tup, Tup&>::value, "");
} }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines