[libc++] Normalize all our '#pragma GCC system_header', and regression-test.

[• Quuxplusone]

Summary

Now we'll notice if a header forgets to include this magic phrase.

(I'm sympathetic to the argument that we should add a new linter test for each different check, instead of piggybacking every check into lint_headers.py (which we could rename to indicate that it checks nothing but include-ordering). However, I don't think we've reached the tipping point of complexity yet. :))

[jloser]

libcxx/test/libcxx/lint/lint_headers.sh.py

46

Nit: I think we rely on python3 exclusively now, so we could make this a Python3 f-string which I think is nicer. Thoughts? I hear the argument that this is consistent with the rest of the file (because it was mostly written when we only supported Python2).

[• Quuxplusone]

libcxx/test/libcxx/lint/lint_headers.sh.py

46

I hear the argument that this is consistent with the rest of the file (because it was mostly written when we only supported Python2).

Actually it was written very recently, but by an old curmudgeon who likes printf. Between these options

• print('foo/%s!' % pretty(x))
• print('foo/{}!'.format(pretty(x)))
• print(f'foo/{pretty(x)}!')

I'm personally inclined to favor #1, just for readability's sake... although I suspect I'm on the losing side of history on this one. ;)

[jloser]

libcxx/test/libcxx/lint/lint_headers.sh.py

46

Ah yes, how could I forget it was written by you last month? :)

I prefer option 3 with the f-string, but maybe I'm just a new-school Python guy. If we care to update these kinds of things, we can use some tool (maybe Black or Ale or something) to fix (and maybe even enforce if we care) "modern" use, so don't feel obligated to do anything in this PR.

[ldionne]

This LGTM, but I care strongly that we indent nested preprocessor directives. This is not different from indenting normal if-else chains.

In a 3-line #if, this is not so bad, however when we start having complicated nested conditions like we do in __config, it's basically impossible to read unless things are indented properly.

[Mordante]

Let's first agree on how the we want to format #pragma GCC system_header\n.

libcxx/include/__format/formatter_pointer.h

27

The spaces in the #if is something we recently changed in the .clang-format file on @ldionne's request https://reviews.llvm.org/D103368#inline-1043939. So I would prefer to keep it that way. If we agree to remove the spaces, please also update the .clang-format. I know we don't use clang-format, but I've been using it in the formatter code since its inception and I prefer to keep using it.

[• Quuxplusone]

libcxx/include/__format/formatter_pointer.h

27

@ldionne, do you want me to change just these few files, or do you want me to change all the rest of the files? I can go either way; it's a simple sed command to change all of them. Personally I'd rather touch the fewest files, because to me the extra couple of whitespaces cost 2 bytes per file and buy literally nothing; but I can sed them all if we want.

What I won't do in this PR is introduce inconsistency. For example, I'm not going to start adding # pragma directives to some files while other files still contain ordinary #pragma directives.

[Mordante]

libcxx/include/__format/formatter_pointer.h

27

I agree, I too don't want inconsistencies! When we want to remove the spaces, then lets also revert the .clang-format patch that adds these spaces. I don't have a strong opinion on whether or not to add spaces.

[ldionne]

LGTM with spaces consistently on all pragmas.

libcxx/include/__format/formatter_pointer.h

27

Let's add the spaces in this PR too.

because to me the extra couple of whitespaces cost 2 bytes per file and buy literally nothing

Do you indent your ifs? Of course, you do. Why?

[• Quuxplusone]

git grep -l 'pragma GCC system_header' ../libcxx/include/ | xargs sed -i -e 's/#pragma GCC system_header/# pragma GCC system_header/'

@ldionne @Mordante LGTY?

[Mordante]

Thanks for the cleanup, LGTM.

libcxx/test/libcxx/lint/lint_headers.sh.py

46

I suggest this change to match the search string.

libcxx/include/__availability

 // -*- 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___AVAILABILITY
 #define _LIBCPP___AVAILABILITY
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#   pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 // Libc++ is shipped by various vendors. In particular, it is used as a system
 // library on macOS, iOS and other Apple platforms. In order for users to be
 // able to compile a binary that is intended to be deployed to an older version
 // of a platform, Clang provides availability attributes [1]. These attributes
 // can be placed on declarations and are used to describe the life cycle of a
 // symbol in the library.

libcxx/include/__bit/byteswap.h

 #define _LIBCPP___BIT_BYTESWAP_H
 
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <cstdint>
 #include <cstdlib>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 template <integral _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept {

libcxx/include/__filesystem/copy_options.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___FILESYSTEM_COPY_OPTIONS_H
 #define _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
 
 #include <__availability>
 #include <__config>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
   none = 0,

libcxx/include/__filesystem/directory_entry.h

 #include <__filesystem/path.h>
 #include <__filesystem/perms.h>
 #include <chrono>
 #include <cstdint>
 #include <cstdlib>
 #include <iosfwd>
 #include <system_error>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH

libcxx/include/__filesystem/directory_iterator.h

 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <cstddef>
 #include <system_error>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 class _LIBCPP_HIDDEN __dir_stream;
 class directory_iterator {

libcxx/include/__filesystem/directory_options.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___FILESYSTEM_DIRECTORY_OPTIONS_H
 #define _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
 
 #include <__availability>
 #include <__config>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
   none = 0,

libcxx/include/__filesystem/file_status.h

 #ifndef _LIBCPP___FILESYSTEM_FILE_STATUS_H
 #define _LIBCPP___FILESYSTEM_FILE_STATUS_H
 
 #include <__availability>
 #include <__config>
 #include <__filesystem/file_type.h>
 #include <__filesystem/perms.h>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 class _LIBCPP_TYPE_VIS file_status {
 public:

libcxx/include/__filesystem/file_time_type.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___FILESYSTEM_FILE_TIME_TYPE_H
 #define _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
 
 #include <__availability>
 #include <__config>
 #include <chrono>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 typedef chrono::time_point<_FilesystemClock> file_time_type;
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H

libcxx/include/__filesystem/file_type.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___FILESYSTEM_FILE_TYPE_H
 #define _LIBCPP___FILESYSTEM_FILE_TYPE_H
 
 #include <__availability>
 #include <__config>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 // On Windows, the library never identifies files as block, character, fifo
 // or socket.
 enum class _LIBCPP_ENUM_VIS file_type : signed char {
   none = 0,

libcxx/include/__filesystem/filesystem_error.h

 #include <__config>
 #include <__filesystem/path.h>
 #include <__memory/shared_ptr.h>
 #include <iosfwd>
 #include <new>
 #include <system_error>
 #include <type_traits>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, error_code __ec)

libcxx/include/__filesystem/operations.h

 #include <__filesystem/path.h>
 #include <__filesystem/perm_options.h>
 #include <__filesystem/perms.h>
 #include <__filesystem/space_info.h>
 #include <chrono>
 #include <cstdint>
 #include <system_error>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 _LIBCPP_FUNC_VIS path __absolute(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS path __canonical(const path&, error_code* __ec = nullptr);

libcxx/include/__filesystem/path.h

 #include <string_view>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 # include <iomanip> // for quoted
 # include <locale>
 #endif
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 template <class _Tp>
 struct __can_convert_char {

libcxx/include/__filesystem/path_iterator.h

 #include <__config>
 #include <__debug>
 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <cstddef>
 #include <string>
 #include <string_view>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 class _LIBCPP_TYPE_VIS path::iterator {
 public:

libcxx/include/__filesystem/perm_options.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___FILESYSTEM_PERM_OPTIONS_H
 #define _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
 
 #include <__availability>
 #include <__config>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
   replace = 1,

libcxx/include/__filesystem/perms.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___FILESYSTEM_PERMS_H
 #define _LIBCPP___FILESYSTEM_PERMS_H
 
 #include <__availability>
 #include <__config>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 // On Windows, these permission bits map to one single readonly flag per
 // file, and the executable bit is always returned as set. When setting

libcxx/include/__filesystem/recursive_directory_iterator.h

 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <cstddef>
 #include <system_error>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 class recursive_directory_iterator {
 public:

libcxx/include/__filesystem/space_info.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___FILESYSTEM_SPACE_INFO_H
 #define _LIBCPP___FILESYSTEM_SPACE_INFO_H
 
 #include <__availability>
 #include <__config>
 #include <cstdint>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 struct _LIBCPP_TYPE_VIS space_info {
   uintmax_t capacity;

libcxx/include/__filesystem/u8path.h

 #ifndef _LIBCPP___FILESYSTEM_U8PATH_H
 #define _LIBCPP___FILESYSTEM_U8PATH_H
 
 #include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <type_traits>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 template <class _InputIt>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T

libcxx/include/__format/format_to_n_result.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_TO_N_RESULT_H
 #define _LIBCPP___FORMAT_FORMAT_TO_N_RESULT_H
 
 #include <__config>
 #include <__iterator/incrementable_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // TODO FMT Remove this once we require compilers with proper C++20 support.
 // If the compiler has no concepts support, the format header will be disabled.

libcxx/include/__format/formatter_floating_point.h

 #include <charconv>
 #include <cmath>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #  include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__format/formatter_pointer.h

 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/parser_std_format_spec.h>
 #include <__iterator/access.h>
 #include <__nullptr>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // TODO FMT Remove this once we require compilers with proper C++20 support.
 // If the compiler has no concepts support, the format header will be disabled.

libcxx/include/__format/parser_std_format_spec.h

 #include <__format/format_string.h>
 #include <__variant/monostate.h>
 #include <bit>
 #include <concepts>
 #include <cstdint>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-# pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__iterator/indirectly_comparable.h

 #ifndef _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H
 #define _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H
 
 #include <__config>
 #include <__functional/identity.h>
 #include <__iterator/concepts.h>
 #include <__iterator/projected.h>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 template <class _I1, class _I2, class _Rp, class _P1 = identity, class _P2 = identity>
 concept indirectly_comparable =
   indirect_binary_predicate<_Rp, projected<_I1, _P1>, projected<_I2, _P2>>;
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H

libcxx/include/__memory/voidify.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_VOIDIFY_H
 #define _LIBCPP___MEMORY_VOIDIFY_H
 
 #include <__config>
 #include <__memory/addressof.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <typename _Tp>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void* __voidify(_Tp& __from) {
   // Cast away cv-qualifiers to allow modifying elements of a range through const iterators.
   return const_cast<void*>(static_cast<const volatile void*>(_VSTD::addressof(__from)));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_VOIDIFY_H

libcxx/include/__numeric/adjacent_difference.h

 #ifndef _LIBCPP___NUMERIC_ADJACENT_DIFFERENCE_H
 #define _LIBCPP___NUMERIC_ADJACENT_DIFFERENCE_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)

libcxx/include/__numeric/exclusive_scan.h

 #ifndef _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H
 #define _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H
 
 #include <__config>
 #include <__functional/operations.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator

libcxx/include/__numeric/gcd_lcm.h

 #define _LIBCPP___NUMERIC_GCD_LCM_H
 
 #include <__config>
 #include <__debug>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__numeric/inclusive_scan.h

 #define _LIBCPP___NUMERIC_INCLUSIVE_SCAN_H
 
 #include <__config>
 #include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator

libcxx/include/__numeric/iota.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___NUMERIC_IOTA_H
 #define _LIBCPP___NUMERIC_IOTA_H
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value_)
 {
     for (; __first != __last; ++__first, (void) ++__value_)
         *__first = __value_;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___NUMERIC_IOTA_H

libcxx/include/__numeric/midpoint.h

 #ifndef _LIBCPP___NUMERIC_MIDPOINT_H
 #define _LIBCPP___NUMERIC_MIDPOINT_H
 
 #include <__config>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__numeric/partial_sum.h

 #ifndef _LIBCPP___NUMERIC_PARTIAL_SUM_H
 #define _LIBCPP___NUMERIC_PARTIAL_SUM_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)

libcxx/include/__numeric/reduce.h

 #ifndef _LIBCPP___NUMERIC_REDUCE_H
 #define _LIBCPP___NUMERIC_REDUCE_H
 
 #include <__config>
 #include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _Tp, class _BinaryOp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp reduce(_InputIterator __first, _InputIterator __last,
                                                                    _Tp __init, _BinaryOp __b) {

libcxx/include/__numeric/transform_exclusive_scan.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___NUMERIC_TRANSFORM_EXCLUSIVE_SCAN_H
 #define _LIBCPP___NUMERIC_TRANSFORM_EXCLUSIVE_SCAN_H
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _InputIterator, class _OutputIterator, class _Tp,
           class _BinaryOp, class _UnaryOp>

libcxx/include/__numeric/transform_inclusive_scan.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___NUMERIC_TRANSFORM_INCLUSIVE_SCAN_H
 #define _LIBCPP___NUMERIC_TRANSFORM_INCLUSIVE_SCAN_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

libcxx/include/__numeric/transform_reduce.h

 #ifndef _LIBCPP___NUMERIC_TRANSFORM_REDUCE_H
 #define _LIBCPP___NUMERIC_TRANSFORM_REDUCE_H
 
 #include <__config>
 #include <__functional/operations.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp transform_reduce(_InputIterator __first,
                                                                              _InputIterator __last, _Tp __init,

libcxx/include/locale.h

 
 #include <__config>
 
 #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   error "The Localization library is not supported since libc++ has been configured with LIBCXX_ENABLE_LOCALIZATION disabled"
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#   pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 #include_next <locale.h>
 
 #endif // _LIBCPP_LOCALE_H

libcxx/test/libcxx/lint/lint_headers.sh.py

 # RUN: %{python} %s
 
 # Verify that each run of consecutive #include directives
 # in each libcxx/include/ header is maintained in alphabetical order.
 
 import glob
 import os
 import re
 
 
 def exclude_from_consideration(path):
     return (
         path.endswith('.txt') or
         path.endswith('.modulemap') or
         os.path.basename(path) == '__config' or
+        os.path.basename(path) == '__config_site.in' or
+        os.path.basename(path) == '__libcpp_version' or
         os.path.basename(path) == '__locale' or
         not os.path.isfile(path)
     )
 
 
 if __name__ == '__main__':
     libcxx_test_libcxx_lint = os.path.dirname(os.path.abspath(__file__))
     libcxx_include = os.path.abspath(os.path.join(libcxx_test_libcxx_lint, '../../../include'))
     assert os.path.isdir(libcxx_include)
 
     def pretty(path):
         return path[len(libcxx_include) + 1:]
 
     all_headers = [
         p for p in (
             glob.glob(os.path.join(libcxx_include, '*')) +
             glob.glob(os.path.join(libcxx_include, '__*/*.h'))
         ) if not exclude_from_consideration(p)
     ]
 
     okay = True
     for fname in all_headers:
         with open(fname, 'r') as f:
             lines = f.readlines()
+
+        if '#pragma GCC system_header\n' not in lines:
+            if pretty(fname) not in ['__undef_macros']:
+                okay = False
+                print('FAILED TO FIND #pragma GCC system_header in libcxx/include/%s!' % pretty(fname))
+
         # Examine each consecutive run of #include directives.
         prevline = None
         for line in lines:
             if re.match(r'^\s*#\s*include ', line):
                 if (prevline is not None) and (line < prevline):
                     okay = False
                     print('LINES OUT OF ORDER in libcxx/include/%s!' % pretty(fname))
                     print(prevline)
                     print(line)
                 prevline = line
             else:
                 prevline = None
     assert okay