PDB HashTable: Make iterator type const

[thakis]

Summary

Having the hash table key change during iteration is bad, so make it
impossible. Nothing relied on the key type not being const. Nothing
needed a mutable value either, so make the whole pair const.
Also rename the iterator typedef to const_iterator.

(This is also necessary to be able to call the const version of
iterator_facade_base::operator->(). Nothing calls this yet, but
I'm adding a few calls to it in a dependent change.)

No behavior change.

[compnerd]

Yeah, mutations of the hashtable during iteration would be bad. LGTM.

[thakis]

Thanks!

llvm/include/llvm/DebugInfo/PDB/Native/HashTable.h

 Error writeSparseBitVector(BinaryStreamWriter &Writer, SparseBitVector<> &Vec);
 
 template <typename ValueT> class HashTable;
 
 template <typename ValueT>
 class HashTableIterator
     : public iterator_facade_base<HashTableIterator<ValueT>,
                                   std::forward_iterator_tag,
-                                  std::pair<uint32_t, ValueT>> {
+                                  const std::pair<uint32_t, ValueT>> {
   friend HashTable<ValueT>;
 
   HashTableIterator(const HashTable<ValueT> &Map, uint32_t Index,
                     bool IsEnd)
       : Map(&Map), Index(Index), IsEnd(IsEnd) {}
 
 public:
   HashTableIterator(const HashTable<ValueT> &Map) : Map(&Map) {
private:
 
   const HashTable<ValueT> *Map;
   uint32_t Index;
   bool IsEnd;
 };
 
 template <typename ValueT>
 class HashTable {
-  using iterator = HashTableIterator<ValueT>;
-  friend iterator;
+  using const_iterator = HashTableIterator<ValueT>;
+  friend const_iterator;
 
   struct Header {
     support::ulittle32_t Size;
     support::ulittle32_t Capacity;
   };
 
   using BucketList = std::vector<std::pair<uint32_t, ValueT>>;
 
void clear() {
     Present.clear();
     Deleted.clear();
   }
 
   bool empty() const { return size() == 0; }
   uint32_t capacity() const { return Buckets.size(); }
   uint32_t size() const { return Present.count(); }
 
-  iterator begin() const { return iterator(*this); }
-  iterator end() const { return iterator(*this, 0, true); }
+  const_iterator begin() const { return const_iterator(*this); }
+  const_iterator end() const { return const_iterator(*this, 0, true); }
 
   /// Find the entry whose key has the specified hash value, using the specified
   /// traits defining hash function and equality.
   template <typename Key, typename TraitsT>
-  iterator find_as(const Key &K, TraitsT &Traits) const {
+  const_iterator find_as(const Key &K, TraitsT &Traits) const {
     uint32_t H = Traits.hashLookupKey(K) % capacity();
     uint32_t I = H;
     Optional<uint32_t> FirstUnused;
     do {
       if (isPresent(I)) {
         if (Traits.storageKeyToLookupKey(Buckets[I].first) == K)
-          return iterator(*this, I, false);
+          return const_iterator(*this, I, false);
       } else {
         if (!FirstUnused)
           FirstUnused = I;
         // Insertion occurs via linear probing from the slot hint, and will be
         // inserted at the first empty / deleted location.  Therefore, if we are
         // probing and find a location that is neither present nor deleted, then
         // nothing must have EVER been inserted at this location, and thus it is
         // not possible for a matching value to occur later.
         if (!isDeleted(I))
           break;
       }
       I = (I + 1) % capacity();
     } while (I != H);
 
     // The only way FirstUnused would not be set is if every single entry in the
     // table were Present.  But this would violate the load factor constraints
     // that we impose, so it should never happen.
     assert(FirstUnused);
-    return iterator(*this, *FirstUnused, true);
+    return const_iterator(*this, *FirstUnused, true);
   }
 
   /// Set the entry using a key type that the specified Traits can convert
   /// from a real key to an internal key.
   template <typename Key, typename TraitsT>
   bool set_as(const Key &K, ValueT V, TraitsT &Traits) {
     return set_as_internal(K, std::move(V), Traits, None);
   }