[libc++] Remove trailing whitespace from libcxx includes, source and tests

[ldionne]

Rebase

[var-const]

This is great!

[philnik]

Thanks!

[ldionne]

Also exclude from libcxx/benchmarks

[Mordante]

Thanks for working on this, LGTM!

libcxx/include/__algorithm/ranges_merge.h

template <
       class _Proj1 = identity,
       class _Proj2 = identity>
     requires mergeable<
         iterator_t<_Range1>,
         iterator_t<_Range2>,
         _OutIter,
         _Comp,
         _Proj1,
-        _Proj2> 
+        _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr merge_result<borrowed_iterator_t<_Range1>, borrowed_iterator_t<_Range2>, _OutIter>
         operator()(
             _Range1&& __range1,
             _Range2&& __range2,
             _OutIter __result,
             _Comp __comp   = {},
             _Proj1 __proj1 = {},
             _Proj2 __proj2 = {}) const {

libcxx/include/__algorithm/ranges_set_difference.h

struct __fn {
 
   template <
       input_range _Range1,
       input_range _Range2,
       weakly_incrementable _OutIter,
       class _Comp  = less,
       class _Proj1 = identity,
       class _Proj2 = identity>
-    requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2> 
+    requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_difference_result<borrowed_iterator_t<_Range1>, _OutIter>
     operator()(
         _Range1&& __range1,
         _Range2&& __range2,
         _OutIter __result,
         _Comp __comp   = {},
         _Proj1 __proj1 = {},
         _Proj2 __proj2 = {}) const {

libcxx/include/__algorithm/ranges_set_intersection.h

template <
       class _Proj1 = identity,
       class _Proj2 = identity>
     requires mergeable<
         iterator_t<_Range1>,
         iterator_t<_Range2>,
         _OutIter,
         _Comp,
         _Proj1,
-        _Proj2> 
+        _Proj2>
     _LIBCPP_HIDE_FROM_ABI constexpr set_intersection_result<borrowed_iterator_t<_Range1>,
                                                             borrowed_iterator_t<_Range2>,
                                                             _OutIter>
     operator()(
         _Range1&& __range1,
         _Range2&& __range2,
         _OutIter __result,
         _Comp __comp   = {},

libcxx/include/__algorithm/ranges_set_symmetric_difference.h

template <
       class _Proj1 = identity,
       class _Proj2 = identity>
     requires mergeable<
         iterator_t<_Range1>,
         iterator_t<_Range2>,
         _OutIter,
         _Comp,
         _Proj1,
-        _Proj2> 
+        _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_symmetric_difference_result<borrowed_iterator_t<_Range1>,
                                                                   borrowed_iterator_t<_Range2>,
                                                                   _OutIter>
     operator()(
         _Range1&& __range1,
         _Range2&& __range2,
         _OutIter __result,
         _Comp __comp   = {},

libcxx/include/__algorithm/ranges_set_union.h

template <
       class _Proj1 = identity,
       class _Proj2 = identity>
     requires mergeable<
         iterator_t<_Range1>,
         iterator_t<_Range2>,
         _OutIter,
         _Comp,
         _Proj1,
-        _Proj2> 
+        _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_union_result<borrowed_iterator_t<_Range1>,
                                                    borrowed_iterator_t<_Range2>,
                                                    _OutIter>
     operator()(
         _Range1&& __range1,
         _Range2&& __range2,
         _OutIter __result,
         _Comp __comp   = {},

libcxx/include/__support/solaris/xlocale.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long
 strtol_l(const char *__nptr, char **__endptr, int __base, locale_t __loc) {
   return ::strtol(__nptr, __endptr, __base);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI unsigned long long
-strtoull_l(const char *__nptr, char **__endptr, int __base, locale_t __loc) 
+strtoull_l(const char *__nptr, char **__endptr, int __base, locale_t __loc)
   return ::strtoull(__nptr, __endptr, __base);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI unsigned long
 strtoul_l(const char *__nptr, char **__endptr, int __base, locale_t __loc) {
   return ::strtoul(__nptr, __endptr, __base);
 }
 

libcxx/include/new

private:
 
   bad_alloc(char const* const __message) noexcept : exception(__message) {}
 };
 
 class bad_array_new_length : public bad_alloc {
 public:
   bad_array_new_length() noexcept : bad_alloc("bad array new length") {}
 };
-#endif // defined(_LIBCPP_ABI_VCRUNTIME) && defined(_HAS_EXCEPTIONS) &&_HAS_EXCEPTIONS == 0 
+#endif // defined(_LIBCPP_ABI_VCRUNTIME) && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_array_new_length()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_array_new_length();

libcxx/src/support/ibm/wcsnrtombs.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <cwchar>  // mbstate_t
 #include <limits.h> // MB_LEN_MAX
 #include <stdlib.h> // MB_CUR_MAX, size_t
 #include <string.h> // memcpy
 
 // Converts `max_source_chars` from the wide character buffer pointer to by *`src`,
 // into the multi byte character sequence buffer stored at `dst`, which must be
 // `dst_size_bytes` bytes in size. Returns the number of bytes in the sequence
-// converted from *src, excluding the null terminator. 
+// converted from *src, excluding the null terminator.
 // Returns (size_t) -1 if an error occurs and sets errno.
 // If `dst` is NULL, `dst_size_bytes` is ignored and no bytes are copied to `dst`.
 _LIBCPP_FUNC_VIS
 size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
                    size_t max_source_chars, size_t dst_size_bytes,
                    mbstate_t *__restrict ps) {
 
   const size_t invalid_wchar = static_cast<size_t>(-1);

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp

test_proxy_in_iterators<ProxyIterator<contiguous_iterator<int*>>>();
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       std::ranges::move(std::begin(a), std::end(a), std::begin(b));
       assert(b[0].get() == 1);
       assert(b[1].get() == 2);
       assert(b[2].get() == 3);
     }
   }
-  
   { // check that a move-only type works for ProxyIterator
     {
       MoveOnly a[] = {1, 2, 3};
       MoveOnly b[3];
       ProxyRange proxyA{a};
       ProxyRange proxyB{b};
       std::ranges::move(proxyA, std::begin(proxyB));
       assert(b[0].get() == 1);

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/ranges_set_intersection.pass.cpp

 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   // Cannot static_assert on the entire permutation test because it exceeds the constexpr execution step limit
   // due to the large number of combination of types of iterators (it is a 3-dimensional cartesian product)
-  // Instead of having one single static_assert that tests all the combinations, in the runAllIteratorPermutationsTests 
-  // function, it has lots of smaller static_assert and each of them test 2-dimensional cartesian product which is less 
+  // Instead of having one single static_assert that tests all the combinations, in the runAllIteratorPermutationsTests
+  // function, it has lots of smaller static_assert and each of them test 2-dimensional cartesian product which is less
   // than the step limit.
   runAllIteratorPermutationsTests();
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/ranges_set_union.pass.cpp

// range overload
       std::ranges::set_union(r1, r2, out.data(), compProjs.comp(), compProjs.proj1(), compProjs.proj2());
 
       assert(std::ranges::equal(out, expected, {}, &Data::data));
       assert(compProjs.numberOfComp < maxOperation);
       assert(compProjs.numberOfProj1 < maxOperation);
       assert(compProjs.numberOfProj2 < maxOperation);
     }
   }
-  
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   // Cannot static_assert on the entire permutation test because it exceeds the constexpr execution step limit
   // due to the large number of combination of types of iterators (it is a 3-dimensional cartesian product)
   // Instead of having one single static_assert that tests all the combinations, in the runAllIteratorPermutationsTests
   // function, it has lots of smaller static_assert and each of them test 2-dimensional cartesian product which is less
   // than the step limit.
   runAllIteratorPermutationsTests();
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/ranges.sort.pass.cpp

/*
     {
       std::array in = {2, 1, 3};
       ProxyRange proxy{in};
       std::ranges::sort(proxy, [](auto i, auto j) { return i.data < j.data; });
       assert((in == std::array{1, 2, 3}));
     }
   }
   */
-  
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/sortable_helpers.h

 #include <type_traits>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER > 17
 #include <compare>
 #include <iterator>
 #include "test_iterators.h"
-#endif 
+#endif
 
 struct TrivialSortable {
     int value;
     TEST_CONSTEXPR TrivialSortable() : value(0) {}
     TEST_CONSTEXPR TrivialSortable(int v) : value(v) {}
     friend TEST_CONSTEXPR bool operator<(const TrivialSortable& a, const TrivialSortable& b) {
         return a.value / 10 < b.value / 10;
     }

 
 template <class Iter>
 struct NonBorrowedRange {
   int* data_;
   size_t size_;
 
   // TODO: some algorithms calls std::__copy
   // std::__copy(contiguous_iterator<int*>, sentinel_wrapper<contiguous_iterator<int*>>, contiguous_iterator<int*>) doesn't seem to work.
-  // It seems that it unwraps contiguous_iterator<int*> into int*, and then it failed because there is no == between int* and 
+  // It seems that it unwraps contiguous_iterator<int*> into int*, and then it failed because there is no == between int* and
   // sentinel_wrapper<contiguous_iterator<int*>>
   using Sent = std::conditional_t<std::contiguous_iterator<Iter>, Iter, sentinel_wrapper<Iter>>;
 
   constexpr NonBorrowedRange(int* d, size_t s) : data_{d}, size_{s} {}
 
   constexpr Iter begin() const { return Iter{data_}; };
   constexpr Sent end() const { return Sent{Iter{data_ + size_}}; };
 };
 #endif // TEST_STD_VER > 17
 
 #endif // SORTABLE_HELPERS_H

libcxx/test/std/ranges/range.adaptors/range.all/all.pass.cpp

constexpr bool test() {
     assert(base(base(std::ranges::end(own))) == globalBuff + 8);
   }
 
   // Check SFINAE friendliness of the call operator
   {
     static_assert(!std::is_invocable_v<decltype(std::views::all)>);
     static_assert(!std::is_invocable_v<decltype(std::views::all), RandomAccessRange, RandomAccessRange>);
 
-    // `views::all(v)` is expression equivalent to `decay-copy(v)` if the decayed type 
-    // of `v` models `view`. If `v` is an lvalue-reference to a move-only view, the 
+    // `views::all(v)` is expression equivalent to `decay-copy(v)` if the decayed type
+    // of `v` models `view`. If `v` is an lvalue-reference to a move-only view, the
     // expression should be ill-formed because `v` is not copyable
     static_assert(!std::is_invocable_v<decltype(std::views::all), MoveOnlyView&>);
   }
 
   // Test that std::views::all is a range adaptor
   {
     // Test `v | views::all`
     {

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

constexpr bool test() {
   {
     // test ID 2
     ForwardNonCommonInner inners[3] = {buffer[0], buffer[1], buffer[2]};
     SimpleForwardCommonOuter<ForwardNonCommonInner> outer{inners};
 
     std::ranges::join_view jv(outer);
     assert(jv.end() == std::ranges::next(jv.begin(), 12));
     assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 12));
-    
     static_assert(HasConstEnd<decltype(jv)>);
     static_assert(std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
     static_assert(!std::ranges::common_range<decltype(jv)>);
     static_assert(!std::ranges::common_range<const decltype(jv)>);
   }
 
   {
     // test ID 3
constexpr bool test() {
   {
     // test ID 8
     ForwardNonCommonInner inners[3] = {buffer[0], buffer[1], buffer[2]};
     NonSimpleForwardCommonOuter<ForwardNonCommonInner> outer{inners};
 
     std::ranges::join_view jv(outer);
     assert(jv.end() == std::ranges::next(jv.begin(), 12));
     assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 12));
-    
     static_assert(HasConstEnd<decltype(jv)>);
     static_assert(!std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
     static_assert(!std::ranges::common_range<decltype(jv)>);
     static_assert(!std::ranges::common_range<const decltype(jv)>);
   }
 
   {
     // test ID 9

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
     std::ranges::join_view jv(buffer);
     assert(std::ranges::iter_move(jv.begin()) == 1);
     static_assert(std::is_same_v<decltype(std::ranges::iter_move(jv.begin())), int&&>);
 
     static_assert(noexcept(std::ranges::iter_move(std::declval<decltype(jv.begin())>())));
   }
 
   {
-    // iter_move calls inner's iter_move and calls 
+    // iter_move calls inner's iter_move and calls
     // iter_move on the correct inner iterator
     IterMoveSwapAwareView inners[2] = {buffer[0], buffer[1]};
     std::ranges::join_view jv(inners);
     auto it = jv.begin();
 
     const auto& iter_move_called_times1 = jv.base().begin()->iter_move_called;
     const auto& iter_move_called_times2 = std::next(jv.base().begin())->iter_move_called;
     assert(iter_move_called_times1 == 0);

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

 static_assert(std::ranges::forward_range<InnerRValue<SimpleForwardCommonOuter<>>>);
 static_assert(!std::ranges::bidirectional_range<InnerRValue<SimpleForwardCommonOuter<>>>);
 static_assert(std::ranges::common_range<InnerRValue<SimpleForwardCommonOuter<>>>);
 LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<InnerRValue<SimpleForwardCommonOuter<>>>);
 static_assert(!std::is_lvalue_reference_v<std::ranges::range_reference_t<InnerRValue<SimpleForwardCommonOuter<>>>>);
 
 struct move_swap_aware_iter {
 
-  // This is a proxy-like iterator where `reference` is a prvalue, and 
+  // This is a proxy-like iterator where `reference` is a prvalue, and
   // `reference` and `value_type` are distinct types (similar to `zip_view::iterator`).
   using value_type = std::pair<int, int>;
   using reference = std::pair<int&, int&>;
   using rvalue_reference = std::pair<int&&, int&&>;
 
   using difference_type = std::intptr_t;
   using iterator_concept = std::input_iterator_tag;
 

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.default.pass.cpp

 
 struct NoDefaultCtrView : std::ranges::view_base {
   NoDefaultCtrView() = delete;
   int* begin() const;
   int* end() const;
 };
 
 // The default constructor requires all underlying views to be default constructible.
-// It is implicitly required by the tuple's constructor. If any of the iterators are 
+// It is implicitly required by the tuple's constructor. If any of the iterators are
 // not default constructible, zip iterator's =default would be implicitly deleted.
 static_assert(std::is_default_constructible_v<std::ranges::zip_view<DefaultConstructibleView>>);
 static_assert(
     std::is_default_constructible_v<std::ranges::zip_view<DefaultConstructibleView, DefaultConstructibleView>>);
 static_assert(!std::is_default_constructible_v<std::ranges::zip_view<DefaultConstructibleView, NoDefaultCtrView>>);
 static_assert(!std::is_default_constructible_v<std::ranges::zip_view<NoDefaultCtrView, NoDefaultCtrView>>);
 static_assert(!std::is_default_constructible_v<std::ranges::zip_view<NoDefaultCtrView>>);
 

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

 
 // x += n;
 // x + n;
 // n + x;
 // x -= n;
 // x - n;
 // x - y;
 // All the arithmetic operators have the constraint `requires all-random-access<Const, Views...>;`,
-// except `operator-(x, y)` which instead has the constraint 
+// except `operator-(x, y)` which instead has the constraint
 //    `requires (sized_­sentinel_­for<iterator_t<maybe-const<Const, Views>>,
 //                                  iterator_t<maybe-const<Const, Views>>> && ...);`
 
 #include <ranges>
 
 #include <array>
 #include <concepts>
 #include <functional>

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp

 
 constexpr bool test() {
   using ZipIter = zip_iter<IterDefaultCtrView>;
   {
     ZipIter iter;
     auto [x] = *iter;
     assert(x == 0); // PODIter has to be initialised to have value 0
   }
-  
   {
     ZipIter iter = {};
     auto [x] = *iter;
     assert(x == 0); // PODIter has to be initialised to have value 0
   }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.zip/range.concept.compile.pass.cpp

 struct OutputView : std::ranges::view_base {
   OutputIter begin() const;
   sentinel_wrapper<OutputIter> end() const;
 };
 static_assert(std::ranges::output_range<OutputView, int>);
 static_assert(!std::ranges::input_range<OutputView>);
 
 template <class... Ts>
-concept zippable = requires { 
-  typename std::ranges::zip_view<Ts...>;  
+concept zippable = requires {
+  typename std::ranges::zip_view<Ts...>;
 };
 
 // output_range is not supported
 static_assert(!zippable<OutputView>);
 static_assert(!zippable<SimpleCommon, OutputView>);
 static_assert(zippable<SimpleCommon>);

libcxx/utils/ci/run-buildbot

if [ -s ${BUILD_DIR}/generated_output.status ]; then
         echo "Did you add all new files it generated?"
         false
     fi
 
     # Reject patches that introduce non-ASCII characters or hard tabs.
     # Depends on LC_COLLATE set at the top of this script.
     ! grep -rn '[^ -~]' libcxx/include/ || false
 
+    # Reject code with trailing whitespace
+    ! grep -rn '[[:blank:]]$' libcxx/include libcxx/src libcxx/test || false
+
     # Reject patches that introduce dependency cycles in the headers.
     python3 libcxx/utils/graph_header_deps.py >/dev/null
 ;;
 generic-cxx03)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx03.cmake"
     check-runtimes
     check-abi-list