[libc++] Make sure our .clang-format is used for all languages

[ldionne]

Summary

In particular, this ensures that it is used for Objective-C and
Objective-C++, since we have a few files that get detected as that.

[Mordante]

Thanks! LGTM!

libcxx/.clang-format

72

Can you add a comment here why we don't specify the language.
Just to avoid somebody trying to fix this "omission" in the future.

[ldionne]

Rebase, address comment and reformat __config, which was not being detected as C++ anymore so wasn't getting formatted.

[ldionne]

Update ignore_format.txt

libcxx/.clang-format

 BasedOnStyle: LLVM
+# Note that we don't specify the language in this file because some files are
+# detected as Cpp, but others are detected as ObjC and we want this formatting
+# to apply to all types of files.
 
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: Consecutive
 AlignConsecutiveBitFields: Consecutive
 AlignEscapedNewlines: Right
 AlignOperands: AlignAfterOperator
 AlignTrailingComments: true
 AllowAllArgumentsOnNextLine: true

 IndentRequires: true
 InsertTrailingCommas: Wrapped
 KeepEmptyLinesAtTheStartOfBlocks: false
 MaxEmptyLinesToKeep: 1
 PackConstructorInitializers: NextLine
 
 PenaltyIndentedWhitespace: 2
 
-Language: Cpp
 Standard: c++20
 SpacesInAngles: Leave
 
 AlwaysBreakTemplateDeclarations: true
 PointerAlignment: Left
 
 
 # libc++'s preferred indentions of preprocessor statements.
 IndentPPDirectives: AfterHash
 
 # libc++ has some long names so we need more than the 80 column limit imposed by LLVM style, for sensible formatting
 ColumnLimit: 120

libcxx/include/__config

 #    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 #      define _LIBCPP_LITTLE_ENDIAN
 #    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #      define _LIBCPP_BIG_ENDIAN
 #    endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #  endif   // __BYTE_ORDER__
 
 #  ifdef __FreeBSD__
-#    include <sys/endian.h>
 #    include <osreldate.h>
+#    include <sys/endian.h>
 #    if _BYTE_ORDER == _LITTLE_ENDIAN
 #      define _LIBCPP_LITTLE_ENDIAN
 #    else // _BYTE_ORDER == _LITTLE_ENDIAN
 #      define _LIBCPP_BIG_ENDIAN
 #    endif // _BYTE_ORDER == _LITTLE_ENDIAN
 #  endif   // __FreeBSD__
 
 #  if defined(__NetBSD__) || defined(__OpenBSD__)

 // clang-format on
 
 #  define _VSTD_FS std::__fs::filesystem
 
 #  if __has_attribute(__enable_if__)
 #    define _LIBCPP_PREFERRED_OVERLOAD __attribute__((__enable_if__(true, "")))
 #  endif
 
-#if !defined(__SIZEOF_INT128__) || defined(_MSC_VER)
+#  if !defined(__SIZEOF_INT128__) || defined(_MSC_VER)
 #    define _LIBCPP_HAS_NO_INT128
 #  endif
 
 #  if __has_attribute(__malloc__)
 #    define _LIBCPP_NOALIAS __attribute__((__malloc__))
 #  else
 #    define _LIBCPP_NOALIAS
 #  endif
 
 #  if __has_attribute(__using_if_exists__)
 #    define _LIBCPP_USING_IF_EXISTS __attribute__((__using_if_exists__))
 #  else
 #    define _LIBCPP_USING_IF_EXISTS
 #  endif
 
 #  ifdef _LIBCPP_CXX03_LANG
 #    define _LIBCPP_DECLARE_STRONG_ENUM(x)                                                                             \
-      struct _LIBCPP_EXPORTED_FROM_ABI x {                                                                                      \
+      struct _LIBCPP_EXPORTED_FROM_ABI x {                                                                             \
         enum __lx
 // clang-format off
 #    define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)                                                                      \
       __lx __v_;                                                                                                       \
       _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {}                                                             \
       _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {}                                  \
       _LIBCPP_INLINE_VISIBILITY operator int() const { return __v_; }                                                  \
       };

 #  endif
 
 #  if _LIBCPP_STD_VER >= 20
 #    define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED
 #  else
 #    define _LIBCPP_DEPRECATED_IN_CXX20
 #  endif
 
-#if _LIBCPP_STD_VER >= 23
-#  define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED
-#else
-#  define _LIBCPP_DEPRECATED_IN_CXX23
-#endif
+#  if _LIBCPP_STD_VER >= 23
+#    define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED
+#  else
+#    define _LIBCPP_DEPRECATED_IN_CXX23
+#  endif
 
 #  if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #    define _LIBCPP_DEPRECATED_WITH_CHAR8_T _LIBCPP_DEPRECATED
 #  else
 #    define _LIBCPP_DEPRECATED_WITH_CHAR8_T
 #  endif
 
 // Macros to enter and leave a state where deprecation warnings are suppressed.

 
 // TODO(varconst): currently, there are bugs in Clang's intrinsics when handling Objective-C++ `id`, so don't use
 // compiler intrinsics in the Objective-C++ mode.
 #  ifdef __OBJC__
 #    define _LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS
 #  endif
 
 // TODO: Make this a proper configuration option
-#define _PSTL_PAR_BACKEND_SERIAL
+#  define _PSTL_PAR_BACKEND_SERIAL
 
-#define _PSTL_PRAGMA(x) _Pragma(#    x)
+#  define _PSTL_PRAGMA(x) _Pragma(#x)
 
 // Enable SIMD for compilers that support OpenMP 4.0
-#if (defined(_OPENMP) && _OPENMP >= 201307)
+#  if (defined(_OPENMP) && _OPENMP >= 201307)
 
-#  define _PSTL_UDR_PRESENT
-#  define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
-#  define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
-#  define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
-#  define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
-#  define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
-#  define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
+#    define _PSTL_UDR_PRESENT
+#    define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
+#    define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
+#    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
+#    define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
+#    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
+#    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
 
 // Declaration of reduction functor, where
 // NAME - the name of the functor
 // OP - type of the callable object with the reduction operation
 // omp_in - refers to the local partial result
 // omp_out - refers to the final value of the combiner operator
 // omp_priv - refers to the private copy of the initial value
 // omp_orig - refers to the original variable to be reduced
-#  define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)                                                                     \
+#    define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)                                                                   \
       _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
 
-#else // (defined(_OPENMP) && _OPENMP >= 201307)
+#  else // (defined(_OPENMP) && _OPENMP >= 201307)
 
-#  define _PSTL_PRAGMA_SIMD
-#  define _PSTL_PRAGMA_DECLARE_SIMD
-#  define _PSTL_PRAGMA_SIMD_REDUCTION(PRM)
-#  define _PSTL_PRAGMA_SIMD_SCAN(PRM)
-#  define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
-#  define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
-#  define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)
+#    define _PSTL_PRAGMA_SIMD
+#    define _PSTL_PRAGMA_DECLARE_SIMD
+#    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM)
+#    define _PSTL_PRAGMA_SIMD_SCAN(PRM)
+#    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
+#    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
+#    define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)
 
-#endif // (defined(_OPENMP) && _OPENMP >= 201307)
+#  endif // (defined(_OPENMP) && _OPENMP >= 201307)
 
-#define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
+#  define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
 
 #endif // __cplusplus
 
 #endif // _LIBCPP___CONFIG

libcxx/include/__type_traits/is_scalar.h

 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_arithmetic.h>
 #include <__type_traits/is_enum.h>
 #include <__type_traits/is_member_pointer.h>
 #include <__type_traits/is_null_pointer.h>
 #include <__type_traits/is_pointer.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
+#  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_scalar)
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp> inline constexpr bool is_scalar_v = __is_scalar(_Tp);
-#endif
+#  if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_scalar_v = __is_scalar(_Tp);
+#  endif
 
 #else // __has_builtin(__is_scalar)
 
-template <class _Tp> struct __is_block : false_type {};
-#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
+template <class _Tp>
+struct __is_block : false_type {};
+#  if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
 template <class _Rp, class... _Args>
 struct __is_block<_Rp (^)(_Args...)> : true_type {};
-#endif
+#  endif
 
 // clang-format off
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_scalar
     : public integral_constant<
           bool, is_arithmetic<_Tp>::value ||
                 is_member_pointer<_Tp>::value ||
                 is_pointer<_Tp>::value ||
                 __is_nullptr_t<_Tp>::value ||
                 __is_block<_Tp>::value ||
                 is_enum<_Tp>::value> {};
 // clang-format on
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
 
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp> inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
-#endif
+#  if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+#  endif
 
 #endif // __has_builtin(__is_scalar)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_SCALAR_H