[libc++] Avoid including <tuple> in compressed_pair.h

[philnik]

Summary

compressed_pair is widely used in the library, but most of the uses don't use the tuple parts. To avoid including <tuple> everywhere, use the forward declaration instead in compressed_pair.h

[philnik]

• Rebased
• Try to fix CI

libcxx/include/__memory/compressed_pair.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_COMPRESSED_PAIR_H
 #define _LIBCPP___MEMORY_COMPRESSED_PAIR_H
 
 #include <__config>
+#include <__fwd/get.h>
+#include <__fwd/tuple.h>
+#include <__tuple/tuple_indices.h>
 #include <__type_traits/dependent_type.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <tuple> // needed in c++03 for some constructors
+#include <__utility/piecewise_construct.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__string/char_traits.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___STRING_CHAR_TRAITS_H
 #define _LIBCPP___STRING_CHAR_TRAITS_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/find_end.h>
 #include <__algorithm/find_first_of.h>
 #include <__algorithm/min.h>
+#include <__compare/ordering.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__iterator/iterator_traits.h>
-#include <compare>
+#include <__type_traits/is_constant_evaluated.h>
+#include <cstddef>
 #include <cstdint>
 #include <cstdio>
-#include <cstring>
 #include <iosfwd>
-#include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #   include <cwchar> // for wmemcpy
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/functional

 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h> // TODO: deprecate
 #include <__functional/unary_negate.h>
 #include <__functional/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <exception>
 #include <memory> // TODO: find out why removing this breaks the modules build
-#include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <tuple>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/test/libcxx/transitive_includes/cxx2b/expected.algorithm

 bit
 climits
-cmath
-compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 initializer_list
 iosfwd
 limits
 new
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.any

 atomic
 climits
-cmath
-compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.barrier

 atomic
 climits
-cmath
-compare
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 iosfwd
 limits
 new
 ratio
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.bitset

 exception
 initializer_list
 iosfwd
 limits
 new
 stdexcept
 string
 string_view
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.condition_variable

 iosfwd
 limits
 new
 ratio
 stdexcept
 string
 string_view
 system_error
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.deque

 ctime
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_algorithm

 algorithm
 bit
 climits
-cmath
-compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 initializer_list
 iosfwd
 limits
 new
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.forward_list

 ctime
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.list

 ctime
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.memory

 ctime
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.queue

 deque
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.random

 iosfwd
 limits
 new
 numeric
 ratio
 stdexcept
 string
 string_view
-tuple
 type_traits
 typeinfo
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.set

 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 initializer_list
 iosfwd
 limits
 new
 optional
 stdexcept
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.shared_mutex

 iosfwd
 limits
 new
 ratio
 stdexcept
 string
 string_view
 system_error
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.stack

 deque
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.string

 cwctype
 exception
 initializer_list
 iosfwd
 limits
 new
 stdexcept
 string_view
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.system_error

 exception
 initializer_list
 iosfwd
 limits
 new
 stdexcept
 string
 string_view
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.unordered_set

 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 initializer_list
 iosfwd
 limits
 new
 optional
 stdexcept
-tuple
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.vector

 ctime
 exception
 initializer_list
 iosfwd
 limits
 new
 ratio
 stdexcept
-tuple
 type_traits
 typeinfo
 version

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.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>
 
 // template<class T, StrictWeakOrder<auto, T> Compare>
 //   requires !SameType<T, Compare> && CopyConstructible<Compare>
 //   pair<const T&, const T&>
 //   minmax(const T& a, const T& b, Compare comp);
 
 #include <algorithm>
-#include <functional>
 #include <cassert>
+#include <functional>
+#include <utility>
 
 #include "test_macros.h"
 
 template <class T, class C>
 void
 test(const T& a, const T& b, C c, const T& x, const T& y)
 {
     std::pair<const T&, const T&> p = std::minmax(a, b, c);

libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp

 
 #include <algorithm>
 #include <functional>
 #include <vector>
 #include <random>
 #include <cassert>
 #include <cstddef>
 #include <memory>
+#include <utility>
 
 #include "test_macros.h"
 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}

libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp

 //   unspecified bind(Fn, Types...);
 // template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
 //   unspecified bind(Fn, Types...);
 
 // Check that the call operators have the proper return type and that they
 // only SFINAE away when too few arguments are provided. Otherwise they should
 // be well formed and should ignore any additional arguments.
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int dummy = 42;
 
 int return_value(int) { return dummy; }
 int& return_lvalue(int) { return dummy; }
 const int& return_const_lvalue(int) { return dummy; }

libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/specialization.pass.cpp

 // <functional>
 
 // template<class T> struct is_bind_expression;
 //   A program may specialize this template for a program-defined type T
 //   to have a base characteristic of true_type to indicate that T should
 //   be treated as a subexpression in a bind call.
 //   https://llvm.org/PR51753
 
-#include <functional>
 #include <cassert>
+#include <functional>
 #include <type_traits>
+#include <utility>
 
 struct MyBind {
     int operator()(int x, int y) const { return 10*x + y; }
 };
 template<> struct std::is_bind_expression<MyBind> : std::true_type {};
 
 int main(int, char**)
 {

libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.isplace/specialization.pass.cpp

 // <functional>
 
 // template<class T> struct is_placeholder;
 //   A program may specialize this template for a program-defined type T
 //   to have a base characteristic of integral_constant<int, N> with N > 0
 //   to indicate that T should be treated as a placeholder type.
 //   https://llvm.org/PR51753
 
-#include <functional>
 #include <cassert>
+#include <functional>
 #include <type_traits>
+#include <utility>
 
 struct My2 {};
 template<> struct std::is_placeholder<My2> : std::integral_constant<int, 2> {};
 
 int main(int, char**)
 {
   {
     auto f = [](auto x) { return 10*x + 9; };

libcxx/test/std/utilities/function.objects/func.identity/identity.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
 
 // struct identity;
 
 #include <functional>
 
 #include <cassert>
 #include <concepts>
+#include <utility>
 
 #include "MoveOnly.h"
 
 static_assert(std::semiregular<std::identity>);
 static_assert(requires { typename std::identity::is_transparent; });
 
 constexpr bool test() {
   std::identity id;

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

 // UNSUPPORTED: c++03, c++11, c++14
 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, function&&);
 //
 // This signature was removed in C++17
 
+#include <cassert>
 #include <functional>
 #include <memory>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 class A
 {
     int data_[10];
 public:
     static int count;

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

 
 // class function<R(ArgTypes...)>
 
 // function& operator=(const function& f);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
-#include <functional>
 #include <cassert>
+#include <functional>
+#include <utility>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 class A {
   int data_[10];
 
 public:

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

 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <memory>
 #include <cstdlib>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 class A
 {
     int data_[10];
 public:

libcxx/test/std/utilities/function.objects/range.cmp/equal_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
 
 // <functional>
 
 // ranges::equal_to
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotEqualityComparable {
   friend bool operator==(const NotEqualityComparable&, const NotEqualityComparable&);

libcxx/test/std/utilities/function.objects/range.cmp/greater.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
 
 // <functional>
 
 // ranges::greater
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.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
 
 // <functional>
 
 // ranges::greater_equal
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/less.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
 
 // <functional>
 
 // ranges::less
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/less_equal.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
 
 // <functional>
 
 // ranges::less_equal
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/not_equal_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
 
 // <functional>
 
 // ranges::not_equal_to
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotEqualityComparable {
   friend bool operator==(const NotEqualityComparable&, const NotEqualityComparable&);

libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.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
 
+#include <cassert>
 #include <memory>
 #include <type_traits>
-#include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include <MoveOnly.h>
 
 int A_constructed = 0;
 
 struct A
 {

libcxx/test/support/container_test_types.h

  * m.emplace(k, std::move(v));
  *
  * // Assert that the "expect" was consumed by a matching "check" call within
  * // Alloc.
  * assert(!cc->unexpected());
  *
  */
 
-#include <functional>
 #include <cassert>
+#include <functional>
 #include <new>
+#include <utility>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER < 11
 #error This header requires C++11 or greater
 #endif
 
 namespace detail {