[ADT] Clean up `enumerate` implementation. NFC.

[kuhar]

Summary

• Remove unnecessary member functions.
• Fix code sample.

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

[zero9178]

LGTM % default constructor

llvm/include/llvm/ADT/STLExtras.h

2200

Any reason not having a default constructor is desired? I'd keep it just to avoid someone needing it in the future

[kuhar]

llvm/include/llvm/ADT/STLExtras.h

2200

result_pair is a wrapper around an iterator, and only gets created when there are some iterators to wrap in the first place. Why would we want to define a default constructor for an internal class with no uses in the code base? If there's a legitimate need in the future, I think it can be added back trivially.

[zero9178]

llvm/include/llvm/ADT/STLExtras.h

2200

Yeah fair enough. I also forgot this was in a details namespace, so direct use is discouraged anways. Thanks for the conversation!

llvm/include/llvm/ADT/STLExtras.h

 template <typename R> class enumerator_iter;
 
 template <typename R> struct result_pair {
   using value_reference =
       typename std::iterator_traits<IterOfRange<R>>::reference;
 
   friend class enumerator_iter<R>;
 
-  result_pair() = default;
   result_pair(std::size_t Index, IterOfRange<R> Iter)
       : Index(Index), Iter(Iter) {}
 
-  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;
-  }
-
   std::size_t index() const { return Index; }
   value_reference value() const { return *Iter; }
 
 private:
   std::size_t Index = std::numeric_limits<std::size_t>::max();
   IterOfRange<R> Iter;
 };
 
public:
 
   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> class enumerator {
 public:
   explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
 

 } // 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:
 ///
 /// std::vector<char> Items = {'A', 'B', 'C', 'D'};
 /// for (auto X : enumerate(Items)) {
-///   printf("Item %d - %c\n", X.index(), X.value());
+///   printf("Item %zu - %c\n", X.index(), X.value());
 /// }
 ///
 /// or using structured bindings:
 ///
 /// for (auto [Index, Value] : enumerate(Items)) {
-///   printf("Item %d - %c\n", Index, Value);
+///   printf("Item %zu - %c\n", Index, Value);
 /// }
 ///
 /// Output:
 ///   Item 0 - A
 ///   Item 1 - B
 ///   Item 2 - C
 ///   Item 3 - D
 ///