Skip to content

[ADT] Use adl_* wrappers across STLExtras #87936

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Apr 9, 2024
Merged

[ADT] Use adl_* wrappers across STLExtras #87936

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
49 changes: 24 additions & 25 deletions llvm/include/llvm/ADT/STLExtras.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -320,7 +320,8 @@ template <typename T> class Callable<T, true> {

/// Returns true if the given container only contains a single element.
template <typename ContainerTy> bool hasSingleElement(ContainerTy &&C) {
auto B = std::begin(C), E = std::end(C);
auto B = adl_begin(C);
auto E = adl_end(C);
return B != E && std::next(B) == E;
}

Expand Down Expand Up @@ -375,8 +376,7 @@ inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {

template <class ContainerTy, class FuncTy>
auto map_range(ContainerTy &&C, FuncTy F) {
return make_range(map_iterator(std::begin(C), F),
map_iterator(std::end(C), F));
return make_range(map_iterator(adl_begin(C), F), map_iterator(adl_end(C), F));
}

/// A base type of mapped iterator, that is useful for building derived
Expand Down Expand Up @@ -572,11 +572,11 @@ iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
make_filter_range(RangeT &&Range, PredicateT Pred) {
using FilterIteratorT =
filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
return make_range(
FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
std::end(std::forward<RangeT>(Range)), Pred),
FilterIteratorT(std::end(std::forward<RangeT>(Range)),
std::end(std::forward<RangeT>(Range)), Pred));
return make_range(FilterIteratorT(adl_begin(std::forward<RangeT>(Range)),
adl_end(std::forward<RangeT>(Range)), Pred),
FilterIteratorT(adl_end(std::forward<RangeT>(Range)),
adl_end(std::forward<RangeT>(Range)),
Pred));
}

/// A pseudo-iterator adaptor that is designed to implement "early increment"
Expand Down Expand Up @@ -656,8 +656,8 @@ iterator_range<early_inc_iterator_impl<detail::IterOfRange<RangeT>>>
make_early_inc_range(RangeT &&Range) {
using EarlyIncIteratorT =
early_inc_iterator_impl<detail::IterOfRange<RangeT>>;
return make_range(EarlyIncIteratorT(std::begin(std::forward<RangeT>(Range))),
EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
return make_range(EarlyIncIteratorT(adl_begin(std::forward<RangeT>(Range))),
EarlyIncIteratorT(adl_end(std::forward<RangeT>(Range))));
}

// Forward declarations required by zip_shortest/zip_equal/zip_first/zip_longest
Expand Down Expand Up @@ -1097,8 +1097,8 @@ class concat_iterator
/// We need the full range to know how to switch between each of the
/// iterators.
template <typename... RangeTs>
explicit concat_iterator(RangeTs &&... Ranges)
: Begins(std::begin(Ranges)...), Ends(std::end(Ranges)...) {}
explicit concat_iterator(RangeTs &&...Ranges)
: Begins(adl_begin(Ranges)...), Ends(adl_end(Ranges)...) {}

using BaseT::operator++;

Expand Down Expand Up @@ -1127,26 +1127,25 @@ template <typename ValueT, typename... RangeTs> class concat_range {
public:
using iterator =
concat_iterator<ValueT,
decltype(std::begin(std::declval<RangeTs &>()))...>;
decltype(adl_begin(std::declval<RangeTs &>()))...>;

private:
std::tuple<RangeTs...> Ranges;

template <size_t... Ns>
iterator begin_impl(std::index_sequence<Ns...>) {
template <size_t... Ns> iterator begin_impl(std::index_sequence<Ns...>) {
return iterator(std::get<Ns>(Ranges)...);
}
template <size_t... Ns>
iterator begin_impl(std::index_sequence<Ns...>) const {
return iterator(std::get<Ns>(Ranges)...);
}
template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) {
return iterator(make_range(std::end(std::get<Ns>(Ranges)),
std::end(std::get<Ns>(Ranges)))...);
return iterator(make_range(adl_end(std::get<Ns>(Ranges)),
adl_end(std::get<Ns>(Ranges)))...);
}
template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
return iterator(make_range(std::end(std::get<Ns>(Ranges)),
std::end(std::get<Ns>(Ranges)))...);
return iterator(make_range(adl_end(std::get<Ns>(Ranges)),
adl_end(std::get<Ns>(Ranges)))...);
}

public:
Expand Down Expand Up @@ -1420,7 +1419,7 @@ template <typename EltTy, typename FirstTy> class first_or_second_type {

/// Given a container of pairs, return a range over the first elements.
template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {
using EltTy = decltype((*std::begin(c)));
using EltTy = decltype((*adl_begin(c)));
return llvm::map_range(std::forward<ContainerTy>(c),
[](EltTy elt) -> typename detail::first_or_second_type<
EltTy, decltype((elt.first))>::type {
Expand All @@ -1430,7 +1429,7 @@ template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {

/// Given a container of pairs, return a range over the second elements.
template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
using EltTy = decltype((*std::begin(c)));
using EltTy = decltype((*adl_begin(c)));
return llvm::map_range(
std::forward<ContainerTy>(c),
[](EltTy elt) ->
Expand Down Expand Up @@ -2106,7 +2105,7 @@ template<typename Container, typename Range = std::initializer_list<
typename Container::value_type>>
void replace(Container &Cont, typename Container::iterator ContIt,
typename Container::iterator ContEnd, Range R) {
replace(Cont, ContIt, ContEnd, R.begin(), R.end());
replace(Cont, ContIt, ContEnd, adl_begin(R), adl_begin(R));
}

/// An STL-style algorithm similar to std::for_each that applies a second
Expand Down Expand Up @@ -2519,19 +2518,19 @@ bool hasNItemsOrLess(

/// Returns true if the given container has exactly N items
template <typename ContainerTy> bool hasNItems(ContainerTy &&C, unsigned N) {
return hasNItems(std::begin(C), std::end(C), N);
return hasNItems(adl_begin(C), adl_end(C), N);
}

/// Returns true if the given container has N or more items
template <typename ContainerTy>
bool hasNItemsOrMore(ContainerTy &&C, unsigned N) {
return hasNItemsOrMore(std::begin(C), std::end(C), N);
return hasNItemsOrMore(adl_begin(C), adl_end(C), N);
}

/// Returns true if the given container has N or less items
template <typename ContainerTy>
bool hasNItemsOrLess(ContainerTy &&C, unsigned N) {
return hasNItemsOrLess(std::begin(C), std::end(C), N);
return hasNItemsOrLess(adl_begin(C), adl_end(C), N);
}

/// Returns a raw pointer that represents the same address as the argument.
Expand Down