[libc++] Granularize <exception> includes

[ldionne]

I am fine with this in principle, but there seems to be a bit of work needed still. LGTM once CI is green. Also, when you remove transitive includes from a public header, let's add it to a _LIBCPP_REMOVE_TRANSITIVE_INCLUDES block (even if it might not be needed strictly speaking because the transitive include still exists via a private header). That documents what the public header is including and for what reasons (e.g. _LIBCPP_REMOVE_TRANSITIVE_INCLUDES implies the reason is legacy), and that's useful to know.

libcxx/include/__functional/function.h

34–35

Are those not needed at all?

libcxx/include/functional

546

Don't we need to add this below to the _LIBCPP_REMOVE_TRANSITIVE_INCLUDES block?

libcxx/include/variant

242

_LIBCPP_REMOVE_TRANSITIVE_INCLUDES?

[philnik]

address comments

[philnik]

Try to fix CI

libcxx/include/__expected/bad_expected_access.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___EXPECTED_BAD_EXPECTED_ACCESS_H
 #define _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
 
 #include <__config>
+#include <__exception/exception.h>
 #include <__utility/move.h>
 
-#include <exception>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__format/buffer.h

 #include <__format/concepts.h>
 #include <__format/enable_insertable.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 <__utility/move.h>
 #include <cstddef>
 #include <string_view>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__functional/function.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___FUNCTIONAL_FUNCTION_H
 #define _LIBCPP___FUNCTIONAL_FUNCTION_H
 
 #include <__assert>
 #include <__config>
+#include <__exception/exception.h>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/builtin_new_allocator.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/is_trivially_copy_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
 #include <__type_traits/strip_signature.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <__verbose_abort>
-#include <exception>
 #include <new>
 #include <tuple>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__ranges/join_view.h

 #include <__concepts/equality_comparable.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/iterator_with_data.h>
 #include <__iterator/segmented_iterator.h>
+#include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/maybe_const.h>

libcxx/include/functional

 #include <__functional/pointer_to_binary_function.h>
 #include <__functional/pointer_to_unary_function.h>
 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/unary_negate.h>
 #include <__functional/unwrap_ref.h>
 #include <__utility/forward.h>
-#include <exception>
 #include <memory> // TODO: find out why removing this breaks the modules build
 #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 <atomic>
 #  include <concepts>
+#  include <exception>
 #  include <tuple>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
+#include <__exception/exception_ptr.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_destructor.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/alignment_of.h>
 #include <__type_traits/strip_signature.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <__verbose_abort>
-#include <exception>
 #include <mutex>
 #include <new>
 #include <system_error>
 #include <thread>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
+#  include <exception>
 #endif
 
 #endif // _LIBCPP_FUTURE

libcxx/include/map

 #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 <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>

libcxx/include/new

 void  operator delete  (void* ptr, void*) noexcept;
 void  operator delete[](void* ptr, void*) noexcept;
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
+#include <__exception/exception.h>
+#include <__type_traits/alignment_of.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
 #include <__verbose_abort>
 #include <cstddef>
 #include <cstdlib>
-#include <exception>
 #include <version>
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <new.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

 
 #endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <exception>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_NEW

libcxx/include/ostream

 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__exception/operations.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <bitset>

libcxx/include/stdexcept

 };
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__verbose_abort>
+#include <__exception/exception.h>
 #include <cstdlib>
-#include <exception>
 #include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw underflow_error(__msg);
 #else
     std::__libcpp_verbose_abort("underflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <exception>
+#endif
+
 #endif // _LIBCPP_STDEXCEPT

libcxx/include/thread

 }  // this_thread
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__exception/terminate.h>
 #include <__functional/hash.h>
+#include <__memory/addressof.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex_base>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <iosfwd>

libcxx/include/typeinfo

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
+#include <__exception/exception.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__verbose_abort>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
-#include <exception>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_typeinfo.h>
 #else
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_cast();
 #else
     std::__libcpp_verbose_abort("bad_cast was thrown in -fno-exceptions mode");
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <exception>
 #  include <type_traits>
 #endif
 
 #endif // __LIBCPP_TYPEINFO

libcxx/include/variant

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__compare/common_comparison_category.h>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.h>
 #include <__config>
+#include <__exception/exception.h>
 #include <__functional/hash.h>
 #include <__functional/invoke.h>
 #include <__functional/operations.h>
 #include <__functional/unary_function.h>
 #include <__memory/addressof.h>
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_cv.h>
 #include <__type_traits/add_pointer.h>

 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__variant/monostate.h>
 #include <__verbose_abort>
-#include <exception>
 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <version>
 
 // standard-mandated includes
 

 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <exception>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_VARIANT

libcxx/test/libcxx/transitive_includes/cxx03.csv

 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
 expected cstdlib
-expected exception
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx11.csv

 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
 expected cstdlib
-expected exception
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx14.csv

 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
 expected cstdlib
-expected exception
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx17.csv

 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
 expected cstdlib
-expected exception
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx20.csv

 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 expected cstddef
 expected cstdlib
-expected exception
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 deque tuple
 deque version
 exception cstddef
 exception cstdlib
 exception version
 execution version
 expected cstddef
 expected cstdlib
-expected exception
 expected initializer_list
 expected new
 expected version
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/iterator cstddef

 fstream string
 fstream typeinfo
 fstream version
 functional array
 functional cstddef
 functional cstdint
 functional cstdlib
 functional cstring
-functional exception
 functional initializer_list
 functional iosfwd
 functional limits
 functional memory
 functional new
 functional stdexcept
 functional tuple
 functional typeinfo
 functional unordered_map
 functional vector
 functional version
 future cstddef
 future cstdint
 future cstdlib
 future cstring
-future exception
 future initializer_list
 future iosfwd
 future limits
 future mutex
 future new
 future ratio
 future stdexcept
 future system_error

 mutex ratio
 mutex stdexcept
 mutex system_error
 mutex tuple
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
-new exception
 new version
 numbers version
 numeric cmath
 numeric cstddef
 numeric limits
 numeric version
 optional compare
 optional cstddef

 sstream string
 sstream version
 stack compare
 stack cstddef
 stack deque
 stack initializer_list
 stack version
 stdexcept cstdlib
-stdexcept exception
 stdexcept iosfwd
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef

 type_traits cstdint
 type_traits version
 typeindex compare
 typeindex typeinfo
 typeindex version
 typeinfo cstddef
 typeinfo cstdint
 typeinfo cstdlib
-typeinfo exception
 unordered_map cmath
 unordered_map compare
 unordered_map cstddef
 unordered_map cstdint
 unordered_map cstdlib
 unordered_map cstring
 unordered_map initializer_list
 unordered_map limits

 valarray limits
 valarray new
 valarray stdexcept
 valarray version
 variant compare
 variant cstddef
 variant cstdint
 variant cstring
-variant exception
 variant initializer_list
 variant limits
 variant new
 variant tuple
 variant version
 vector climits
 vector compare
 vector cstddef

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp

 //     When 'T2' notifies 'cv' and the wait method attempts to re-lock
 //    'm' an exception will be thrown from 'm.lock()'.
 //
 //   6 Check that control flow does not return from the wait method and that
 //     terminate is called (If the program exits with a 0 exit code we know
 //     that terminate has been called)
 
 
-#include <condition_variable>
 #include <atomic>
-#include <thread>
+#include <cassert>
 #include <chrono>
-#include <string>
+#include <condition_variable>
 #include <cstdlib>
-#include <cassert>
+#include <exception>
+#include <string>
+#include <thread>
 
 #include "make_test_thread.h"
 
 void my_terminate() {
   std::_Exit(0); // Use _Exit to prevent cleanup from taking place.
 }
 
 // The predicate used in the cv.wait calls.

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp

 
 
 // <thread>
 
 // class thread
 
 // ~thread();
 
-#include <thread>
-#include <new>
-#include <cstdlib>
 #include <cassert>
+#include <cstdlib>
+#include <exception>
+#include <new>
+#include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 class G
 {
     int alive_;
 public: