[libc++] NFC: Move unwrap_iter to its own header

[ldionne]

Summary

This test 996889 again. It seems @Quuxplusone found a solution for the
issue. This tests the original patch with the fix included.

@ldionne feel free to commandeer the patch again.

Depends on D102781

[• Quuxplusone]

Well, my solution was to add this new header (and all new headers) to module.modulemap. So I assume this PR will fail buildkite as-is; it would need to add this header (and/or other new headers) to module.modulemap in order to keep buildkite happy. But I recommend people discuss the issue/solution(s) over on https://reviews.llvm.org/D102781#inline-979125 just to keep it all in the same place.

[Mordante]

Rebase on top of D102781, see whether the CI likes this version better.

[Mordante]

In D103369#2788352, @Quuxplusone wrote:

Well, my solution was to add this new header (and all new headers) to module.modulemap. So I assume this PR will fail buildkite as-is; it would need to add this header (and/or other new headers) to module.modulemap in order to keep buildkite happy. But I recommend people discuss the issue/solution(s) over on https://reviews.llvm.org/D102781#inline-979125 just to keep it all in the same place.

I agree it would be good to keep the discussion in D102781. This is mainly to test whether your approach also works here or more changes are required. The original patch broke the Linux builds. I tested Linux locally with only your __iterator_iterator_traits_h module applied and that fixed it locally.

[ldionne]

Fix CI issues (I hope).

[ldionne]

Poke CI. I suspect the previous failure is a fluke because it only happens in the back-deployment configuration, and those nodes were problematic in the past few days. Will investigate if it fails again.

[ldionne]

Poke CI - now this should build since the Apple issues have been fixed.

[ldionne]

Looks like this is working now.

[ldionne]

@zoecarver is going to handle that as part of the algorithm split.

libcxx/include/CMakeLists.txt

 set(files
+  __algorithm/unwrap_iter.h
   __availability
   __bit_reference
   __bits
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __config
   __debug
   __errc

libcxx/include/__algorithm/unwrap_iter.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_UNWRAP_ITER_H
+#define _LIBCPP___ALGORITHM_UNWRAP_ITER_H
+
+#include <__config>
+#include <__iterator/iterator_traits.h> // __is_cpp17_contiguous_iterator
+#include <__memory/pointer_traits.h> // __to_address
+#include <utility>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// __unwrap_iter, __rewrap_iter
+
+// The job of __unwrap_iter is to lower contiguous iterators (such as
+// vector<T>::iterator) into pointers, to reduce the number of template
+// instantiations and to enable pointer-based optimizations e.g. in std::copy.
+// For iterators that are not contiguous, it must be a no-op.
+// In debug mode, we don't do this.
+//
+// __unwrap_iter is non-constexpr for user-defined iterators whose
+// `to_address` and/or `operator->` is non-constexpr. This is okay; but we
+// try to avoid doing __unwrap_iter in constant-evaluated contexts anyway.
+//
+// Some algorithms (e.g. std::copy, but not std::sort) need to convert an
+// "unwrapped" result back into a contiguous iterator. Since contiguous iterators
+// are random-access, we can do this portably using iterator arithmetic; this
+// is the job of __rewrap_iter.
+
+template <class _Iter, bool = __is_cpp17_contiguous_iterator<_Iter>::value>
+struct __unwrap_iter_impl {
+    static _LIBCPP_CONSTEXPR _Iter
+    __apply(_Iter __i) _NOEXCEPT {
+        return __i;
+    }
+};
+
+#if _LIBCPP_DEBUG_LEVEL < 2
+
+template <class _Iter>
+struct __unwrap_iter_impl<_Iter, true> {
+    static _LIBCPP_CONSTEXPR decltype(_VSTD::__to_address(declval<_Iter>()))
+    __apply(_Iter __i) _NOEXCEPT {
+        return _VSTD::__to_address(__i);
+    }
+};
+
+#endif // _LIBCPP_DEBUG_LEVEL < 2
+
+template<class _Iter, class _Impl = __unwrap_iter_impl<_Iter> >
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+decltype(_Impl::__apply(_VSTD::declval<_Iter>()))
+__unwrap_iter(_Iter __i) _NOEXCEPT
+{
+    return _Impl::__apply(__i);
+}
+
+template<class _OrigIter>
+_OrigIter __rewrap_iter(_OrigIter, _OrigIter __result)
+{
+    return __result;
+}
+
+template<class _OrigIter, class _UnwrappedIter>
+_OrigIter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result)
+{
+    // Precondition: __result is reachable from __first
+    // Precondition: _OrigIter is a contiguous iterator
+    return __first + (__result - _VSTD::__unwrap_iter(__first));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_UNWRAP_ITER_H

libcxx/include/algorithm

 template <class BidirectionalIterator, class Compare>
     constexpr bool     // constexpr in C++20
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
 
 }  // std
 
 */
 
+#include <__algorithm/unwrap_iter.h>
 #include <__config>
 #include <__bits> // __libcpp_clz
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>

 _ForwardIterator
 search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type __v;
     return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count),
                            __value_, __equal_to<__v, _Tp>());
 }
 
-// __unwrap_iter, __rewrap_iter
-
-// The job of __unwrap_iter is to lower contiguous iterators (such as
-// vector<T>::iterator) into pointers, to reduce the number of template
-// instantiations and to enable pointer-based optimizations e.g. in std::copy.
-// For iterators that are not contiguous, it must be a no-op.
-// In debug mode, we don't do this.
-//
-// __unwrap_iter is non-constexpr for user-defined iterators whose
-// `to_address` and/or `operator->` is non-constexpr. This is okay; but we
-// try to avoid doing __unwrap_iter in constant-evaluated contexts anyway.
-//
-// Some algorithms (e.g. std::copy, but not std::sort) need to convert an
-// "unwrapped" result back into a contiguous iterator. Since contiguous iterators
-// are random-access, we can do this portably using iterator arithmetic; this
-// is the job of __rewrap_iter.
-
-template <class _Iter, bool = __is_cpp17_contiguous_iterator<_Iter>::value>
-struct __unwrap_iter_impl {
-    static _LIBCPP_CONSTEXPR _Iter
-    __apply(_Iter __i) _NOEXCEPT {
-        return __i;
-    }
-};
-
-#if _LIBCPP_DEBUG_LEVEL < 2
-
-template <class _Iter>
-struct __unwrap_iter_impl<_Iter, true> {
-    static _LIBCPP_CONSTEXPR decltype(_VSTD::__to_address(declval<_Iter>()))
-    __apply(_Iter __i) _NOEXCEPT {
-        return _VSTD::__to_address(__i);
-    }
-};
-
-#endif // _LIBCPP_DEBUG_LEVEL < 2
-
-template<class _Iter, class _Impl = __unwrap_iter_impl<_Iter> >
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-decltype(_Impl::__apply(declval<_Iter>()))
-__unwrap_iter(_Iter __i) _NOEXCEPT
-{
-    return _Impl::__apply(__i);
-}
-
-template<class _OrigIter>
-_OrigIter __rewrap_iter(_OrigIter, _OrigIter __result)
-{
-    return __result;
-}
-
-template<class _OrigIter, class _UnwrappedIter>
-_OrigIter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result)
-{
-    // Precondition: __result is reachable from __first
-    // Precondition: _OrigIter is a contiguous iterator
-    return __first + (__result - _VSTD::__unwrap_iter(__first));
-}
-
 // copy
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 __copy_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     for (; __first != __last; ++__first, (void) ++__result)

libcxx/include/module.modulemap

module std [system] {
 
   // FIXME: These should be private.
   module __bit_reference { header "__bit_reference" export * }
   module __bits { header "__bits" export * }
   module __debug { header "__debug" export * }
   module __errc { header "__errc" export * }
   module __functional_base { header "__functional_base" export * }
   module __hash_table { header "__hash_table" export * }
+  module __iterator_iterator_traits { header "__iterator/iterator_traits.h" export * }
   module __locale { header "__locale" export * }
   module __mutex_base { header "__mutex_base" export * }
   module __node_handle { header "__node_handle" export * }
   module __split_buffer { header "__split_buffer" export * }
   module __std_stream { header "__std_stream" export * }
   module __string { header "__string" export * }
   module __threading_support { header "__threading_support" export * }
   module __tree { header "__tree" export * }