[libc++] Adds missing includes.

[Mordante]

Summary

This patch makes are code less dependant on transitive includes.

This was part of D145800. This patch will be abandoned, but these
changes are still useful. I manually verified declarations of the new
includes are used in these files.

libcxx/include/__format/buffer.h

 #include <__format/format_to_n_result.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__type_traits/add_pointer.h>
+#include <__type_traits/conditional.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <string_view>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__random/seed_seq.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___RANDOM_SEED_SEQ_H
 #define _LIBCPP___RANDOM_SEED_SEQ_H
 
 #include <__algorithm/copy.h>
 #include <__algorithm/fill.h>
 #include <__algorithm/max.h>
 #include <__config>
+#include <__iterator/iterator_traits.h>
 #include <cstdint>
 #include <initializer_list>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.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
 
 // <vector>
 
 #include <cstddef>
+#include <memory>
 #include <vector>
 
 #include "test_macros.h"
 
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 template<class T, class AdlTrap = Holder<Incomplete>>

libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.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: no-exceptions
 
 // (bug report: https://llvm.org/PR58392)
 // Check that vector<bool> constructors don't leak memory when an operation inside the constructor throws an exception
 
 #include <cstddef>
 #include <type_traits>
+#include <memory>
 #include <vector>
 
 #include "count_new.h"
 #include "test_iterators.h"
 
 template <class T>
 struct Allocator {
   using value_type      = T;

libcxx/test/std/containers/sequences/vector.bool/reference/assign_copy.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>
 
 // reference& operator=(const reference&)
 
 #include <cassert>
 #include <vector>
+#include <utility>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   std::vector<bool> vec;
   typedef std::vector<bool>::reference Ref;
   vec.push_back(true);
   vec.push_back(false);

libcxx/test/std/containers/sequences/vector/vector.cons/assign_move.addressof.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // vector& operator=(vector&& c);
 
 // Validate whether the container can be copy-assigned with an ADL-hijacking operator&
 
 #include <vector>
+#include <utility>
 
 #include "test_macros.h"
 #include "operator_hijacker.h"
 
 void test() {
   std::vector<operator_hijacker> vo;
   std::vector<operator_hijacker> v;
   v = std::move(vo);
 }

libcxx/test/std/containers/sequences/vector/vector.cons/deduct.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>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    vector(InputIterator, InputIterator, Allocator = Allocator())
 //    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
+#include <algorithm>
 #include <vector>
 #include <cassert>
 #include <cstddef>
 #include <climits> // INT_MAX
 #include <iterator>
 #include <type_traits>
 
 #include "deduction_guides_sfinae_checks.h"

libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.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: no-exceptions
 
 // (bug report: https://llvm.org/PR58392)
 // Check that vector constructors don't leak memory when an operation inside the constructor throws an exception
 
 #include <cstddef>
+#include <memory>
 #include <type_traits>
 #include <vector>
 
 #include "count_new.h"
 #include "test_iterators.h"
 
 template <class T>
 struct Allocator {

libcxx/test/std/containers/sequences/vector/vector.cons/move.addressof.compile.pass.cpp

 
 // <vector>
 
 // vector(vector&& c);
 
 // Validate whether the container can be copy-assigned with an ADL-hijacking operator&
 
 #include <vector>
+#include <utility>
 
 #include "test_macros.h"
 #include "operator_hijacker.h"
 
 void test() {
   {
     std::vector<operator_hijacker> vo;
     std::vector<operator_hijacker> v(std::move(vo));
   }
   {
     std::vector<operator_hijacker> vo;
     std::vector<operator_hijacker> v(std::move(vo), std::allocator<operator_hijacker>());
   }
 }

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/ctor.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
 
 // std::ranges::as_rvalue_view::as_rvalue_view(...)
 
 #include <cassert>
 #include <ranges>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 struct DefaultConstructibleView : std::ranges::view_base {
   int* begin() const;
   int* end() const;
 
   int i_ = 23;
 };

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp

 // <optional>
 
 // template <class U, class... Args>
 //     constexpr
 //     explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
 
 #include <optional>
 #include <type_traits>
+#include <memory>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 using std::in_place_t;
 using std::in_place;

libcxx/test/support/nasty_containers.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 NASTY_CONTAINERS_H
 #define NASTY_CONTAINERS_H
 
 #include <cassert>
 #include <cstddef>
 #include <vector>
 #include <list>
+#include <type_traits>
 
 #include "test_macros.h"
 
 template <class T>
 class nasty_vector
 {
 public:
     typedef typename std::vector<T>                           nested_container;