This is an archive of the discontinued LLVM Phabricator instance.

Differential D103840

[libcxx][ranges][nfc] Factor out common logic in the copy algorithms.
AbandonedPublic

Authored by philnik on Jun 7 2021, 1:55 PM.

Details

Reviewers
ldionne
EricWF
• Quuxplusone
zoecarver
cjdb
Group Reviewers
Restricted Project
Summary

Factors out common logic from std::copy, std::copy_backward, std::copy_if, and std::copy_n into __copy_*_impl. Also adds __in_out_result which is the return type for the impl function. This will make adding support for the ranges overloads super easy.

This is an example of how this will be done for all algorithms. Once this lands, I'll update all the algorithms, so let's get this review right.

Diff Detail

Unit TestsFailed

TimeTest
1,680 mslibcxx CI C++03 > libcxx-trunk-shared.libcxx::double_include.sh.cpp
1,680 mslibcxx CI C++03 > libcxx-trunk-shared.libcxx::double_include.sh.cpp
1,680 mslibcxx CI C++03 > libcxx-trunk-shared.libcxx::double_include.sh.cpp
1,610 mslibcxx CI C++03 > libcxx-trunk-shared.libcxx::min_max_macros.compile.pass.cpp
1,610 mslibcxx CI C++03 > libcxx-trunk-shared.libcxx::min_max_macros.compile.pass.cpp
View Full Test Results (6,816 Failed)

Event Timeline

zoecarver created this revision.Jun 7 2021, 1:55 PM
Herald added a subscriber: mgorny. · View Herald TranscriptJun 7 2021, 1:55 PM
zoecarver requested review of this revision.Jun 7 2021, 1:55 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 7 2021, 1:55 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B108068: Diff 350409.Jun 7 2021, 2:09 PM
cjdb added a comment.Jun 7 2021, 2:26 PM

We're going to need to hold off on this patch until we determine what's breaking Fuchsia.

cjdb requested changes to this revision.Jun 7 2021, 5:26 PM

This is blocked by https://bugs.llvm.org/show_bug.cgi?id=50592.

This revision now requires changes to proceed.Jun 7 2021, 5:26 PM
• Quuxplusone requested changes to this revision.Jun 8 2021, 5:27 AM
• Quuxplusone added inline comments.
libcxx/include/__algorithm/copy.h
83

_VSTD:: — but also I worry a little bit about the codegen here. As you've written it so far, ranges::copy could just be

return __in_out_result{__last, _VSTD::copy(__first, __last, __result)};

and save a lot of modifications. Which is obviously not C++20-compliant. So for C++20, we're going to have to write a new ranges::copy algorithm that returns the computed iterator, generated by incrementing __first, which ended up comparing equal to _Sentinel __last. That's a much different-looking algorithm from what we've got today for std::copy, and might not even be able to share any code with it.

I strongly strongly strongly ask that you continue working on this PR until it succeeds at implementing the C++20 ranges::copy semantics, and then see if you still think this is a good direction. I strongly strongly strongly oppose merging this PR in its current state.

libcxx/test/std/algorithms/robust_against_adl.pass.cpp
15

This is testing that your library code is robust against ADL.
I assume it's failing at the moment because you didn't ADL-proof your call to __copy above.
Remember, every time you call a function in namespace _VSTD that would be subject to ADL, you need to qualify it. (The one common exception we make is for declval, because it takes no arguments.)

cjdb added a parent revision: D104171: Revert "Revert "[libcxx][gardening] Move all algorithms into their own headers."".Jun 16 2021, 10:09 PM
cjdb resigned from this revision.Jan 18 2022, 1:38 PM
philnik commandeered this revision.Sep 12 2022, 12:55 AM
philnik added a reviewer: zoecarver.
philnik added a subscriber: philnik.

The ranges algorithms have been implemented and the code for copy etc. have been massively changed, so I'll abandon this patch.

Herald added a project: Restricted Project. · View Herald TranscriptSep 12 2022, 12:55 AM
philnik abandoned this revision.Sep 12 2022, 12:56 AM

Revision Contents

PathSize
libcxx/
include/
1 line
__algorithm/
80 lines
77 lines
1 line
1 line
test/
std/
algorithms/
3 lines

Diff 350409

libcxx/include/CMakeLists.txt

Show All 15 Linesset(files
__algorithm/find_end.h __algorithm/find_end.h
__algorithm/find_first_of.h __algorithm/find_first_of.h
__algorithm/find_if.h __algorithm/find_if.h
__algorithm/find_if_not.h __algorithm/find_if_not.h
__algorithm/for_each.h __algorithm/for_each.h
__algorithm/for_each_n.h __algorithm/for_each_n.h
__algorithm/generate.h __algorithm/generate.h
__algorithm/half_positive.h __algorithm/half_positive.h
__algorithm/in_out_result.h
__algorithm/includes.h __algorithm/includes.h
__algorithm/inplace_merge.h __algorithm/inplace_merge.h
__algorithm/is_heap.h __algorithm/is_heap.h
__algorithm/is_heap_until.h __algorithm/is_heap_until.h
__algorithm/is_partitioned.h __algorithm/is_partitioned.h
__algorithm/is_permutation.h __algorithm/is_permutation.h
__algorithm/is_sorted.h __algorithm/is_sorted.h
__algorithm/lexicographical_compare.h __algorithm/lexicographical_compare.h
▲ Show 20 Lines • Show All 323 Lines • Show Last 20 Lines

libcxx/include/__algorithm/copy.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_COPY_H #ifndef _LIBCPP___ALGORITHM_COPY_H
#define _LIBCPP___ALGORITHM_COPY_H #define _LIBCPP___ALGORITHM_COPY_H
#include <__config> #include <__config>
#include <__algorithm/in_out_result.h>
#include <__algorithm/unwrap_iter.h> #include <__algorithm/unwrap_iter.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <cstring> #include <cstring>
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
Show All 36 Lines__copy(_Tp* __first, _Tp* __last, _Up* __result)
const size_t __n = static_cast<size_t>(__last - __first); const size_t __n = static_cast<size_t>(__last - __first);
if (__n > 0) if (__n > 0)
_VSTD::memmove(__result, __first, __n * sizeof(_Up)); _VSTD::memmove(__result, __first, __n * sizeof(_Up));
return __result + __n; return __result + __n;
} }
template <class _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator __in_out_result<_InputIterator, _OutputIterator>
copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) __copy_impl(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
{ {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return _VSTD::__copy_constexpr(__first, __last, __result); return {__last, _VSTD::__copy_constexpr(__first, __last, __result)};
} else { } else {
return _VSTD::__rewrap_iter(__result, return {__last, _VSTD::__rewrap_iter(__result,
_VSTD::__copy(_VSTD::__unwrap_iter(__first), _VSTD::__copy(_VSTD::__unwrap_iter(__first),
_VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__last),
_VSTD::__unwrap_iter(__result))); _VSTD::__unwrap_iter(__result)))};
} }
} }
template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
return __copy_impl(__first, __last, __result).__get_out();
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

_VSTD:: — but also I worry a little bit about the codegen here. As you've written it so far, ranges::copy could just be

return __in_out_result{__last, _VSTD::copy(__first, __last, __result)};

and save a lot of modifications. Which is obviously not C++20-compliant. So for C++20, we're going to have to write a new ranges::copy algorithm that returns the computed iterator, generated by incrementing __first, which ended up comparing equal to _Sentinel __last. That's a much different-looking algorithm from what we've got today for std::copy, and might not even be able to share any code with it.

I strongly strongly strongly ask that you continue working on this PR until it succeeds at implementing the C++20 ranges::copy semantics, and then see if you still think this is a good direction. I strongly strongly strongly oppose merging this PR in its current state.

Quuxplusone: `_VSTD::` — but also I worry a little bit about the codegen here. As you've written it so far…
}
// copy_backward // copy_backward
template <class _BidirectionalIterator, class _OutputIterator> template <class _BidirectionalIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator _OutputIterator
__copy_backward_constexpr(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) __copy_backward_constexpr(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
{ {
while (__first != __last) while (__first != __last)
Show All 25 Lines if (__n > 0)
__result -= __n; __result -= __n;
_VSTD::memmove(__result, __first, __n * sizeof(_Up)); _VSTD::memmove(__result, __first, __n * sizeof(_Up));
} }
return __result; return __result;
} }
template <class _BidirectionalIterator1, class _BidirectionalIterator2> template <class _BidirectionalIterator1, class _BidirectionalIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_BidirectionalIterator2 __in_out_result<_BidirectionalIterator1, _BidirectionalIterator2>
copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, __copy_backward_impl(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
_BidirectionalIterator2 __result) _BidirectionalIterator2 __result)
{ {
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return _VSTD::__copy_backward_constexpr(__first, __last, __result); return {__last, _VSTD::__copy_backward_constexpr(__first, __last, __result)};
} else { } else {
return _VSTD::__rewrap_iter(__result, return {__last,
_VSTD::__rewrap_iter(__result,
_VSTD::__copy_backward(_VSTD::__unwrap_iter(__first), _VSTD::__copy_backward(_VSTD::__unwrap_iter(__first),
_VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__last),
_VSTD::__unwrap_iter(__result))); _VSTD::__unwrap_iter(__result)))};
}
} }
template <class _BidirectionalIterator1, class _BidirectionalIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_BidirectionalIterator2
copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
_BidirectionalIterator2 __result) {
return __copy_backward_impl(__first, __last, __result).__get_out();
} }
// copy_if // copy_if
template<class _InputIterator, class _OutputIterator, class _Predicate> template<class _InputIterator, class _OutputIterator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator __in_out_result<_InputIterator, _OutputIterator>
copy_if(_InputIterator __first, _InputIterator __last, __copy_if_impl(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred) _OutputIterator __result, _Predicate __pred)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
{ {
if (__pred(*__first)) if (__pred(*__first))
{ {
*__result = *__first; *__result = *__first;
++__result; ++__result;
} }
} }
return __result; return {__last, __result};
}
template<class _InputIterator, class _OutputIterator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred) {
return __copy_if_impl(__first, __last, __result, __pred).__get_out();
} }
// copy_n // copy_n
template<class _InputIterator, class _Size, class _OutputIterator> template<class _InputIterator, class _Size, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
typename enable_if typename enable_if
< <
__is_cpp17_input_iterator<_InputIterator>::value && __is_cpp17_input_iterator<_InputIterator>::value &&
!__is_cpp17_random_access_iterator<_InputIterator>::value, !__is_cpp17_random_access_iterator<_InputIterator>::value,
_OutputIterator __in_out_result<_InputIterator, _OutputIterator>
>::type >::type
copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) __copy_n_impl(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
{ {
typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize; typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
_IntegralSize __n = __orig_n; _IntegralSize __n = __orig_n;
if (__n > 0) if (__n > 0)
{ {
*__result = *__first; *__result = *__first;
++__result; ++__result;
for (--__n; __n > 0; --__n) for (--__n; __n > 0; --__n)
{ {
++__first; ++__first;
*__result = *__first; *__result = *__first;
++__result; ++__result;
} }
} }
return __result; return {_VSTD::next(__first, __orig_n), __result};
} }
template<class _InputIterator, class _Size, class _OutputIterator> template<class _InputIterator, class _Size, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
typename enable_if typename enable_if
< <
__is_cpp17_random_access_iterator<_InputIterator>::value, __is_cpp17_random_access_iterator<_InputIterator>::value,
_OutputIterator __in_out_result<_InputIterator, _OutputIterator>
>::type >::type
copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) __copy_n_impl(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
{ {
typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize; typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
_IntegralSize __n = __orig_n; _IntegralSize __n = __orig_n;
return _VSTD::copy(__first, __first + __n, __result); return {__first + __n, _VSTD::copy(__first, __first + __n, __result)};
}
template<class _InputIterator, class _Size, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) {
return __copy_n_impl(__first, __orig_n, __result).__get_out();
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_COPY_H #endif // _LIBCPP___ALGORITHM_COPY_H

libcxx/include/__algorithm/in_out_result.h

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// 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_IN_OUT_RESULT_H
#define _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _In, class _Out, bool = is_class<_In>::value && is_class<_Out>::value>
struct __in_out_result : _In, _Out {
_LIBCPP_CONSTEXPR __in_out_result(_In __i, _Out __o)
: _In(_VSTD::move(__i)), _Out(_VSTD::move(__o)) {}
_LIBCPP_CONSTEXPR _In __get_in() const& { return static_cast<_In const&>(*this); }
_LIBCPP_CONSTEXPR _In __get_in() && { return static_cast<_In&&>(*this); }
_LIBCPP_CONSTEXPR _Out __get_out() const& { return static_cast<_Out const&>(*this); }
_LIBCPP_CONSTEXPR _Out __get_out() && { return static_cast<_Out&&>(*this); }
template<class _I2, class _O2>
_LIBCPP_CONSTEXPR operator __in_out_result<_I2, _O2>() const& {
return {static_cast<_In const&>(*this), static_cast<_Out const&>(*this)};
}
template<class _I2, class _O2>
_LIBCPP_CONSTEXPR operator __in_out_result<_I2, _O2>() && {
return {static_cast<_In&&>(*this), static_cast<_Out&&>(*this)};
}
};
template<class _In, class _Out>
struct __in_out_result<_In, _Out, false> {
_LIBCPP_CONSTEXPR __in_out_result(_In __i, _Out __o)
: __in_(_VSTD::move(__i)), __out_(_VSTD::move(__o)) {}
_LIBCPP_CONSTEXPR _In __get_in() const& { return __in_; }
_LIBCPP_CONSTEXPR _In __get_in() && { return _VSTD::move(__out_); }
_LIBCPP_CONSTEXPR _Out __get_out() const& { return __out_; }
_LIBCPP_CONSTEXPR _Out __get_out() && { return _VSTD::move(__out_); }
template<class _I2, class _O2>
_LIBCPP_CONSTEXPR operator __in_out_result<_I2, _O2>() const& {
return {__in_, __out_};
}
template<class _I2, class _O2>
_LIBCPP_CONSTEXPR operator __in_out_result<_I2, _O2>() && {
return {_VSTD::move(__in_), _VSTD::move(__out_)};
}
private:
_In __in_;
_Out __out_;
};
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H

libcxx/include/algorithm

Show First 20 Lines • Show All 676 Lines • ▼ Show 20 Lines
#include <__algorithm/find_end.h> #include <__algorithm/find_end.h>
#include <__algorithm/find_first_of.h> #include <__algorithm/find_first_of.h>
#include <__algorithm/find_if.h> #include <__algorithm/find_if.h>
#include <__algorithm/find_if_not.h> #include <__algorithm/find_if_not.h>
#include <__algorithm/for_each.h> #include <__algorithm/for_each.h>
#include <__algorithm/for_each_n.h> #include <__algorithm/for_each_n.h>
#include <__algorithm/generate.h> #include <__algorithm/generate.h>
#include <__algorithm/half_positive.h> #include <__algorithm/half_positive.h>
#include <__algorithm/in_out_result.h>
#include <__algorithm/includes.h> #include <__algorithm/includes.h>
#include <__algorithm/inplace_merge.h> #include <__algorithm/inplace_merge.h>
#include <__algorithm/is_heap.h> #include <__algorithm/is_heap.h>
#include <__algorithm/is_heap_until.h> #include <__algorithm/is_heap_until.h>
#include <__algorithm/is_partitioned.h> #include <__algorithm/is_partitioned.h>
#include <__algorithm/is_permutation.h> #include <__algorithm/is_permutation.h>
#include <__algorithm/is_sorted.h> #include <__algorithm/is_sorted.h>
#include <__algorithm/lexicographical_compare.h> #include <__algorithm/lexicographical_compare.h>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/include/module.modulemap

Show First 20 Lines • Show All 235 Lines • ▼ Show 20 Lines module __algorithm {
module find_end { header "__algorithm/find_end.h" } module find_end { header "__algorithm/find_end.h" }
module find_first_of { header "__algorithm/find_first_of.h" } module find_first_of { header "__algorithm/find_first_of.h" }
module find_if { header "__algorithm/find_if.h" } module find_if { header "__algorithm/find_if.h" }
module find_if_not { header "__algorithm/find_if_not.h" } module find_if_not { header "__algorithm/find_if_not.h" }
module for_each { header "__algorithm/for_each.h" } module for_each { header "__algorithm/for_each.h" }
module for_each_n { header "__algorithm/for_each_n.h" } module for_each_n { header "__algorithm/for_each_n.h" }
module generate { header "__algorithm/generate.h" } module generate { header "__algorithm/generate.h" }
module half_positive { header "__algorithm/half_positive.h" } module half_positive { header "__algorithm/half_positive.h" }
module in_out_result { header "__algorithm/in_out_result.h" }
module includes { header "__algorithm/includes.h" } module includes { header "__algorithm/includes.h" }
module inplace_merge { header "__algorithm/inplace_merge.h" } module inplace_merge { header "__algorithm/inplace_merge.h" }
module is_heap { header "__algorithm/is_heap.h" } module is_heap { header "__algorithm/is_heap.h" }
module is_heap_until { header "__algorithm/is_heap_until.h" } module is_heap_until { header "__algorithm/is_heap_until.h" }
module is_partitioned { header "__algorithm/is_partitioned.h" } module is_partitioned { header "__algorithm/is_partitioned.h" }
module is_permutation { header "__algorithm/is_permutation.h" } module is_permutation { header "__algorithm/is_permutation.h" }
module is_sorted { header "__algorithm/is_sorted.h" } module is_sorted { header "__algorithm/is_sorted.h" }
module lexicographical_compare { header "__algorithm/lexicographical_compare.h" } module lexicographical_compare { header "__algorithm/lexicographical_compare.h" }
▲ Show 20 Lines • Show All 538 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/robust_against_adl.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: clang-8 // UNSUPPORTED: clang-8
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: *
// <algorithm> // <algorithm>
// TODO: figure out what this is testing and how we can continue to test it.
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

This is testing that your library code is robust against ADL.
I assume it's failing at the moment because you didn't ADL-proof your call to __copy above.
Remember, every time you call a function in namespace _VSTD that would be subject to ADL, you need to qualify it. (The one common exception we make is for declval, because it takes no arguments.)

Quuxplusone: This is testing that your library code is robust against ADL. I assume it's failing at the…
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include "test_macros.h" #include "test_macros.h"
struct Incomplete; struct Incomplete;
template<class T> struct Holder { T t; }; template<class T> struct Holder { T t; };
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines