diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -847,7 +847,7 @@
 
 template <template <typename...> class ItType, typename... Args> class zippy {
 public:
-  using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
+  using iterator = ItType<decltype(adl_begin(std::declval<Args>()))...>;
   using iterator_category = typename iterator::iterator_category;
   using value_type = typename iterator::value_type;
   using difference_type = typename iterator::difference_type;
@@ -859,10 +859,10 @@
 
   template <size_t... Ns>
   iterator begin_impl(std::index_sequence<Ns...>) const {
-    return iterator(std::begin(std::get<Ns>(ts))...);
+    return iterator(adl_begin(std::get<Ns>(ts))...);
   }
   template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
-    return iterator(std::end(std::get<Ns>(ts))...);
+    return iterator(adl_end(std::get<Ns>(ts))...);
   }
 
 public:
@@ -2141,130 +2141,209 @@
 
 namespace detail {
 
-template <typename R> class enumerator_iter;
+/// Infinite stream of increasing 0-based `size_t` indices.
+struct index_stream {
+  struct iterator : iterator_facade_base<iterator, std::forward_iterator_tag,
+                                         const iterator> {
+    std::size_t operator*() const { return Index; }
+    iterator &operator++() {
+      ++Index;
+      return *this;
+    }
 
-template <typename R> struct result_pair {
-  using value_reference =
-      typename std::iterator_traits<IterOfRange<R>>::reference;
+    bool operator==(const iterator &Other) const {
+      return Index == Other.Index;
+    }
 
-  friend class enumerator_iter<R>;
+    std::size_t Index = 0;
+  };
+
+  iterator begin() const { return {}; }
+  iterator end() const {
+    // We approximate 'infinity' with the max size_t value, which should be good
+    // enough to index over any container.
+    iterator It;
+    It.Index = std::numeric_limits<std::size_t>::max();
+    return It;
+  }
+};
 
-  result_pair() = default;
-  result_pair(std::size_t Index, IterOfRange<R> Iter)
-      : Index(Index), Iter(Iter) {}
+// Zippy iterator that uses the second iterator for comparisons. For the
+// increment to be safe, the second range has to be the shortest.
+template <typename... Iters>
+struct zip_second : public zip_common<zip_second<Iters...>, Iters...> {
+  static_assert(sizeof...(Iters) >= 2, "Expected at least two iteratees");
+  using Base = zip_common<zip_second<Iters...>, Iters...>;
 
-  result_pair(const result_pair<R> &Other)
-      : Index(Other.Index), Iter(Other.Iter) {}
-  result_pair &operator=(const result_pair &Other) {
-    Index = Other.Index;
-    Iter = Other.Iter;
-    return *this;
+  bool operator==(const zip_second &Other) const {
+    return std::get<1>(this->iterators) == std::get<1>(Other.iterators);
   }
 
-  std::size_t index() const { return Index; }
-  value_reference value() const { return *Iter; }
+  zip_second(Iters &&...It) : Base(std::forward<Iters>(It)...) {}
+};
+
+template <typename... Ranges> struct enumerator_result {
+  static constexpr std::size_t NumRanges = sizeof...(Ranges);
+  static_assert(NumRanges != 0);
+  // `NumValues` includes the index stream.
+  static constexpr std::size_t NumValues = NumRanges + 1;
+
+  // We use `zippy` to handle the underlying iterators. Because index is the
+  // first one, we use the second range to determine when to finish iteration.
+  using range = zippy<zip_second, index_stream, Ranges...>;
+  using iterator = typename range::iterator;
+
+  // Tuple type whose element types are references for each `Range`.
+  using range_reference_tuple =
+      typename ZipTupleType<IterOfRange<Ranges>...>::type;
+  // Tuple type who elements are references to all values, including both
+  // the index and `Range` reference types.
+  using value_reference_tuple =
+      typename ZipTupleType<index_stream::iterator,
+                            IterOfRange<Ranges>...>::type;
+
+  template <typename... R> friend class enumerator_iter;
+
+  enumerator_result(iterator Iter) : Iter(Iter) {}
+
+  /// Returns the 0-based index of the current position within the original
+  /// input `Range`(s).
+  std::size_t index() const {
+    // Index is always the first iteratee.
+    return std::get<0>(*Iter);
+  }
+
+  /// Returns the value(s) for the current iterator. This does not include the
+  /// index.
+  decltype(auto) value() const {
+    if constexpr (NumRanges == 1) {
+      using value_result = std::tuple_element_t<0, range_reference_tuple>;
+      return value_result(std::get<1>(*Iter));
+    } else {
+      return get_values(std::index_sequence_for<Ranges...>{});
+    }
+  }
+
+  /// Returns the value at index `I`. This includes the index.
+  template <std::size_t I>
+  friend decltype(auto) get(const enumerator_result &Result) {
+    static_assert(I < NumValues, "Index out of bounds");
+    return std::tuple_element_t<I, value_reference_tuple>(
+        std::get<I>(*Result.Iter));
+  }
+
+  template <typename... Ts>
+  friend bool operator==(const enumerator_result &Result,
+                         const std::tuple<std::size_t, Ts...> &Other) {
+    static_assert(NumRanges == sizeof...(Ts), "Size mismatch");
+    return Result.is_value_equal(Other, std::make_index_sequence<NumValues>{});
+  }
 
 private:
-  std::size_t Index = std::numeric_limits<std::size_t>::max();
-  IterOfRange<R> Iter;
-};
+  template <std::size_t... Idx>
+  range_reference_tuple get_values(std::index_sequence<Idx...>) const {
+    return {std::tuple_element_t<Idx, range_reference_tuple>(
+        std::get<Idx + 1>(*Iter))...};
+  }
 
-template <std::size_t i, typename R>
-decltype(auto) get(const result_pair<R> &Pair) {
-  static_assert(i < 2);
-  if constexpr (i == 0) {
-    return Pair.index();
-  } else {
-    return Pair.value();
+  template <typename Tuple, std::size_t... Idx>
+  bool is_value_equal(const Tuple &Other, std::index_sequence<Idx...>) const {
+    return ((std::get<Idx>(*Iter) == std::get<Idx>(Other)) && ...);
   }
-}
 
-template <typename R>
-class enumerator_iter
-    : public iterator_facade_base<enumerator_iter<R>, std::forward_iterator_tag,
-                                  const result_pair<R>> {
-  using result_type = result_pair<R>;
+  iterator Iter;
+};
 
+template <typename... Ranges>
+class enumerator_iter
+    : public iterator_facade_base<enumerator_iter<Ranges...>,
+                                  std::forward_iterator_tag,
+                                  const enumerator_result<Ranges...>> {
 public:
-  explicit enumerator_iter(IterOfRange<R> EndIter)
-      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
+  using result_type = enumerator_result<Ranges...>;
+  using result_range = typename result_type::range;
+  using result_iter = typename result_type::iterator;
 
-  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
-      : Result(Index, Iter) {}
+  explicit enumerator_iter(result_iter Iter) : Result(Iter) {}
 
   const result_type &operator*() const { return Result; }
 
   enumerator_iter &operator++() {
-    assert(Result.Index != std::numeric_limits<size_t>::max());
     ++Result.Iter;
-    ++Result.Index;
     return *this;
   }
 
-  bool operator==(const enumerator_iter &RHS) const {
-    // Don't compare indices here, only iterators.  It's possible for an end
-    // iterator to have different indices depending on whether it was created
-    // by calling std::end() versus incrementing a valid iterator.
-    return Result.Iter == RHS.Result.Iter;
-  }
-
-  enumerator_iter(const enumerator_iter &Other) : Result(Other.Result) {}
-  enumerator_iter &operator=(const enumerator_iter &Other) {
-    Result = Other.Result;
-    return *this;
+  bool operator==(const enumerator_iter &Rhs) const {
+    return Result.Iter == Rhs.Result.Iter;
   }
 
 private:
   result_type Result;
 };
 
-template <typename R> class enumerator {
+template <typename... Ranges> class enumerator {
 public:
-  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
+  explicit enumerator(Ranges &&...Range)
+      : TheRange(index_stream{}, std::forward<Ranges>(Range)...) {}
+  using iterator = enumerator_iter<Ranges...>;
 
-  enumerator_iter<R> begin() {
-    return enumerator_iter<R>(0, std::begin(TheRange));
-  }
-  enumerator_iter<R> begin() const {
-    return enumerator_iter<R>(0, std::begin(TheRange));
-  }
+  iterator begin() { return iterator{adl_begin(TheRange)}; }
+  iterator begin() const { return iterator{adl_begin(TheRange)}; }
 
-  enumerator_iter<R> end() {
-    return enumerator_iter<R>(std::end(TheRange));
-  }
-  enumerator_iter<R> end() const {
-    return enumerator_iter<R>(std::end(TheRange));
-  }
+  iterator end() { return iterator{adl_end(TheRange)}; }
+  iterator end() const { return iterator{adl_end(TheRange)}; }
 
 private:
-  R TheRange;
+  using range = typename enumerator_iter<Ranges...>::result_range;
+  range TheRange;
 };
 
 } // end namespace detail
 
-/// Given an input range, returns a new range whose values are are pair (A,B)
-/// such that A is the 0-based index of the item in the sequence, and B is
-/// the value from the original sequence.  Example:
+/// Given two or more input ranges, returns a new range whose values are are
+/// tuples (A, B, C, ...), such that A is the 0-based index of the item in the
+/// sequence, and B, C, ..., are the values from the original input ranges. All
+/// input ranges are required to have equal lengths. Note that the returned
+/// iterator allows for the values (B, C, ...) to be modified.  Example:
+///
+/// ```c++
+/// std::vector<char> Letters = {'A', 'B', 'C', 'D'};
+/// std::vector<int> Vals = {10, 11, 12, 13};
 ///
-/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
-/// for (auto X : enumerate(Items)) {
-///   printf("Item %d - %c\n", X.index(), X.value());
+/// for (auto [Index, Letter, Value] : enumerate(Letters, Vals)) {
+///   printf("Item %zu - %c: %d\n", Index, Letter, Value);
+///   Value -= 10;
 /// }
+/// ```
 ///
-/// or using structured bindings:
+/// Output:
+///   Item 0 - A: 10
+///   Item 1 - B: 11
+///   Item 2 - C: 12
+///   Item 3 - D: 13
 ///
-/// for (auto [Index, Value] : enumerate(Items)) {
-///   printf("Item %d - %c\n", Index, Value);
+/// or using an iterator:
+/// ```c++
+/// for (auto it : enumerate(Vals)) {
+///   it.value() += 10;
+///   printf("Item %zu: %d\n", it.index(), it.value());
 /// }
+/// ```
 ///
 /// Output:
-///   Item 0 - A
-///   Item 1 - B
-///   Item 2 - C
-///   Item 3 - D
+///   Item 0: 20
+///   Item 1: 21
+///   Item 2: 22
+///   Item 3: 23
 ///
-template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
-  return detail::enumerator<R>(std::forward<R>(TheRange));
+template <typename FirstRange, typename... RestRanges>
+auto enumerate(FirstRange &&First, RestRanges &&...Rest) {
+  assert((sizeof...(Rest) == 0 ||
+          all_equal({std::distance(adl_begin(First), adl_end(First)),
+                     std::distance(adl_begin(Rest), adl_end(Rest))...})) &&
+         "Ranges have different length");
+  return detail::enumerator<FirstRange, RestRanges...>(
+      std::forward<FirstRange>(First), std::forward<RestRanges>(Rest)...);
 }
 
 namespace detail {
@@ -2396,15 +2475,14 @@
 } // end namespace llvm
 
 namespace std {
-template <typename R>
-struct tuple_size<llvm::detail::result_pair<R>>
-    : std::integral_constant<std::size_t, 2> {};
-
-template <std::size_t i, typename R>
-struct tuple_element<i, llvm::detail::result_pair<R>>
-    : std::conditional<i == 0, std::size_t,
-                       typename llvm::detail::result_pair<R>::value_reference> {
-};
+template <typename... Ranges>
+struct tuple_size<llvm::detail::enumerator_result<Ranges...>>
+    : std::integral_constant<std::size_t, sizeof...(Ranges) + 1> {};
+
+template <std::size_t I, typename... Ranges>
+struct tuple_element<I, llvm::detail::enumerator_result<Ranges...>>
+    : std::tuple_element<I, typename llvm::detail::enumerator_result<
+                                Ranges...>::value_reference_tuple> {};
 
 } // namespace std
 
diff --git a/llvm/unittests/ADT/STLExtrasTest.cpp b/llvm/unittests/ADT/STLExtrasTest.cpp
--- a/llvm/unittests/ADT/STLExtrasTest.cpp
+++ b/llvm/unittests/ADT/STLExtrasTest.cpp
@@ -13,7 +13,12 @@
 #include "gtest/gtest.h"
 
 #include <climits>
+#include <cstddef>
+#include <initializer_list>
 #include <list>
+#include <tuple>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
@@ -151,6 +156,91 @@
                                    PairType(2u, '4')));
 }
 
+TEST(STLExtrasTest, EnumerateTwoRanges) {
+  using Tuple = std::tuple<size_t, int, bool>;
+
+  std::vector<int> Ints = {1, 2};
+  std::vector<bool> Bools = {true, false};
+  EXPECT_THAT(llvm::enumerate(Ints, Bools),
+              ElementsAre(Tuple(0, 1, true), Tuple(1, 2, false)));
+
+  // Check that we can modify the values when the temporary is a const
+  // reference.
+  for (const auto &[Idx, Int, Bool] : llvm::enumerate(Ints, Bools)) {
+    (void)Idx;
+    (void)Bool; // FIXME: This should be a non-const reference.
+    Int = -1;
+  }
+
+  // Check that we can modify the values when the iterator get copied.
+  for (auto [Idx, Bool, Int] : llvm::enumerate(Bools, Ints)) {
+    (void)Idx;
+    (void)Int;
+    Bool = false;
+  }
+
+  EXPECT_THAT(Ints, ElementsAre(-1, -1));
+  EXPECT_THAT(Bools, ElementsAre(false, false));
+
+  // Check that we can modify the values through `.values()`.
+  for (auto It : llvm::enumerate(Bools, Ints)) {
+    EXPECT_LT(It.index(), 3u);
+    std::get<0>(It.value()) = true;
+    std::get<1>(It.value()) = 3;
+  }
+
+  EXPECT_THAT(Ints, ElementsAre(3, 3));
+  EXPECT_THAT(Bools, ElementsAre(true, true));
+}
+
+TEST(STLExtrasTest, EnumerateThreeRanges) {
+  using Tuple = std::tuple<size_t, int, bool, char>;
+
+  std::vector<int> Ints = {1, 2};
+  std::vector<bool> Bools = {true, false};
+  char Chars[] = {'X', 'D'};
+  EXPECT_THAT(llvm::enumerate(Ints, Bools, Chars),
+              ElementsAre(Tuple(0, 1, true, 'X'), Tuple(1, 2, false, 'D')));
+
+  for (auto [Idx, Int, Bool, Char] : llvm::enumerate(Ints, Bools, Chars)) {
+    (void)Idx;
+    Int = 0;
+    Bool = true;
+    Char = '!';
+  }
+
+  EXPECT_THAT(Ints, ElementsAre(0, 0));
+  EXPECT_THAT(Bools, ElementsAre(true, true));
+  EXPECT_THAT(Chars, ElementsAre('!', '!'));
+
+  // Check that we can modify the values through `.values()`.
+  for (auto It : llvm::enumerate(Ints, Bools, Chars)) {
+    EXPECT_LT(It.index(), 3u);
+    auto [Int, Bool, Char] = It.value();
+    Int = 42;
+    Bool = false;
+    Char = '$';
+  }
+
+  EXPECT_THAT(Ints, ElementsAre(42, 42));
+  EXPECT_THAT(Bools, ElementsAre(false, false));
+  EXPECT_THAT(Chars, ElementsAre('$', '$'));
+}
+
+#if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
+TEST(STLExtrasTest, EnumerateDifferentLengths) {
+  std::vector<int> Ints = {0, 1};
+  bool Bools[] = {true, false, true};
+  std::string Chars = "abc";
+  EXPECT_DEATH(llvm::enumerate(Ints, Bools, Chars),
+               "Ranges have different length");
+  EXPECT_DEATH(llvm::enumerate(Bools, Ints, Chars),
+               "Ranges have different length");
+  EXPECT_DEATH(llvm::enumerate(Bools, Chars, Ints),
+               "Ranges have different length");
+}
+#endif
+
 template <bool B> struct CanMove {};
 template <> struct CanMove<false> {
   CanMove(CanMove &&) = delete;
@@ -188,8 +278,8 @@
 template <bool Moveable, bool Copyable>
 struct Range : Counted<Moveable, Copyable> {
   using Counted<Moveable, Copyable>::Counted;
-  int *begin() { return nullptr; }
-  int *end() { return nullptr; }
+  int *begin() const { return nullptr; }
+  int *end() const { return nullptr; }
 };
 
 TEST(STLExtrasTest, EnumerateLifetimeSemanticsPRValue) {