Merge branch 'llvm18'

Upgrades the LLVM, Clang, and LLD dependencies to LLVM 18.x

Related to #16270

1 files changed, 175 insertions, 191 deletions

diff --git a/lib/libcxx/include/__iterator/reverse_iterator.h b/lib/libcxx/include/__iterator/reverse_iterator.h
index beb10f7f4f..79b48bcea5 100644
--- a/lib/libcxx/include/__iterator/reverse_iterator.h
+++ b/lib/libcxx/include/__iterator/reverse_iterator.h
@@ -57,279 +57,262 @@ class _LIBCPP_TEMPLATE_VIS reverse_iterator
                       typename iterator_traits<_Iter>::reference>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 private:
 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
-    _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
+  _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
 #endif
 
 #if _LIBCPP_STD_VER >= 20
-    static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>,
-        "reverse_iterator<It> requires It to be a bidirectional iterator.");
+  static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>,
+                "reverse_iterator<It> requires It to be a bidirectional iterator.");
 #endif // _LIBCPP_STD_VER >= 20
 
 protected:
-    _Iter current;
+  _Iter current;
+
 public:
-    using iterator_type = _Iter;
+  using iterator_type = _Iter;
 
-    using iterator_category = _If<__has_random_access_iterator_category<_Iter>::value,
-                                  random_access_iterator_tag,
-                                  typename iterator_traits<_Iter>::iterator_category>;
-    using pointer = typename iterator_traits<_Iter>::pointer;
+  using iterator_category =
+      _If<__has_random_access_iterator_category<_Iter>::value,
+          random_access_iterator_tag,
+          typename iterator_traits<_Iter>::iterator_category>;
+  using pointer = typename iterator_traits<_Iter>::pointer;
 #if _LIBCPP_STD_VER >= 20
-    using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>;
-    using value_type = iter_value_t<_Iter>;
-    using difference_type = iter_difference_t<_Iter>;
-    using reference = iter_reference_t<_Iter>;
+  using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>;
+  using value_type       = iter_value_t<_Iter>;
+  using difference_type  = iter_difference_t<_Iter>;
+  using reference        = iter_reference_t<_Iter>;
 #else
-    using value_type = typename iterator_traits<_Iter>::value_type;
-    using difference_type = typename iterator_traits<_Iter>::difference_type;
-    using reference = typename iterator_traits<_Iter>::reference;
+  using value_type      = typename iterator_traits<_Iter>::value_type;
+  using difference_type = typename iterator_traits<_Iter>::difference_type;
+  using reference       = typename iterator_traits<_Iter>::reference;
 #endif
 
 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator() : __t_(), current() {}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    explicit reverse_iterator(_Iter __x) : __t_(__x), current(__x) {}
-
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator(const reverse_iterator<_Up>& __u)
-        : __t_(__u.base()), current(__u.base())
-    { }
-
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value &&
-        is_convertible<_Up const&, _Iter>::value &&
-        is_assignable<_Iter&, _Up const&>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
-        __t_ = current = __u.base();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator() : __t_(), current() {}
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit reverse_iterator(_Iter __x) : __t_(__x), current(__x) {}
+
+  template <class _Up,
+            class = __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value > >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator(const reverse_iterator<_Up>& __u)
+      : __t_(__u.base()), current(__u.base()) {}
+
+  template <class _Up,
+            class = __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value &&
+                                   is_assignable<_Iter&, _Up const&>::value > >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
+    __t_ = current = __u.base();
+    return *this;
+  }
 #else
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator() : current() {}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    explicit reverse_iterator(_Iter __x) : current(__x) {}
-
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator(const reverse_iterator<_Up>& __u)
-        : current(__u.base())
-    { }
-
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value &&
-        is_convertible<_Up const&, _Iter>::value &&
-        is_assignable<_Iter&, _Up const&>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
-        current = __u.base();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator() : current() {}
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit reverse_iterator(_Iter __x) : current(__x) {}
+
+  template <class _Up,
+            class = __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value > >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator(const reverse_iterator<_Up>& __u)
+      : current(__u.base()) {}
+
+  template <class _Up,
+            class = __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value &&
+                                   is_assignable<_Iter&, _Up const&>::value > >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
+    current = __u.base();
+    return *this;
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    _Iter base() const {return current;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator*() const {_Iter __tmp = current; return *--__tmp;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const { return current; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator*() const {
+    _Iter __tmp = current;
+    return *--__tmp;
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr pointer operator->() const
-      requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
-    {
-      if constexpr (is_pointer_v<_Iter>) {
-        return std::prev(current);
-      } else {
-        return std::prev(current).operator->();
-      }
+  _LIBCPP_HIDE_FROM_ABI constexpr pointer operator->() const
+    requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
+  {
+    if constexpr (is_pointer_v<_Iter>) {
+      return std::prev(current);
+    } else {
+      return std::prev(current).operator->();
     }
+  }
 #else
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    pointer operator->() const {
-      return std::addressof(operator*());
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer operator->() const { return std::addressof(operator*()); }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator++() {--current; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator--() {++current; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator[](difference_type __n) const {return *(*this + __n);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator++() {
+    --current;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator++(int) {
+    reverse_iterator __tmp(*this);
+    --current;
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator--() {
+    ++current;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator--(int) {
+    reverse_iterator __tmp(*this);
+    ++current;
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator+(difference_type __n) const {
+    return reverse_iterator(current - __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator+=(difference_type __n) {
+    current -= __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator-(difference_type __n) const {
+    return reverse_iterator(current + __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator-=(difference_type __n) {
+    current += __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](difference_type __n) const {
+    return *(*this + __n);
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI friend constexpr
-    iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i)
-      noexcept(is_nothrow_copy_constructible_v<_Iter> &&
-          noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
-      auto __tmp = __i.base();
-      return ranges::iter_move(--__tmp);
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i) noexcept(
+      is_nothrow_copy_constructible_v<_Iter>&& noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
+    auto __tmp = __i.base();
+    return ranges::iter_move(--__tmp);
+  }
 
-    template <indirectly_swappable<_Iter> _Iter2>
-    _LIBCPP_HIDE_FROM_ABI friend constexpr
-    void iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y)
-      noexcept(is_nothrow_copy_constructible_v<_Iter> &&
-          is_nothrow_copy_constructible_v<_Iter2> &&
-          noexcept(ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) {
-      auto __xtmp = __x.base();
-      auto __ytmp = __y.base();
-      ranges::iter_swap(--__xtmp, --__ytmp);
-    }
+  template <indirectly_swappable<_Iter> _Iter2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y) noexcept(
+      is_nothrow_copy_constructible_v<_Iter> &&
+      is_nothrow_copy_constructible_v<_Iter2>&& noexcept(
+          ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) {
+    auto __xtmp = __x.base();
+    auto __ytmp = __y.base();
+    ranges::iter_swap(--__xtmp, --__ytmp);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-      { __x.base() == __y.base() } -> convertible_to<bool>;
-    }
+  requires requires {
+    { __x.base() == __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() == __y.base();
+  return __x.base() == __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() > __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() > __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() > __y.base();
+  return __x.base() > __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-      { __x.base() != __y.base() } -> convertible_to<bool>;
-    }
+  requires requires {
+    { __x.base() != __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() != __y.base();
+  return __x.base() != __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() < __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() < __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() < __y.base();
+  return __x.base() < __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() <= __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() <= __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() <= __y.base();
+  return __x.base() <= __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() >= __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() >= __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() >= __y.base();
+  return __x.base() >= __y.base();
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
-_LIBCPP_HIDE_FROM_ABI constexpr
-compare_three_way_result_t<_Iter1, _Iter2>
-operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-{
-    return __y.base() <=> __x.base();
+_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Iter1, _Iter2>
+operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) {
+  return __y.base() <=> __x.base();
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto
 operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
--> decltype(__y.base() - __x.base())
-{
-    return __y.base() - __x.base();
+    -> decltype(__y.base() - __x.base()) {
+  return __y.base() - __x.base();
 }
 #else
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename reverse_iterator<_Iter1>::difference_type
-operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-{
-    return __y.base() - __x.base();
+inline _LIBCPP_HIDE_FROM_ABI typename reverse_iterator<_Iter1>::difference_type
+operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) {
+  return __y.base() - __x.base();
 }
 #endif
 
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<_Iter>
-operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
-{
-    return reverse_iterator<_Iter>(__x.base() - __n);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<_Iter>
+operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x) {
+  return reverse_iterator<_Iter>(__x.base() - __n);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter1, class _Iter2>
-  requires (!sized_sentinel_for<_Iter1, _Iter2>)
+  requires(!sized_sentinel_for<_Iter1, _Iter2>)
 inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true;
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
-{
-    return reverse_iterator<_Iter>(__i);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i) {
+  return reverse_iterator<_Iter>(__i);
 }
 #endif
 
@@ -369,13 +352,15 @@ public:
 
   using iterator_type = _Iter;
   using iterator_category =
-      _If<__has_random_access_iterator_category<_Iter>::value, random_access_iterator_tag, __iterator_category_type<_Iter>>;
-  using pointer = __iterator_pointer_type<_Iter>;
-  using value_type = iter_value_t<_Iter>;
+      _If<__has_random_access_iterator_category<_Iter>::value,
+          random_access_iterator_tag,
+          __iterator_category_type<_Iter>>;
+  using pointer         = __iterator_pointer_type<_Iter>;
+  using value_type      = iter_value_t<_Iter>;
   using difference_type = iter_difference_t<_Iter>;
-  using reference = iter_reference_t<_Iter>;
+  using reference       = iter_reference_t<_Iter>;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator()                                        = default;
   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator(const __unconstrained_reverse_iterator&) = default;
   _LIBCPP_HIDE_FROM_ABI constexpr explicit __unconstrained_reverse_iterator(_Iter __iter) : __iter_(__iter) {}
 
@@ -393,10 +378,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI friend constexpr
-  iter_rvalue_reference_t<_Iter> iter_move(const __unconstrained_reverse_iterator& __i)
-    noexcept(is_nothrow_copy_constructible_v<_Iter> &&
-        noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter>
+  iter_move(const __unconstrained_reverse_iterator& __i) noexcept(
+      is_nothrow_copy_constructible_v<_Iter>&& noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
     auto __tmp = __i.base();
     return ranges::iter_move(--__tmp);
   }
@@ -484,7 +468,7 @@ public:
 
 template <template <class> class _RevIter1, template <class> class _RevIter2, class _Iter>
 struct __unwrap_reverse_iter_impl {
-  using _UnwrappedIter = decltype(__unwrap_iter_impl<_Iter>::__unwrap(std::declval<_Iter>()));
+  using _UnwrappedIter  = decltype(__unwrap_iter_impl<_Iter>::__unwrap(std::declval<_Iter>()));
   using _ReverseWrapper = _RevIter1<_RevIter2<_Iter> >;
 
   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ReverseWrapper
@@ -500,9 +484,9 @@ struct __unwrap_reverse_iter_impl {
 
 #if _LIBCPP_STD_VER >= 20
 template <ranges::bidirectional_range _Range>
-_LIBCPP_HIDE_FROM_ABI constexpr ranges::
-    subrange<reverse_iterator<ranges::iterator_t<_Range>>, reverse_iterator<ranges::iterator_t<_Range>>>
-    __reverse_range(_Range&& __range) {
+_LIBCPP_HIDE_FROM_ABI constexpr ranges::subrange<reverse_iterator<ranges::iterator_t<_Range>>,
+                                                 reverse_iterator<ranges::iterator_t<_Range>>>
+__reverse_range(_Range&& __range) {
   auto __first = ranges::begin(__range);
   return {std::make_reverse_iterator(ranges::next(__first, ranges::end(__range))), std::make_reverse_iterator(__first)};
 }