[ADT] Use `adl_begin`/`end` in `enumerate`

[kuhar]

Summary

This allows enumerate to work with range types that expose custom
begin/end functions.

This is a cleanup in preparation for future changes in
https://reviews.llvm.org/D144503.

[zero9178]

LGTM

llvm/include/llvm/ADT/STLExtras.h

private:
   result_type Result;
 };
 
 template <typename R> class enumerator {
 public:
   explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
 
   enumerator_iter<R> begin() {
-    return enumerator_iter<R>(0, std::begin(TheRange));
+    return enumerator_iter<R>(0, adl_begin(TheRange));
   }
   enumerator_iter<R> begin() const {
-    return enumerator_iter<R>(0, std::begin(TheRange));
+    return enumerator_iter<R>(0, adl_begin(TheRange));
   }
 
-  enumerator_iter<R> end() {
-    return enumerator_iter<R>(std::end(TheRange));
-  }
+  enumerator_iter<R> end() { return enumerator_iter<R>(adl_end(TheRange)); }
   enumerator_iter<R> end() const {
-    return enumerator_iter<R>(std::end(TheRange));
+    return enumerator_iter<R>(adl_end(TheRange));
   }
 
 private:
   R TheRange;
 };
 
 } // end namespace detail
 

llvm/unittests/ADT/STLExtrasTest.cpp

int Destructors = 0;
     EXPECT_EQ(0, Moves);
     EXPECT_EQ(0, Destructors);
   }
   EXPECT_EQ(0, Copies);
   EXPECT_EQ(0, Moves);
   EXPECT_EQ(1, Destructors);
 }
 
+namespace some_namespace {
+struct some_struct {
+  std::vector<int> data;
+  std::string swap_val;
+};
+
+std::vector<int>::const_iterator begin(const some_struct &s) {
+  return s.data.begin();
+}
+
+std::vector<int>::const_iterator end(const some_struct &s) {
+  return s.data.end();
+}
+
+void swap(some_struct &lhs, some_struct &rhs) {
+  // make swap visible as non-adl swap would even seem to
+  // work with std::swap which defaults to moving
+  lhs.swap_val = "lhs";
+  rhs.swap_val = "rhs";
+}
+
+struct requires_move {};
+int *begin(requires_move &&) { return nullptr; }
+int *end(requires_move &&) { return nullptr; }
+} // namespace some_namespace
+
+TEST(STLExtrasTest, EnumerateCustomBeginEnd) {
+  // Check that `enumerate` uses ADL to find `begin`/`end` iterators
+  // of the enumerated type.
+  some_namespace::some_struct X{};
+  X.data = {1, 2, 3};
+
+  unsigned Iters = 0;
+  for (auto [Idx, Val] : enumerate(X)) {
+    EXPECT_EQ(Val, X.data[Idx]);
+    ++Iters;
+  }
+  EXPECT_EQ(Iters, 3u);
+}
+
 TEST(STLExtrasTest, CountAdaptor) {
   std::vector<int> v;
 
   v.push_back(1);
   v.push_back(2);
   v.push_back(1);
   v.push_back(4);
   v.push_back(3);
TEST(STLExtrasTest, AppendRange) {
 
   std::string Str;
   append_range(Str, "abc");
   EXPECT_THAT(Str, ElementsAre('a', 'b', 'c', '\0'));
   append_range(Str, "def");
   EXPECT_THAT(Str, ElementsAre('a', 'b', 'c', '\0', 'd', 'e', 'f', '\0'));
 }
 
-namespace some_namespace {
-struct some_struct {
-  std::vector<int> data;
-  std::string swap_val;
-};
-
-std::vector<int>::const_iterator begin(const some_struct &s) {
-  return s.data.begin();
-}
-
-std::vector<int>::const_iterator end(const some_struct &s) {
-  return s.data.end();
-}
-
-void swap(some_struct &lhs, some_struct &rhs) {
-  // make swap visible as non-adl swap would even seem to
-  // work with std::swap which defaults to moving
-  lhs.swap_val = "lhs";
-  rhs.swap_val = "rhs";
-}
-
-struct requires_move {};
-int *begin(requires_move &&) { return nullptr; }
-int *end(requires_move &&) { return nullptr; }
-} // namespace some_namespace
-
 TEST(STLExtrasTest, ADLTest) {
   some_namespace::some_struct s{{1, 2, 3, 4, 5}, ""};
   some_namespace::some_struct s2{{2, 4, 6, 8, 10}, ""};
 
   EXPECT_EQ(*adl_begin(s), 1);
   EXPECT_EQ(*(adl_end(s) - 1), 5);
 
   adl_swap(s, s2);