[pstl] Indent preprocessor directives as part of the clang-format rules

[ldionne]

Summary

Indenting preprocessor directives provides a significant gain in
readability. We do it for normal if statements, and it makes sense
to do it for preprocessor ifs too.

[MikeDvorskiy]

a significant gain in readability

To tell the truth, I guess it is subjectively... and rather it is a question of habit IMHO...

Or this style is accepted for libcxx and libcstd and we have to do it for making code consistent ? If yes, I have no objections.

[ldionne]

In D59767#1442829, @MikeDvorskiy wrote:

a significant gain in readability

To tell the truth, I guess it is subjectively... and rather it is a question of habit IMHO...

Why do we indent normal if statements? This isn't true for all libraries, but a base library like the standard library tends to have so much preprocessor-level logic that things become really hard to grasp when things are not indented properly. Again, to be clear, it's not about the cuteness of indenting inside a single #if, it's about how to spot matching #endifs when deeply nested.

Or this style is accepted for libcxx and libcstd and we have to do it for making code consistent ? If yes, I have no objections.

libc++ doesn't do this consistently and this has been a source of confusion in the past, in __config where there are many nested #ifs.

[dexonsmith]

I'm in favour of this.

In D59767#1442908, @ldionne wrote:

libc++ doesn't do this consistently and this has been a source of confusion in the past, in __config where there are many nested #ifs.

Seems like something we could/should add to libcxx as well then. Might even be acceptable to do in an en masse change there.

[rodgert]

I am also in favor of this.

@dexonsmith - libstdc++ also indents it's conditional definitions

Is this something clang-format can mechanically apply?

pstl/trunk/.clang-format

 AlwaysBreakAfterReturnType: All
 PointerAlignment: Left
 AllowShortIfStatementsOnASingleLine: false
 BreakBeforeBraces: Allman
 
 # Disable formatting options which may break tests.
 SortIncludes: false
 ReflowComments: false
+
+# Indent preprocessor directives
+IndentPPDirectives: AfterHash

pstl/trunk/include/pstl/algorithm

 // -*- C++ -*-
 //===-- algorithm ---------------------------------------------------------===//
 //
 // 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 __PSTL_algorithm
 #define __PSTL_algorithm
 
 #include "internal/pstl_config.h"
 
 #if __PSTL_EXECUTION_POLICIES_DEFINED
 // If <execution> has already been included, pull in implementations
-#include "internal/glue_algorithm_impl.h"
+#    include "internal/glue_algorithm_impl.h"
 #else
 // Otherwise just pull in forward declarations
-#include "internal/glue_algorithm_defs.h"
-#define __PSTL_ALGORITHM_FORWARD_DECLARED 1
+#    include "internal/glue_algorithm_defs.h"
+#    define __PSTL_ALGORITHM_FORWARD_DECLARED 1
 #endif
 
 #endif /* __PSTL_algorithm */

pstl/trunk/include/pstl/execution

 #define __PSTL_execution
 
 #include "internal/pstl_config.h"
 #include "internal/execution_defs.h"
 
 #define __PSTL_EXECUTION_POLICIES_DEFINED 1
 
 #if __PSTL_ALGORITHM_FORWARD_DECLARED
-#include "internal/glue_algorithm_impl.h"
+#    include "internal/glue_algorithm_impl.h"
 #endif
 
 #if __PSTL_MEMORY_FORWARD_DECLARED
-#include "internal/glue_memory_impl.h"
+#    include "internal/glue_memory_impl.h"
 #endif
 
 #if __PSTL_NUMERIC_FORWARD_DECLARED
-#include "internal/glue_numeric_impl.h"
+#    include "internal/glue_numeric_impl.h"
 #endif
 
 #if __PSTL_CPP17_EXECUTION_POLICIES_PRESENT
 __PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution")
 #else
-#include "internal/glue_execution_defs.h"
+#    include "internal/glue_execution_defs.h"
 __PSTL_PRAGMA_MESSAGE_POLICIES(
     "The <Parallel STL> execution policies are injected into the standard namespace std::execution")
 #endif
 
 //TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of
 // standard C++ library
 namespace pstl
 {
 namespace execution
 {
 using namespace __pstl::execution;
 }
 }
 
 #endif /* __PSTL_execution */

pstl/trunk/include/pstl/internal/algorithm_impl.h

 #include <algorithm>
 
 #include "execution_impl.h"
 #include "memory_impl.h"
 #include "parallel_backend_utils.h"
 #include "unseq_backend_simd.h"
 
 #if __PSTL_USE_PAR_POLICIES
-#include "parallel_backend.h"
-#include "parallel_impl.h"
+#    include "parallel_backend.h"
+#    include "parallel_impl.h"
 #endif
 
 namespace __pstl
 {
 namespace __internal
 {
 
 //------------------------------------------------------------------------
return __internal::__except_handler([&]() {
             __par_backend::__parallel_stable_sort(
                 std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp,
                 [__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j,
                                                   _Compare __comp) {
                     _ForwardIterator __i1 = __first + (__i - __d_first);
                     _ForwardIterator __j1 = __first + (__j - __d_first);
 
                 // 1. Copy elements from input to output
-#if !__PSTL_ICC_18_OMP_SIMD_BROKEN
+#    if !__PSTL_ICC_18_OMP_SIMD_BROKEN
                     __internal::__brick_copy(__i1, __j1, __i, __is_vector);
-#else
+#    else
                     std::copy(__i1, __j1, __i);
-#endif
+#    endif
                     // 2. Sort elements in output sequence
                     std::sort(__i, __j, __comp);
                 },
                 __n1);
             return __d_first + __n1;
         }
         else
         {

pstl/trunk/include/pstl/internal/glue_execution_defs.h

 
 #include "execution_defs.h"
 
 namespace std
 {
 // Type trait
 using __pstl::execution::is_execution_policy;
 #if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
-#if __INTEL_COMPILER
+#    if __INTEL_COMPILER
 template <class T>
 constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
-#else
+#    else
 using __pstl::execution::is_execution_policy_v;
-#endif
+#    endif
 #endif
 
 namespace execution
 {
 // Standard C++ policy classes
 using __pstl::execution::sequenced_policy;
 #if __PSTL_USE_PAR_POLICIES
 using __pstl::execution::parallel_policy;

pstl/trunk/include/pstl/internal/numeric_impl.h

 #include <type_traits>
 #include <numeric>
 
 #include "execution_impl.h"
 #include "unseq_backend_simd.h"
 #include "algorithm_fwd.h"
 
 #if __PSTL_USE_PAR_POLICIES
-#include "parallel_backend.h"
+#    include "parallel_backend.h"
 #endif
 
 namespace __pstl
 {
 namespace __internal
 {
 
 //------------------------------------------------------------------------

pstl/trunk/include/pstl/internal/parallel_backend.h

 // -*- C++ -*-
 //===-- parallel_backend.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 __PSTL_parallel_backend_H
 #define __PSTL_parallel_backend_H
 
 #if __PSTL_PAR_BACKEND_TBB
-#include "parallel_backend_tbb.h"
+#    include "parallel_backend_tbb.h"
 #else
 __PSTL_PRAGMA_MESSAGE("Parallel backend was not specified");
 #endif
 
 #endif /* __PSTL_parallel_backend_H */

pstl/trunk/include/pstl/internal/parallel_backend_tbb.h

 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 #include <tbb/parallel_scan.h>
 #include <tbb/parallel_invoke.h>
 #include <tbb/task_arena.h>
 #include <tbb/tbb_allocator.h>
 
 #if TBB_INTERFACE_VERSION < 10000
-#error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.
+#    error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.
 #endif
 
 namespace __pstl
 {
 namespace __par_backend
 {
 
 //! Raw memory buffer with automatic freeing and no exceptions.

pstl/trunk/include/pstl/internal/pstl_config.h

 #define __PSTL_config_H
 
 #define PSTL_VERSION 203
 #define PSTL_VERSION_MAJOR (PSTL_VERSION / 100)
 #define PSTL_VERSION_MINOR (PSTL_VERSION - PSTL_VERSION_MAJOR * 100)
 
 // Check the user-defined macro for parallel policies
 #if defined(PSTL_USE_PARALLEL_POLICIES)
-#undef __PSTL_USE_PAR_POLICIES
-#define __PSTL_USE_PAR_POLICIES PSTL_USE_PARALLEL_POLICIES
+#    undef __PSTL_USE_PAR_POLICIES
+#    define __PSTL_USE_PAR_POLICIES PSTL_USE_PARALLEL_POLICIES
 // Check the internal macro for parallel policies
 #elif !defined(__PSTL_USE_PAR_POLICIES)
-#define __PSTL_USE_PAR_POLICIES 1
+#    define __PSTL_USE_PAR_POLICIES 1
 #endif
 
 #if __PSTL_USE_PAR_POLICIES
-#if !defined(__PSTL_PAR_BACKEND_TBB)
-#define __PSTL_PAR_BACKEND_TBB 1
-#endif
+#    if !defined(__PSTL_PAR_BACKEND_TBB)
+#        define __PSTL_PAR_BACKEND_TBB 1
+#    endif
 #else
-#undef __PSTL_PAR_BACKEND_TBB
+#    undef __PSTL_PAR_BACKEND_TBB
 #endif
 
 // Check the user-defined macro for warnings
 #if defined(PSTL_USAGE_WARNINGS)
-#undef __PSTL_USAGE_WARNINGS
-#define __PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS
+#    undef __PSTL_USAGE_WARNINGS
+#    define __PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS
 // Check the internal macro for warnings
 #elif !defined(__PSTL_USAGE_WARNINGS)
-#define __PSTL_USAGE_WARNINGS 0
+#    define __PSTL_USAGE_WARNINGS 0
 #endif
 
 // Portability "#pragma" definition
 #ifdef _MSC_VER
-#define __PSTL_PRAGMA(x) __pragma(x)
+#    define __PSTL_PRAGMA(x) __pragma(x)
 #else
-#define __PSTL_PRAGMA(x) _Pragma(#x)
+#    define __PSTL_PRAGMA(x) _Pragma(#    x)
 #endif
 
 #define __PSTL_STRING_AUX(x) #x
 #define __PSTL_STRING(x) __PSTL_STRING_AUX(x)
 #define __PSTL_STRING_CONCAT(x, y) x #y
 
 // note that when ICC or Clang is in use, __PSTL_GCC_VERSION might not fully match
 // the actual GCC version on the system.
 #define __PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 
 #if __clang__
 // according to clang documentation, version can be vendor specific
-#define __PSTL_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+#    define __PSTL_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
 #endif
 
 // Enable SIMD for compilers that support OpenMP 4.0
 #if (_OPENMP >= 201307) || (__INTEL_COMPILER >= 1600) || (!defined(__INTEL_COMPILER) && __PSTL_GCC_VERSION >= 40900)
-#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 __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))
 #elif !defined(_MSC_VER) //#pragma simd
-#define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(simd)
-#define __PSTL_PRAGMA_DECLARE_SIMD
-#define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(simd reduction(PRM))
+#    define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(simd)
+#    define __PSTL_PRAGMA_DECLARE_SIMD
+#    define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(simd reduction(PRM))
 #else //no simd
-#define __PSTL_PRAGMA_SIMD
-#define __PSTL_PRAGMA_DECLARE_SIMD
-#define __PSTL_PRAGMA_SIMD_REDUCTION(PRM)
+#    define __PSTL_PRAGMA_SIMD
+#    define __PSTL_PRAGMA_DECLARE_SIMD
+#    define __PSTL_PRAGMA_SIMD_REDUCTION(PRM)
 #endif //Enable SIMD
 
 #if (__INTEL_COMPILER)
-#define __PSTL_PRAGMA_FORCEINLINE __PSTL_PRAGMA(forceinline)
+#    define __PSTL_PRAGMA_FORCEINLINE __PSTL_PRAGMA(forceinline)
 #else
-#define __PSTL_PRAGMA_FORCEINLINE
+#    define __PSTL_PRAGMA_FORCEINLINE
 #endif
 
 #if (__INTEL_COMPILER >= 1900)
-#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_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))
 #else
-#define __PSTL_PRAGMA_SIMD_SCAN(PRM)
-#define __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
-#define __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
+#    define __PSTL_PRAGMA_SIMD_SCAN(PRM)
+#    define __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
+#    define __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
 #endif
 
 // Should be defined to 1 for environments with a vendor implementation of C++17 execution policies
 #define __PSTL_CPP17_EXECUTION_POLICIES_PRESENT (_MSC_VER >= 1912)
 
 #define __PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT                                                                     \
     (_MSC_VER >= 1900 || __cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304)
 #define __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT                                                                     \
     (_MSC_VER >= 1900 || __cplusplus >= 201402L || __cpp_lib_make_reverse_iterator == 201402)
 #define __PSTL_CPP14_INTEGER_SEQUENCE_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201402L)
 #define __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT                                                                        \
     (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700) && (_MSC_FULL_VER >= 190023918 || __cplusplus >= 201402L)
 
 #define __PSTL_EARLYEXIT_PRESENT (__INTEL_COMPILER >= 1800)
 #define __PSTL_MONOTONIC_PRESENT (__INTEL_COMPILER >= 1800)
 
 #if (__INTEL_COMPILER >= 1900 || !defined(__INTEL_COMPILER) && __PSTL_GCC_VERSION >= 40900 || _OPENMP >= 201307)
-#define __PSTL_UDR_PRESENT 1
+#    define __PSTL_UDR_PRESENT 1
 #else
-#define __PSTL_UDR_PRESENT 0
+#    define __PSTL_UDR_PRESENT 0
 #endif
 
 #define __PSTL_UDS_PRESENT (__INTEL_COMPILER >= 1900 && __INTEL_COMPILER_BUILD_DATE >= 20180626)
 
 #if __PSTL_EARLYEXIT_PRESENT
-#define __PSTL_PRAGMA_SIMD_EARLYEXIT __PSTL_PRAGMA(omp simd early_exit)
+#    define __PSTL_PRAGMA_SIMD_EARLYEXIT __PSTL_PRAGMA(omp simd early_exit)
 #else
-#define __PSTL_PRAGMA_SIMD_EARLYEXIT
+#    define __PSTL_PRAGMA_SIMD_EARLYEXIT
 #endif
 
 #if __PSTL_MONOTONIC_PRESENT
-#define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) __PSTL_PRAGMA(omp ordered simd monotonic(PRM))
-#define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) __PSTL_PRAGMA(omp ordered simd monotonic(PRM1, PRM2))
+#    define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) __PSTL_PRAGMA(omp ordered simd monotonic(PRM))
+#    define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) __PSTL_PRAGMA(omp ordered simd monotonic(PRM1, PRM2))
 #else
-#define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM)
-#define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2)
+#    define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM)
+#    define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2)
 #endif
 
 // 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)                                                                      \
-    __PSTL_PRAGMA(omp declare reduction(NAME : OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
+    __PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
 
 #if (__INTEL_COMPILER >= 1600)
-#define __PSTL_PRAGMA_VECTOR_UNALIGNED __PSTL_PRAGMA(vector unaligned)
+#    define __PSTL_PRAGMA_VECTOR_UNALIGNED __PSTL_PRAGMA(vector unaligned)
 #else
-#define __PSTL_PRAGMA_VECTOR_UNALIGNED
+#    define __PSTL_PRAGMA_VECTOR_UNALIGNED
 #endif
 
 // Check the user-defined macro to use non-temporal stores
 #if defined(PSTL_USE_NONTEMPORAL_STORES) && (__INTEL_COMPILER >= 1600)
-#define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED __PSTL_PRAGMA(vector nontemporal)
+#    define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED __PSTL_PRAGMA(vector nontemporal)
 #else
-#define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
+#    define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
 #endif
 
 #if _MSC_VER || __INTEL_COMPILER //the preprocessors don't type a message location
-#define __PSTL_PRAGMA_LOCATION __FILE__ ":" __PSTL_STRING(__LINE__) ": [Parallel STL message]: "
+#    define __PSTL_PRAGMA_LOCATION __FILE__ ":" __PSTL_STRING(__LINE__) ": [Parallel STL message]: "
 #else
-#define __PSTL_PRAGMA_LOCATION " [Parallel STL message]: "
+#    define __PSTL_PRAGMA_LOCATION " [Parallel STL message]: "
 #endif
 
 #define __PSTL_PRAGMA_MESSAGE_IMPL(x) __PSTL_PRAGMA(message(__PSTL_STRING_CONCAT(__PSTL_PRAGMA_LOCATION, x)))
 
 #if __PSTL_USAGE_WARNINGS
-#define __PSTL_PRAGMA_MESSAGE(x) __PSTL_PRAGMA_MESSAGE_IMPL(x)
-#define __PSTL_PRAGMA_MESSAGE_POLICIES(x) __PSTL_PRAGMA_MESSAGE_IMPL(x)
+#    define __PSTL_PRAGMA_MESSAGE(x) __PSTL_PRAGMA_MESSAGE_IMPL(x)
+#    define __PSTL_PRAGMA_MESSAGE_POLICIES(x) __PSTL_PRAGMA_MESSAGE_IMPL(x)
 #else
-#define __PSTL_PRAGMA_MESSAGE(x)
-#define __PSTL_PRAGMA_MESSAGE_POLICIES(x)
+#    define __PSTL_PRAGMA_MESSAGE(x)
+#    define __PSTL_PRAGMA_MESSAGE_POLICIES(x)
 #endif
 
 // broken macros
 #define __PSTL_CPP11_STD_ROTATE_BROKEN ((__GLIBCXX__ && __GLIBCXX__ < 20150716) || (_MSC_VER && _MSC_VER < 1800))
 
 #define __PSTL_ICC_18_OMP_SIMD_BROKEN (__INTEL_COMPILER == 1800)
 
 #endif /* __PSTL_config_H */

pstl/trunk/include/pstl/memory

 // -*- C++ -*-
 //===-- memory ------------------------------------------------------------===//
 //
 // 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 __PSTL_memory
 #define __PSTL_memory
 
 #include "internal/pstl_config.h"
 
 #if __PSTL_EXECUTION_POLICIES_DEFINED
 // If <execution> has already been included, pull in implementations
-#include "internal/glue_memory_impl.h"
+#    include "internal/glue_memory_impl.h"
 #else
 // Otherwise just pull in forward declarations
-#include "internal/glue_memory_defs.h"
-#define __PSTL_MEMORY_FORWARD_DECLARED 1
+#    include "internal/glue_memory_defs.h"
+#    define __PSTL_MEMORY_FORWARD_DECLARED 1
 #endif
 
 #endif /* __PSTL_memory */

pstl/trunk/include/pstl/numeric

 // -*- C++ -*-
 //===-- numeric -----------------------------------------------------------===//
 //
 // 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 __PSTL_numeric
 #define __PSTL_numeric
 
 #include "internal/pstl_config.h"
 
 #if __PSTL_EXECUTION_POLICIES_DEFINED
 // If <execution> has already been included, pull in implementations
-#include "internal/glue_numeric_impl.h"
+#    include "internal/glue_numeric_impl.h"
 #else
 // Otherwise just pull in forward declarations
-#include "internal/glue_numeric_defs.h"
-#define __PSTL_NUMERIC_FORWARD_DECLARED 1
+#    include "internal/glue_numeric_defs.h"
+#    define __PSTL_NUMERIC_FORWARD_DECLARED 1
 #endif
 
 #endif /* __PSTL_numeric */