[libcxx][iwyu] ensures we IWYU as prep for modules

[cjdb]

Summary

This has been broken out of D104170 since it should be merged whether or
not we go ahead with the module map changes.

[• Quuxplusone]

libcxx/include/__memory/allocator_traits.h

360–368

All the #include changes look fine to me, but I question the wisdom of(*) splitting up the specializations of __is_default_allocator. Generally for a type-trait we want to keep the "true" and "false" branches together in the same file.
So, please don't make this diff. Either leave it as-is, or, if you really can't get the modules build building without a diff here, make the diff to add

template <class _Tp> class allocator;

right above line 360.

(* yes, this is understatement)

[cjdb]

updates a lot of that were lacking explicit header inclusions (see most recent failures in D104170)

[ldionne]

Include changes LGTM, but I don't understand the change to __function_like.

libcxx/include/__function_like.h

40

Why is this change necessary?

[cjdb]

libcxx/include/__function_like.h

40

The modules build seems to think that types derived from __function_like still have addresses. This sent me round the twist trying to figure out why, and I eventually explicitly deleted the operators in the derived types.

I don't want anyone to need to go through this again, so I think it's best we delete the operator from the base type so people realise they need to add it to the derived type.

[• Quuxplusone]

libcxx/include/__function_like.h

40

This explains the many changes in __iterator/advance.h etc.
Since this is absolutely unrelated to IWYU, I think it should be a separate PR. Also, for the record, I'll repeat my usual drumbeat that libc++ does not have to do any of this __function_like stuff, and if it's causing problems, I'd prefer us to just rip it out so that the libc++ code will be as simple as possible.

[cjdb]

libcxx/include/__function_like.h

40

Since this is absolutely unrelated to IWYU, I think it should be a separate PR.

Sure, I can move it into D104170 patch, since it's directly driven by that patch.

This explains the many changes in __iterator/advance.h etc.
Also, for the record, I'll repeat my usual drumbeat that libc++ does not have to do any of this __function_like stuff, and if it's causing problems, I'd prefer us to just rip it out so that the libc++ code will be as simple as possible.

It would be really beneficial if you bothered to understand design decisions instead of wrongly asserting that something isn't necessary ad infinitum.

I'll spell it out for you, even though it's documented directly above this type's definition. Everything derived from this type is supposed to have the properties of a function. Functions cannot be default constructed. Functions cannot be moved. Functions cannot be copied. Standard functions are not allowed to have their addresses taken. It's extremely tempting to use functions that are derived from __function_like as higher-order functions. Hyrum's law dictates that users will eventually treat this as allowed if we don't prevent these things from happening. There was a deliberate decision to not make them function objects in the standard, and I do not want users to start treating them as if they are.

[zoecarver]

No opinion on what patch the operator change goes in. Thanks for explaining the rational.

Send it :)

[ldionne]

LGTM but can you please move the operator& changes to the other patch? Also, I think this does reduce the usefulness of __function_like by quite a bit, cause now we have to think about adding a declaration in the function objects *and* derive from __function_like. I think we should fix the underlying modules bug (seriously, modules shouldn't have anything to do with this!) and more operator& back into __function_like.

[cjdb]

removes the addressof operator juggling from this patch

libcxx/include/__function_like.h

 // the properties that function objects get by default (e.g. semiregularity, addressability), to
 // limit the surface area of the unintended public interface, so as to curb the effect of Hyrum's
 // law.
 struct __function_like {
   __function_like() = delete;
   __function_like(__function_like const&) = delete;
   __function_like& operator=(__function_like const&) = delete;
 
-  void operator&() const = delete;
-
   struct __tag { };
 
 protected:
   constexpr explicit __function_like(__tag) noexcept {}
   ~__function_like() = default;
 };
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_FUNCTION_LIKE_H

libcxx/include/__iterator/advance.h

 #ifndef _LIBCPP___ITERATOR_ADVANCE_H
 #define _LIBCPP___ITERATOR_ADVANCE_H
 
 #include <__config>
 #include <__debug>
 #include <__function_like.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <concepts>
 #include <limits>
 #include <type_traits>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
if constexpr (sized_sentinel_for<_Sp, _Ip>) {
           ++__n;
         }
       }
       return __n;
     }
 
     _LIBCPP_UNREACHABLE();
   }
+
+  void operator&() const = delete;
 };
 
 inline constexpr auto advance = __advance_fn(__function_like::__tag());
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_ADVANCE_H

libcxx/include/__iterator/next.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___ITERATOR_NEXT_H
 #define _LIBCPP___ITERATOR_NEXT_H
 
 #include <__config>
+#include <__debug>
 #include <__function_like.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
constexpr _Ip operator()(_Ip __x, _Sp __bound) const {
     return __x;
   }
 
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
   constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Sp __bound) const {
     ranges::advance(__x, __n, __bound);
     return __x;
   }
+
+  void operator&() const = delete;
 };
 
 inline constexpr auto next = __next_fn(__function_like::__tag());
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_PRIMITIVES_H

libcxx/include/__iterator/prev.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___ITERATOR_PREV_H
 #define _LIBCPP___ITERATOR_PREV_H
 
 #include <__config>
+#include <__debug>
 #include <__function_like.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
     return __x;
   }
 
   template <bidirectional_iterator _Ip>
   constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Ip __bound) const {
     ranges::advance(__x, -__n, __bound);
     return __x;
   }
+
+  void operator&() const = delete;
 };
 
 inline constexpr auto prev = __prev_fn(__function_like::__tag());
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_PREV_H

libcxx/include/__memory/allocation_guard.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_ALLOCATION_GUARD_H
 #define _LIBCPP___MEMORY_ALLOCATION_GUARD_H
 
 #include <__config>
 #include <__memory/allocator_traits.h>
 #include <cstddef>
+#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/allocator_traits.h

 struct __rebind_alloc_helper {
 #ifndef _LIBCPP_CXX03_LANG
     using type _LIBCPP_NODEBUG_TYPE = typename _Traits::template rebind_alloc<_Tp>;
 #else
     using type = typename _Traits::template rebind_alloc<_Tp>::other;
 #endif
 };
 
 // __is_default_allocator
 template <class _Tp>
 struct __is_default_allocator : false_type { };
 
+template <class> class allocator;
+
 template <class _Tp>
 struct __is_default_allocator<allocator<_Tp> > : true_type { };
 
 // __is_cpp17_move_insertable
 template <class _Alloc, class = void>
 struct __is_cpp17_move_insertable
     : is_move_constructible<typename _Alloc::value_type>
 { };
 
 template <class _Alloc>
 struct __is_cpp17_move_insertable<_Alloc, _EnableIf<

libcxx/include/__memory/auto_ptr.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_AUTO_PTR_H
 #define _LIBCPP___MEMORY_AUTO_PTR_H
 
 #include <__config>
+#include <__nullptr>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/pointer_safety.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_POINTER_SAFETY_H
 #define _LIBCPP___MEMORY_POINTER_SAFETY_H
 
 #include <__config>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/pointer_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_POINTER_TRAITS_H
 #define _LIBCPP___MEMORY_POINTER_TRAITS_H
 
 #include <__config>
+#include <__memory/addressof.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__ranges/access.h

 // -*- C++ -*-
 //===------------------------ __ranges/access.h ---------------------------===//
 //
 // 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___RANGES_ACCESS_H
 #define _LIBCPP___RANGES_ACCESS_H
 
 #include <__config>
 #include <__iterator/concepts.h>
+#include <__iterator/readable_traits.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__ranges/concepts.h

 // -*- C++ -*-
 //===--------------------- __ranges/concepts.h ----------------------------===//
 //
 // 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___RANGES_CONCEPTS_H
 #define _LIBCPP___RANGES_CONCEPTS_H
 
 #include <__config>
 #include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
+#include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
+#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__ranges/data.h

 // -*- C++ -*-
 //===------------------------ __ranges/data.h ------------------------------===//
 //
 // 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___RANGES_DATA_H
 #define _LIBCPP___RANGES_DATA_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/__ranges/empty.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___RANGES_EMPTY_H
 #define _LIBCPP___RANGES_EMPTY_H
 
 #include <__config>
 #include <__iterator/concepts.h>
+#include <__ranges/access.h>
 #include <__ranges/size.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/size.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___RANGES_SIZE_H
 #define _LIBCPP___RANGES_SIZE_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
+#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__ranges/view_interface.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___RANGES_VIEW_INTERFACE_H
 #define _LIBCPP___RANGES_VIEW_INTERFACE_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/prev.h>
+#include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
+#include <__ranges/concepts.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_view.h>
+#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp

 
 // <shared_mutex>
 
 // class timed_mutex;
 
 // template <class Rep, class Period>
 //   shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 
-#include <shared_mutex>
 #include <thread>
-#include <vector>
-#include <cstdlib>
+
+#include <atomic>
 #include <cassert>
+#include <cstdlib>
+#include <shared_mutex>
+#include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::steady_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp

 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // template <class Clock, class Duration>
 //   shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 
-#include <shared_mutex>
 #include <thread>
-#include <vector>
-#include <cstdlib>
+
+#include <atomic>
 #include <cassert>
+#include <cstdlib>
+#include <shared_mutex>
+#include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::steady_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && x86_64-apple-macosx10.9
 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // void lock();
 
-#include <shared_mutex>
 #include <thread>
+
+#include <atomic>
 #include <cstdlib>
 #include <cassert>
+#include <shared_mutex>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && x86_64-apple-macosx10.9
 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // void lock_shared();
 
-#include <shared_mutex>
 #include <thread>
-#include <vector>
-#include <cstdlib>
+
+#include <atomic>
 #include <cassert>
+#include <cstdlib>
+#include <shared_mutex>
+#include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp

 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // template <class Clock, class Duration>
 //     bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
 
-#include <shared_mutex>
 #include <thread>
-#include <vector>
-#include <cstdlib>
+
+#include <atomic>
 #include <cassert>
+#include <cstdlib>
+#include <shared_mutex>
+#include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::steady_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // <format>
 
 // constexpr void advance_to(const_iterator it);
 
 #include <format>
+
 #include <cassert>
+#include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
 

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // <format>
 
 // constexpr begin() const noexcept;
 
 #include <format>
+
 #include <cassert>
+#include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(context.begin() == &fmt[0]);

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

 // XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.10
 // XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.9
 
 // <format>
 
 // constexpr void check_arg_id(size_t id);
 
 #include <format>
+
 #include <cassert>
+#include <string_view>
 
 #include "test_macros.h"
 
 constexpr bool test() {
   std::format_parse_context context("", 10);
   for (size_t i = 0; i < 10; ++i)
     context.check_arg_id(i);
 

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

 
 // <format>
 
 // constexpr explicit
 // basic_format_parse_context(basic_string_view<charT> fmt,
 //                            size_t num_args = 0) noexcept
 
 #include <format>
+
 #include <cassert>
+#include <string_view>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   // Validate the constructor is explicit.
   static_assert(

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // <format>
 
 // constexpr end() const noexcept;
 
 #include <format>
+
 #include <cassert>
+#include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(context.end() == &fmt[3]);

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.pass.cpp

 // XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.10
 // XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.9
 
 // <format>
 
 // constexpr size_t next_arg_id();
 
 #include <format>
+
 #include <cassert>
+#include <string_view>
 
 #include "test_macros.h"
 
 constexpr bool test() {
   std::format_parse_context context("");
   for (size_t i = 0; i < 10; ++i)
     assert(i == context.next_arg_id());
 

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/types.compile.pass.cpp

 //   using iterator = const_iterator;
 // }
 //
 // Namespace std typedefs:
 // using format_parse_context = basic_format_parse_context<char>;
 // using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
 #include <format>
+
+#include <string_view>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test() {
   static_assert(
       std::is_same_v<typename std::basic_format_parse_context<CharT>::char_type,

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp

 // template <class T>
 // bool
 // atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v,
 //                                shared_ptr<T> w);
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+
+#include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp

 // bool
 // atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
 //                                         shared_ptr<T> w, memory_order success,
 //                                         memory_order failure);
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+
+#include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp

 // bool
 // atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
 //                                       shared_ptr<T> w, memory_order success,
 //                                       memory_order failure);
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+
+#include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp

 
 // template <class T>
 // shared_ptr<T>
 // atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r)
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+
+#include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> r(new int(3));
         r = std::atomic_exchange_explicit(&p, r, std::memory_order_seq_cst);
         assert(*p == 3);
         assert(*r == 4);
     }
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp

 
 // template <class T>
 // shared_ptr<T>
 // atomic_load_explicit(const shared_ptr<T>* p, memory_order mo)
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+
+#include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         const std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load_explicit(&p, std::memory_order_relaxed);
         assert(*q == *p);
     }
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp

 
 // template <class T>
 // void
 // atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo)
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+
+#include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::shared_ptr<int> p;
         std::shared_ptr<int> r(new int(3));
         std::atomic_store_explicit(&p, r, std::memory_order_seq_cst);
         assert(*p == *r);
     }
 
   return 0;
 }