Support: Make VarStreamArrayIterator iterate over const values

[dexonsmith]

Summary

VarStreamArrayIterator returns a reference to a just-computed internal
value. Change it to iterate over const ValueType to avoid allowing
clients to mutate the internal state, and to drop the
non-const-qualified operator*().

The removed operator*() was from 175d70ee5c2f03f6 to get
iterator_facade_base::operator->() working, and this fixes the root
cause instead: setting T to const ValueType causes
iterator_facade_base to infer PointerT as const ValueType*.

Ironically, this is the last blocker for removing the const-incorrect
overload of iterator_facade_base::operator->(), whose presence
triggered adding the workaround in the first place :).

This is an alternative to https://reviews.llvm.org/D113796.

[dblaikie]

Oh, I see, didn't realize this was posted as a separate alternative patch. Approving this direction over D113796

[dexonsmith]

Just triggering CI after pushing 9a2b54af221717bf71040b530c4ac8043e1db23a, which added const to some range-based for loops in lld.

llvm/include/llvm/Support/BinaryStreamArray.h

private:
   BinaryStreamRef Stream;
   Extractor E;
   uint32_t Skew = 0;
 };
 
 template <typename ValueType, typename Extractor>
 class VarStreamArrayIterator
     : public iterator_facade_base<VarStreamArrayIterator<ValueType, Extractor>,
-                                  std::forward_iterator_tag, ValueType> {
+                                  std::forward_iterator_tag, const ValueType> {
   typedef VarStreamArrayIterator<ValueType, Extractor> IterType;
   typedef VarStreamArray<ValueType, Extractor> ArrayType;
 
 public:
   VarStreamArrayIterator(const ArrayType &Array, const Extractor &E,
                          uint32_t Offset, bool *HadError)
       : IterRef(Array.Stream.drop_front(Offset)), Extract(E),
         Array(&Array), AbsOffset(Offset), HadError(HadError) {
bool operator==(const IterType &R) const {
     return false;
   }
 
   const ValueType &operator*() const {
     assert(Array && !HasError);
     return ThisValue;
   }
 
-  ValueType &operator*() {
-    assert(Array && !HasError);
-    return ThisValue;
-  }
-
   IterType &operator+=(unsigned N) {
     for (unsigned I = 0; I < N; ++I) {
       // We are done with the current record, discard it so that we are
       // positioned at the next record.
       AbsOffset += ThisLen;
       IterRef = IterRef.drop_front(ThisLen);
       if (IterRef.getLength() == 0) {
         // There is nothing after the current record, we must make this an end

llvm/tools/llvm-pdbutil/ExplainOutputStyle.cpp

static void explainDbiModiSubstreamOffset(LinePrinter &P, DbiStream &Dbi,
   while (true) {
     Prev = Current;
     ++Current;
     if (Current == ModuleDescriptors.end() || Offset < Current.offset())
       break;
     ++Index;
   }
 
-  DbiModuleDescriptor &Descriptor = *Prev;
+  const DbiModuleDescriptor &Descriptor = *Prev;
   P.formatLine("which contains the descriptor for module {0} ({1}).", Index,
                Descriptor.getModuleName());
 }
 
 template <typename T>
 static void dontExplain(LinePrinter &Printer, T &Stream, uint32_t Offset) {}
 
 template <typename T, typename SubstreamRangeT>