[libc++] Avoid a Microsoft SAL macro.

[pkasting]

Summary

Bug: https://github.com/llvm/llvm-project/issues/55195

[Mordante]

I didn't look closely at the patch, but no objections against this direction.
The CI fails since you missed some __bounds. I'll review the patch after the CI is green.

[pkasting]

More bounds. Format.

[pkasting]

More formatting.

[pkasting]

The MSAN failure doesn't look like me.

Also looks like there are bugs in clang-format (e.g. nasty_macros.compile.pass.cpp line 81), but if I skip it the linter complains :P

PTAL?

[Mordante]

In D124695#3484759, @pkasting wrote:

The MSAN failure doesn't look like me.

Correct that was main being broken. Please rebase your patch before the next iteration, that should fix these build errors.

libcxx/include/__functional/perfect_forward.h

34

I'm not thrilled by the trailing double underscore, this deviates from our coding style.
Maybe change __bound_ to __bound_args_ in this file, please also update the template name to _BoundArgs.

Please make similar changes at other places, having function arguments with a trailing underscore will lead to confusion. If you're having trouble finding good names, leave a comment to the names you need assistance with.

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

91

Format errors aren't hard errors, so feel free to ignore them.
(At some point we should decide what we want with formatting.)

[pkasting]

Review comments

[pkasting]

Rebased, but now I got a strange AIX timeout. Presumably this is also flake or trunk bustage; PTAL?

[philnik]

In D124695#3492085, @pkasting wrote:

Rebased, but now I got a strange AIX timeout. Presumably this is also flake or trunk bustage; PTAL?

You can ignore the timeout. The test is right on the edge of timing out.

[Mordante]

LGTM modulo some nits, please fix them before landing this patch.

libcxx/include/__functional/perfect_forward.h

34

Next time when you address review comments can you mark the comment as done? That makes reviewing easier.

37–85

Minor nit.

libcxx/include/__iterator/advance.h

120

Same for the other comments.

libcxx/include/__ranges/iota_view.h

381

We don't indent nested namespaces.

[pkasting]

Review comments

[pkasting]

I don't have LLVM commit permissions; can you commit for me?

[Mordante]

Landed on your behalf.

[ldionne]

libcxx/include/__functional/perfect_forward.h

59–62

I am not thrilled by this reformatting. There is a reason why we align things like that. We do it consistently everywhere so that we can grep more easily and change these write-it-three-times if needed.

[ldionne]

libcxx/include/__functional/perfect_forward.h

34

I think this also made the indentation inconsistent (2 spaces vs 4 spaces). After the change, there is a mix of the two indentations in the file.

[ldionne]

I fixed the formatting in 9fffca04448d34b62dff1207170bed0c5fd15e09.

libcxx/include/__functional/bind_back.h

 
 #if _LIBCPP_STD_VER > 17
 
 template <size_t _NBound, class = make_index_sequence<_NBound>>
 struct __bind_back_op;
 
 template <size_t _NBound, size_t ..._Ip>
 struct __bind_back_op<_NBound, index_sequence<_Ip...>> {
-    template <class _Fn, class _Bound, class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Fn&& __f, _Bound&& __bound, _Args&& ...__args) const
-        noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_Bound>(__bound))...)))
-        -> decltype(      _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_Bound>(__bound))...))
-        { return          _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_Bound>(__bound))...); }
+  template <class _Fn, class _BoundArgs, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const
+      noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...,
+                                      _VSTD::get<_Ip>(_VSTD::forward<_BoundArgs>(__bound_args))...)))
+          -> decltype(_VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...,
+                                    _VSTD::get<_Ip>(_VSTD::forward<_BoundArgs>(__bound_args))...)) {
+    return _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...,
+                         _VSTD::get<_Ip>(_VSTD::forward<_BoundArgs>(__bound_args))...);
+  }
 };
 
 template <class _Fn, class _BoundArgs>
 struct __bind_back_t : __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs> {
     using __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs>::__perfect_forward;
 };
 
 template <class _Fn, class ..._Args, class = enable_if_t<

libcxx/include/__functional/perfect_forward.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
-template <class _Op, class _Indices, class ..._Bound>
+template <class _Op, class _Indices, class... _BoundArgs>
 struct __perfect_forward_impl;
 
-template <class _Op, size_t ..._Idx, class ..._Bound>
-struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _Bound...> {
+template <class _Op, size_t... _Idx, class... _BoundArgs>
+struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _BoundArgs...> {
 private:
-    tuple<_Bound...> __bound_;
+  tuple<_BoundArgs...> __bound_args_;
 
 public:
-    template <class ..._BoundArgs, class = enable_if_t<
-        is_constructible_v<tuple<_Bound...>, _BoundArgs&&...>
-    >>
-    explicit constexpr __perfect_forward_impl(_BoundArgs&& ...__bound)
-        : __bound_(_VSTD::forward<_BoundArgs>(__bound)...)
-    { }
+  template <class... _Args, class = enable_if_t< is_constructible_v<tuple<_BoundArgs...>, _Args&&...>>>
+  explicit constexpr __perfect_forward_impl(_Args&&... __bound_args)
+      : __bound_args_(_VSTD::forward<_Args>(__bound_args)...) {}
 
-    __perfect_forward_impl(__perfect_forward_impl const&) = default;
-    __perfect_forward_impl(__perfect_forward_impl&&) = default;
 
-    __perfect_forward_impl& operator=(__perfect_forward_impl const&) = default;
-    __perfect_forward_impl& operator=(__perfect_forward_impl&&) = default;
 
-    template <class ..._Args, class = enable_if_t<is_invocable_v<_Op, _Bound&..., _Args...>>>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) &
-        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
-        -> decltype(      _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...))
-        { return          _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...); }
+  template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs&..., _Args...>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) & noexcept(
+      noexcept(_Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...)))
+      -> decltype(_Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...)) {
+    return _Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args, class = enable_if_t<!is_invocable_v<_Op, _Bound&..., _Args...>>>
-    auto operator()(_Args&&...) & = delete;
+  template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs&..., _Args...>>>
 
-    template <class ..._Args, class = enable_if_t<is_invocable_v<_Op, _Bound const&..., _Args...>>>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&
-        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
-        -> decltype(      _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...))
-        { return          _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...); }
+  template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs const&..., _Args...>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const& noexcept(
+      noexcept(_Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...)))
+      -> decltype(_Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...)) {
+    return _Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args, class = enable_if_t<!is_invocable_v<_Op, _Bound const&..., _Args...>>>
-    auto operator()(_Args&&...) const& = delete;
+  template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs const&..., _Args...>>>
 
-    template <class ..._Args, class = enable_if_t<is_invocable_v<_Op, _Bound..., _Args...>>>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) &&
-        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...)))
-        -> decltype(      _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...))
-        { return          _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...); }
+  template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs..., _Args...>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) && noexcept(
+      noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...)))
+      -> decltype(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...)) {
+    return _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args, class = enable_if_t<!is_invocable_v<_Op, _Bound..., _Args...>>>
-    auto operator()(_Args&&...) && = delete;
+  template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs..., _Args...>>>
 
-    template <class ..._Args, class = enable_if_t<is_invocable_v<_Op, _Bound const..., _Args...>>>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&&
-        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...)))
-        -> decltype(      _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...))
-        { return          _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...); }
+  template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs const..., _Args...>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&& noexcept(
+      noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...)))
+      -> decltype(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...)) {
+    return _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args, class = enable_if_t<!is_invocable_v<_Op, _Bound const..., _Args...>>>
-    auto operator()(_Args&&...) const&& = delete;
+  template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs const..., _Args...>>>
 };
 
 // __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require].
 template <class _Op, class ..._Args>
 using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>;
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H

libcxx/include/__iterator/advance.h

if constexpr (random_access_iterator<_Ip>) {
       return;
     } else {
       // Otherwise, if `n` is non-negative, increments `i` by `n`.
       __advance_forward(__i, __n);
       return;
     }
   }
 
-  // Preconditions: Either `assignable_from<I&, S> || sized_sentinel_for<S, I>` is modeled, or [i, bound) denotes a range.
+  // Preconditions: Either `assignable_from<I&, S> || sized_sentinel_for<S, I>` is modeled, or [i, bound_sentinel) denotes a range.
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator()(_Ip& __i, _Sp __bound) const {
-    // If `I` and `S` model `assignable_from<I&, S>`, equivalent to `i = std::move(bound)`.
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Ip& __i, _Sp __bound_sentinel) const {
+    // If `I` and `S` model `assignable_from<I&, S>`, equivalent to `i = std::move(bound_sentinel)`.
     if constexpr (assignable_from<_Ip&, _Sp>) {
-      __i = _VSTD::move(__bound);
+      __i = _VSTD::move(__bound_sentinel);
     }
-    // Otherwise, if `S` and `I` model `sized_sentinel_for<S, I>`, equivalent to `ranges::advance(i, bound - i)`.
+    // Otherwise, if `S` and `I` model `sized_sentinel_for<S, I>`, equivalent to `ranges::advance(i, bound_sentinel - i)`.
     else if constexpr (sized_sentinel_for<_Sp, _Ip>) {
-      (*this)(__i, __bound - __i);
+      (*this)(__i, __bound_sentinel - __i);
     }
-    // Otherwise, while `bool(i != bound)` is true, increments `i`.
+    // Otherwise, while `bool(i != bound_sentinel)` is true, increments `i`.
     else {
-      while (__i != __bound) {
+      while (__i != __bound_sentinel) {
         ++__i;
       }
     }
   }
 
   // Preconditions:
-  //   * If `n > 0`, [i, bound) denotes a range.
-  //   * If `n == 0`, [i, bound) or [bound, i) denotes a range.
-  //   * If `n < 0`, [bound, i) denotes a range, `I` models `bidirectional_iterator`, and `I` and `S` model `same_as<I, S>`.
+  //   * If `n > 0`, [i, bound_sentinel) denotes a range.
+  //   * If `n == 0`, [i, bound_sentinel) or [bound_sentinel, i) denotes a range.
+  //   * If `n < 0`, [bound_sentinel, i) denotes a range, `I` models `bidirectional_iterator`, and `I` and `S` model `same_as<I, S>`.
   // Returns: `n - M`, where `M` is the difference between the ending and starting position.
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr iter_difference_t<_Ip> operator()(_Ip& __i, iter_difference_t<_Ip> __n, _Sp __bound) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip& __i, iter_difference_t<_Ip> __n,
+                                                                    _Sp __bound_sentinel) const {
     _LIBCPP_ASSERT((__n >= 0) || (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>),
                    "If `n < 0`, then `bidirectional_iterator<I> && same_as<I, S>` must be true.");
     // If `S` and `I` model `sized_sentinel_for<S, I>`:
     if constexpr (sized_sentinel_for<_Sp, _Ip>) {
-      // If |n| >= |bound - i|, equivalent to `ranges::advance(i, bound)`.
+      // If |n| >= |bound_sentinel - i|, equivalent to `ranges::advance(i, bound_sentinel)`.
       // __magnitude_geq(a, b) returns |a| >= |b|, assuming they have the same sign.
       auto __magnitude_geq = [](auto __a, auto __b) {
         return __a == 0 ? __b == 0 :
                __a > 0  ? __a >= __b :
                           __a <= __b;
       };
-      if (const auto __M = __bound - __i; __magnitude_geq(__n, __M)) {
-        (*this)(__i, __bound);
+      if (const auto __M = __bound_sentinel - __i; __magnitude_geq(__n, __M)) {
+        (*this)(__i, __bound_sentinel);
         return __n - __M;
       }
 
       // Otherwise, equivalent to `ranges::advance(i, n)`.
       (*this)(__i, __n);
       return 0;
     } else {
-      // Otherwise, if `n` is non-negative, while `bool(i != bound)` is true, increments `i` but at
+      // Otherwise, if `n` is non-negative, while `bool(i != bound_sentinel)` is true, increments `i` but at
       // most `n` times.
-      while (__i != __bound && __n > 0) {
+      while (__i != __bound_sentinel && __n > 0) {
         ++__i;
         --__n;
       }
 
-      // Otherwise, while `bool(i != bound)` is true, decrements `i` but at most `-n` times.
+      // Otherwise, while `bool(i != bound_sentinel)` is true, decrements `i` but at most `-n` times.
       if constexpr (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>) {
-        while (__i != __bound && __n < 0) {
+        while (__i != __bound_sentinel && __n < 0) {
           --__i;
           ++__n;
         }
       }
       return __n;
     }
 
     __libcpp_unreachable();

libcxx/include/__iterator/next.h

struct __fn {
   template <input_or_output_iterator _Ip>
   _LIBCPP_HIDE_FROM_ABI
   constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
     ranges::advance(__x, __n);
     return __x;
   }
 
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x, _Sp __bound) const {
-    ranges::advance(__x, __bound);
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, _Sp __bound_sentinel) const {
+    ranges::advance(__x, __bound_sentinel);
     return __x;
   }
 
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Sp __bound) const {
-    ranges::advance(__x, __n, __bound);
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Sp __bound_sentinel) const {
+    ranges::advance(__x, __n, __bound_sentinel);
     return __x;
   }
 };
 
 } // namespace __next
 
 inline namespace __cpo {
   inline constexpr auto next = __next::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_NEXT_H

libcxx/include/__iterator/prev.h

struct __fn {
   template <bidirectional_iterator _Ip>
   _LIBCPP_HIDE_FROM_ABI
   constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
     ranges::advance(__x, -__n);
     return __x;
   }
 
   template <bidirectional_iterator _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Ip __bound) const {
-    ranges::advance(__x, -__n, __bound);
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Ip __bound_iter) const {
+    ranges::advance(__x, -__n, __bound_iter);
     return __x;
   }
 };
 
 } // namespace __prev
 
 inline namespace __cpo {
   inline constexpr auto prev = __prev::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_PREV_H

libcxx/include/__ranges/iota_view.h

namespace ranges {
   template<class>
   struct __iota_iterator_category {};
 
   template<incrementable _Tp>
   struct __iota_iterator_category<_Tp> {
     using iterator_category = input_iterator_tag;
   };
 
-  template<weakly_incrementable _Start, semiregular _Bound = unreachable_sentinel_t>
-    requires __weakly_equality_comparable_with<_Start, _Bound> && copyable<_Start>
-  class iota_view : public view_interface<iota_view<_Start, _Bound>> {
+  template <weakly_incrementable _Start, semiregular _BoundSentinel = unreachable_sentinel_t>
+    requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
+  class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
     struct __iterator : public __iota_iterator_category<_Start> {
       friend class iota_view;
 
       using iterator_concept =
         _If<__advanceable<_Start>,   random_access_iterator_tag,
         _If<__decrementable<_Start>, bidirectional_iterator_tag,
         _If<incrementable<_Start>,   forward_iterator_tag,
         /*Else*/                     input_iterator_tag>>>;
struct __iterator : public __iota_iterator_category<_Start> {
         return __x.__value_ - __y.__value_;
       }
     };
 
     struct __sentinel {
       friend class iota_view;
 
     private:
-      _Bound __bound_ = _Bound();
+      _BoundSentinel __bound_sentinel_ = _BoundSentinel();
 
     public:
       _LIBCPP_HIDE_FROM_ABI
       __sentinel() = default;
-      constexpr explicit __sentinel(_Bound __bound) : __bound_(std::move(__bound)) {}
+      constexpr explicit __sentinel(_BoundSentinel __bound_sentinel) : __bound_sentinel_(std::move(__bound_sentinel)) {}
 
       _LIBCPP_HIDE_FROM_ABI
       friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
-        return __x.__value_ == __y.__bound_;
+        return __x.__value_ == __y.__bound_sentinel_;
       }
 
       _LIBCPP_HIDE_FROM_ABI
       friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __sentinel& __y)
-        requires sized_sentinel_for<_Bound, _Start>
+        requires sized_sentinel_for<_BoundSentinel, _Start>
       {
-        return __x.__value_ - __y.__bound_;
+        return __x.__value_ - __y.__bound_sentinel_;
       }
 
       _LIBCPP_HIDE_FROM_ABI
       friend constexpr iter_difference_t<_Start> operator-(const __sentinel& __x, const __iterator& __y)
-        requires sized_sentinel_for<_Bound, _Start>
+        requires sized_sentinel_for<_BoundSentinel, _Start>
       {
         return -(__y - __x);
       }
     };
 
     _Start __value_ = _Start();
-    _Bound __bound_ = _Bound();
+    _BoundSentinel __bound_sentinel_ = _BoundSentinel();
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     iota_view() requires default_initializable<_Start> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_Bound> __bound)
-      : __value_(std::move(__value)), __bound_(std::move(__bound)) {
+    constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
+        : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
       // Validate the precondition if possible.
-      if constexpr (totally_ordered_with<_Start, _Bound>) {
-        _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_),
+      if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
+        _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_sentinel_),
                        "Precondition violated: value is greater than bound.");
       }
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iota_view(__iterator __first, __iterator __last)
-      requires same_as<_Start, _Bound>
-      : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
+      requires same_as<_Start, _BoundSentinel>
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, _Bound __last)
-      requires same_as<_Bound, unreachable_sentinel_t>
-      : iota_view(std::move(__first.__value_), std::move(__last)) {}
+    constexpr iota_view(__iterator __first, _BoundSentinel __last)
+      requires same_as<_BoundSentinel, unreachable_sentinel_t>
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iota_view(__iterator __first, __sentinel __last)
-      requires (!same_as<_Start, _Bound> && !same_as<_Start, unreachable_sentinel_t>)
-      : iota_view(std::move(__first.__value_), std::move(__last.__bound_)) {}
+      requires(!same_as<_Start, _BoundSentinel> && !same_as<_Start, unreachable_sentinel_t>)
+    : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __iterator begin() const { return __iterator{__value_}; }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto end() const {
-      if constexpr (same_as<_Bound, unreachable_sentinel_t>)
+      if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
         return unreachable_sentinel;
       else
-        return __sentinel{__bound_};
+        return __sentinel{__bound_sentinel_};
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator end() const requires same_as<_Start, _Bound> {
-      return __iterator{__bound_};
+    constexpr __iterator end() const
+      requires same_as<_Start, _BoundSentinel>
+    {
+      return __iterator{__bound_sentinel_};
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto size() const
-      requires (same_as<_Start, _Bound> && __advanceable<_Start>) ||
-               (integral<_Start> && integral<_Bound>) ||
-               sized_sentinel_for<_Bound, _Start>
+      requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
+              (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
     {
-      if constexpr (__integer_like<_Start> && __integer_like<_Bound>) {
+      if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
         if (__value_ < 0) {
-          if (__bound_ < 0) {
-            return std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_);
+          if (__bound_sentinel_ < 0) {
+            return std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_);
           }
-          return std::__to_unsigned_like(__bound_) + std::__to_unsigned_like(-__value_);
+          return std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_);
         }
-        return std::__to_unsigned_like(__bound_) - std::__to_unsigned_like(__value_);
+        return std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
       }
-      return std::__to_unsigned_like(__bound_ - __value_);
+      return std::__to_unsigned_like(__bound_sentinel_ - __value_);
     }
   };
 
-  template<class _Start, class _Bound>
-    requires (!__integer_like<_Start> || !__integer_like<_Bound> ||
-              (__signed_integer_like<_Start> == __signed_integer_like<_Bound>))
-  iota_view(_Start, _Bound) -> iota_view<_Start, _Bound>;
+  template <class _Start, class _BoundSentinel>
+    requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
+             (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
+  iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
 
-  template<class _Start, class _Bound>
-  inline constexpr bool enable_borrowed_range<iota_view<_Start, _Bound>> = true;
+  template <class _Start, class _BoundSentinel>
+  inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
 
  namespace views {
  namespace __iota {
   struct __fn {
     template<class _Start>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Start&& __start) const
       noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start))))
       -> decltype(      ranges::iota_view(std::forward<_Start>(__start)))
       { return          ranges::iota_view(std::forward<_Start>(__start)); }
 
-    template<class _Start, class _Bound>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Start&& __start, _Bound&& __bound) const
-      noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_Bound>(__bound))))
-      -> decltype(      ranges::iota_view(std::forward<_Start>(__start), std::forward<_Bound>(__bound)))
-      { return          ranges::iota_view(std::forward<_Start>(__start), std::forward<_Bound>(__bound)); }
+    template <class _Start, class _BoundSentinel>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const noexcept(
+        noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
+        -> decltype(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))) {
+      return ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel));
+    }
   };
 } // namespace __iota
 
 inline namespace __cpo {
   inline constexpr auto iota = __iota::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_IOTA_VIEW_H

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #ifndef _WIN32
 # define _C2 NASTY_MACRO
 #endif
 
 // Test that libc++ doesn't use names that collide with Win32 API macros.
 // Obviously we can only define these on non-Windows platforms.
 #ifndef _WIN32
 # define __allocator NASTY_MACRO
+# define __bound NASTY_MACRO
 # define __deallocate NASTY_MACRO
 # define __deref NASTY_MACRO
 # define __full NASTY_MACRO
 # define __in NASTY_MACRO
 # define __inout NASTY_MACRO
 # define __nz NASTY_MACRO
 # define __out NASTY_MACRO
 # define __part NASTY_MACRO
 # define __post NASTY_MACRO
 # define __pre NASTY_MACRO
 #endif
 
 #define __input NASTY_MACRO
 #define __output NASTY_MACRO
 
 #define __acquire NASTY_MACRO
 #define __release NASTY_MACRO