__locale
__mbstate_t.h
__memory/addressof.h
+ __memory/align.h
__memory/allocate_at_least.h
__memory/allocation_guard.h
__memory/allocator.h
__memory/allocator_traits.h
__memory/assume_aligned.h
__memory/auto_ptr.h
+ __memory/builtin_new_allocator.h
__memory/compressed_pair.h
__memory/concepts.h
__memory/construct_at.h
+ __memory/destruct_n.h
__memory/pointer_traits.h
__memory/ranges_construct_at.h
__memory/ranges_uninitialized_algorithms.h
__memory/raw_storage_iterator.h
__memory/shared_ptr.h
__memory/swap_allocator.h
+ __memory/temp_value.h
__memory/temporary_buffer.h
__memory/uninitialized_algorithms.h
__memory/unique_ptr.h
__type_traits/integral_constant.h
__type_traits/is_abstract.h
__type_traits/is_aggregate.h
+ __type_traits/is_allocator.h
__type_traits/is_arithmetic.h
__type_traits/is_array.h
__type_traits/is_assignable.h
__type_traits/maybe_const.h
__type_traits/nat.h
__type_traits/negation.h
+ __type_traits/noexcept_move_assign_container.h
__type_traits/promote.h
__type_traits/rank.h
__type_traits/remove_all_extents.h
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/reverse_iterator.h>
-#include <memory>
+#include <__memory/destruct_n.h>
+#include <__memory/temporary_buffer.h>
+#include <__memory/unique_ptr.h>
+#include <__utility/pair.h>
+#include <new>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/subrange.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/subrange.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/concepts.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#include <initializer_list>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/dangling.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/subrange.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/concepts.h>
#include <__ranges/size.h>
#include <__ranges/subrange.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/size.h>
#include <__ranges/subrange.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/dangling.h>
#include <__type_traits/decay.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/subrange.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/dangling.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__config>
#include <__iterator/iterator_traits.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__config>
#include <__iterator/iterator_traits.h>
#include <__utility/move.h>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__functional/operations.h>
#include <__functional/ranges_operations.h>
#include <__iterator/iterator_traits.h>
+#include <__memory/destruct_n.h>
+#include <__memory/unique_ptr.h>
#include <climits>
-#include <memory>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__iterator/advance.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
-#include <memory>
+#include <__memory/destruct_n.h>
+#include <__memory/temporary_buffer.h>
+#include <__memory/unique_ptr.h>
+#include <__utility/pair.h>
+#include <new>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__algorithm/sort.h>
#include <__config>
#include <__iterator/iterator_traits.h>
+#include <__memory/destruct_n.h>
+#include <__memory/temporary_buffer.h>
+#include <__memory/unique_ptr.h>
#include <__utility/move.h>
-#include <memory>
+#include <__utility/pair.h>
+#include <new>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#ifndef _LIBCPP___BSD_LOCALE_FALLBACKS_H
#define _LIBCPP___BSD_LOCALE_FALLBACKS_H
-#include <memory>
#include <stdarg.h>
#include <stdlib.h>
#include <__config>
#include <__filesystem/path.h>
#include <__memory/shared_ptr.h>
+#include <__utility/forward.h>
#include <iosfwd>
#include <new>
#include <system_error>
#include <__config>
#include <__format/concepts.h>
#include <__format/format_arg.h>
+#include <__utility/forward.h>
#include <cstring>
#include <string>
#include <string_view>
#include <__format/formatter_output.h>
#include <__format/parser_std_format_spec.h>
#include <__utility/unreachable.h>
+#include <array>
#include <charconv>
#include <limits>
#include <string>
#include <__functional/unary_function.h>
#include <__iterator/iterator_traits.h>
#include <__memory/addressof.h>
+#include <__memory/allocator.h>
#include <__memory/allocator_traits.h>
+#include <__memory/builtin_new_allocator.h>
#include <__memory/compressed_pair.h>
#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <__utility/piecewise_construct.h>
#include <__utility/swap.h>
#include <exception>
-#include <memory> // TODO: replace with <__memory/__builtin_new_allocator.h>
+#include <new>
+#include <tuple>
#include <type_traits>
+#include <typeinfo>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__debug>
#include <__functional/hash.h>
#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
#include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
#include <__type_traits/can_extract_key.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
#include <__utility/swap.h>
#include <cmath>
+#include <cstring>
#include <initializer_list>
-#include <memory>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__availability>
#include <__config>
+#include <__memory/shared_ptr.h>
#include <cctype>
#include <cstdint>
#include <locale.h>
-#include <memory>
#include <mutex>
#include <string>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_ALIGN_H
+#define _LIBCPP___MEMORY_ALIGN_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_ALIGN_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_BUILTIN_NEW_ALLOCATOR_H
+#define _LIBCPP___MEMORY_BUILTIN_NEW_ALLOCATOR_H
+
+#include <__config>
+#include <__memory/unique_ptr.h>
+#include <cstddef>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// __builtin_new_allocator -- A non-templated helper for allocating and
+// deallocating memory using __builtin_operator_new and
+// __builtin_operator_delete. It should be used in preference to
+// `std::allocator<T>` to avoid additional instantiations.
+struct __builtin_new_allocator {
+ struct __builtin_new_deleter {
+ typedef void* pointer_type;
+
+ _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
+ : __size_(__size), __align_(__align) {}
+
+ void operator()(void* __p) const _NOEXCEPT {
+ _VSTD::__libcpp_deallocate(__p, __size_, __align_);
+ }
+
+ private:
+ size_t __size_;
+ size_t __align_;
+ };
+
+ typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
+
+ static __holder_t __allocate_bytes(size_t __s, size_t __align) {
+ return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
+ __builtin_new_deleter(__s, __align));
+ }
+
+ static void __deallocate_bytes(void* __p, size_t __s,
+ size_t __align) _NOEXCEPT {
+ _VSTD::__libcpp_deallocate(__p, __s, __align);
+ }
+
+ template <class _Tp>
+ _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
+ static __holder_t __allocate_type(size_t __n) {
+ return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+ }
+
+ template <class _Tp>
+ _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
+ static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
+ __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_BUILTIN_NEW_ALLOCATOR_H
#include <__memory/voidify.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <new>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_DESTRUCT_N_H
+#define _LIBCPP___MEMORY_DESTRUCT_N_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __destruct_n
+{
+private:
+ size_t __size_;
+
+ template <class _Tp>
+ _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
+ {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
+
+ template <class _Tp>
+ _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
+ {}
+
+ _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
+ {++__size_;}
+ _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
+ {}
+
+ _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
+ {__size_ = __s;}
+ _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
+ {}
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
+ : __size_(__s) {}
+
+ template <class _Tp>
+ _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
+ {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+
+ template <class _Tp>
+ _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
+ {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+
+ template <class _Tp>
+ _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
+ {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_DESTRUCT_N_H
#include <__utility/declval.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <new>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
+#include <new>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__memory/addressof.h>
#include <__utility/move.h>
#include <cstddef>
+#include <new>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <cstddef>
#include <cstdlib> // abort
#include <iosfwd>
+#include <new>
#include <stdexcept>
#include <type_traits>
#include <typeinfo>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_TEMP_VALUE_H
+#define _LIBCPP___MEMORY_TEMP_VALUE_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/allocator_traits.h>
+#include <__type_traits/aligned_storage.h>
+#include <__utility/forward.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Alloc>
+struct __temp_value {
+ typedef allocator_traits<_Alloc> _Traits;
+
+#ifdef _LIBCPP_CXX03_LANG
+ typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
+#else
+ union { _Tp __v; };
+#endif
+ _Alloc &__a;
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp *__addr() {
+#ifdef _LIBCPP_CXX03_LANG
+ return reinterpret_cast<_Tp*>(std::addressof(__v));
+#else
+ return std::addressof(__v);
+#endif
+ }
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp & get() { return *__addr(); }
+
+ template<class... _Args>
+ _LIBCPP_NO_CFI
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
+ _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
+ }
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_TEMP_VALUE_H
#include <__utility/move.h>
#include <__utility/pair.h>
#include <__utility/transaction.h>
+#include <new>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__assert>
#include <__config>
-#include <memory>
+#include <__memory/allocator_traits.h>
+#include <__memory/pointer_traits.h>
#include <optional>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/move_iterator.h>
+#include <__memory/allocate_at_least.h>
#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
#include <__memory/swap_allocator.h>
#include <__utility/forward.h>
-#include <memory>
+#include <__utility/move.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/next.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
#include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
#include <__type_traits/can_extract_key.h>
#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
#include <__utility/swap.h>
#include <limits>
-#include <memory>
#include <stdexcept>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_IS_ALLOCATOR_H
+#define _LIBCPP___TYPE_IS_ALLOCATOR_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<typename _Alloc, typename = void, typename = void>
+struct __is_allocator : false_type {};
+
+template<typename _Alloc>
+struct __is_allocator<_Alloc,
+ typename __void_t<typename _Alloc::value_type>::type,
+ typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type
+ >
+ : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_IS_ALLOCATOR_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
+#define _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
+
+#include <__config>
+#include <__memory/allocator_traits.h>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
+struct __noexcept_move_assign_container : public integral_constant<bool,
+ _Traits::propagate_on_container_move_assignment::value
+#if _LIBCPP_STD_VER > 14
+ || _Traits::is_always_equal::value
+#else
+ && is_nothrow_move_assignable<_Alloc>::value
+#endif
+ > {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
using _ForwardLike = _OverrideRef<_Ap&&, _CopyConst<remove_reference_t<_Ap>, remove_reference_t<_Bp>>>;
template <class _Tp, class _Up>
-[[nodiscard]] constexpr auto forward_like(_Up&& __ux) noexcept -> _ForwardLike<_Tp, _Up> {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto forward_like(_Up&& __ux) noexcept -> _ForwardLike<_Tp, _Up> {
return static_cast<_ForwardLike<_Tp, _Up>>(__ux);
}
#include <__debug>
#include <cstddef>
#include <cstring>
-#include <memory>
#include <type_traits>
#include <version>
#endif
#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
-# include <__pstl_algorithm>
+# include <__pstl_algorithm>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <atomic>
# include <iterator>
+# include <memory>
+# include <stdexcept>
# include <utility>
#endif
#include <__assert> // all public C++ headers provide the assertion handler
#include <__availability>
#include <__config>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
#include <__utility/forward.h>
#include <__utility/in_place.h>
#include <__utility/move.h>
#include <__utility/unreachable.h>
#include <cstdlib>
#include <initializer_list>
-#include <memory>
#include <type_traits>
#include <typeinfo>
#include <version>
# include <chrono> // IGNORE-CYCLE due to <format>
#endif
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <iterator>
+# include <memory>
+# include <variant>
+#endif
+
#endif // _LIBCPP_ANY
#include <__assert> // all public C++ headers provide the assertion handler
#include <__availability>
#include <__config>
+#include <__memory/unique_ptr.h>
#include <__thread/timed_backoff_policy.h>
+#include <__utility/move.h>
#include <atomic>
#include <limits>
-#include <memory>
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <concepts>
+# include <iterator>
+# include <memory>
+# include <stdexcept>
+# include <variant>
+#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
#include <__mutex_base>
-#include <memory>
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#include <__iterator/next.h>
#include <__iterator/prev.h>
#include <__iterator/reverse_iterator.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/temp_value.h>
+#include <__memory/unique_ptr.h>
#include <__split_buffer>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <__utility/swap.h>
#include <__functional/operations.h>
#include <cstddef>
#include <experimental/__config>
-#include <memory> // for hash<T*>
#include <new>
#include <type_traits>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <atomic>
+# include <climits>
+# include <cmath>
+# include <compare>
+# include <concepts>
+# include <ctime>
+# include <initializer_list>
+# include <iosfwd>
+# include <iterator>
+# include <memory>
+# include <ratio>
+# include <stdexcept>
+# include <tuple>
+# include <typeinfo>
+# include <utility>
+# include <variant>
+#endif
+
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
*/
#include <__assert> // all public C++ headers provide the assertion handler
+#include <__memory/allocator_traits.h>
#include <__tuple>
#include <__utility/move.h>
#include <cstddef>
#include <experimental/__config>
#include <experimental/__memory>
#include <limits>
-#include <memory>
#include <new>
#include <stdexcept>
+#include <tuple>
#include <type_traits>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <atomic>
+# include <climits>
+# include <concepts>
+# include <cstring>
+# include <ctime>
+# include <iterator>
+# include <memory>
+# include <ratio>
+# include <variant>
+#endif
+
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#include <__iterator/iterator_traits.h>
#include <__iterator/move_iterator.h>
#include <__iterator/next.h>
+#include <__memory/addressof.h>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
#include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
+#include <__utility/move.h>
#include <limits>
-#include <memory>
#include <type_traits>
#include <version>
#include <cstring>
#include <istream>
#include <ostream>
+#include <typeinfo>
#include <version>
#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
#include <__utility/forward.h>
#include <concepts>
#include <exception>
-#include <memory>
+#include <memory> // TODO: find out why removing this breaks the modules build
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <exception>
-#include <memory>
#include <mutex>
+#include <new>
#include <system_error>
#include <thread>
#include <version>
#include <__iterator/next.h>
#include <__iterator/prev.h>
#include <__iterator/reverse_iterator.h>
+#include <__memory/addressof.h>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
#include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <__utility/swap.h>
+#include <cstring>
#include <limits>
-#include <memory>
#include <type_traits>
#include <version>
#include <__iterator/istreambuf_iterator.h>
#include <__iterator/ostreambuf_iterator.h>
#include <__locale>
+#include <__memory/unique_ptr.h>
#include <cstdarg> // TODO: Remove this include
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <ios>
#include <limits>
-#include <memory>
+#include <new>
#include <streambuf>
#include <version>
#include <__iterator/erase_if_container.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/reverse_iterator.h>
+#include <__memory/allocator.h>
#include <__node_handle>
#include <__tree>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
+#include <__utility/piecewise_construct.h>
#include <__utility/swap.h>
-#include <memory>
+#include <tuple>
#include <type_traits>
#include <version>
*/
-#include <__algorithm/copy.h>
-#include <__algorithm/move.h>
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
#include <__memory/addressof.h>
+#include <__memory/align.h>
#include <__memory/allocate_at_least.h>
#include <__memory/allocation_guard.h>
#include <__memory/allocator.h>
#include <__memory/uninitialized_algorithms.h>
#include <__memory/unique_ptr.h>
#include <__memory/uses_allocator.h>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iosfwd>
-#include <new>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-#include <typeinfo>
#include <version>
// standard-mandated includes
# pragma GCC system_header
#endif
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct __destruct_n
-{
-private:
- size_t __size_;
-
- template <class _Tp>
- _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
- {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
-
- template <class _Tp>
- _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
- {}
-
- _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
- {++__size_;}
- _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
- {}
-
- _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
- {__size_ = __s;}
- _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
- {}
-public:
- _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
- : __size_(__s) {}
-
- template <class _Tp>
- _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
- {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-
- template <class _Tp>
- _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
- {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-
- template <class _Tp>
- _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
- {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-};
-
-_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
-
-template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool,
- _Traits::propagate_on_container_move_assignment::value
-#if _LIBCPP_STD_VER > 14
- || _Traits::is_always_equal::value
-#else
- && is_nothrow_move_assignable<_Alloc>::value
-#endif
- > {};
-
-
-template <class _Tp, class _Alloc>
-struct __temp_value {
- typedef allocator_traits<_Alloc> _Traits;
-
-#ifdef _LIBCPP_CXX03_LANG
- typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
-#else
- union { _Tp __v; };
-#endif
- _Alloc &__a;
-
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp *__addr() {
-#ifdef _LIBCPP_CXX03_LANG
- return reinterpret_cast<_Tp*>(std::addressof(__v));
-#else
- return std::addressof(__v);
-#endif
- }
-
- _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp & get() { return *__addr(); }
-
- template<class... _Args>
- _LIBCPP_NO_CFI
- _LIBCPP_CONSTEXPR_SINCE_CXX20 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
- _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
- }
-
- _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
-};
-
-template<typename _Alloc, typename = void, typename = void>
-struct __is_allocator : false_type {};
-
-template<typename _Alloc>
-struct __is_allocator<_Alloc,
- typename __void_t<typename _Alloc::value_type>::type,
- typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type
- >
- : true_type {};
-
-// __builtin_new_allocator -- A non-templated helper for allocating and
-// deallocating memory using __builtin_operator_new and
-// __builtin_operator_delete. It should be used in preference to
-// `std::allocator<T>` to avoid additional instantiations.
-struct __builtin_new_allocator {
- struct __builtin_new_deleter {
- typedef void* pointer_type;
-
- _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
- : __size_(__size), __align_(__align) {}
-
- void operator()(void* __p) const _NOEXCEPT {
- _VSTD::__libcpp_deallocate(__p, __size_, __align_);
- }
-
- private:
- size_t __size_;
- size_t __align_;
- };
-
- typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
-
- static __holder_t __allocate_bytes(size_t __s, size_t __align) {
- return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
- __builtin_new_deleter(__s, __align));
- }
-
- static void __deallocate_bytes(void* __p, size_t __s,
- size_t __align) _NOEXCEPT {
- _VSTD::__libcpp_deallocate(__p, __s, __align);
- }
-
- template <class _Tp>
- _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
- static __holder_t __allocate_type(size_t __n) {
- return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
- }
-
- template <class _Tp>
- _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
- static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
- __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
- }
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
# include <__pstl_memory>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <cstddef>
+# include <cstdint>
+# include <cstring>
+# include <iosfwd>
# include <iterator>
+# include <new>
+# include <stdexcept>
+# include <tuple>
+# include <type_traits>
+# include <typeinfo>
# include <utility>
#endif
module __memory {
module addressof { private header "__memory/addressof.h" }
+ module align { private header "__memory/align.h" }
module allocate_at_least { private header "__memory/allocate_at_least.h" }
module allocation_guard { private header "__memory/allocation_guard.h" }
module allocator { private header "__memory/allocator.h" }
module allocator_traits { private header "__memory/allocator_traits.h" }
module assume_aligned { private header "__memory/assume_aligned.h" }
module auto_ptr { private header "__memory/auto_ptr.h" }
+ module builtin_new_allocator { private header "__memory/builtin_new_allocator.h" }
module compressed_pair { private header "__memory/compressed_pair.h" }
module concepts { private header "__memory/concepts.h" }
module construct_at { private header "__memory/construct_at.h" }
+ module destruct_n { private header "__memory/destruct_n.h" }
module pointer_traits { private header "__memory/pointer_traits.h" }
module ranges_construct_at { private header "__memory/ranges_construct_at.h" }
module ranges_uninitialized_algorithms { private header "__memory/ranges_uninitialized_algorithms.h" }
module raw_storage_iterator { private header "__memory/raw_storage_iterator.h" }
module shared_ptr { private header "__memory/shared_ptr.h" }
module swap_allocator { private header "__memory/swap_allocator.h" }
+ module temp_value { private header "__memory/temp_value.h" }
module temporary_buffer { private header "__memory/temporary_buffer.h" }
module uninitialized_algorithms { private header "__memory/uninitialized_algorithms.h" }
module unique_ptr { private header "__memory/unique_ptr.h" }
module integral_constant { private header "__type_traits/integral_constant.h" }
module is_abstract { private header "__type_traits/is_abstract.h" }
module is_aggregate { private header "__type_traits/is_aggregate.h" }
+ module is_allocator { private header "__type_traits/is_allocator.h" }
module is_arithmetic { private header "__type_traits/is_arithmetic.h" }
module is_array { private header "__type_traits/is_array.h" }
module is_assignable { private header "__type_traits/is_assignable.h" }
module maybe_const { private header "__type_traits/maybe_const.h" }
module nat { private header "__type_traits/nat.h" }
module negation { private header "__type_traits/negation.h" }
+ module noexcept_move_assign_container { private header "__type_traits/noexcept_move_assign_container.h" }
module promote { private header "__type_traits/promote.h" }
module rank { private header "__type_traits/rank.h" }
module remove_all_extents { private header "__type_traits/remove_all_extents.h" }
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
+#include <__memory/shared_ptr.h>
#include <__mutex_base>
#include <__threading_support>
#include <__utility/forward.h>
#include <cstdint>
-#include <memory>
#ifndef _LIBCPP_CXX03_LANG
# include <tuple>
#endif
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
+#include <__memory/unique_ptr.h>
#include <bitset>
#include <ios>
#include <locale>
+#include <new>
#include <streambuf>
#include <version>
_LIBCPP_END_NAMESPACE_STD
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <functional>
#endif
#include <__iterator/wrap_iter.h>
#include <__locale>
#include <__utility/move.h>
+#include <__utility/pair.h>
#include <__utility/swap.h>
#include <deque>
-#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
+#include <__memory/allocator_traits.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/remove_reference.h>
#include <__utility/forward.h>
-#include <memory>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
+#include <tuple>
#include <version>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <atomic>
+# include <climits>
+# include <concepts>
+# include <cstring>
+# include <ctime>
+# include <iterator>
+# include <memory>
+# include <ratio>
+# include <stdexcept>
+# include <variant>
+#endif
+
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#include <__iterator/erase_if_container.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/reverse_iterator.h>
+#include <__memory/allocator.h>
#include <__node_handle>
#include <__tree>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
#include <version>
#include <__iterator/reverse_iterator.h>
#include <__iterator/wrap_iter.h>
#include <__memory/allocate_at_least.h>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
+#include <__memory/pointer_traits.h>
#include <__memory/swap_allocator.h>
#include <__string/char_traits.h>
#include <__string/extern_template_lists.h>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/noexcept_move_assign_container.h>
#include <__utility/auto_cast.h>
#include <__utility/move.h>
#include <__utility/swap.h>
#include <cstring>
#include <iosfwd>
#include <limits>
-#include <memory>
#include <stdexcept>
#include <string_view>
#include <type_traits>
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
#include <__functional/hash.h>
+#include <__memory/unique_ptr.h>
#include <__mutex_base>
#include <__thread/poll_with_backoff.h>
#include <__thread/timed_backoff_policy.h>
#include <__utility/forward.h>
#include <cstddef>
#include <iosfwd>
-#include <memory>
#include <system_error>
#include <tuple>
#include <type_traits>
#include <__iterator/erase_if_container.h>
#include <__iterator/iterator_traits.h>
#include <__memory/addressof.h>
+#include <__memory/allocator.h>
#include <__node_handle>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
#include <stdexcept>
#include <tuple>
#include <__iterator/erase_if_container.h>
#include <__iterator/iterator_traits.h>
#include <__memory/addressof.h>
+#include <__memory/allocator.h>
#include <__node_handle>
+#include <__type_traits/is_allocator.h>
#include <__utility/forward.h>
#include <version>
#include <__memory/allocate_at_least.h>
#include <__memory/pointer_traits.h>
#include <__memory/swap_allocator.h>
+#include <__memory/temp_value.h>
+#include <__memory/uninitialized_algorithms.h>
#include <__split_buffer>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/noexcept_move_assign_container.h>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <__utility/swap.h>
#include <cstring>
#include <iosfwd> // for forward declaration of vector
#include <limits>
-#include <memory>
#include <stdexcept>
#include <type_traits>
#include <version>
#include <assert.h>
#include <memory>
+#include <new>
#include "test_macros.h"
#include <__locale> // expected-error@*:* {{use of private header from outside its module: '__locale'}}
#include <__mbstate_t.h> // expected-error@*:* {{use of private header from outside its module: '__mbstate_t.h'}}
#include <__memory/addressof.h> // expected-error@*:* {{use of private header from outside its module: '__memory/addressof.h'}}
+#include <__memory/align.h> // expected-error@*:* {{use of private header from outside its module: '__memory/align.h'}}
#include <__memory/allocate_at_least.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocate_at_least.h'}}
#include <__memory/allocation_guard.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocation_guard.h'}}
#include <__memory/allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator.h'}}
#include <__memory/allocator_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_traits.h'}}
#include <__memory/assume_aligned.h> // expected-error@*:* {{use of private header from outside its module: '__memory/assume_aligned.h'}}
#include <__memory/auto_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/auto_ptr.h'}}
+#include <__memory/builtin_new_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/builtin_new_allocator.h'}}
#include <__memory/compressed_pair.h> // expected-error@*:* {{use of private header from outside its module: '__memory/compressed_pair.h'}}
#include <__memory/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__memory/concepts.h'}}
#include <__memory/construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/construct_at.h'}}
+#include <__memory/destruct_n.h> // expected-error@*:* {{use of private header from outside its module: '__memory/destruct_n.h'}}
#include <__memory/pointer_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/pointer_traits.h'}}
#include <__memory/ranges_construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_construct_at.h'}}
#include <__memory/ranges_uninitialized_algorithms.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_uninitialized_algorithms.h'}}
#include <__memory/raw_storage_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/raw_storage_iterator.h'}}
#include <__memory/shared_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/shared_ptr.h'}}
#include <__memory/swap_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/swap_allocator.h'}}
+#include <__memory/temp_value.h> // expected-error@*:* {{use of private header from outside its module: '__memory/temp_value.h'}}
#include <__memory/temporary_buffer.h> // expected-error@*:* {{use of private header from outside its module: '__memory/temporary_buffer.h'}}
#include <__memory/uninitialized_algorithms.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uninitialized_algorithms.h'}}
#include <__memory/unique_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/unique_ptr.h'}}
#include <__type_traits/integral_constant.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/integral_constant.h'}}
#include <__type_traits/is_abstract.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_abstract.h'}}
#include <__type_traits/is_aggregate.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_aggregate.h'}}
+#include <__type_traits/is_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_allocator.h'}}
#include <__type_traits/is_arithmetic.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_arithmetic.h'}}
#include <__type_traits/is_array.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_array.h'}}
#include <__type_traits/is_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_assignable.h'}}
#include <__type_traits/maybe_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/maybe_const.h'}}
#include <__type_traits/nat.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/nat.h'}}
#include <__type_traits/negation.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/negation.h'}}
+#include <__type_traits/noexcept_move_assign_container.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/noexcept_move_assign_container.h'}}
#include <__type_traits/promote.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/promote.h'}}
#include <__type_traits/rank.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/rank.h'}}
#include <__type_traits/remove_all_extents.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_all_extents.h'}}
// This test is not supported when we remove the transitive includes provided for backwards
// compatibility. When we bulk-remove them, we'll adjust the includes that are expected by
// this test instead.
-// XFAIL: transitive-includes-disabled
+// UNSUPPORTED: transitive-includes-disabled
// Prevent <ext/hash_map> from generating deprecated warnings for this test.
#if defined(__DEPRECATED)
-atomic
bit
climits
cmath
cstdint
cstdlib
cstring
-ctime
exception
initializer_list
iosfwd
limits
-memory
new
-ratio
-stdexcept
tuple
type_traits
-typeinfo
version
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
climits
cmath
compare
-concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
-initializer_list
iosfwd
limits
-memory
new
ratio
-stdexcept
tuple
type_traits
-typeinfo
version
-atomic
cctype
climits
cmath
cstdio
cstdlib
cstring
-ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
-memory
new
-ratio
stdexcept
string
string_view
tuple
type_traits
-typeinfo
version
istream
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
mutex
new
ratio
istream
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
istream
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
algorithm
-atomic
bit
climits
cmath
cstdint
cstdlib
cstring
-ctime
exception
initializer_list
iosfwd
limits
-memory
new
-ratio
-stdexcept
tuple
type_traits
-typeinfo
version
-atomic
-climits
-cmath
-compare
-concepts
cstddef
cstdint
cstdlib
cstring
-ctime
exception
-initializer_list
-iosfwd
limits
-memory
new
-ratio
-stdexcept
-tuple
type_traits
-typeinfo
version
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
iosfwd
limits
list
-memory
new
ratio
stdexcept
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
experimental/memory_resource
experimental/utility
iosfwd
limits
map
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
utility
version
-atomic
-climits
cmath
compare
-concepts
cstddef
cstdint
cstdlib
-cstring
-ctime
exception
experimental/utility
initializer_list
iosfwd
limits
-memory
new
-ratio
stdexcept
tuple
type_traits
-typeinfo
utility
version
initializer_list
iosfwd
limits
-memory
mutex
new
ratio
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
set
stdexcept
tuple
type_traits
-typeinfo
utility
version
-atomic
cctype
climits
cmath
cstdio
cstdlib
cstring
-ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
-memory
new
-ratio
stdexcept
string
string_view
tuple
type_traits
-typeinfo
utility
version
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
unordered_map
utility
version
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
unordered_set
utility
version
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
istream
limits
locale
-memory
mutex
new
ostream
iosfwd
limits
locale
-memory
mutex
new
optional
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
istream
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
mutex
new
ratio
istream
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
mutex
new
ratio
istream
limits
locale
-memory
mutex
new
ostream
iosfwd
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
ios
iosfwd
limits
-memory
mutex
new
ratio
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
version
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
iosfwd
limits
locale
-memory
mutex
new
ratio
-array
atomic
climits
cmath
ctime
deque
exception
-functional
initializer_list
iosfwd
limits
-memory
new
-optional
ratio
stdexcept
tuple
type_traits
typeinfo
-unordered_map
vector
version
initializer_list
iosfwd
limits
-memory
new
numeric
ratio
initializer_list
iosfwd
limits
-memory
mutex
new
ratio
-atomic
-climits
cmath
compare
-concepts
cstddef
cstdint
cstdlib
-cstring
-ctime
exception
-initializer_list
-iosfwd
limits
-memory
new
-ratio
-stdexcept
tuple
type_traits
-typeinfo
version
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
version
-atomic
cctype
cerrno
climits
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
system_error
tuple
type_traits
-typeinfo
version
istream
limits
locale
-memory
mutex
new
ostream
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
ios
iosfwd
limits
-memory
mutex
new
ratio
-atomic
cctype
climits
cmath
cstdio
cstdlib
cstring
-ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
-memory
new
-ratio
stdexcept
string_view
tuple
type_traits
-typeinfo
version
istream
limits
locale
-memory
mutex
new
ostream
-atomic
cctype
cerrno
climits
cstdio
cstdlib
cstring
-ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
-memory
new
-ratio
stdexcept
string
string_view
tuple
type_traits
-typeinfo
version
-atomic
cctype
cerrno
climits
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
system_error
tuple
type_traits
-typeinfo
version
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
version
-atomic
-climits
cmath
compare
concepts
cstdint
cstdlib
cstring
-ctime
exception
initializer_list
iosfwd
limits
-memory
new
optional
-ratio
stdexcept
tuple
type_traits
-typeinfo
version
initializer_list
iosfwd
limits
-memory
new
ratio
stdexcept
#include <cassert>
#include <cstddef>
#include <memory>
+#include <new>
#include <type_traits>
#include <utility>
#include <memory>
#include <cassert>
+#include <utility>
+
#include "test_macros.h"
struct Irrelevant;
// UNSUPPORTED: c++03
#include <memory>
+#include <type_traits>
template <int> struct Tag {};
#include <algorithm>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <algorithm>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <array>
#include <cassert>
#include <functional>
+#include <memory>
#include <ranges>
#include "test_iterators.h"
#include <cassert>
#include <vector>
#include <deque>
+#include <utility>
#include "test_macros.h"
#include <forward_list>
#include <cassert>
+#include <exception>
#include "test_macros.h"
#include <list>
#include <cassert>
+#include <exception>
#include "test_macros.h"
#include <list>
#include <cassert>
+#include <exception>
#include "test_macros.h"
#include <experimental/coroutine>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <experimental/coroutine>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <locale>
#include <cassert>
+#include <typeinfo>
#include "test_macros.h"
#include <array>
#include <cassert>
+#include <tuple>
#include <vector>
#include <string>
#include <string>
#include <cassert>
+#include <new>
#include "test_macros.h"
#include "min_allocator.h"
#include <functional>
#include <cassert>
+#include <memory>
#include "test_macros.h"
#include <functional>
#include <cassert>
+#include <memory>
#include "test_macros.h"
#include <cassert>
#include <concepts>
+#include <cstddef>
#include <memory>
// check that std::allocation_result exists and isn't restricted to pointers
// UNSUPPORTED: c++03, c++11, c++14, c++17
-#include <memory>
-#include <cstdint>
#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
#include "test_macros.h"
#include <new>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include "incomplete_type_helper.h"
// UNSUPPORTED: c++03, c++11, c++14, c++17
-#include <memory>
#include <cassert>
+#include <cstddef>
+#include <memory>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <new>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <type_traits>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <utility>
+
#include "test_macros.h"
struct Irrelevant;
#include <memory>
#include <cassert>
+#include <type_traits>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <type_traits>
#include "test_macros.h"
// void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
-#include <memory>
#include <cassert>
+#include <cstddef>
+#include <memory>
#include "test_macros.h"
struct Nasty
{
Nasty() : i_ ( counter_++ ) {}
- Nasty * operator &() const { return NULL; }
+ Nasty * operator &() const { return nullptr; }
int i_;
static int counter_;
};
struct Nasty
{
Nasty() : i_ ( counter_++ ) {}
- Nasty * operator &() const { return NULL; }
+ Nasty * operator &() const { return nullptr; }
int i_;
static int counter_;
};
struct Nasty
{
Nasty() : i_ ( counter_++ ) {}
- Nasty * operator &() const { return NULL; }
+ Nasty * operator &() const { return nullptr; }
int i_;
static int counter_;
};
struct Nasty
{
Nasty() : i_ ( counter_++ ) {}
- Nasty * operator &() const { return NULL; }
+ Nasty * operator &() const { return nullptr; }
int i_;
static int counter_;
};
#include <memory>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <type_traits>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <new>
#include <cstdlib>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include "count_new.h"
#include "test_macros.h"
-#include <memory>
#include <cassert>
+#include <memory>
+#include <new>
+#include <utility>
static bool construct_called = false;
static bool destroy_called = false;
#include <memory>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
#include <memory>
#include <type_traits>
#include <cassert>
+#include <utility>
#include "test_macros.h"
// bad_weak_ptr();
// };
+#include <exception>
#include <memory>
#include <type_traits>
#include <cassert>
#include <memory>
#include <cassert>
+#include <type_traits>
+
#include "test_macros.h"
struct Deleter {
#include <memory>
#include <cassert>
+// TODO: Move TEST_IS_CONSTANT_EVALUATED into it's own header
+#include <type_traits>
+
#include "test_macros.h"
class A {
#include <tuple>
#include <utility>
#include <cassert>
+#include <memory>
#include "test_macros.h"
#include "MoveOnly.h"
#include <tuple>
#include <string>
+#include <memory>
+
#include "test_macros.h"
struct UserType {};
#define ALLOCATORS_H
#include <memory>
+#include <new>
#include <type_traits>
#include <utility>
#include <functional>
#include <cassert>
+#include <new>
#include "test_macros.h"
#include <cstring>
#include <cstdint>
#include <cassert>
+#include <new>
+
#include "test_macros.h"
#include "type_id.h"
#include <climits>
#include <iterator>
#include <memory>
+#include <new>
#include "test_macros.h"
# endif
#endif
+#include <__threading_support>
+#include <cstring>
#include <limits.h>
#include <stdlib.h>
-#include <__threading_support>
+
#ifndef _LIBCXXABI_HAS_NO_THREADS
# if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
# pragma comment(lib, "pthread")
#include <cstdlib>
#include <cstring>
#include <limits>
+#include <new>
#include <utility>
DEMANGLE_NAMESPACE_BEGIN
projects / platform / upstream / llvm.git / commitdiff