some fix

changkhothuychung · changkhothuychung · commit 60a09f661269 · 2024-12-27T17:12:20.000-05:00
diff --git a/libcxx/include/__ranges/concat_view.h b/libcxx/include/__ranges/concat_view.h
@@ -63,18 +63,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template <class _T, class... _Ts>
-struct __extract_last : __extract_last<_Ts...> {};
+template <class _T, class... _Tp>
+struct __extract_last : __extract_last<_Tp...> {};
 
 template <class _T>
 struct __extract_last<_T> {
   using type = _T;
 };
 
-template <class _T, class... _Ts>
+template <class _T, class... _Tp>
 struct __derived_from_pack {
   constexpr static bool value =
-      __derived_from_pack<_T, typename __extract_last<_Ts...>::type>::value && __derived_from_pack<_Ts...>::value;
+      __derived_from_pack<_T, typename __extract_last<_Tp...>::type>::value && __derived_from_pack<_Tp...>::value;
 };
 
 template <class _T, class _IterCategory>
@@ -155,45 +155,45 @@ class concat_view : public view_interface<concat_view<_Views...>> {
 
   _LIBCPP_HIDE_FROM_ABI constexpr explicit concat_view(_Views... views) : views_(std::move(views)...) {}
 
-  constexpr iterator<false> begin()
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator<false> begin()
     requires(!(__simple_view<_Views> && ...))
   {
     iterator<false> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));
     it.template satisfy<0>();
     return it;
   }
 
-  constexpr iterator<true> begin() const
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator<true> begin() const
     requires((range<const _Views> && ...) && __concatable<const _Views...>)
   {
     iterator<true> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));
     it.template satisfy<0>();
     return it;
   }
 
-  constexpr auto end()
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
     requires(!(__simple_view<_Views> && ...))
   {
     if constexpr (common_range<typename __last_view<_Views...>::type>) {
-      constexpr auto N = sizeof...(_Views);
-      return iterator<false>(this, in_place_index<N - 1>, ranges::end(get<N - 1>(views_)));
+      constexpr auto __N = sizeof...(_Views);
+      return iterator<false>(this, in_place_index<__N - 1>, ranges::end(get<__N - 1>(views_)));
     } else {
       return default_sentinel;
     }
   }
 
-  constexpr auto end() const
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
     requires(range<const _Views> && ...)
   {
     if constexpr (common_range<typename __last_view<_Views...>::type>) {
-      constexpr auto N = sizeof...(_Views);
-      return iterator<true>(this, in_place_index<N - 1>, ranges::end(get<N - 1>(views_)));
+      constexpr auto __N = sizeof...(_Views);
+      return iterator<true>(this, in_place_index<__N - 1>, ranges::end(get<__N - 1>(views_)));
     } else {
       return default_sentinel;
     }
   }
 
-  constexpr auto size()
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
     requires(sized_range<_Views> && ...)
   {
     return apply(
@@ -204,7 +204,7 @@ class concat_view : public view_interface<concat_view<_Views...>> {
         tuple_transform(ranges::size, views_));
   }
 
-  constexpr auto size() const
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
     requires(sized_range<const _Views> && ...)
   {
     return apply(
@@ -255,7 +255,7 @@ class concat_view<_Views...>::iterator {
   __maybe_const<_Const, concat_view>* parent_ = nullptr;
 
   template <std::size_t N>
-  constexpr void satisfy() {
+  _LIBCPP_HIDE_FROM_ABI constexpr void satisfy() {
     if constexpr (N < (sizeof...(_Views) - 1)) {
       if (get<N>(it_) == ranges::end(get<N>(parent_->views_))) {
         it_.template emplace<N + 1>(ranges::begin(get<N + 1>(parent_->views_)));
@@ -265,7 +265,7 @@ class concat_view<_Views...>::iterator {
   }
 
   template <std::size_t N>
-  constexpr void prev() {
+  _LIBCPP_HIDE_FROM_ABI constexpr void prev() {
     if constexpr (N == 0) {
       --get<0>(it_);
     } else {
@@ -285,7 +285,7 @@ class concat_view<_Views...>::iterator {
   }
 
   template <std::size_t N>
-  constexpr void advance_fwd(difference_type offset, difference_type steps) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void advance_fwd(difference_type offset, difference_type steps) {
     using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base_iter>>;
     if constexpr (N == sizeof...(_Views) - 1) {
       get<N>(it_) += static_cast<underlying_diff_type>(steps);
@@ -301,7 +301,7 @@ class concat_view<_Views...>::iterator {
   }
 
   template <std::size_t N>
-  constexpr void advance_bwd(difference_type offset, difference_type steps) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void advance_bwd(difference_type offset, difference_type steps) {
     using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base_iter>>;
     if constexpr (N == 0) {
       get<N>(it_) -= static_cast<underlying_diff_type>(steps);
@@ -317,12 +317,12 @@ class concat_view<_Views...>::iterator {
   }
 
   template <size_t... Is, typename Func>
-  constexpr void apply_fn_with_const_index(size_t index, Func&& func, std::index_sequence<Is...>) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void apply_fn_with_const_index(size_t index, Func&& func, std::index_sequence<Is...>) {
     ((index == Is ? (func(std::integral_constant<size_t, Is>{}), 0) : 0), ...);
   }
 
   template <size_t N, typename Func>
-  constexpr void apply_fn_with_const_index(size_t index, Func&& func) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void apply_fn_with_const_index(size_t index, Func&& func) {
     apply_fn_with_const_index(index, std::forward<Func>(func), std::make_index_sequence<N>{});
   }
 
@@ -332,18 +332,18 @@ class concat_view<_Views...>::iterator {
       : it_(std::forward<Args>(args)...), parent_(parent) {}
 
 public:
-  iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI iterator() = default;
 
-  constexpr iterator(iterator<!_Const> i)
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator(iterator<!_Const> i)
     requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<const _Views>> && ...)
       : it_(base_iter(in_place_index<i.index()>, std::get<i.index()>(std::move(i.it_)))), parent_(i.parent_) {}
 
-  constexpr decltype(auto) operator*() const {
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const {
     using reference = __concat_reference_t<__maybe_const<_Const, _Views>...>;
     return std::visit([](auto&& it) -> reference { return *it; }, it_);
   }
 
-  constexpr iterator& operator++() {
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator++() {
     size_t active_index = it_.index();
     apply_fn_with_const_index<std::variant_size_v<decltype(it_)>>(active_index, [&](auto index_constant) {
       constexpr size_t i = index_constant.value;
@@ -353,17 +353,17 @@ class concat_view<_Views...>::iterator {
     return *this;
   }
 
-  constexpr void operator++(int) { ++*this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
 
-  constexpr iterator operator++(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator operator++(int)
     requires(forward_range<__maybe_const<_Const, _Views>> && ...)
   {
     auto tmp = *this;
     ++*this;
     return tmp;
   }
 
-  constexpr iterator& operator--()
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator--()
     requires __concat_is_bidirectional<_Const, _Views...>
   {
     size_t active_index = it_.index();
@@ -374,41 +374,41 @@ class concat_view<_Views...>::iterator {
     return *this;
   }
 
-  constexpr iterator operator--(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator operator--(int)
     requires __concat_is_bidirectional<_Const, _Views...>
   {
     auto __tmp = *this;
     --*this;
     return __tmp;
   }
 
-  friend constexpr bool operator==(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const iterator& x, const iterator& y)
     requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
   {
     return x.it_ == y.it_;
   }
 
-  constexpr decltype(auto) operator[](difference_type n) const
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type n) const
     requires __concat_is_random_access<_Const, _Views...>
   {
     return *((*this) + n);
   }
 
-  friend constexpr iterator operator+(const iterator& it, difference_type n)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iterator operator+(const iterator& it, difference_type n)
     requires __concat_is_random_access<_Const, _Views...>
   {
     auto temp = it;
     temp += n;
     return temp;
   }
 
-  friend constexpr iterator operator+(difference_type n, const iterator& it)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iterator operator+(difference_type n, const iterator& it)
     requires __concat_is_random_access<_Const, _Views...>
   {
     return it + n;
   }
 
-  constexpr iterator& operator+=(difference_type n)
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator+=(difference_type n)
     requires __concat_is_random_access<_Const, _Views...>
   {
     size_t active_index = it_.index();
@@ -443,51 +443,51 @@ class concat_view<_Views...>::iterator {
     return *this;
   }
 
-  constexpr iterator& operator-=(difference_type n)
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator-=(difference_type n)
     requires __concat_is_random_access<_Const, _Views...>
   {
     *this += -n;
     return *this;
   }
 
-  friend constexpr bool operator==(const iterator& it, default_sentinel_t) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const iterator& it, default_sentinel_t) {
     constexpr auto last_idx = sizeof...(_Views) - 1;
     return it.it_.index() == last_idx &&
            std::get<last_idx>(it.it_) == ranges::end(std::get<last_idx>(it.parent_->views_));
   }
 
-  friend constexpr bool operator<(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const iterator& x, const iterator& y)
     requires(random_access_range<__maybe_const<_Const, _Views>> && ...)
   {
     return x.it_ < y.it_;
   }
 
-  friend constexpr bool operator>(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const iterator& x, const iterator& y)
     requires(random_access_range<__maybe_const<_Const, _Views>> && ...)
   {
     return x.it_ > y.it_;
   }
 
-  friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const iterator& x, const iterator& y)
     requires(random_access_range<__maybe_const<_Const, _Views>> && ...)
   {
     return x.it_ <= y.it_;
   }
 
-  friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const iterator& x, const iterator& y)
     requires(random_access_range<__maybe_const<_Const, _Views>> && ...)
   {
     return x.it_ >= y.it_;
   }
 
-  friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const iterator& x, const iterator& y)
     requires((random_access_range<__maybe_const<_Const, _Views>> && ...) &&
              (three_way_comparable<__maybe_const<_Const, _Views>> && ...))
   {
     return x.it_ <=> y.it_;
   }
 
-  friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(
+  _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(
 
       ((is_nothrow_invocable_v< decltype(ranges::iter_move), const iterator_t<__maybe_const<_Const, _Views>>& >) &&
        ...) &&
@@ -503,7 +503,7 @@ class concat_view<_Views...>::iterator {
         it.it_);
   }
 
-  friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const iterator& x, const iterator& y)
 
       noexcept((noexcept(ranges::swap(*x, *y))) &&
                (noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<_Const, _Views>>>(),
@@ -525,7 +525,7 @@ class concat_view<_Views...>::iterator {
         y.it_);
   }
 
-  friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const iterator& x, const iterator& y)
     requires __concat_is_random_access<_Const, _Views...>
   {
     size_t ix = x.it_.index();
@@ -560,15 +560,15 @@ class concat_view<_Views...>::iterator {
     }
   }
 
-  friend constexpr iterator operator-(const iterator& it, difference_type n)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iterator operator-(const iterator& it, difference_type n)
     requires __concat_is_random_access<_Const, _Views...>
   {
     auto temp = it;
     temp -= n;
     return temp;
   }
 
-  friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
     requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
              ...) &&
             (__apply_drop_first<_Const, _Views...>::value)
@@ -591,7 +591,7 @@ class concat_view<_Views...>::iterator {
         x.it_);
   }
 
-  friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
     requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
              ...) &&
             (__apply_drop_first<_Const, _Views...>::value)
@@ -605,8 +605,7 @@ namespace __concat {
 struct __fn {
   template <class... _Views>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Views... views) const
-      noexcept(noexcept(concat_view(std::forward<_Views>(views)...)))
-          -> decltype(concat_view(std::forward<_Views>(views)...)) {
+      noexcept(noexcept(concat_view(std::forward<_Views>(views)...))) -> decltype(concat_view(std::forward<_Views>(views)...)) {
     return concat_view(std::forward<_Views>(views)...);
   }
 };

Original file line number	Diff line number	Diff line change
`@@ -63,18 +63,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD`
`63`	`63`
`64`	`64`	`namespace ranges {`
`65`	`65`
`66`		`-template <class _T, class... _Ts>`
`67`		`-struct __extract_last : __extract_last<_Ts...> {};`
	`66`	`+template <class _T, class... _Tp>`
	`67`	`+struct __extract_last : __extract_last<_Tp...> {};`
`68`	`68`
`69`	`69`	`template <class _T>`
`70`	`70`	`struct __extract_last<_T> {`
`71`	`71`	`using type = _T;`
`72`	`72`	`};`
`73`	`73`
`74`		`-template <class _T, class... _Ts>`
	`74`	`+template <class _T, class... _Tp>`
`75`	`75`	`struct __derived_from_pack {`
`76`	`76`	`constexpr static bool value =`
`77`		`- __derived_from_pack<_T, typename __extract_last<_Ts...>::type>::value && __derived_from_pack<_Ts...>::value;`
	`77`	`+ __derived_from_pack<_T, typename __extract_last<_Tp...>::type>::value && __derived_from_pack<_Tp...>::value;`
`78`	`78`	`};`
`79`	`79`
`80`	`80`	`template <class _T, class _IterCategory>`
`@@ -155,45 +155,45 @@ class concat_view : public view_interface<concat_view<_Views...>> {`
`155`	`155`
`156`	`156`	`_LIBCPP_HIDE_FROM_ABI constexpr explicit concat_view(_Views... views) : views_(std::move(views)...) {}`
`157`	`157`
`158`		`- constexpr iterator<false> begin()`
	`158`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator<false> begin()`
`159`	`159`	`requires(!(__simple_view<_Views> && ...))`
`160`	`160`	`{`
`161`	`161`	`iterator<false> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));`
`162`	`162`	`it.template satisfy<0>();`
`163`	`163`	`return it;`
`164`	`164`	`}`
`165`	`165`
`166`		`- constexpr iterator<true> begin() const`
	`166`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator<true> begin() const`
`167`	`167`	`requires((range<const _Views> && ...) && __concatable<const _Views...>)`
`168`	`168`	`{`
`169`	`169`	`iterator<true> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));`
`170`	`170`	`it.template satisfy<0>();`
`171`	`171`	`return it;`
`172`	`172`	`}`
`173`	`173`
`174`		`- constexpr auto end()`
	`174`	`+ _LIBCPP_HIDE_FROM_ABI constexpr auto end()`
`175`	`175`	`requires(!(__simple_view<_Views> && ...))`
`176`	`176`	`{`
`177`	`177`	`if constexpr (common_range<typename __last_view<_Views...>::type>) {`
`178`		`- constexpr auto N = sizeof...(_Views);`
`179`		`- return iterator<false>(this, in_place_index<N - 1>, ranges::end(get<N - 1>(views_)));`
	`178`	`+ constexpr auto __N = sizeof...(_Views);`
	`179`	`+ return iterator<false>(this, in_place_index<__N - 1>, ranges::end(get<__N - 1>(views_)));`
`180`	`180`	`} else {`
`181`	`181`	`return default_sentinel;`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`
`185`		`- constexpr auto end() const`
	`185`	`+ _LIBCPP_HIDE_FROM_ABI constexpr auto end() const`
`186`	`186`	`requires(range<const _Views> && ...)`
`187`	`187`	`{`
`188`	`188`	`if constexpr (common_range<typename __last_view<_Views...>::type>) {`
`189`		`- constexpr auto N = sizeof...(_Views);`
`190`		`- return iterator<true>(this, in_place_index<N - 1>, ranges::end(get<N - 1>(views_)));`
	`189`	`+ constexpr auto __N = sizeof...(_Views);`
	`190`	`+ return iterator<true>(this, in_place_index<__N - 1>, ranges::end(get<__N - 1>(views_)));`
`191`	`191`	`} else {`
`192`	`192`	`return default_sentinel;`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
`196`		`- constexpr auto size()`
	`196`	`+ _LIBCPP_HIDE_FROM_ABI constexpr auto size()`
`197`	`197`	`requires(sized_range<_Views> && ...)`
`198`	`198`	`{`
`199`	`199`	`return apply(`
`@@ -204,7 +204,7 @@ class concat_view : public view_interface<concat_view<_Views...>> {`
`204`	`204`	`tuple_transform(ranges::size, views_));`
`205`	`205`	`}`
`206`	`206`
`207`		`- constexpr auto size() const`
	`207`	`+ _LIBCPP_HIDE_FROM_ABI constexpr auto size() const`
`208`	`208`	`requires(sized_range<const _Views> && ...)`
`209`	`209`	`{`
`210`	`210`	`return apply(`
`@@ -255,7 +255,7 @@ class concat_view<_Views...>::iterator {`
`255`	`255`	`__maybe_const<_Const, concat_view>* parent_ = nullptr;`
`256`	`256`
`257`	`257`	`template <std::size_t N>`
`258`		`- constexpr void satisfy() {`
	`258`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void satisfy() {`
`259`	`259`	`if constexpr (N < (sizeof...(_Views) - 1)) {`
`260`	`260`	`if (get<N>(it_) == ranges::end(get<N>(parent_->views_))) {`
`261`	`261`	`it_.template emplace<N + 1>(ranges::begin(get<N + 1>(parent_->views_)));`
`@@ -265,7 +265,7 @@ class concat_view<_Views...>::iterator {`
`265`	`265`	`}`
`266`	`266`
`267`	`267`	`template <std::size_t N>`
`268`		`- constexpr void prev() {`
	`268`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void prev() {`
`269`	`269`	`if constexpr (N == 0) {`
`270`	`270`	`--get<0>(it_);`
`271`	`271`	`} else {`
`@@ -285,7 +285,7 @@ class concat_view<_Views...>::iterator {`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`template <std::size_t N>`
`288`		`- constexpr void advance_fwd(difference_type offset, difference_type steps) {`
	`288`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void advance_fwd(difference_type offset, difference_type steps) {`
`289`	`289`	`using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base_iter>>;`
`290`	`290`	`if constexpr (N == sizeof...(_Views) - 1) {`
`291`	`291`	`get<N>(it_) += static_cast<underlying_diff_type>(steps);`
`@@ -301,7 +301,7 @@ class concat_view<_Views...>::iterator {`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`template <std::size_t N>`
`304`		`- constexpr void advance_bwd(difference_type offset, difference_type steps) {`
	`304`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void advance_bwd(difference_type offset, difference_type steps) {`
`305`	`305`	`using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base_iter>>;`
`306`	`306`	`if constexpr (N == 0) {`
`307`	`307`	`get<N>(it_) -= static_cast<underlying_diff_type>(steps);`
`@@ -317,12 +317,12 @@ class concat_view<_Views...>::iterator {`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`template <size_t... Is, typename Func>`
`320`		`- constexpr void apply_fn_with_const_index(size_t index, Func&& func, std::index_sequence<Is...>) {`
	`320`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void apply_fn_with_const_index(size_t index, Func&& func, std::index_sequence<Is...>) {`
`321`	`321`	`((index == Is ? (func(std::integral_constant<size_t, Is>{}), 0) : 0), ...);`
`322`	`322`	`}`
`323`	`323`
`324`	`324`	`template <size_t N, typename Func>`
`325`		`- constexpr void apply_fn_with_const_index(size_t index, Func&& func) {`
	`325`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void apply_fn_with_const_index(size_t index, Func&& func) {`
`326`	`326`	`apply_fn_with_const_index(index, std::forward<Func>(func), std::make_index_sequence<N>{});`
`327`	`327`	`}`
`328`	`328`
`@@ -332,18 +332,18 @@ class concat_view<_Views...>::iterator {`
`332`	`332`	`: it_(std::forward<Args>(args)...), parent_(parent) {}`
`333`	`333`
`334`	`334`	`public:`
`335`		`- iterator() = default;`
	`335`	`+ _LIBCPP_HIDE_FROM_ABI iterator() = default;`
`336`	`336`
`337`		`- constexpr iterator(iterator<!_Const> i)`
	`337`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator(iterator<!_Const> i)`
`338`	`338`	`requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<const _Views>> && ...)`
`339`	`339`	`: it_(base_iter(in_place_index<i.index()>, std::get<i.index()>(std::move(i.it_)))), parent_(i.parent_) {}`
`340`	`340`
`341`		`- constexpr decltype(auto) operator*() const {`
	`341`	`+ _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const {`
`342`	`342`	`using reference = __concat_reference_t<__maybe_const<_Const, _Views>...>;`
`343`	`343`	`return std::visit([](auto&& it) -> reference { return *it; }, it_);`
`344`	`344`	`}`
`345`	`345`
`346`		`- constexpr iterator& operator++() {`
	`346`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator++() {`
`347`	`347`	`size_t active_index = it_.index();`
`348`	`348`	`apply_fn_with_const_index<std::variant_size_v<decltype(it_)>>(active_index, [&](auto index_constant) {`
`349`	`349`	`constexpr size_t i = index_constant.value;`
`@@ -353,17 +353,17 @@ class concat_view<_Views...>::iterator {`
`353`	`353`	`return *this;`
`354`	`354`	`}`
`355`	`355`
`356`		`- constexpr void operator++(int) { ++*this; }`
	`356`	`+ _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }`
`357`	`357`
`358`		`- constexpr iterator operator++(int)`
	`358`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator operator++(int)`
`359`	`359`	`requires(forward_range<__maybe_const<_Const, _Views>> && ...)`
`360`	`360`	`{`
`361`	`361`	`auto tmp = *this;`
`362`	`362`	`++*this;`
`363`	`363`	`return tmp;`
`364`	`364`	`}`
`365`	`365`
`366`		`- constexpr iterator& operator--()`
	`366`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator--()`
`367`	`367`	`requires __concat_is_bidirectional<_Const, _Views...>`
`368`	`368`	`{`
`369`	`369`	`size_t active_index = it_.index();`
`@@ -374,41 +374,41 @@ class concat_view<_Views...>::iterator {`
`374`	`374`	`return *this;`
`375`	`375`	`}`
`376`	`376`
`377`		`- constexpr iterator operator--(int)`
	`377`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator operator--(int)`
`378`	`378`	`requires __concat_is_bidirectional<_Const, _Views...>`
`379`	`379`	`{`
`380`	`380`	`auto __tmp = *this;`
`381`	`381`	`--*this;`
`382`	`382`	`return __tmp;`
`383`	`383`	`}`
`384`	`384`
`385`		`- friend constexpr bool operator==(const iterator& x, const iterator& y)`
	`385`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const iterator& x, const iterator& y)`
`386`	`386`	`requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)`
`387`	`387`	`{`
`388`	`388`	`return x.it_ == y.it_;`
`389`	`389`	`}`
`390`	`390`
`391`		`- constexpr decltype(auto) operator[](difference_type n) const`
	`391`	`+ _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type n) const`
`392`	`392`	`requires __concat_is_random_access<_Const, _Views...>`
`393`	`393`	`{`
`394`	`394`	`return ((this) + n);`
`395`	`395`	`}`
`396`	`396`
`397`		`- friend constexpr iterator operator+(const iterator& it, difference_type n)`
	`397`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr iterator operator+(const iterator& it, difference_type n)`
`398`	`398`	`requires __concat_is_random_access<_Const, _Views...>`
`399`	`399`	`{`
`400`	`400`	`auto temp = it;`
`401`	`401`	`temp += n;`
`402`	`402`	`return temp;`
`403`	`403`	`}`
`404`	`404`
`405`		`- friend constexpr iterator operator+(difference_type n, const iterator& it)`
	`405`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr iterator operator+(difference_type n, const iterator& it)`
`406`	`406`	`requires __concat_is_random_access<_Const, _Views...>`
`407`	`407`	`{`
`408`	`408`	`return it + n;`
`409`	`409`	`}`
`410`	`410`
`411`		`- constexpr iterator& operator+=(difference_type n)`
	`411`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator+=(difference_type n)`
`412`	`412`	`requires __concat_is_random_access<_Const, _Views...>`
`413`	`413`	`{`
`414`	`414`	`size_t active_index = it_.index();`
`@@ -443,51 +443,51 @@ class concat_view<_Views...>::iterator {`
`443`	`443`	`return *this;`
`444`	`444`	`}`
`445`	`445`
`446`		`- constexpr iterator& operator-=(difference_type n)`
	`446`	`+ _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator-=(difference_type n)`
`447`	`447`	`requires __concat_is_random_access<_Const, _Views...>`
`448`	`448`	`{`
`449`	`449`	`*this += -n;`
`450`	`450`	`return *this;`
`451`	`451`	`}`
`452`	`452`
`453`		`- friend constexpr bool operator==(const iterator& it, default_sentinel_t) {`
	`453`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const iterator& it, default_sentinel_t) {`
`454`	`454`	`constexpr auto last_idx = sizeof...(_Views) - 1;`
`455`	`455`	`return it.it_.index() == last_idx &&`
`456`	`456`	`std::get<last_idx>(it.it_) == ranges::end(std::get<last_idx>(it.parent_->views_));`
`457`	`457`	`}`
`458`	`458`
`459`		`- friend constexpr bool operator<(const iterator& x, const iterator& y)`
	`459`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const iterator& x, const iterator& y)`
`460`	`460`	`requires(random_access_range<__maybe_const<_Const, _Views>> && ...)`
`461`	`461`	`{`
`462`	`462`	`return x.it_ < y.it_;`
`463`	`463`	`}`
`464`	`464`
`465`		`- friend constexpr bool operator>(const iterator& x, const iterator& y)`
	`465`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const iterator& x, const iterator& y)`
`466`	`466`	`requires(random_access_range<__maybe_const<_Const, _Views>> && ...)`
`467`	`467`	`{`
`468`	`468`	`return x.it_ > y.it_;`
`469`	`469`	`}`
`470`	`470`
`471`		`- friend constexpr bool operator<=(const iterator& x, const iterator& y)`
	`471`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const iterator& x, const iterator& y)`
`472`	`472`	`requires(random_access_range<__maybe_const<_Const, _Views>> && ...)`
`473`	`473`	`{`
`474`	`474`	`return x.it_ <= y.it_;`
`475`	`475`	`}`
`476`	`476`
`477`		`- friend constexpr bool operator>=(const iterator& x, const iterator& y)`
	`477`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const iterator& x, const iterator& y)`
`478`	`478`	`requires(random_access_range<__maybe_const<_Const, _Views>> && ...)`
`479`	`479`	`{`
`480`	`480`	`return x.it_ >= y.it_;`
`481`	`481`	`}`
`482`	`482`
`483`		`- friend constexpr auto operator<=>(const iterator& x, const iterator& y)`
	`483`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const iterator& x, const iterator& y)`
`484`	`484`	`requires((random_access_range<__maybe_const<_Const, _Views>> && ...) &&`
`485`	`485`	`(three_way_comparable<__maybe_const<_Const, _Views>> && ...))`
`486`	`486`	`{`
`487`	`487`	`return x.it_ <=> y.it_;`
`488`	`488`	`}`
`489`	`489`
`490`		`- friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(`
	`490`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(`
`491`	`491`
`492`	`492`	`((is_nothrow_invocable_v< decltype(ranges::iter_move), const iterator_t<__maybe_const<_Const, _Views>>& >) &&`
`493`	`493`	`...) &&`
`@@ -503,7 +503,7 @@ class concat_view<_Views...>::iterator {`
`503`	`503`	`it.it_);`
`504`	`504`	`}`
`505`	`505`
`506`		`- friend constexpr void iter_swap(const iterator& x, const iterator& y)`
	`506`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const iterator& x, const iterator& y)`
`507`	`507`
`508`	`508`	`noexcept((noexcept(ranges::swap(x, y))) &&`
`509`	`509`	`(noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<_Const, _Views>>>(),`
`@@ -525,7 +525,7 @@ class concat_view<_Views...>::iterator {`
`525`	`525`	`y.it_);`
`526`	`526`	`}`
`527`	`527`
`528`		`- friend constexpr difference_type operator-(const iterator& x, const iterator& y)`
	`528`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const iterator& x, const iterator& y)`
`529`	`529`	`requires __concat_is_random_access<_Const, _Views...>`
`530`	`530`	`{`
`531`	`531`	`size_t ix = x.it_.index();`
`@@ -560,15 +560,15 @@ class concat_view<_Views...>::iterator {`
`560`	`560`	`}`
`561`	`561`	`}`
`562`	`562`
`563`		`- friend constexpr iterator operator-(const iterator& it, difference_type n)`
	`563`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr iterator operator-(const iterator& it, difference_type n)`
`564`	`564`	`requires __concat_is_random_access<_Const, _Views...>`
`565`	`565`	`{`
`566`	`566`	`auto temp = it;`
`567`	`567`	`temp -= n;`
`568`	`568`	`return temp;`
`569`	`569`	`}`
`570`	`570`
`571`		`- friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)`
	`571`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)`
`572`	`572`	`requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&`
`573`	`573`	`...) &&`
`574`	`574`	`(__apply_drop_first<_Const, _Views...>::value)`
`@@ -591,7 +591,7 @@ class concat_view<_Views...>::iterator {`
`591`	`591`	`x.it_);`
`592`	`592`	`}`
`593`	`593`
`594`		`- friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)`
	`594`	`+ _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)`
`595`	`595`	`requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&`
`596`	`596`	`...) &&`
`597`	`597`	`(__apply_drop_first<_Const, _Views...>::value)`
`@@ -605,8 +605,7 @@ namespace __concat {`
`605`	`605`	`struct __fn {`
`606`	`606`	`template <class... _Views>`
`607`	`607`	`[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Views... views) const`
`608`		`- noexcept(noexcept(concat_view(std::forward<_Views>(views)...)))`
`609`		`- -> decltype(concat_view(std::forward<_Views>(views)...)) {`
	`608`	`+ noexcept(noexcept(concat_view(std::forward<_Views>(views)...))) -> decltype(concat_view(std::forward<_Views>(views)...)) {`
`610`	`609`	`return concat_view(std::forward<_Views>(views)...);`
`611`	`610`	`}`
`612`	`611`	`};`