[clang][test] Fix prefix operator++ signature in iterators

[gamesh411]

Summary

Prefix operator++ should return the iterator incremented by reference.

[martong]

What is the context here? Did it cause any crash/bug or were you just reading through the code for a good night sleep? :D

[gamesh411]

In D89528#2334795, @martong wrote:

What is the context here? Did it cause any crash/bug or were you just reading through the code for a good night sleep? :D

No crashes this time 🙏, just happened to notice it with @baloghadamsoftware.

Actually I was debugging thru iterator-related code and was making assumptions on the signature of operators.
Then I noticed the assymetry of return types in case of operator++ (fundamental types have ref return values in prefix case, but the simulator header did not for iterators).

Note that the libc++ implementation uses reference return types:
https://github.com/llvm/llvm-project/blob/master/libcxx/include/iterator
So does the libstd++ implementation:
https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/stl_iterator.h

[martong]

Ok, thanks for the context. LG!

clang/test/Analysis/Inputs/system-header-simulator-cxx.h

template <typename T, typename Ptr, typename Ref> struct __vector_iterator {
   typedef ptrdiff_t difference_type;
   typedef T value_type;
   typedef Ptr pointer;
   typedef Ref reference;
   typedef std::random_access_iterator_tag iterator_category;
 
   __vector_iterator(const Ptr p = 0) : ptr(p) {}
   __vector_iterator(const iterator &rhs): ptr(rhs.base()) {}
-  __vector_iterator<T, Ptr, Ref> operator++() { ++ ptr; return *this; }
+  __vector_iterator<T, Ptr, Ref>& operator++() { ++ ptr; return *this; }
   __vector_iterator<T, Ptr, Ref> operator++(int) {
     auto tmp = *this;
     ++ ptr;
     return tmp;
   }
   __vector_iterator<T, Ptr, Ref> operator--() { -- ptr; return *this; }
   __vector_iterator<T, Ptr, Ref> operator--(int) {
     auto tmp = *this; -- ptr;
template <typename T, typename Ptr, typename Ref> struct __deque_iterator {
   typedef ptrdiff_t difference_type;
   typedef T value_type;
   typedef Ptr pointer;
   typedef Ref reference;
   typedef std::random_access_iterator_tag iterator_category;
 
   __deque_iterator(const Ptr p = 0) : ptr(p) {}
   __deque_iterator(const iterator &rhs): ptr(rhs.base()) {}
-  __deque_iterator<T, Ptr, Ref> operator++() { ++ ptr; return *this; }
+  __deque_iterator<T, Ptr, Ref>& operator++() { ++ ptr; return *this; }
   __deque_iterator<T, Ptr, Ref> operator++(int) {
     auto tmp = *this;
     ++ ptr;
     return tmp;
   }
   __deque_iterator<T, Ptr, Ref> operator--() { -- ptr; return *this; }
   __deque_iterator<T, Ptr, Ref> operator--(int) {
     auto tmp = *this; -- ptr;
template <typename T, typename Ptr, typename Ref> struct __list_iterator {
   typedef ptrdiff_t difference_type;
   typedef T value_type;
   typedef Ptr pointer;
   typedef Ref reference;
   typedef std::bidirectional_iterator_tag iterator_category;
 
   __list_iterator(T* it = 0) : item(it) {}
   __list_iterator(const iterator &rhs): item(rhs.item) {}
-  __list_iterator<T, Ptr, Ref> operator++() { item = item->next; return *this; }
+  __list_iterator<T, Ptr, Ref>& operator++() { item = item->next; return *this; }
   __list_iterator<T, Ptr, Ref> operator++(int) {
     auto tmp = *this;
     item = item->next;
     return tmp;
   }
   __list_iterator<T, Ptr, Ref> operator--() { item = item->prev; return *this; }
   __list_iterator<T, Ptr, Ref> operator--(int) {
     auto tmp = *this;
template <typename T, typename Ptr, typename Ref> struct __fwdl_iterator {
   typedef ptrdiff_t difference_type;
   typedef T value_type;
   typedef Ptr pointer;
   typedef Ref reference;
   typedef std::forward_iterator_tag iterator_category;
 
   __fwdl_iterator(T* it = 0) : item(it) {}
   __fwdl_iterator(const iterator &rhs): item(rhs.item) {}
-  __fwdl_iterator<T, Ptr, Ref> operator++() { item = item->next; return *this; }
+  __fwdl_iterator<T, Ptr, Ref>& operator++() { item = item->next; return *this; }
   __fwdl_iterator<T, Ptr, Ref> operator++(int) {
     auto tmp = *this;
     item = item->next;
     return tmp;
   }
   Ref operator*() const { return item->data; }
   Ptr operator->() const { return &item->data; }
 
template<
   class Alloc = std::allocator<Key>
 > class set {
   public:
     set(initializer_list<Key> __list) {}
 
     class iterator {
     public:
       iterator(Key *key): ptr(key) {}
-      iterator operator++() { ++ptr; return *this; }
+      iterator& operator++() { ++ptr; return *this; }
       bool operator!=(const iterator &other) const { return ptr != other.ptr; }
       const Key &operator*() const { return *ptr; }
     private:
       Key *ptr;
     };
 
   public:
     Key *val;
     iterator begin() const { return iterator(val); }
     iterator end() const { return iterator(val + 1); }
 };
 
 template<
   class Key,
   class Hash = std::hash<Key>,
   class Compare = std::less<Key>,
   class Alloc = std::allocator<Key>
 > class unordered_set {
   public:
     unordered_set(initializer_list<Key> __list) {}
 
     class iterator {
     public:
       iterator(Key *key): ptr(key) {}
-      iterator operator++() { ++ptr; return *this; }
+      iterator& operator++() { ++ptr; return *this; }
       bool operator!=(const iterator &other) const { return ptr != other.ptr; }
       const Key &operator*() const { return *ptr; }
     private:
       Key *ptr;
     };
 
   public:
     Key *val;