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
@@ -26,6 +26,7 @@
 #include "llvm/Config/abi-breaking.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
+#include <bits/utility.h>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -847,7 +848,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 +860,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:
@@ -2139,69 +2140,146 @@
 
 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;
+    }
+
+    bool operator==(const iterator &Other) const {
+      return Index == Other.Index;
+    }
+
+    std::size_t Index = 0;
+  };
 
-template <typename R> struct enumerator_result {
-  using value_reference =
-      typename std::iterator_traits<IterOfRange<R>>::reference;
+  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;
+  }
+};
 
-  friend class enumerator_iter<R>;
+// 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...>;
+
+  bool operator==(const zip_second &Other) const {
+    return std::get<1>(this->iterators) == std::get<1>(Other.iterators);
+  }
+
+  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() = default;
-  enumerator_result(std::size_t Index, IterOfRange<R> Iter)
-      : Index(Index), Iter(Iter) {}
+  enumerator_result(iterator Iter) : Iter(Iter) {}
 
   enumerator_result(const enumerator_result &) = default;
   enumerator_result &operator=(const enumerator_result &) = default;
 
-  std::size_t index() const { return Index; }
-  value_reference value() const { return *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 value_reference_tuple(
+          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 + 1, value_reference_tuple>(
+        std::get<Idx + 1>(*Iter))...};
+  }
 
-template <std::size_t I, typename R>
-decltype(auto) get(const enumerator_result<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>
+  iterator Iter;
+};
+
+template <typename... Ranges>
 class enumerator_iter
-    : public iterator_facade_base<enumerator_iter<R>, std::forward_iterator_tag,
-                                  const enumerator_result<R>> {
+    : public iterator_facade_base<enumerator_iter<Ranges...>,
+                                  std::forward_iterator_tag,
+                                  const enumerator_result<Ranges...>> {
 public:
-  using result_type = enumerator_result<R>;
-
-  explicit enumerator_iter(IterOfRange<R> EndIter)
-      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
-
-  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
-      : Result(Index, Iter) {}
+  using result_type = enumerator_result<Ranges...>;
+  using result_range = typename result_type::range;
+  using result_iter = typename result_type::iterator;
 
+  explicit enumerator_iter(result_iter Iter) : Result(Iter) {}
   enumerator_iter(const enumerator_iter &) = default;
   enumerator_iter &operator=(const enumerator_iter &) = default;
 
   const result_type &operator*() const { return Result; }
-  result_type &operator*() { 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 `adl_end` versus incrementing a valid iterator.
     return Result.Iter == Rhs.Result.Iter;
   }
 
@@ -2209,46 +2287,69 @@
   result_type Result;
 };
 
-template <typename R> class enumerator {
+template <typename... Ranges> class enumerator {
 public:
-  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
-  using iterator = enumerator_iter<R>;
+  explicit enumerator(Ranges &&...Range)
+      : TheRange(index_stream{}, std::forward<Ranges>(Range)...) {}
+  using iterator = enumerator_iter<Ranges...>;
 
-  iterator begin() { return iterator(0, adl_begin(TheRange)); }
-  iterator begin() const { return iterator(0, adl_begin(TheRange)); }
+  iterator begin() { return iterator{adl_begin(TheRange)}; }
+  iterator begin() const { return iterator{adl_begin(TheRange)}; }
 
-  iterator end() { return iterator(adl_end(TheRange)); }
-  iterator end() const { return iterator(adl_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 {
@@ -2380,15 +2481,14 @@
 } // end namespace llvm
 
 namespace std {
-template <typename R>
-struct tuple_size<llvm::detail::enumerator_result<R>>
-    : std::integral_constant<std::size_t, 2> {};
-
-template <std::size_t I, typename R>
-struct tuple_element<I, llvm::detail::enumerator_result<R>>
-    : std::conditional<
-          I == 0, std::size_t,
-          typename llvm::detail::enumerator_result<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
@@ -156,6 +156,69 @@
                                    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 iterator is a const
+  // reference. Note that 'Bool' is interesting because it's returned
+  // as a `std::vector` reference wrapper.
+  for (auto [Idx, Int, Bool] : llvm::enumerate(Ints, Bools)) {
+    (void)Idx;
+    (void)Bool;
+    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));
+}
+
+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('!', '!'));
+}
+
+#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;
@@ -193,8 +256,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) {
@@ -998,207 +1061,4 @@
                 "addEnumValues(ULongLongMax, C::Two) failed.");
 }
 
-
-namespace jakub {
-
-using namespace llvm::detail;
-
-template <typename R, std::size_t NumValues> class enumerator_iter;
-
-template <typename R>
-using const_value_reference = decltype(*adl_begin(std::declval<const R&>()));
-
-template <typename R, std::size_t NumValues> struct result_pair {
-  using value_reference =
-      typename std::iterator_traits<IterOfRange<R>>::reference;
-  using const_value_reference = const_value_reference<R>;
-
-  friend class enumerator_iter<R, NumValues>;
-  static_assert(NumValues > 0);
-
-  result_pair() = default;
-  result_pair(std::size_t Index, IterOfRange<R> Iter)
-      : Index(Index), Iter(Iter) {}
-
-  result_pair(const result_pair &Other)
-      : Index(Other.Index), Iter(Other.Iter) {}
-  result_pair &operator=(const result_pair &Other) {
-    Index = Other.Index;
-    Iter = Other.Iter;
-    return *this;
-  }
-
-  std::size_t index() const { return Index; }
-  const_value_reference value() const {
-    return *Iter;
-  }
-
-  auto as_tuple() const {
-    if constexpr (NumValues == 1) {
-      return std::make_tuple(index(), value());
-    } else {
-      return std::tuple_cat(std::make_tuple(index()), value());
-    }
-  }
-
-  template <typename T>
-  friend bool operator==(const result_pair &Pair,
-                         const std::pair<std::size_t, T> &Other) {
-    return Pair.Index == Other.first && *Pair.Iter == Other.second;
-  }
-
-  template <typename... Ts>
-  friend bool operator==(const result_pair &Pair,
-                         const std::tuple<std::size_t, Ts...> &Other) {
-    static_assert(NumValues == sizeof...(Ts), "Size mismatch");
-    return Pair.as_tuple() == Other;
-  }
-
-private:
-  std::size_t Index = std::numeric_limits<std::size_t>::max();
-  IterOfRange<R> Iter;
-};
-
-template <std::size_t I, typename R, std::size_t NumValues>
-decltype(auto) get(const result_pair<R, NumValues> &Pair) {
-  static_assert(I < NumValues + 1);
-  return std::get<I>(Pair.as_tuple());
-}
-
-template <typename R, std::size_t NumValues>
-class enumerator_iter
-    : public iterator_facade_base<enumerator_iter<R, NumValues>, std::forward_iterator_tag,
-                                  const result_pair<R, true>> {
-  using result_type = result_pair<R, NumValues>;
-
-public:
-  explicit enumerator_iter(IterOfRange<R> EndIter)
-      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
-
-  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
-      : Result(Index, Iter) {}
-
-  const result_type &operator*() const { return Result; }
-  result_type &operator*() { 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;
-  }
-
-private:
-  result_type Result;
-};
-
-template <typename R, std::size_t NumValues> class enumerator {
-public:
-  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
-  using iterator = enumerator_iter<R, NumValues>;
-
-  iterator begin() { return iterator{0, adl_begin(TheRange)}; }
-  iterator begin() const { return iterator{0, adl_begin(TheRange)}; }
-
-  iterator end() { return iterator{adl_end(TheRange)}; }
-  iterator end() const { return iterator{adl_end(TheRange)}; }
-
-private:
-  R TheRange;
-};
-
-/// 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:
-///
-/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
-/// for (auto X : enumerate(Items)) {
-///   printf("Item %d - %c\n", X.index(), X.value());
-/// }
-///
-/// or using structured bindings:
-///
-/// for (auto [Index, Value] : enumerate(Items)) {
-///   printf("Item %d - %c\n", Index, Value);
-/// }
-///
-/// Output:
-///   Item 0 - A
-///   Item 1 - B
-///   Item 2 - C
-///   Item 3 - D
-///
-template <typename R> jakub::enumerator<R, 1> enumerate(R &&TheRange) {
-  return jakub::enumerator<R, 1>(std::forward<R>(TheRange));
-}
-
-template <typename FirstIteratee, typename SecondIteratee,
-          typename... RestIteratees>
-auto enumerate(FirstIteratee &&first, SecondIteratee &&second,
-               RestIteratees &&...rest) {
-  using RangeType = decltype(zip_equal(std::forward<FirstIteratee>(first),
-                                       std::forward<SecondIteratee>(second),
-                                       std::forward<RestIteratees>(rest)...));
-  return jakub::enumerator<RangeType, 2 + sizeof...(RestIteratees)>(zip_equal(
-      std::forward<FirstIteratee>(first), std::forward<SecondIteratee>(second),
-      std::forward<RestIteratees>(rest)...));
-}
-
-} // end namespace jakub
-} // namespace
-
-namespace std {
-template <typename R, std::size_t NumValues>
-struct tuple_size<::jakub::result_pair<R, NumValues>>
-    : std::integral_constant<std::size_t, NumValues + 1> {};
-
-template <std::size_t I, typename R, std::size_t NumValues>
-struct tuple_element<I, jakub::result_pair<R, NumValues>>
-    : std::conditional<I == 0, const std::size_t,
-                       decltype(jakub::get<I>(
-                           declval<jakub::result_pair<R, NumValues>>()))> {};
-} // namespace std
-
-namespace {
-
-TEST(STLExtrasTest, JAKUBEnumerateOne) {
-  using Pair = std::pair<size_t, int>;
-  using Tuple = std::tuple<size_t, int>;
-
-  std::initializer_list<int> values = {1, 2};
-  EXPECT_THAT(jakub::enumerate(values), ElementsAre(Pair(0, 1), Pair(1, 2)));
-  EXPECT_THAT(jakub::enumerate(values), ElementsAre(Tuple(0, 1), Tuple(1, 2)));
-}
-
-TEST(STLExtrasTest, JAKUBEnumerateTwo) {
-  using Pair = std::pair<size_t, std::tuple<int, bool>>;
-  using Tuple = std::tuple<size_t, int, bool>;
-
-  std::vector<int> ints = {1, 2};
-  std::vector<bool> bools = {true, false};
-  EXPECT_THAT(jakub::enumerate(ints, bools), ElementsAre(Pair(0, {1, true}), Pair(1, {2, false})));
-  EXPECT_THAT(jakub::enumerate(ints, bools), ElementsAre(Tuple(0, 1, true), Tuple(1, 2, false)));
-
-  for (const auto& [_, i] : llvm::enumerate(ints))
-    i = -1;
-
-  for (auto [_, b] : llvm::enumerate(bools))
-    b = false;
-
-  EXPECT_THAT(ints, ElementsAre(-1, -1));
-  EXPECT_THAT(bools, ElementsAre(false, false));
-}
 } // namespace