[libc++] Update and normalize the "all the headers" tests.

[• Quuxplusone]

Summary

As I promised @ldionne in D92240! :) Some C++20 headers weren't added properly to all three of these test files. Add them, and take the time to normalize the formatting so that

diff <(grep '#include' foo.cpp) <(grep '#include' bar.cpp)

shows no diffs (except that no_assert_include deliberately excludes <cassert>).

[curdeius]

Nice findings! Apparently all of barrier, latch, semaphore and simd are missing _LIBCPP_PUSH_MACROS #include <__undef_macros>. And semaphore includes <cassert>.

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

100

You found the culprit!

[• Quuxplusone]

• Remove an unused include of <cassert> from <semaphore>.
• Add macro guards to <{barrier,latch,semaphore}>.
• Add macro guards to <experimental/simd>.

[ldionne]

Thank you! I think it would be neat to add a script that can generate those, or generate them from CMake. Anything that would remove the need to do it manually would be great. WDYT?

[• Quuxplusone]

Two semaphore tests were relying on <semaphore> including <cassert>. Include-what-you-use in the semaphore tests.

[• Quuxplusone]

I think it would be neat to add a script that can generate those, or generate them from CMake. Anything that would remove the need to do it manually would be great. WDYT?

I'm OCD enough not to mind doing it by hand, but I think engineering-wise your position is more defensible than mine. ;)
We already have libcxx/utils/generate_feature_test_macro_components.py; presumably we could generate these similarly. I'm not volunteering to write the Python.

[ldionne]

Thanks! I'll look into automating that. I've been thinking about it for a while, and it has caused issues internally in the past so there's justification for me to look into it.

libcxx/include/barrier

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error <barrier> is not supported on this single threaded system
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 struct __empty_completion
 {
     inline _LIBCPP_INLINE_VISIBILITY
     void operator()() noexcept
void arrive_and_drop()
         __b.arrive_and_drop();
     }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
+_LIBCPP_POP_MACROS
+
 #endif //_LIBCPP_BARRIER

libcxx/include/experimental/simd

 #include <array>
 #include <cstddef>
 #include <functional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
 
 #if _LIBCPP_STD_VER >= 17
 
 enum class _StorageKind {
   _Scalar,
   _Array,
   _VecExt,
public:
   friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
 };
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 
+_LIBCPP_POP_MACROS
+
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */

libcxx/include/latch

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error <latch> is not supported on this single threaded system
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class latch
 {
     __atomic_base<ptrdiff_t> __a;
 
void arrive_and_wait(ptrdiff_t __update = 1)
         wait();
     }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
+_LIBCPP_POP_MACROS
+
 #endif //_LIBCPP_LATCH

libcxx/include/semaphore

 }
 
 */
 
 #include <__config>
 #include <__availability>
 #include <__threading_support>
 #include <atomic>
-#include <cassert>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error <semaphore> is not supported on this single threaded system
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 /*
 
 __atomic_semaphore_base is the general-case implementation, to be used for
 user-requested least-max values that exceed the OS implementation support

 };
 
 using binary_semaphore = counting_semaphore<1>;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
+_LIBCPP_POP_MACROS
+
 #endif //_LIBCPP_SEMAPHORE

libcxx/test/libcxx/double_include.sh.cpp

 #endif
 
 // Top level headers
 #include <algorithm>
 #include <any>
 #include <array>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <atomic>
-#include <latch>
+#endif
+#ifndef _LIBCPP_HAS_NO_THREADS
 #include <barrier>
-#include <semaphore>
 #endif
 #include <bit>
 #include <bitset>
 #include <cassert>
 #include <ccomplex>
 #include <cctype>
 #include <cerrno>
 #include <cfenv>

 #include <functional>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>
 #include <iosfwd>
 #include <iterator>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <latch>
+#endif
 #include <limits>
 #include <limits.h>
 #include <list>
 #include <map>
 #include <math.h>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 #endif
 #include <new>
 #include <numbers>
 #include <numeric>
 #include <optional>
 #include <queue>
 #include <random>
 #include <ratio>
 #include <scoped_allocator>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <semaphore>
+#endif
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 #endif
 #include <span>
 #include <stack>
 #include <stdbool.h>

 #include <experimental/filesystem>
 #include <experimental/forward_list>
 #include <experimental/functional>
 #include <experimental/iterator>
 #include <experimental/list>
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
-#include <experimental/simd>
 #include <experimental/set>
+#include <experimental/simd>
 #include <experimental/string>
 #include <experimental/type_traits>
 #include <experimental/unordered_map>
 #include <experimental/unordered_set>
 #include <experimental/utility>
 #include <experimental/vector>
 #endif // __cplusplus >= 201103L
 
 // extended headers
 #include <ext/hash_map>
 #include <ext/hash_set>
 
 #if defined(WITH_MAIN)
 int main(int, char**) { return 0; }
 #endif

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <any>
 TEST_MACROS();
 #include <array>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <atomic>
 TEST_MACROS();
 #endif
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <barrier>
+TEST_MACROS();
+#endif
+#include <bit>
+TEST_MACROS();
 #include <bitset>
 TEST_MACROS();
 #include <cassert>
 TEST_MACROS();
 #include <ccomplex>
 TEST_MACROS();
 #include <cctype>
 TEST_MACROS();

 #include <cinttypes>
 TEST_MACROS();
 #include <ciso646>
 TEST_MACROS();
 #include <climits>
 TEST_MACROS();
 #include <cmath>
 TEST_MACROS();
+#include <compare>
+TEST_MACROS();
 #include <complex>
 TEST_MACROS();
 #include <complex.h>
 TEST_MACROS();
+#include <concepts>
+TEST_MACROS();
 #include <condition_variable>
 TEST_MACROS();
 #include <csetjmp>
 TEST_MACROS();
 #include <csignal>
 TEST_MACROS();
 #include <cstdarg>
 TEST_MACROS();

 #include <cwctype>
 TEST_MACROS();
 #include <deque>
 TEST_MACROS();
 #include <errno.h>
 TEST_MACROS();
 #include <exception>
 TEST_MACROS();
+#include <execution>
+TEST_MACROS();
+#include <fenv.h>
+TEST_MACROS();
 #include <filesystem>
 TEST_MACROS();
 #include <float.h>
 TEST_MACROS();
 #include <forward_list>
 TEST_MACROS();
 #include <functional>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <future>
 TEST_MACROS();
 #endif
 #include <initializer_list>
 TEST_MACROS();
 #include <inttypes.h>
 TEST_MACROS();
 #include <iosfwd>
 TEST_MACROS();
 #include <iterator>
 TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <latch>
+TEST_MACROS();
+#endif
 #include <limits>
 TEST_MACROS();
 #include <limits.h>
 TEST_MACROS();
 #include <list>
 TEST_MACROS();
 #include <map>
 TEST_MACROS();
 #include <math.h>
 TEST_MACROS();
 #include <memory>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 TEST_MACROS();
 #endif
 #include <new>
 TEST_MACROS();
+#include <numbers>
+TEST_MACROS();
 #include <numeric>
 TEST_MACROS();
 #include <optional>
 TEST_MACROS();
 #include <queue>
 TEST_MACROS();
 #include <random>
 TEST_MACROS();
 #include <ratio>
 TEST_MACROS();
 #include <scoped_allocator>
 TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <semaphore>
+TEST_MACROS();
+#endif
 #include <set>
 TEST_MACROS();
 #include <setjmp.h>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 TEST_MACROS();
 #endif

 #include <utility>
 TEST_MACROS();
 #include <valarray>
 TEST_MACROS();
 #include <variant>
 TEST_MACROS();
 #include <vector>
 TEST_MACROS();
+#include <version>
+TEST_MACROS();
 #include <wchar.h>
 TEST_MACROS();
 #include <wctype.h>
 TEST_MACROS();
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #   include <clocale>
     TEST_MACROS();
#       include <experimental/regex>
         TEST_MACROS();
 #   endif
 #endif
 
 // experimental headers
 #if __cplusplus >= 201103L
 #include <experimental/algorithm>
 TEST_MACROS();
+#if defined(__cpp_coroutines)
+#include <experimental/coroutine>
+TEST_MACROS();
+#endif
 #include <experimental/deque>
 TEST_MACROS();
 #include <experimental/filesystem>
 TEST_MACROS();
 #include <experimental/forward_list>
 TEST_MACROS();
 #include <experimental/functional>
 TEST_MACROS();
 #include <experimental/iterator>
 TEST_MACROS();
 #include <experimental/list>
 TEST_MACROS();
 #include <experimental/map>
 TEST_MACROS();
 #include <experimental/memory_resource>
 TEST_MACROS();
 #include <experimental/propagate_const>
 TEST_MACROS();
 #include <experimental/set>
 TEST_MACROS();
+#include <experimental/simd>
+TEST_MACROS();
 #include <experimental/string>
 TEST_MACROS();
 #include <experimental/type_traits>
 TEST_MACROS();
 #include <experimental/unordered_map>
 TEST_MACROS();
 #include <experimental/unordered_set>
 TEST_MACROS();

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 
 // Top level headers
 #include <algorithm>
 #include <any>
 #include <array>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <atomic>
 #endif
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <barrier>
+#endif
 #include <bit>
 #include <bitset>
 #include <ccomplex>
 #include <cctype>
 #include <cerrno>
 #include <cfenv>
 #include <cfloat>
 #include <charconv>
 #include <chrono>
 #include <cinttypes>
 #include <ciso646>
 #include <climits>
 #include <cmath>
 #include <compare>
 #include <complex>
 #include <complex.h>
+#include <concepts>
 #include <condition_variable>
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>

 #include <functional>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>
 #include <iosfwd>
 #include <iterator>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <latch>
+#endif
 #include <limits>
 #include <limits.h>
 #include <list>
 #include <map>
 #include <math.h>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 #endif
 #include <new>
+#include <numbers>
 #include <numeric>
 #include <optional>
 #include <queue>
 #include <random>
 #include <ratio>
 #include <scoped_allocator>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <semaphore>
+#endif
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 #endif
 #include <span>
 #include <stack>
 #include <stdbool.h>

 #include <experimental/filesystem>
 #include <experimental/forward_list>
 #include <experimental/functional>
 #include <experimental/iterator>
 #include <experimental/list>
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
-#include <experimental/simd>
 #include <experimental/set>
+#include <experimental/simd>
 #include <experimental/string>
 #include <experimental/type_traits>
 #include <experimental/unordered_map>
 #include <experimental/unordered_set>
 #include <experimental/utility>
 #include <experimental/vector>
 #endif // __cplusplus >= 201103L
 
 // extended headers
 #include <ext/hash_map>
 #include <ext/hash_set>
 
 #ifdef assert
 #error "Do not include cassert or assert.h in standard header files"
 #endif

libcxx/test/std/thread/thread.semaphore/timed.pass.cpp

 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 
 // <semaphore>
 
 #include <semaphore>
 #include <thread>
 #include <chrono>
+#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
   auto const start = std::chrono::steady_clock::now();
 

libcxx/test/std/thread/thread.semaphore/try_acquire.pass.cpp

 // XFAIL: with_system_cxx_lib=macosx10.13
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 
 // <semaphore>
 
+#include <cassert>
 #include <semaphore>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {