Support integer ranges that use all values of the type

Closes #1180

These now work correctly:

// Prints 0 to 255 inclusive
MIN: u8 = 0;
MAX: u8 = 255;
for MIN..=MAX do (i) {
    std::cout << i as u32 << " ";
}

// Not an endless loop
for 0 ..= std::numeric_limits<i32>::max() do (i) { /*...*/ }

Author: hsutter

include/cpp2util.h

@@ -2263,115 +2263,162 @@ inline auto make_args(int argc, char** argv) -> args
 //
 //  range: a range of [begin, end) or [first, last]
 //
+//  TT is the type we actually store for 'first' and 'last'.
+// 
+//  If T is integral, store a widened representation to ensure that
+//  the past-the-end value is representable even if [first,last] are
+//  numeric_limits<T> [min,max].
+// 
+//  This lets us represent all ranges as half-open ranges using just
+//  'first' and (possibly-adjusted-by-one) 'last' without any extra
+//  data or a Closed parameter etc. = single simpler implementation.
+//
 //-----------------------------------------------------------------------
 //
 template<typename T>
-struct range
+class range
 {
+    using TT = std::conditional_t<
+        std::is_integral_v<T>, 
+        std::conditional_t<
+            std::is_signed_v<T>, 
+            std::ptrdiff_t, 
+            std::size_t
+        >, 
+        T
+    >;
+
+    TT first;
+    TT last;
+
+public:
     using difference_type = std::ptrdiff_t;
-    using value_type = T;
-    using pointer = T*;
-    using reference = T&;
+    using value_type      = T;
+    using pointer         = T*;
+    using reference       = T&;
 
     range(
-        T const& f,
-        T const& l,
-        bool     include_last = false
+        T const&                       f,
+        std::type_identity_t<T> const& l,
+        bool                           include_last = false
     )
+        //  For smaller-than-size_t/ptrdiff_t numeric types, these will widen
         : first{ f }
         , last{ l }
     {
+        //  Represent all ranges as half-open; after this we can forget the flag
         if (include_last) {
             ++last;
         }
     }
 
-    //  If T is numeric, use explicit narrowing to avoid compiler warnings
-    static auto inc_by(T& t, difference_type i) -> T&
-    {
-        if constexpr (std::integral<T>) {
-            return t += unsafe_narrow<T>(i);
-        }
-        else {
-            return t += i;
-        }
-    }
-
     class iterator 
     {
+        TT first = T{};
+        TT last  = T{};
+        TT curr  = T{};
+
+        // Helper type trait to check for the existence of iterator_category
+        template <typename I, typename = void>
+        struct range_iterator_category {
+            using tag = std::random_access_iterator_tag;
+        };
+        template <typename I>
+        struct range_iterator_category<I, std::void_t<typename std::iterator_traits<I>::iterator_category>> {
+            using tag = typename std::iterator_traits<I>::iterator_category;
+        };
+
     public:
         using difference_type   = std::ptrdiff_t;
         using value_type        = T;
         using pointer           = T*;
         using reference         = T&;
-        using iterator_category = std::random_access_iterator_tag;
+        using iterator_category = typename range_iterator_category<T>::tag;
 
         iterator() { }
 
-        iterator(T const& f, T const& l, T start) : first{ f }, last{ l }, curr{ start } {}
+        iterator(TT const& f, TT const& l, TT start) : first{ f }, last{ l }, curr{ start } {}
 
         auto operator<=>(iterator const&) const = default;
 
-        auto operator*() const -> T {
-            if (curr != last) { return curr; }
-            else              { return T{}; }
+        //  In this section, we don't use relational comparisons so that
+        //  this works when T is a less-powerful-than-random-access iterator
+        //
+        auto operator*() const -> T
+        {
+            if (curr != last) { 
+                if constexpr (std::is_same_v<T, TT>) { 
+                    return curr;
+                }
+                else {
+                    return unsafe_narrow<T>(curr);
+                }
+            }
+            else { 
+                return T{};
+            }
         }
 
-        auto operator++()                  -> iterator& { if (curr != last ) { ++curr; }  return *this; }
-        auto operator--()                  -> iterator& { if (curr != first) { --curr; }  return *this; }
-        auto operator++(int)               -> iterator  { auto old = *this;  ++*this;  return old; }
-        auto operator--(int)               -> iterator  { auto old = *this;  ++*this;  return old; }
+        auto operator++()    -> iterator& { if (curr != last ) { ++curr; }  return *this; }
+        auto operator--()    -> iterator& { if (curr != first) { --curr; }  return *this; }
+        auto operator++(int) -> iterator  { auto old = *this;  ++*this;  return old; }
+        auto operator--(int) -> iterator  { auto old = *this;  ++*this;  return old; }
 
-        //  And now all the random-access operations (valid if T is random-access)
+        //  And now all the random-access operations which can use relational
+        //  comparisons (these functions are valid if T is random-access)
         //
         auto operator[](difference_type i) const -> T {
-            if (curr + i != last) { return curr + i; }
-            else                  { return T{}; }
+            if (curr + i != last) { 
+                if constexpr (std::is_same_v<T, TT>) { 
+                    return curr + i;
+                }
+                else {
+                    return unsafe_narrow<T>(curr + i);
+                }
+            }
+            else {
+                return T{};
+            }
         }
 
-        auto operator+=(difference_type i) -> iterator& { if (curr + i <= last ) { inc_by(curr,  i); } else { curr = last; }  return *this; }
-        auto operator-=(difference_type i) -> iterator& { if (curr - i >= first) { inc_by(curr, -i); } else { curr = first; }  return *this; }
+        auto operator+=(difference_type i) -> iterator& 
+            { if (curr + i <= last ) { curr += i; } else { curr = last;  }  return *this; }
+        auto operator-=(difference_type i) -> iterator& 
+            { if (curr - i >= first) { curr -= i; } else { curr = first; }  return *this; }
 
         friend 
-        auto operator+ (difference_type i, iterator const& this_) -> iterator { auto ret = *this_;  return ret += i; }
+        auto operator+ (difference_type i, iterator const& iter) -> iterator 
+            { auto ret = *iter;  return ret += i; }
 
         auto operator+ (difference_type i   ) const -> iterator        { auto ret = *this;  return ret += i; }
         auto operator- (difference_type i   ) const -> iterator        { auto ret = *this;  return ret -= i; }
         auto operator- (iterator        that) const -> difference_type { return that.curr - curr; }
-
-        //auto operator+(difference_type i) -> iterator {
-        //    if (i > 0) { return { first, last, std::min(curr + i, last) }; }
-        //    else       { return { first, last, std::max(curr + i, 0) }; }
-        //}
-        //auto operator- (difference_type i) -> iterator  { return operator+(-i); }
-
-    private:
-        T first = T{};
-        T last = T{};
-        T curr = T{};
     };
 
-    auto begin()  const -> iterator    { return iterator{ first, last, first }; }
-    auto end()    const -> iterator    { return iterator{ first, last, last }; }
-    auto cbegin() const -> iterator    { return begin(); }
-    auto cend()   const -> iterator    { return end(); }
-    auto size()   const -> std::size_t { return unsafe_narrow<std::size_t>(ssize()); }
-    auto ssize()  const -> int         { return last - first; }
+    auto begin()  const -> iterator       { return iterator{ first, last, first }; }
+    auto end()    const -> iterator       { return iterator{ first, last, last }; }
+    auto cbegin() const -> iterator       { return begin(); }
+    auto cend()   const -> iterator       { return end(); }
+    auto size()   const -> std::size_t    { return unsafe_narrow<std::size_t>(ssize()); }
+    auto ssize()  const -> std::ptrdiff_t { return last - first; }
 
-    auto operator[](difference_type i) const {
-        if (0 <= i && i < ssize()) { return first + i; }
-        else                       { return T{}; }
+    auto operator[](difference_type i) const -> T
+    {
+        if (0 <= i && i < ssize()) { 
+            if constexpr (std::is_same_v<T, TT>) { 
+                return first + i;
+            }
+            else {
+                return unsafe_narrow<T>(first + i);
+            }
+        }
+        else { 
+            return T{}; 
+        }
     }
-
-    T first;
-    T last;
 };
 
 
-template<typename T, typename U>
-range(T, U, bool = false) -> range<std::common_type_t<T, U>>;
-
-
 //-----------------------------------------------------------------------
 //
 //  alien_memory: memory typed as T but that is outside C++ and that the

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.7.1   Build 9724:1613
+cppfront compiler v0.7.1   Build 9724:2021
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"9724:1613"
+"9724:2021"