[libc++] Granularize <iterator> includes

[ldionne]

Let's follow up with the removal of <iterator> before LLVM 15, since we are already removing several transitive includes. If we are going to cause some work to downstream users, we might as well try to get the most out of it (and try not to break them at every release if we can help it).

[philnik]

• Try to fix CI

libcxx/include/__algorithm/equal_range.h

 
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/half_positive.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__functional/identity.h>
-#include <iterator>
+#include <__iterator/advance.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _ForwardIterator, class _Tp>

libcxx/include/__algorithm/inplace_merge.h

 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/min.h>
 #include <__algorithm/move.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/upper_bound.h>
 #include <__config>
+#include <__iterator/advance.h>
+#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__algorithm/lower_bound.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___ALGORITHM_LOWER_BOUND_H
 #define _LIBCPP___ALGORITHM_LOWER_BOUND_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/half_positive.h>
 #include <__config>
 #include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__iterator/advance.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
 #include <__type_traits/is_callable.h>
-#include <iterator>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iter, class _Sent, class _Type, class _Proj, class _Comp>

libcxx/include/__algorithm/partition_point.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___ALGORITHM_PARTITION_POINT_H
 #define _LIBCPP___ALGORITHM_PARTITION_POINT_H
 
 #include <__algorithm/half_positive.h>
 #include <__config>
-#include <iterator>
+#include <__iterator/advance.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _ForwardIterator, class _Predicate>

libcxx/include/__algorithm/ranges_count.h

 #define _LIBCPP___ALGORITHM_RANGES_COUNT_H
 
 #include <__algorithm/ranges_count_if.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__algorithm/ranges_count_if.h

 #define _LIBCPP___ALGORITHM_RANGES_COUNT_IF_H
 
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__algorithm/ranges_for_each_n.h

 #define _LIBCPP___ALGORITHM_RANGES_FOR_EACH_N_H
 
 #include <__algorithm/in_fun_result.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__algorithm/rotate.h

 #include <__algorithm/move_backward.h>
 #include <__algorithm/swap_ranges.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <iterator>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator>

libcxx/include/__algorithm/sample.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___ALGORITHM_SAMPLE_H
 #define _LIBCPP___ALGORITHM_SAMPLE_H
 
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
 #include <__random/uniform_int_distribution.h>
-#include <iterator>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/sort.h

 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/partial_sort.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__bits>
 #include <__config>
 #include <__debug>
 #include <__functional/operations.h>
+#include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
 #include <climits>
 #include <memory>
 
 #if defined(_LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
 #  include <__algorithm/shuffle.h>
 #endif
 

libcxx/include/__algorithm/stable_partition.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___ALGORITHM_STABLE_PARTITION_H
 #define _LIBCPP___ALGORITHM_STABLE_PARTITION_H
 
 #include <__algorithm/rotate.h>
 #include <__config>
+#include <__iterator/advance.h>
+#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__algorithm/unwrap_iter.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___ALGORITHM_UNWRAP_ITER_H
 #define _LIBCPP___ALGORITHM_UNWRAP_ITER_H
 
 #include <__config>
+#include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
-#include <iterator>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__algorithm/upper_bound.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___ALGORITHM_UPPER_BOUND_H
 #define _LIBCPP___ALGORITHM_UPPER_BOUND_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/half_positive.h>
 #include <__config>
-#include <iterator>
+#include <__iterator/advance.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _ForwardIterator, class _Tp>

libcxx/include/__format/format_arg_store.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___FORMAT_FORMAT_ARG_STORE_H
 #define _LIBCPP___FORMAT_FORMAT_ARG_STORE_H
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#include <__concepts/arithmetic.h>
+#include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_arg.h>
 #include <cstring>
 #include <string>
 #include <string_view>
 #include <type_traits>
 

libcxx/include/__format/formatter.h

 #ifndef _LIBCPP___FORMAT_FORMATTER_H
 #define _LIBCPP___FORMAT_FORMATTER_H
 
 #include <__algorithm/copy.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/transform.h>
 #include <__assert>
 #include <__availability>
+#include <__concepts/same_as.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <string_view>

libcxx/include/__hash_table

 
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
+#include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
 #include <cmath>
 #include <initializer_list>
-#include <iterator>
 #include <memory>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__memory/raw_storage_iterator.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_RAW_STORAGE_ITERATOR_H
 #define _LIBCPP___MEMORY_RAW_STORAGE_ITERATOR_H
 
 #include <__config>
+#include <__iterator/iterator.h>
+#include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__utility/move.h>
 #include <cstddef>
-#include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)

libcxx/include/__tree

 // -*- 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___TREE
 #define _LIBCPP___TREE
 
 #include <__algorithm/min.h>
+#include <__assert>
 #include <__config>
+#include <__debug>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
-#include <iterator>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/algorithm

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bits>
 #include <__config>
 #include <__debug>
 #include <cstddef>
 #include <cstring>
 #include <initializer_list>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>
 #include <__algorithm/binary_search.h>

libcxx/include/any

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #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>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/array

 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/swap_ranges.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__iterator/reverse_iterator.h>
 #include <__tuple>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
-#include <iterator>
+#include <compare>
+#include <iterator> // TODO: Remove this include
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/deque

 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__format/enable_insertable.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__iterator/reverse_iterator.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <initializer_list>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/ext/hash_map

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
 #include <functional>
+#include <iterator> // TODO: Remove this include
 #include <stdexcept>
 #include <type_traits>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else
 #   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>

libcxx/include/ext/hash_set

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
 #include <functional>
+#include <iterator> // TODO: Remove this include
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
 #endif
 #endif

libcxx/include/format

 #include <__format/formatter.h>
 #include <__format/formatter_bool.h>
 #include <__format/formatter_char.h>
 #include <__format/formatter_floating_point.h>
 #include <__format/formatter_integer.h>
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
 #include <__format/parser_std_format_spec.h>
+#include <__iterator/incrementable_traits.h>
 #include <__variant/monostate.h>
 #include <array>
 #include <concepts>
 #include <string>
 #include <string_view>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION

libcxx/include/forward_list

 
 */
 
 #include <__algorithm/comp.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/move_iterator.h>
+#include <__iterator/next.h>
 #include <__utility/forward.h>
 #include <initializer_list>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/istream

template <class Stream, class T>
   Stream&& operator>>(Stream&& is, T&& x);
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__iterator/istreambuf_iterator.h>
 #include <__utility/forward.h>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/list

 #include <__algorithm/comp.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/move_iterator.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__iterator/reverse_iterator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <initializer_list>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/locale

 #include <__algorithm/equal.h>
 #include <__algorithm/find.h>
 #include <__algorithm/max.h>
 #include <__algorithm/reverse.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
+#include <__iterator/access.h>
+#include <__iterator/back_insert_iterator.h>
+#include <__iterator/istreambuf_iterator.h>
+#include <__iterator/ostreambuf_iterator.h>
 #include <__locale>
 #ifndef __APPLE__
 # include <cstdarg>
 #endif
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ios>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <memory>
 #include <streambuf>
 #include <version>
 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 // Most unix variants have catopen.  These are the specific ones that don't.
 #  if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)

libcxx/include/map

 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
+#include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <initializer_list>
-#include <iterator> // __libcpp_erase_if_container
+#include <iterator> // TODO: Remove this include
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/memory

 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
 #include <compare>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <iosfwd>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)

libcxx/include/numeric

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cmath> // for isnormal
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <version>
 
 #include <__numeric/accumulate.h>
 #include <__numeric/adjacent_difference.h>
 #include <__numeric/exclusive_scan.h>
 #include <__numeric/gcd_lcm.h>
 #include <__numeric/inclusive_scan.h>
 #include <__numeric/inner_product.h>

libcxx/include/ostream

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <bitset>
 #include <ios>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <locale>
 #include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/regex

 
 } // std
 */
 
 #include <__algorithm/find.h>
 #include <__algorithm/search.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__iterator/access.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <deque>
 #include <initializer_list>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/set

 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
+#include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <initializer_list>
-#include <iterator> // __libcpp_erase_if_container
+#include <iterator> // TODO: Remove this include
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/span

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__fwd/span.h>
 #include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
+#include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__utility/forward.h>
 #include <array>        // for array
 #include <cstddef>      // for byte
-#include <iterator>     // for iterators
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <type_traits>  // for remove_cv, etc
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/string

 #include <__algorithm/remove_if.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__ios/fpos.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
 #include <version>
 
 // TODO: remove these headers

libcxx/include/string_view

 */
 
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__fwd/string_view.h>
+#include <__iterator/concepts.h>
+#include <__iterator/readable_traits.h>
+#include <__iterator/reverse_iterator.h>
+#include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <compare>
 #include <iosfwd>
-#include <iterator>
+#include <iterator> // TODO: Remove this include
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/unordered_map

 
 #include <__algorithm/is_permutation.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
+#include <__iterator/distance.h>
+#include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>
-#include <iterator> // __libcpp_erase_if_container
+#include <iterator> // TODO: Remove this include
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/unordered_set

 
 #include <__algorithm/is_permutation.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
+#include <__iterator/distance.h>
+#include <__iterator/erase_if_container.h>
+#include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>
-#include <iterator> // __libcpp_erase_if_container
+#include <iterator> // TODO: Remove this include
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/vector

 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit_reference>
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
+#include <__iterator/advance.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <climits>
 #include <compare>

libcxx/src/include/to_chars_floating_point.h

 // clang-format off
 
 #include <__algorithm/find.h>
 #include <__algorithm/find_if.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
+#include <__functional/operations.h>
 #include <__iterator/access.h>
 #include <__iterator/size.h>
 #include <bit>
 #include <cfloat>
 #include <climits>
 
 #include "include/ryu/ryu.h"
 

libcxx/test/libcxx/algorithms/alg.modifying.operations/copy.pass.cpp

 // UNSUPPORTED: libcpp-has-debug-mode
 
 // <algorithm>
 
 // This test checks that std::copy forwards to memmove when appropriate.
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <type_traits>
 
 struct S {
   int i;
   constexpr S(int i_) : i(i_) {}
   S(const S&) = default;
   S(S&&) = delete;
   constexpr S& operator=(const S&) = default;

libcxx/test/libcxx/algorithms/specialized.algorithms/special.mem.concepts/nothrow_sentinel_for.compile.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-has-no-incomplete-ranges
 
 // template<class S, class I>
 // concept __nothrow_sentinel_for;
 
+#include <iterator>
 #include <memory>
 
 static_assert(std::ranges::__nothrow_sentinel_for<int*, int*>);
 static_assert(!std::ranges::__nothrow_sentinel_for<int*, long*>);
 
 // Because `__nothrow_sentinel_for` is essentially an alias for `sentinel_for`,
 // the two concepts should subsume each other.
 

libcxx/test/libcxx/fuzzing/fuzz.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 TEST_LIBCXX_FUZZING_FUZZ_H
 #define TEST_LIBCXX_FUZZING_FUZZ_H
 
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring> // std::strlen
+#include <iterator>
 #include <type_traits>
 #include <utility> // std::swap
 
 
 // This is a struct we can use to test the stable_XXX algorithms.
 // Perform the operation on the key, then check the order of the payload.
 struct ByteWithPayload {
   std::uint8_t key;

libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp

 // <numeric>
 
 // template <class _Tp>
 // _Tp midpoint(_Tp __a, _Tp __b) noexcept
 //
 
 #include <numeric>
 #include <cassert>
+#include <cstdint>
 #include "test_macros.h"
 
 //  Users are not supposed to provide template argument lists for
 //  functions in the standard library (there's an exception for min and max)
 //  However, libc++ protects against this for pointers, so we check to make
 //  sure that our protection is working here.
 //  In some cases midpoint<int>(0,0) might get deduced as the pointer overload.
 

libcxx/test/std/algorithms/robust_against_adl.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 #include <algorithm>
 #include <cstddef>
 #include <functional>
+#include <iterator>
 
 #include "test_macros.h"
 
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 template<class>
 struct ConvertibleToIntegral {

libcxx/test/std/containers/associative/map/map.cons/deduct_const.pass.cpp

 // template<class Key, class Allocator>
 // map(initializer_list<Key>, Allocator)
 //   -> map<Key, less<Key>, Allocator>;
 
 #include <algorithm> // std::equal
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
+#include <iterator>
 #include <map>
 #include <type_traits>
 
 #include "test_allocator.h"
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;
 using PCC = std::pair<const int, const long>;

libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

 // <map>
 
 // class map
 
 // map(map&& m, const allocator_type& a);
 
 #include <map>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "Counter.h"
 

libcxx/test/std/containers/associative/multimap/multimap.cons/deduct_const.pass.cpp

 // template<class Key, class Allocator>
 // multimap(initializer_list<Key>, Allocator)
 //   -> multimap<Key, less<Key>, Allocator>;
 
 #include <algorithm> // std::equal
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
+#include <iterator>
 #include <map>
 #include <type_traits>
 
 #include "test_allocator.h"
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;
 using PCC = std::pair<const int, const long>;

libcxx/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp

 // <set>
 
 // class multiset
 
 // multiset(multiset&& s, const allocator_type& a);
 
 #include <set>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 #include "Counter.h"
 
 int main(int, char**)

libcxx/test/std/containers/associative/set/insert_iter_rv.pass.cpp

 // <set>
 
 // class set
 
 // iterator insert(const_iterator position, value_type&& v);
 
 #include <set>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp

 // <set>
 
 // class set
 
 // set(set&& s, const allocator_type& a);
 
 #include <set>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 #include "Counter.h"
 
 int main(int, char**)

libcxx/test/std/containers/map_allocator_requirement_test_templates.h

 
 // insert(...);
 // emplace(...);
 // emplace_hint(...);
 
 // UNSUPPORTED: c++03
 
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "count_new.h"
 #include "container_test_types.h"
 
 
 template <class Container>
 void testMapInsert()

libcxx/test/std/containers/sequences/array/array.data/data.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // T *data();
 
 #include <array>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
+#include <cstdint>
 
 #include "test_macros.h"
 
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
 #if TEST_STD_VER < 11

libcxx/test/std/containers/sequences/array/array.data/data_const.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // const T* data() const;
 
 #include <array>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
+#include <cstdint>
 
 #include "test_macros.h"
 
 struct NoDefault {
     TEST_CONSTEXPR NoDefault(int) { }
 };
 
 #if TEST_STD_VER < 11

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // void clear() noexcept;
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // iterator erase_after(const_iterator first, const_iterator last);
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef int T;

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // iterator erase_after(const_iterator p);
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef int T;

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // void resize(size_type n);
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // void resize(size_type n, const value_type& v);
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
 #if TEST_STD_VER >= 11
 #include "container_test_types.h"
 #endif

libcxx/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // void swap(forward_list& x);
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // template <class T, class Allocator>
 //     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y);
 
 #include <forward_list>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/vector.bool/erase_iter.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // vector<bool>
 
 // iterator erase(const_iterator position);
 
 #include <vector>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {

libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // vector<bool>
 
 // iterator erase(const_iterator first, const_iterator last);
 
 #include <vector>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {

libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp

 // {
 //     size_t operator()(T val) const;
 // };
 
 // Not very portable
 
 #include <vector>
 #include <cassert>
+#include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/set_allocator_requirement_test_templates.h

 // class unordered_set
 
 // insert(...);
 // emplace(...);
 // emplace_hint(...);
 
 
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "count_new.h"
 #include "container_test_types.h"
 
 
 template <class Container>
 void testSetInsert()

libcxx/test/std/containers/unord/unord.map/bucket.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // size_type bucket(const key_type& __k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/bucket_count.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // size_type bucket_count() const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/bucket_size.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // size_type bucket_size(size_type n) const
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/count.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // size_type count(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/eq.pass.cpp

 // template <class Key, class T, class Hash, class Pred, class Alloc>
 // bool
 // operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
 //            const unordered_map<Key, T, Hash, Pred, Alloc>& y);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 #include "test_comparisons.h"
 
 int main(int, char**)
 {

libcxx/test/std/containers/unord/unord.map/equal_range_const.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // pair<iterator, iterator> equal_range(const key_type& k);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/find_const.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // const_iterator find(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/find_non_const.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // iterator find(const key_type& k);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/load_factor.pass.cpp

 
 // float load_factor() const
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cmath>
 #include <cfloat>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp

 // class unordered_map
 
 // void swap(unordered_map& __u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cstddef>
+#include <iterator>
 
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main(int, char**)

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp

 // template<class Key, class T, class Hash, class Allocator>
 // unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //               Allocator)
 //   -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
 
 #include <algorithm> // is_permutation
 #include <cassert>
 #include <climits> // INT_MAX
+#include <iterator>
 #include <type_traits>
 #include <unordered_map>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_allocator.h"
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct_const.pass.cpp

 // template<class Key, class T, class Hash, class Allocator>
 // unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //               Allocator)
 //   -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
 
 #include <algorithm> // std::is_permutation
 #include <cassert>
 #include <climits> // INT_MAX
+#include <iterator>
 #include <type_traits>
 #include <unordered_map>
 
 #include "test_allocator.h"
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;
 

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // iterator erase(const_iterator first, const_iterator last)
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.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
 
 // <unordered_map>
 
 // class unordered_map
 
 // node_type extract(key_type const&);
 
+#include <iterator>
 #include <unordered_map>
+
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "Counter.h"
 
 template <class Container, class KeyTypeIter>
 void test(Container& c, KeyTypeIter first, KeyTypeIter last)
 {
     size_t sz = c.size();

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp

 //  pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);                 // C++17
 // template <class M>
 //  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);   // C++17
 // template <class M>
 //  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);        // C++17
 
 #include <unordered_map>
 #include <cassert>
+#include <iterator>
 #include <tuple>
 
 #include "test_macros.h"
 
 
 class Moveable
 {
     Moveable(const Moveable&);

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp

 //  pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);               // C++17
 // template <class... Args>
 //  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
 // template <class... Args>
 //  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);      // C++17
 
 #include <unordered_map>
 #include <cassert>
+#include <iterator>
 #include <tuple>
 
 #include "test_macros.h"
 
 class Moveable
 {
     Moveable(const Moveable&);
     Moveable& operator=(const Moveable&);

libcxx/test/std/containers/unord/unord.multimap/bucket.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type bucket(const key_type& __k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type bucket_count() const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
         const C c;

libcxx/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type bucket_size(size_type n) const
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/count.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type count(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/eq.pass.cpp

 // template <class Key, class T, class Hash, class Pred, class Alloc>
 // bool
 // operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
 //            const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 #include "test_comparisons.h"
 
 int main(int, char**)
 {

libcxx/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp

 // class unordered_multimap
 
 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
 #include <set>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp

 // class unordered_multimap
 
 // pair<iterator, iterator> equal_range(const key_type& k);
 
 #include <unordered_map>
 #include <string>
 #include <set>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/find_const.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // const_iterator find(const key_type& k) const;
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // iterator find(const key_type& k);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/load_factor.pass.cpp

 
 // float load_factor() const
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;

libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp

 
 // void swap(unordered_multimap& __u);
 
 #include <unordered_map>
 #include <string>
 #include <set>
 #include <cassert>
 #include <cstddef>
+#include <iterator>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
 
 #include "min_allocator.h"
 

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct_const.pass.cpp

 // unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //                    Allocator)
 //   -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;
 
 #include <algorithm> // is_permutation
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
+#include <iterator>
 #include <type_traits>
 #include <unordered_map>
 
 #include "test_allocator.h"
 
 using P = std::pair<int, long>;
 using PC = std::pair<const int, long>;
 

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp

 // class unordered_multimap
 
 // template <class... Args>
 //     iterator emplace_hint(const_iterator p, Args&&... args);
 
 
 #include <unordered_map>
 #include <cassert>
+#include <iterator>
 
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp

 
 // void swap(unordered_multimap& __u);
 
 #include <unordered_map>
 #include <string>
 #include <set>
 #include <cassert>
 #include <cstddef>
+#include <iterator>
 
 #include "test_macros.h"
 #include "../../../check_consecutive.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 

libcxx/test/std/containers/views/views.span/span.cons/assign.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
 
 // <span>
 
 //  constexpr span& operator=(const span& other) noexcept = default;
 
 #include <span>
 #include <cassert>
+#include <iterator>
 #include <string>
 #include <utility>
 
 #include "test_macros.h"
 
 template <typename T>
 constexpr bool doAssign(T lhs, T rhs)
 {

libcxx/test/std/containers/views/views.span/span.cons/deduct.pass.cpp

 //
 //   template<class R>
 //     span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
 
 
 #include <span>
 #include <array>
 #include <cassert>
+#include <iterator>
 #include <memory>
 #include <string>
 
 #include "test_macros.h"
 
 void test_iterator_sentinel() {
   int arr[] = {1, 2, 3};
   {

libcxx/test/std/re/re.iter/re.regiter/re.regiter.incr/post.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class regex_iterator<BidirectionalIterator, charT, traits>
 
 // regex_iterator operator++(int);
 
 #include <regex>
 #include <cassert>
+#include <iterator>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         std::cregex_iterator i(std::begin(phone_book), std::end(phone_book), phone_numbers);

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp

 // regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
 //                      const regex_type& re,
 //                      const int (&submatches)[N],
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
 #include <regex>
 #include <cassert>
+#include <iterator>
+
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
         const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
         const int indices[] = {-1, 0, 1};

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp

 // regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
 //                      const regex_type& re,
 //                      initializer_list<int> submatches,
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
 #include <regex>
 #include <cassert>
+#include <iterator>
+
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
         const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp

 
 // regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
 //                      const regex_type& re, int submatch = 0,
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
 #include <regex>
 #include <cassert>
+#include <iterator>
+
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp

 // regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
 //                      const regex_type& re,
 //                      const std::vector<int>& submatches,
 //                      regex_constants::match_flag_type m =
 //                                              regex_constants::match_default);
 
 #include <regex>
 #include <cassert>
+#include <iterator>
+
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
         const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
         std::vector<int> v;

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class regex_token_iterator<BidirectionalIterator, charT, traits>
 
 // const value_type& operator*() const;
 
 #include <regex>
 #include <cassert>
+#include <iterator>
+
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class regex_token_iterator<BidirectionalIterator, charT, traits>
 
 // regex_token_iterator& operator++(int);
 
 #include <regex>
 #include <cassert>
+#include <iterator>
+
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,

libcxx/test/std/strings/string.view/string.view.access/data.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: !stdlib=libc++ && (c++03 || c++11 || c++14)
 
 // <string_view>
 
 // constexpr const _CharT* data() const noexcept;
 
 #include <string_view>
 #include <cassert>
+#include <iterator>
 
 #include "test_macros.h"
 
 template <typename CharT>
 void test ( const CharT *s, size_t len ) {
     std::basic_string_view<CharT> sv ( s, len );
     assert ( sv.length() == len );
     assert ( sv.data() == s );

libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp

 // [string.view.capacity], capacity
 // constexpr size_type size()     const noexcept;
 // constexpr size_type length()   const noexcept;
 // constexpr size_type max_size() const noexcept;
 // constexpr bool empty()         const noexcept;
 
 #include <string_view>
 #include <cassert>
+#include <iterator>
 #include <limits>
 
 #include "test_macros.h"
 
 template<typename SV>
 void test1 () {
 #if TEST_STD_VER > 11
     {

libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp

 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "test.hpp"
 
 #include <algorithm>
 #include <array>
 #include <assert.h>
 #include <charconv>
 #include <chrono>
 #include <cmath>
 #include <fstream>
 #include <functional>
+#include <iterator>
 #include <limits>
 #include <locale>
 #include <optional>
 #include <random>
 #include <set>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>

libcxx/test/std/utilities/format/format.functions/format_tests.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 TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
 #define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
 
 #include <format>
 
 #include <algorithm>
+#include <cassert>
 #include <charconv>
 #include <cmath>
 #include <cstdint>
+#include <iterator>
 
 #include "make_string.h"
 #include "string_literal.h"
 #include "test_macros.h"
 
 // In this file the following template types are used:
 // TestFunction must be callable as check(expected-result, string-to-format, args-to-format...)
 // ExceptionTest must be callable as check_exception(expected-exception, string-to-format, args-to-format...)

libcxx/test/std/utilities/memory/allocator.traits/allocate_at_least.pass.cpp

 
 // <memory>
 
 // template<class Allocator>
 // [[nodiscard]] constexpr allocation_result<typename allocator_traits<Allocator>::pointer>
 //   allocate_at_least(Allocator& a, size_t n);
 
 #include <cassert>
+#include <concepts>
 #include <memory>
 
 // check that std::allocation_result exists and isn't restricted to pointers
 using AllocResult = std::allocation_result<int>;
 
 template <class T>
 struct no_allocate_at_least {
   using value_type = T;

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate_at_least.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, c++20
 
 // <memory>
 
 // allocation_result<T*> allocate_at_least(size_t n)
 
 #include <cassert>
+#include <concepts>
 #include <memory>
 
 #include "count_new.h"
 
 #ifdef TEST_HAS_NO_ALIGNED_ALLOCATION
 static const bool UsingAlignedNew = false;
 #else
 static const bool UsingAlignedNew = true;

libcxx/test/std/utilities/memory/storage.iterator/types.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // raw_storage_iterator associated types
 
 #include <cstddef>
+#include <iterator>
 #include <memory>
 #include <type_traits>
 
 #include "test_macros.h"
 
 struct T;
 typedef T* OutputIt;
 typedef std::raw_storage_iterator<OutputIt, T> It;

libcxx/test/support/archetypes.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 TEST_SUPPORT_ARCHETYPES_H
 #define TEST_SUPPORT_ARCHETYPES_H
 
 #include <type_traits>
 #include <cassert>
+#include <initializer_list>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
 #if TEST_STD_VER >= 11
 
 namespace ArchetypeBases {
 

libcxx/test/support/deduction_guides_sfinae_checks.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 TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
 #define TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
 
 #include <functional>
 #include <initializer_list>
+#include <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 // `SFINAEs_away` template variable checks whether the template arguments for
 // a given template class `Instantiated` can be deduced from the given

libcxx/test/support/min_allocator.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 MIN_ALLOCATOR_H
 #define MIN_ALLOCATOR_H
 
 #include <cstddef>
 #include <cstdlib>
 #include <cstddef>
 #include <cassert>
 #include <climits>
+#include <iterator>
 #include <memory>
 
 #include "test_macros.h"
 
 template <class T>
 class bare_allocator
 {
 public: