[libc++] Add a bunch of missing _LIBCPP_HIDE_FROM_ABI in <ranges>

[ldionne]

Summary

We've been forgetting to add those to most of the <ranges> review.
To avoid forgetting in the future, I added an item in the pre-commit
checklist.

[ldionne]

Fix a few failures with [[nodiscard]] interaction

[Mordante]

libcxx/docs/Contributing.rst

34

Shouldn't this be more general?
Did you mark all functions and type declarations with the proper visibility macro?
Where visibility macro links to https://libcxx.llvm.org/DesignDocs/VisibilityMacros.html

Maybe, in a separate commit, you can have a look at the VisibilityMacro page. It doesn't list _LIBCPP_INLINE_VISIBILITY. I wonder what the difference between _LIBCPP_HIDE_FROM_ABI` and _LIBCPP_INLINE_VISIBILITY is. Grepping our codebase I see not many occurrences of _LIBCPP_HIDE_FROM_ABI, but a lot of _LIBCPP_INLINE_VISIBILITY. Looking at the amount of _LIBCPP_HIDE_FROM_ABI used in ranges I start to wonder whether the wrong macro is used at other places.

[ldionne]

libcxx/docs/Contributing.rst

34

Shouldn't this be more general?

Hmm, yes, I agree. Will fix.

Maybe, in a separate commit, you can have a look at the VisibilityMacro page. It doesn't list _LIBCPP_INLINE_VISIBILITY.

That's loaded with history. Basically, _LIBCPP_INLINE_VISIBILITY is the same as _LIBCPP_HIDE_FROM_ABI, but _LIBCPP_HIDE_FROM_ABI is the newer and more descriptive spelling. In the past, it made sense to use _LIBCPP_INLINE_VISIBILITY because it was implemented with __always_inline__, but it's not anymore, so _LIBCPP_HIDE_FROM_ABI makes more sense. I didn't do a wholesale renaming of _LIBCPP_INLINE_VISIBILITY => _LIBCPP_HIDE_FROM_ABI because I wanted to avoid touching like 50% of the lines in the library.

[Mordante]

libcxx/docs/Contributing.rst

34

Basically, _LIBCPP_INLINE_VISIBILITY is the same as _LIBCPP_HIDE_FROM_ABI, but _LIBCPP_HIDE_FROM_ABI is the newer and more descriptive spelling. In the past, it made sense to use _LIBCPP_INLINE_VISIBILITY because it was implemented with __always_inline__, but it's not anymore, so _LIBCPP_HIDE_FROM_ABI makes more sense. I didn't do a wholesale renaming of _LIBCPP_INLINE_VISIBILITY => _LIBCPP_HIDE_FROM_ABI because I wanted to avoid touching like 50% of the lines in the library.

I agree it's not a good idea to do this conversion, unless we want to do other large changes touching the entire library; like running clang-format on all code. The only disadvantage of having most code using _LIBCPP_INLINE_VISIBILITY is that (new) contributors will probably emulate the wrong style. So maybe adding a note here about the state of _LIBCPP_INLINE_VISIBILITY would be a good idea. In the format library I've used _LIBCPP_INLINE_VISIBILITY, since I thought that was the proper way.

[ldionne]

libcxx/docs/Contributing.rst

34

I added documentation for _LIBCPP_INLINE_VISIBILITY and reworded the checklist as you suggested. Thanks for the comments!

[Mordante]

libcxx/docs/Contributing.rst

34

Thanks the change looks good!

libcxx/docs/Contributing.rst

 =====================
 
 Before committing or creating a review, please go through this check-list to make
 sure you don't forget anything:
 
 - Do you have tests for every public class and/or function you're adding or modifying?
 - Did you update the synopsis of the relevant headers?
 - Did you update the relevant files to track implementation status (in ``docs/Status/``)?
+- Did you mark all functions and type declarations with the :ref:`proper visibility macro <visibility-macros>`?
 - If you added a header:
 
   - Did you add it to ``include/module.modulemap``?
   - Did you add it to ``include/CMakeLists.txt``?
   - If it's a public header, did you add a test under ``test/libcxx`` that the new header defines ``_LIBCPP_VERSION``? See ``test/libcxx/algorithms/version.pass.cpp`` for an example. NOTE: This should be automated.
   - If it's a public header, did you update ``utils/generate_header_inclusion_tests.py``?
 
 - Did you add the relevant feature test macro(s) for your feature? Did you update the ``generate_feature_test_macro_components.py`` script with it?

libcxx/docs/DesignDocs/VisibilityMacros.rst

 ========================
 Symbol Visibility Macros
 ========================
 
 .. contents::
    :local:
 
+.. _visibility-macros:
+
 Overview
 ========
 
 Libc++ uses various "visibility" macros in order to provide a stable ABI in
 both the library and the headers. These macros work by changing the
 visibility and inlining characteristics of the symbols they are applied to.
 
 Visibility Macros
**_LIBCPP_OVERRIDABLE_FUNC_VIS**
   locally overridable, and therefore must not be marked `dllimport`. On Windows,
   this macro therefore expands to `__declspec(dllexport)` when building the
   library and has an empty definition otherwise.
 
 **_LIBCPP_HIDE_FROM_ABI**
   Mark a function as not being part of the ABI of any final linked image that
   uses it.
 
+**_LIBCPP_INLINE_VISIBILITY**
+  Historical predecessor of ``_LIBCPP_HIDE_FROM_ABI`` -- please use
+  ``_LIBCPP_HIDE_FROM_ABI`` instead.
+
 **_LIBCPP_HIDE_FROM_ABI_AFTER_V1**
   Mark a function as being hidden from the ABI (per `_LIBCPP_HIDE_FROM_ABI`)
   when libc++ is built with an ABI version after ABI v1. This macro is used to
   maintain ABI compatibility for symbols that have been historically exported
   by libc++ in v1 of the ABI, but that we don't want to export in the future.
 
   This macro works as follows. When we build libc++, we either hide the symbol
   from the ABI (if the symbol is not part of the ABI in the version we're

libcxx/include/__iterator/advance.h

 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 // [range.iter.op.advance]
 struct __advance_fn final : __function_like {
 private:
   template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr _Tp __abs(_Tp __n) noexcept {
     return __n < 0 ? -__n : __n;
   }
 
   template <class _Ip>
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr void __advance_forward(_Ip& __i, iter_difference_t<_Ip> __n) {
     while (__n > 0) {
       --__n;
       ++__i;
     }
   }
 
   template <class _Ip>
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr void __advance_backward(_Ip& __i, iter_difference_t<_Ip> __n) {
     while (__n < 0) {
       ++__n;
       --__i;
     }
   }
 
 public:
   constexpr explicit __advance_fn(__tag __x) noexcept : __function_like(__x) {}
 
   // Preconditions: If `I` does not model `bidirectional_iterator`, `n` is not negative.
   template <input_or_output_iterator _Ip>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr void operator()(_Ip& __i, iter_difference_t<_Ip> __n) const {
     _LIBCPP_ASSERT(__n >= 0 || bidirectional_iterator<_Ip>,
                    "If `n < 0`, then `bidirectional_iterator<I>` must be true.");
 
     // If `I` models `random_access_iterator`, equivalent to `i += n`.
     if constexpr (random_access_iterator<_Ip>) {
       __i += __n;
       return;
     } else if constexpr (bidirectional_iterator<_Ip>) {
       // Otherwise, if `n` is non-negative, increments `i` by `n`.
       __advance_forward(__i, __n);
       // Otherwise, decrements `i` by `-n`.
       __advance_backward(__i, __n);
       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.
   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)`.
     if constexpr (assignable_from<_Ip&, _Sp>) {
       __i = std::move(__bound);
     }
     // Otherwise, if `S` and `I` model `sized_sentinel_for<S, I>`, equivalent to `ranges::advance(i, bound - i)`.
     else if constexpr (sized_sentinel_for<_Sp, _Ip>) {
       (*this)(__i, __bound - __i);
     }
     // Otherwise, while `bool(i != bound)` is true, increments `i`.
     else {
       while (__i != __bound) {
         ++__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>`.
   // Returns: `n - M`, where `M` is the difference between the 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_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 (const auto __M = __bound - __i; __abs(__n) >= __abs(__M)) {
         (*this)(__i, __bound);

libcxx/include/__iterator/erase_if_container.h

 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Container, class _Predicate>
+_LIBCPP_HIDE_FROM_ABI
 typename _Container::size_type
 __libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
   typename _Container::size_type __old_size = __c.size();
 
   const typename _Container::iterator __last = __c.end();
   for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) {
     if (__pred(*__iter))
       __iter = __c.erase(__iter);

libcxx/include/__iterator/iter_move.h

 // The expression ranges::iter_move(E) for a subexpression E is
 // expression-equivalent to:
 struct __fn {
   // [iterator.cust.move]/1.1
   // iter_move(E), if E has class or enumeration type and iter_move(E) is a
   // well-formed expression when treated as an unevaluated operand, [...]
   template<class _Ip>
     requires __class_or_enum<remove_cvref_t<_Ip>> && __unqualified_iter_move<_Ip>
-  [[nodiscard]] constexpr decltype(auto) operator()(_Ip&& __i) const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
     noexcept(noexcept(iter_move(_VSTD::forward<_Ip>(__i))))
   {
     return iter_move(_VSTD::forward<_Ip>(__i));
   }
 
   // [iterator.cust.move]/1.2
   // Otherwise, if the expression *E is well-formed:
   //  1.2.1 if *E is an lvalue, std::move(*E);
   //  1.2.2 otherwise, *E.
   template<class _Ip>
     requires (!(__class_or_enum<remove_cvref_t<_Ip>> && __unqualified_iter_move<_Ip>)) &&
     requires(_Ip&& __i) { *_VSTD::forward<_Ip>(__i); }
-  [[nodiscard]] constexpr decltype(auto) operator()(_Ip&& __i) const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
     noexcept(noexcept(*_VSTD::forward<_Ip>(__i)))
   {
     if constexpr (is_lvalue_reference_v<decltype(*_VSTD::forward<_Ip>(__i))>) {
       return _VSTD::move(*_VSTD::forward<_Ip>(__i));
     } else {
       return *_VSTD::forward<_Ip>(__i);
     }
   }

libcxx/include/__iterator/iter_swap.h

namespace __iter_swap {
   template<class _T1, class _T2>
   concept __readable_swappable =
     indirectly_readable<_T1> && indirectly_readable<_T2> &&
     swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
 
   struct __fn {
     template <class _T1, class _T2>
       requires __unqualified_iter_swap<_T1, _T2>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y))))
     {
       (void)iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
     }
 
     template <class _T1, class _T2>
       requires (!__unqualified_iter_swap<_T1, _T2>) &&
                __readable_swappable<_T1, _T2>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y))))
     {
       ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y));
     }
 
     template <class _T1, class _T2>
       requires (!__unqualified_iter_swap<_T1, _T2> &&
                 !__readable_swappable<_T1, _T2>) &&
                indirectly_movable_storable<_T1, _T2> &&
                indirectly_movable_storable<_T2, _T1>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(iter_value_t<_T2>(ranges::iter_move(__y))) &&
                noexcept(*__y = ranges::iter_move(__x)) &&
                noexcept(*_VSTD::forward<_T1>(__x) = declval<iter_value_t<_T2>>()))
     {
       iter_value_t<_T2> __old(ranges::iter_move(__y));
       *__y = ranges::iter_move(__x);
       *_VSTD::forward<_T1>(__x) = _VSTD::move(__old);

libcxx/include/__iterator/next.h

inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   _VSTD::advance(__x, __n);
   return __x;
 }
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 struct __next_fn final : private __function_like {
+  _LIBCPP_HIDE_FROM_ABI
   constexpr explicit __next_fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <input_or_output_iterator _Ip>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr _Ip operator()(_Ip __x) const {
     ++__x;
     return __x;
   }
 
   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);
     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);
     return __x;
   }
 };
 
 inline constexpr auto next = __next_fn(__function_like::__tag());
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_PRIMITIVES_H

libcxx/include/__iterator/prev.h

inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   _VSTD::advance(__x, -__n);
   return __x;
 }
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 struct __prev_fn final : private __function_like {
+  _LIBCPP_HIDE_FROM_ABI
   constexpr explicit __prev_fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <bidirectional_iterator _Ip>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr _Ip operator()(_Ip __x) const {
     --__x;
     return __x;
   }
 
   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);
     return __x;
   }
 };
 
 inline constexpr auto prev = __prev_fn(__function_like::__tag());
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_PREV_H

libcxx/include/__ranges/access.h

concept __unqualified_begin =
     __class_or_enum<remove_cvref_t<_Tp> > &&
     requires(_Tp && __t) {
       { _VSTD::__decay_copy(begin(__t)) } -> input_or_output_iterator;
     };
 
   struct __fn {
     template <class _Tp>
     requires is_array_v<remove_cv_t<_Tp>>
-    [[nodiscard]] constexpr auto operator()(_Tp& __t) const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const noexcept {
       constexpr bool __complete = __is_complete<iter_value_t<_Tp> >;
       if constexpr (__complete) { // used to disable cryptic diagnostic
         return __t + 0;
       }
       else {
         static_assert(__complete, "`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type.");
       }
     }
 
     template <class _Tp>
     requires __member_begin<_Tp>
-    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(_VSTD::__decay_copy(__t.begin())))
     {
       return __t.begin();
     }
 
     template <class _Tp>
     requires __unqualified_begin<_Tp>
-    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(_VSTD::__decay_copy(begin(__t))))
     {
       return begin(__t);
     }
 
     void operator()(auto&&) const = delete;
   };
 } // namespace ranges::__begin
concept __unqualified_end =
     requires(_Tp && __t) {
       typename iterator_t<_Tp>;
       { _VSTD::__decay_copy(end(_VSTD::forward<_Tp>(__t))) } -> sentinel_for<iterator_t<_Tp> >;
     };
 
   class __fn {
   public:
     template <class _Tp, size_t _Np>
-    [[nodiscard]] constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept {
       constexpr bool __complete = __is_complete<remove_cv_t<_Tp> >;
       if constexpr (__complete) { // used to disable cryptic diagnostic
         return __t + _Np;
       }
       else {
         static_assert(__complete, "`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type.");
       }
     }
 
     template <class _Tp>
     requires __member_end<_Tp>
-    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(_VSTD::__decay_copy(__t.end())))
     {
       return _VSTD::forward<_Tp>(__t).end();
     }
 
     template <class _Tp>
     requires __unqualified_end<_Tp>
-    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(_VSTD::__decay_copy(end(__t))))
     {
       return end(__t);
     }
 
     void operator()(auto&&) const = delete;
   };
 } // namespace ranges::__end
 
 namespace ranges::inline __cpo {
   inline constexpr auto end = __end::__fn{};
 } // namespace ranges::__cpo
 
 namespace ranges::__cbegin {
   struct __fn {
     template <class _Tp>
     requires invocable<decltype(ranges::begin), _Tp const&>
-    [[nodiscard]] constexpr auto operator()(_Tp& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const
     noexcept(noexcept(ranges::begin(_VSTD::as_const(__t))))
     {
       return ranges::begin(_VSTD::as_const(__t));
     }
 
     template <class _Tp>
     requires is_rvalue_reference_v<_Tp> && invocable<decltype(ranges::begin), _Tp const&&>
-    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(ranges::begin(static_cast<_Tp const&&>(__t))))
     {
       return ranges::begin(static_cast<_Tp const&&>(__t));
     }
   };
 } // namespace ranges::__cbegin
 
 namespace ranges::inline __cpo {
   inline constexpr auto cbegin = __cbegin::__fn{};
 } // namespace ranges::__cpo
 
 namespace ranges::__cend {
   struct __fn {
     template <class _Tp>
     requires invocable<decltype(ranges::end), _Tp const&>
-    [[nodiscard]] constexpr auto operator()(_Tp& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const
     noexcept(noexcept(ranges::end(_VSTD::as_const(__t))))
     {
       return ranges::end(_VSTD::as_const(__t));
     }
 
     template <class _Tp>
     requires is_rvalue_reference_v<_Tp> && invocable<decltype(ranges::end), _Tp const&&>
-    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(ranges::end(static_cast<_Tp const&&>(__t))))
     {
       return ranges::end(static_cast<_Tp const&&>(__t));
     }
   };
 } // namespace ranges::__cend
 
 namespace ranges::inline __cpo {

libcxx/include/__ranges/all.h

 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace views {
 
 namespace __all {
   struct __fn {
     template<class _Tp>
       requires ranges::view<decay_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(_VSTD::__decay_copy(_VSTD::forward<_Tp>(__t))))
     {
       return _VSTD::forward<_Tp>(__t);
     }
 
     template<class _Tp>
       requires (!ranges::view<decay_t<_Tp>>) &&
                requires (_Tp&& __t) { ranges::ref_view{_VSTD::forward<_Tp>(__t)}; }
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::ref_view{_VSTD::forward<_Tp>(__t)}))
     {
       return ranges::ref_view{_VSTD::forward<_Tp>(__t)};
     }
 
     template<class _Tp>
       requires (!ranges::view<decay_t<_Tp>> &&
                 !requires (_Tp&& __t) { ranges::ref_view{_VSTD::forward<_Tp>(__t)}; } &&
                  requires (_Tp&& __t) { ranges::subrange{_VSTD::forward<_Tp>(__t)}; })
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::subrange{_VSTD::forward<_Tp>(__t)}))
     {
       return ranges::subrange{_VSTD::forward<_Tp>(__t)};
     }
   };
 }
 

libcxx/include/__ranges/data.h

concept __ranges_begin_invocable =
     requires(_Tp&& __t) {
       { _VSTD::forward<_Tp>(__t) } -> __can_borrow;
       { ranges::begin(_VSTD::forward<_Tp>(__t)) } -> contiguous_iterator;
     };
 
   struct __fn {
     template <__member_data _Tp>
       requires __can_borrow<_Tp>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr __ptr_to_object auto operator()(_Tp&& __t) const
         noexcept(noexcept(__t.data())) {
       return __t.data();
     }
 
     template<__ranges_begin_invocable _Tp>
       requires __can_borrow<_Tp>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr __ptr_to_object auto operator()(_Tp&& __t) const
         noexcept(noexcept(_VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t))))) {
       return _VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t)));
     }
   };
 } // end namespace __data
 
 inline namespace __cpo {

libcxx/include/__ranges/drop_view.h

class drop_view
     // is not a forward iterator.
     [[no_unique_address]] conditional_t<_UseCache, _Cache, _Empty> __cached_begin_;
     range_difference_t<_View> __count_ = 0;
     _View __base_ = _View();
 
 public:
     drop_view() requires default_initializable<_View> = default;
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr drop_view(_View __base, range_difference_t<_View> __count)
       : __cached_begin_()
       , __count_(__count)
       , __base_(_VSTD::move(__base))
     {
       _LIBCPP_ASSERT(__count_ >= 0, "count must be greater than or equal to zero.");
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr drop_view(drop_view const& __other)
       : __cached_begin_() // Intentionally not propagating the cached begin iterator.
       , __count_(__other.__count_)
       , __base_(__other.__base_)
     { }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr drop_view(drop_view&& __other)
       : __cached_begin_() // Intentionally not propagating the cached begin iterator.
       , __count_(_VSTD::move(__other.__count_))
       , __base_(_VSTD::move(__other.__base_))
     { }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr drop_view& operator=(drop_view const& __other) {
       if constexpr (_UseCache) {
         __cached_begin_.reset();
       }
       __base_ = __other.__base_;
       __count_ = __other.__count_;
       return *this;
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr drop_view& operator=(drop_view&& __other) {
       if constexpr (_UseCache) {
         __cached_begin_.reset();
         __other.__cached_begin_.reset();
       }
       __base_ = _VSTD::move(__other.__base_);
       __count_ = _VSTD::move(__other.__count_);
       return *this;
     }
 
-    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-    constexpr _View base() && { return _VSTD::move(__base_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return _VSTD::move(__base_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin()
       requires (!(__simple_view<_View> &&
                   random_access_range<const _View> && sized_range<const _View>))
     {
       if constexpr (_UseCache)
         if (__cached_begin_)
           return *__cached_begin_;
 
       auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
       if constexpr (_UseCache)
         __cached_begin_ = __tmp;
       return __tmp;
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin() const
       requires random_access_range<const _View> && sized_range<const _View>
     {
       return ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto end()
       requires (!__simple_view<_View>)
     { return ranges::end(__base_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto end() const
       requires range<const _View>
     { return ranges::end(__base_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     static constexpr auto __size(auto& __self) {
       const auto __s = ranges::size(__self.__base_);
       const auto __c = static_cast<decltype(__s)>(__self.__count_);
       return __s < __c ? 0 : __s - __c;
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto size()
       requires sized_range<_View>
     { return __size(*this); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto size() const
       requires sized_range<const _View>
     { return __size(*this); }
   };
 
   template<class _Range>
   drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>;
 
   template<class _Tp>
   inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>;
-
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/__ranges/empty.h

concept __can_compare_begin_end =
     !__can_invoke_size<_Tp> &&
     requires(_Tp&& __t) {
       bool(ranges::begin(__t) == ranges::end(__t));
       { ranges::begin(__t) } -> forward_iterator;
     };
 
   struct __fn {
     template <__member_empty _Tp>
-    [[nodiscard]] constexpr bool operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
         noexcept(noexcept(bool(__t.empty()))) {
       return __t.empty();
     }
 
     template <__can_invoke_size _Tp>
-    [[nodiscard]] constexpr bool operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::size(_VSTD::forward<_Tp>(__t)))) {
       return ranges::size(_VSTD::forward<_Tp>(__t)) == 0;
     }
 
     template<__can_compare_begin_end _Tp>
-    [[nodiscard]] constexpr bool operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
         noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
       return ranges::begin(__t) == ranges::end(__t);
     }
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto empty = __empty::__fn{};

libcxx/include/__ranges/empty_view.h

 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
   template<class _Tp>
     requires is_object_v<_Tp>
   class empty_view : public view_interface<empty_view<_Tp>> {
   public:
-    static constexpr _Tp* begin() noexcept { return nullptr; }
-    static constexpr _Tp* end() noexcept { return nullptr; }
-    static constexpr _Tp* data() noexcept { return nullptr; }
-    static constexpr size_t size() noexcept { return 0; }
-    static constexpr bool empty() noexcept { return true; }
+    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
+    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
+    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
+    _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
+    _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
   };
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_EMPTY_VIEW_H

libcxx/include/__ranges/ref_view.h

class ref_view : public view_interface<ref_view<_Range>> {
 
     static void __fun(_Range&);
     static void __fun(_Range&&) = delete;
 
 public:
     template<class _Tp>
       requires __different_from<_Tp, ref_view> &&
         convertible_to<_Tp, _Range&> && requires { __fun(declval<_Tp>()); }
+    _LIBCPP_HIDE_FROM_ABI
     constexpr ref_view(_Tp&& __t)
       : __range_(_VSTD::addressof(static_cast<_Range&>(_VSTD::forward<_Tp>(__t))))
     {}
 
-    constexpr _Range& base() const { return *__range_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
 
-    constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
-    constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr bool empty() const
       requires requires { ranges::empty(*__range_); }
     { return ranges::empty(*__range_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto size() const
       requires sized_range<_Range>
     { return ranges::size(*__range_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr auto data() const
       requires contiguous_range<_Range>
     { return ranges::data(*__range_); }
   };
 
   template<class _Range>
   ref_view(_Range&) -> ref_view<_Range>;
 

libcxx/include/__ranges/size.h

concept __difference =
     __class_or_enum<remove_cvref_t<_Tp>> &&
     requires(_Tp&& __t) {
       { ranges::begin(__t) } -> forward_iterator;
       { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(declval<_Tp>()))>;
     };
 
   struct __fn {
     template <class _Tp, size_t _Sz>
-    [[nodiscard]] constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
       return _Sz;
     }
 
     template <class _Tp, size_t _Sz>
-    [[nodiscard]] constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
       return _Sz;
     }
 
     template <__member_size _Tp>
-    [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(_VSTD::forward<_Tp>(__t).size())) {
       return _VSTD::forward<_Tp>(__t).size();
     }
 
     template <__unqualified_size _Tp>
-    [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(size(_VSTD::forward<_Tp>(__t)))) {
       return size(_VSTD::forward<_Tp>(__t));
     }
 
     template<__difference _Tp>
-    [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
       return _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
     }
   };
 } // end namespace __size
 
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 
 namespace __ssize {
   struct __fn {
     template<class _Tp>
       requires requires (_Tp&& __t) { ranges::size(__t); }
-    [[nodiscard]] constexpr integral auto operator()(_Tp&& __t) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::size(__t))) {
       using _Signed = make_signed_t<decltype(ranges::size(__t))>;
       if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
         return static_cast<ptrdiff_t>(ranges::size(__t));
       else
         return static_cast<_Signed>(ranges::size(__t));
     }
   };

libcxx/include/__ranges/subrange.h

namespace ranges {
   enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
 
   template<class _Iter, class _Sent, bool>
   struct __subrange_base {
     static constexpr bool __store_size = false;
     _Iter __begin_ = _Iter();
     _Sent __end_ = _Sent();
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr __subrange_base() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
     constexpr __subrange_base(_Iter __iter, _Sent __sent, make_unsigned_t<iter_difference_t<_Iter>> = 0)
       : __begin_(_VSTD::move(__iter)), __end_(__sent) { }
   };
 
   template<class _Iter, class _Sent>
   struct __subrange_base<_Iter, _Sent, true> {
     static constexpr bool __store_size = true;
     _Iter __begin_ = _Iter();
     _Sent __end_ = _Sent();
     make_unsigned_t<iter_difference_t<_Iter>> __size_ = 0;
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr __subrange_base() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
     constexpr __subrange_base(_Iter __iter, _Sent __sent, decltype(__size_) __size)
       : __begin_(_VSTD::move(__iter)), __end_(__sent), __size_(__size) { }
   };
 
   template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
            subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
              ? subrange_kind::sized
              : subrange_kind::unsized>
     requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
   struct _LIBCPP_TEMPLATE_VIS subrange
     : public view_interface<subrange<_Iter, _Sent, _Kind>>,
       private __subrange_base<_Iter, _Sent, _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>> {
 
     using _Base = __subrange_base<_Iter, _Sent, _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>>;
 
+    _LIBCPP_HIDE_FROM_ABI
     subrange() requires default_initializable<_Iter> = default;
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
       requires (!_Base::__store_size)
       : _Base(_VSTD::move(__iter), __sent) {}
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent,
                        make_unsigned_t<iter_difference_t<_Iter>> __n)
       requires (_Kind == subrange_kind::sized)
       : _Base(_VSTD::move(__iter), __sent, __n) { }
 
     template<__different_from<subrange> _Range>
       requires borrowed_range<_Range> &&
                __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
                convertible_to<sentinel_t<_Range>, _Sent>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(_Range&& __range)
       requires (!_Base::__store_size)
       : subrange(ranges::begin(__range), ranges::end(__range)) { }
 
     template<__different_from<subrange> _Range>
       requires borrowed_range<_Range> &&
                __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
                convertible_to<sentinel_t<_Range>, _Sent>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(_Range&& __range)
       requires _Base::__store_size && sized_range<_Range>
       : subrange(__range, ranges::size(__range)) { }
 
 
     template<borrowed_range _Range>
       requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
                convertible_to<sentinel_t<_Range>, _Sent>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
       requires (_Kind == subrange_kind::sized)
       : subrange(ranges::begin(__range), ranges::end(__range), __n) { }
 
     template<__different_from<subrange> _Pair>
       requires __pair_like_convertible_from<_Pair, const _Iter&, const _Sent&>
+    _LIBCPP_HIDE_FROM_ABI
     constexpr operator _Pair() const { return _Pair(this->__begin_, this->__end_); }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr _Iter begin() const requires copyable<_Iter> {
       return this->__begin_;
     }
 
-    [[nodiscard]] constexpr _Iter begin() requires (!copyable<_Iter>) {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() requires (!copyable<_Iter>) {
       return _VSTD::move(this->__begin_);
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr _Sent end() const { return this->__end_; }
 
-    [[nodiscard]] constexpr bool empty() const { return this->__begin_ == this->__end_; }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return this->__begin_ == this->__end_; }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
       requires (_Kind == subrange_kind::sized)
     {
       if constexpr (_Base::__store_size)
         return this->__size_;
       else
         return __to_unsigned_like(this->__end_ - this->__begin_);
     }
 
-    [[nodiscard]] constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
       requires forward_iterator<_Iter> {
       auto __tmp = *this;
       __tmp.advance(__n);
       return __tmp;
     }
 
-    [[nodiscard]] constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
       advance(__n);
       return _VSTD::move(*this);
     }
 
-    [[nodiscard]] constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
       requires bidirectional_iterator<_Iter> {
       auto __tmp = *this;
       __tmp.advance(-__n);
       return __tmp;
     }
 
+    _LIBCPP_HIDE_FROM_ABI
     constexpr subrange& advance(iter_difference_t<_Iter> __n) {
       if constexpr (bidirectional_iterator<_Iter>) {
         if (__n < 0) {
           ranges::advance(this->__begin_, __n);
           if constexpr (_Base::__store_size)
             this->__size_ += _VSTD::__to_unsigned_like(-__n);
           return *this;
         }
subrange(_Range&&) -> subrange<iterator_t<_Range>, sentinel_t<_Range>,
                                    ? subrange_kind::sized : subrange_kind::unsized>;
 
   template<borrowed_range _Range>
   subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>)
     -> subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
 
   template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
     requires (_Index < 2)
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
     if constexpr (_Index == 0)
       return __subrange.begin();
     else
       return __subrange.end();
   }
 
   template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
     requires (_Index < 2)
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
     if constexpr (_Index == 0)
       return __subrange.begin();
     else
       return __subrange.end();
   }
 
   template<class _Ip, class _Sp, subrange_kind _Kp>

libcxx/include/__ranges/transform_view.h

 class transform_view : public view_interface<transform_view<_View, _Fn>> {
   template<bool> class __iterator;
   template<bool> class __sentinel;
 
   [[no_unique_address]] __copyable_box<_Fn> __func_;
   [[no_unique_address]] _View __base_ = _View();
 
 public:
+  _LIBCPP_HIDE_FROM_ABI
   transform_view()
     requires default_initializable<_View> && default_initializable<_Fn> = default;
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr transform_view(_View __base, _Fn __func)
     : __func_(_VSTD::in_place, _VSTD::move(__func)), __base_(_VSTD::move(__base)) {}
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() && { return _VSTD::move(__base_); }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<false> begin() {
     return __iterator<false>{*this, ranges::begin(__base_)};
   }
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<true> begin() const
     requires range<const _View> &&
              regular_invocable<const _Fn&, range_reference_t<const _View>>
   {
     return __iterator<true>(*this, ranges::begin(__base_));
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __sentinel<false> end() {
     return __sentinel<false>(ranges::end(__base_));
   }
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<false> end()
     requires common_range<_View>
   {
     return __iterator<false>(*this, ranges::end(__base_));
   }
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __sentinel<true> end() const
     requires range<const _View> &&
              regular_invocable<const _Fn&, range_reference_t<const _View>>
   {
     return __sentinel<true>(ranges::end(__base_));
   }
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<true> end() const
     requires common_range<const _View> &&
              regular_invocable<const _Fn&, range_reference_t<const _View>>
   {
     return __iterator<true>(*this, ranges::end(__base_));
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }
 };
 
 template<class _Range, class _Fn>
 transform_view(_Range&&, _Fn) -> transform_view<views::all_t<_Range>, _Fn>;
 
 template<class _View>
 struct __transform_view_iterator_concept { using type = input_iterator_tag; };

 
 public:
   iterator_t<_Base> __current_ = iterator_t<_Base>();
 
   using iterator_concept = typename __transform_view_iterator_concept<_View>::type;
   using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
   using difference_type = range_difference_t<_Base>;
 
+  _LIBCPP_HIDE_FROM_ABI
   __iterator() requires default_initializable<iterator_t<_Base>> = default;
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
     : __parent_(_VSTD::addressof(__parent)), __current_(_VSTD::move(__current)) {}
 
   // Note: `__i` should always be `__iterator<false>`, but directly using
   // `__iterator<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
     : __parent_(__i.__parent_), __current_(_VSTD::move(__i.__current_)) {}
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr iterator_t<_Base> base() const&
     requires copyable<iterator_t<_Base>>
   {
     return __current_;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr iterator_t<_Base> base() && {
     return _VSTD::move(__current_);
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator*() const
     noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, *__current_)))
   {
     return _VSTD::invoke(*__parent_->__func_, *__current_);
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator& operator++() {
     ++__current_;
     return *this;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr void operator++(int) { ++__current_; }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator operator++(int)
     requires forward_range<_Base>
   {
     auto __tmp = *this;
     ++*this;
     return __tmp;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator& operator--()
     requires bidirectional_range<_Base>
   {
     --__current_;
     return *this;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator operator--(int)
     requires bidirectional_range<_Base>
   {
     auto __tmp = *this;
     --*this;
     return __tmp;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator& operator+=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ += __n;
     return *this;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator& operator-=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ -= __n;
     return *this;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator[](difference_type __n) const
     noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, __current_[__n])))
     requires random_access_range<_Base>
   {
     return _VSTD::invoke(*__parent_->__func_, __current_[__n]);
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
     requires equality_comparable<iterator_t<_Base>>
   {
     return __x.__current_ == __y.__current_;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ < __y.__current_;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ > __y.__current_;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ <= __y.__current_;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ >= __y.__current_;
   }
 
 // TODO: Fix this as soon as soon as three_way_comparable is implemented.
+//   _LIBCPP_HIDE_FROM_ABI
 //   friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
 //     requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
 //   {
 //     return __x.__current_ <=> __y.__current_;
 //   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr __iterator operator+(__iterator __i, difference_type __n)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ + __n};
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr __iterator operator+(difference_type __n, __iterator __i)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ + __n};
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr __iterator operator-(__iterator __i, difference_type __n)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ - __n};
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
     requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
   {
     return __x.__current_ - __y.__current_;
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr decltype(auto) iter_move(const __iterator& __i)
     noexcept(noexcept(*__i))
   {
     if constexpr (is_lvalue_reference_v<decltype(*__i)>)
       return _VSTD::move(*__i);
     else
       return *__i;
   }
class transform_view<_View, _Fn>::__sentinel {
 
   template<bool>
   friend class transform_view<_View, _Fn>::__iterator;
 
   template<bool>
   friend class transform_view<_View, _Fn>::__sentinel;
 
 public:
+  _LIBCPP_HIDE_FROM_ABI
   __sentinel() = default;
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr explicit __sentinel(sentinel_t<_Base> __end_) : __end_(__end_) {}
 
   // Note: `__i` should always be `__sentinel<false>`, but directly using
   // `__sentinel<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
+  _LIBCPP_HIDE_FROM_ABI
   constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
     : __end_(_VSTD::move(__i.__end_)) {}
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr sentinel_t<_Base> base() const { return __end_; }
 
   template<bool _OtherConst>
     requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
     return __x.__current_ == __y.__end_;
   }
 
   template<bool _OtherConst>
     requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
   operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
     return __x.__current_ - __y.__end_;
   }
 
   template<bool _OtherConst>
     requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI
   friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
   operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
     return __x.__end_ - __y.__current_;
   }
 };
 
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H

libcxx/include/__ranges/view_interface.h

 concept __can_empty = requires(_Tp __t) { ranges::empty(__t); };
 
 template<class _Tp>
 void __implicitly_convert_to(type_identity_t<_Tp>) noexcept;
 
 template<class _Derived>
   requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
 class view_interface : public view_base {
+  _LIBCPP_HIDE_FROM_ABI
   constexpr _Derived& __derived() noexcept {
     return static_cast<_Derived&>(*this);
   }
 
+  _LIBCPP_HIDE_FROM_ABI
   constexpr _Derived const& __derived() const noexcept {
     return static_cast<_Derived const&>(*this);
   }
 
 public:
   template<class _D2 = _Derived>
-  [[nodiscard]] constexpr bool empty()
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
     noexcept(noexcept(__implicitly_convert_to<bool>(ranges::begin(__derived()) == ranges::end(__derived()))))
     requires forward_range<_D2>
   {
     return ranges::begin(__derived()) == ranges::end(__derived());
   }
 
   template<class _D2 = _Derived>
-  [[nodiscard]] constexpr bool empty() const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
     noexcept(noexcept(__implicitly_convert_to<bool>(ranges::begin(__derived()) == ranges::end(__derived()))))
     requires forward_range<const _D2>
   {
     return ranges::begin(__derived()) == ranges::end(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr explicit operator bool()
     noexcept(noexcept(ranges::empty(declval<_D2>())))
     requires __can_empty<_D2>
   {
     return !ranges::empty(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr explicit operator bool() const
     noexcept(noexcept(ranges::empty(declval<const _D2>())))
     requires __can_empty<const _D2>
   {
     return !ranges::empty(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto data()
     noexcept(noexcept(_VSTD::to_address(ranges::begin(__derived()))))
     requires contiguous_iterator<iterator_t<_D2>>
   {
     return _VSTD::to_address(ranges::begin(__derived()));
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto data() const
     noexcept(noexcept(_VSTD::to_address(ranges::begin(__derived()))))
     requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>
   {
     return _VSTD::to_address(ranges::begin(__derived()));
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto size()
     noexcept(noexcept(ranges::end(__derived()) - ranges::begin(__derived())))
     requires forward_range<_D2>
       && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>
   {
     return ranges::end(__derived()) - ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() const
     noexcept(noexcept(ranges::end(__derived()) - ranges::begin(__derived())))
     requires forward_range<const _D2>
       && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>
   {
     return ranges::end(__derived()) - ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) front()
     noexcept(noexcept(*ranges::begin(__derived())))
     requires forward_range<_D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) front() const
     noexcept(noexcept(*ranges::begin(__derived())))
     requires forward_range<const _D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) back()
     noexcept(noexcept(*ranges::prev(ranges::end(__derived()))))
     requires bidirectional_range<_D2> && common_range<_D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
   template<class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) back() const
     noexcept(noexcept(*ranges::prev(ranges::end(__derived()))))
     requires bidirectional_range<const _D2> && common_range<const _D2>
   {
     _LIBCPP_ASSERT(!empty(),
         "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
   template<random_access_range _RARange = _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator[](range_difference_t<_RARange> __index)
     noexcept(noexcept(ranges::begin(__derived())[__index]))
   {
     return ranges::begin(__derived())[__index];
   }
 
   template<random_access_range _RARange = const _Derived>
+  _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const
     noexcept(noexcept(ranges::begin(__derived())[__index]))
   {
     return ranges::begin(__derived())[__index];
   }
 };
 
 }
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_VIEW_INTERFACE_H