[STLExtras] Make const the * operator for mapped_iterator.

[asbirlea]

Summary

The current non-const * operator shadows the const operator in
iterator_adaptor_base.

[rriddle]

Thanks for fixing this. I've been bitten by this non-const operator* quite a bit.

llvm/include/llvm/ADT/STLExtras.h

: public iterator_adaptor_base<
              typename std::iterator_traits<ItTy>::iterator_category,
              typename std::remove_reference<FuncReturnTy>::type> {
 public:
   mapped_iterator(ItTy U, FuncTy F)
     : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
 
   ItTy getCurrent() { return this->I; }
 
-  FuncReturnTy operator*() { return F(*this->I); }
+  FuncReturnTy operator*() const { return F(*this->I); }
 
 private:
   FuncTy F;
 };
 
 // map_iterator - Provide a convenient way to create mapped_iterators, just like
 // make_pair is useful for creating pairs...
 template <class ItTy, class FuncTy>

mlir/include/mlir/IR/Attributes.h

private:
   template <typename AttrTy>
   class attr_value_iterator final
       : public llvm::mapped_iterator<ArrayAttr::iterator,
                                      AttrTy (*)(Attribute)> {
   public:
     explicit attr_value_iterator(ArrayAttr::iterator it)
         : llvm::mapped_iterator<ArrayAttr::iterator, AttrTy (*)(Attribute)>(
               it, [](Attribute attr) { return attr.cast<AttrTy>(); }) {}
-    AttrTy operator*() { return (*this->I).template cast<AttrTy>(); }
+    AttrTy operator*() const { return (*this->I).template cast<AttrTy>(); }
   };
 
 public:
   template <typename AttrTy>
   llvm::iterator_range<attr_value_iterator<AttrTy>> getAsRange() {
     return llvm::make_range(attr_value_iterator<AttrTy>(begin()),
                             attr_value_iterator<AttrTy>(end()));
   }