Merge 2019-07 LWG Motion 25

P1522R1 Iterator difference type and integer overflow

Fixes #3029.

Author: zygoloid

source/iterators.tex

@@ -476,7 +476,7 @@
 is valid where \tcode{o} is a value of type \tcode{T}.
 For every iterator type
 \tcode{X},
-there is a corresponding signed integer type called the
+there is a corresponding signed integer-like type\iref{iterator.concept.winc} called the
 \term{difference type}
 of the iterator.
 
@@ -1280,17 +1280,126 @@
 
 \indexlibrary{\idxcode{WeaklyIncrementable}}%
 \begin{codeblock}
+template<class T>
+  inline constexpr bool @\placeholder{is-integer-like}@ = @\seebelow@; @\itcorr[-2]@           // exposition only
+
+template<class T>
+  inline constexpr bool @\placeholder{is-signed-integer-like}@ = @\seebelow@; @\itcorr[-2]@    // exposition only
+
 template<class I>
   concept WeaklyIncrementable =
     DefaultConstructible<I> && Movable<I> &&
     requires(I i) {
       typename iter_difference_t<I>;
-      requires SignedIntegral<iter_difference_t<I>>;
-      { ++i } -> Same<I&>; // not required to be equality-preserving
-      i++; // not required to be equality-preserving
+      requires @\placeholdernc{is-signed-integer-like}@<iter_difference_t<I>>;
+      { ++i } -> Same<I&>;      // not required to be equality-preserving
+      i++;                      // not required to be equality-preserving
     };
 \end{codeblock}
 
+\pnum
+A type \tcode{I} is an \defnadj{integer-class}{type}
+if it is in a set of implementation-defined class types
+that behave as integer types do, as defined in below.
+
+\pnum
+The range of representable values of an integer-class type
+is the continuous set of values over which it is defined.
+The values 0 and 1 are part of the range of every integer-class type.
+If any negative numbers are part of the range,
+the type is a \defnadj{signed-integer-class}{type};
+otherwise, it is an \defnadj{unsigned-integer-class}{type}.
+
+\pnum
+For every integer-class type \tcode{I},
+let \tcode{B(I)} be a hypothetical extended integral type
+of the same signedness with the smallest width\iref{basic.fundamental}
+capable of representing the same range of values.
+The width of \tcode{I} is equal to the width of \tcode{B(I)}.
+
+\pnum
+Let \tcode{a} and \tcode{b} be objects of integer-class type \tcode{I},
+let \tcode{x} and \tcode{y} be objects of type \tcode{B(I)} as described above
+that represent the same values as \tcode{a} and \tcode{b} respectively, and
+let \tcode{c} be an lvalue of any integral type.
+\begin{itemize}
+\item
+  For every unary operator \tcode{@} for which the expression \tcode{@x}
+  is well-formed, \tcode{@a} shall also be well-formed
+  and have the same value, effects, and value category as \tcode{@x}
+  provided that value is representable by \tcode{I}.
+  If \tcode{@x} has type \tcode{bool}, so too does \tcode{@a};
+  if \tcode{@x} has type \tcode{B(I)}, then \tcode{@a} has type \tcode{I}.
+\item
+  For every assignment operator \tcode{@=}
+  for which \tcode{c @= x} is well-formed,
+  \tcode{c @= a} shall also be well-formed and
+  shall have the same value and effects as \tcode{c @= x}.
+  The expression \tcode{c @= a} shall be an lvalue referring to \tcode{c}.
+\item
+  For every binary operator \tcode{@} for which \tcode{x @ y} is well-formed,
+  \tcode{a @ b} shall also be well-formed and
+  shall have the same value, effects, and value category as \tcode{x @ y}
+  provided that value is representable by \tcode{I}.
+  If \tcode{x @ y} has type \tcode{bool}, so too does \tcode{a @ b};
+  if \tcode{x @ y} has type \tcode{B(I)}, then \tcode{a @ b} has type \tcode{I}.
+\end{itemize}
+
+\pnum
+All integer-class types are explicitly convertible to all integral types and
+implicitly and explicitly convertible from all integral types.
+
+\pnum
+All integer-class types are contextually convertible to \tcode{bool}
+as if by \tcode{bool(a != I(0))}, where \tcode{a} is an
+instance of the integral-class type \tcode{I}.
+
+\pnum
+All integer-class types model
+\libconcept{Regular}\iref{concepts.object} and
+\libconcept{StrictTotallyOrdered}\iref{concept.stricttotallyordered}.
+
+\pnum
+A value-initialized object of integer-class type has value 0.
+
+\pnum
+For every (possibly cv-qualified) integer-class type \tcode{I},
+\tcode{numeric_limits<I>} is specialized such that:
+\begin{itemize}
+\item
+  \tcode{numeric_limits<I>::is_specialized} is \tcode{true},
+\item
+  \tcode{numeric_limits<I>::is_signed} is \tcode{true}
+  if and only if \tcode{I} is a signed-integer-class type,
+\item
+  \tcode{numeric_limits<I>::is_integer} is \tcode{true},
+\item
+  \tcode{numeric_limits<I>::is_exact} is \tcode{true},
+\item
+  \tcode{numeric_limits<I>::digits} is equal to the width of the integer-class type,
+\item
+  \tcode{numeric_limits<I>::digits10} is equal to \tcode{static_cast<int>(digits * log10(2))}, and
+\item
+  \tcode{numeric_limits<I>::min()} and \tcode{numeric_limits<I>::max()} return
+  the lowest and highest representable values of \tcode{I}, respectively, and
+  \tcode{numeric_limits<I>::lowest()} returns \tcode{numeric_limits<I>::\brk{}min()}.
+\end{itemize}
+
+\pnum
+A type \tcode{I} is \defn{integer-like}
+if it models \tcode{Integral<I>} or if it is an integer-class type.
+A type \tcode{I} is \defn{signed-integer-like}
+if it models \tcode{SignedIntegral<I>} or if it is a signed-integer-class type.
+A type \tcode{I} is \defn{unsigned-integer-like}
+if it models \tcode{UnsignedIntegral<I>} or
+if it is an unsigned-integer-class type.
+
+\pnum
+\tcode{\placeholdernc{is-integer-like}<I>} is \tcode{true}
+if and only if \tcode{I} is an integer-like type.
+\tcode{\placeholdernc{is-signed-integer-like}<I>} is \tcode{true}
+if and only if I is a signed-integer-like type.
+
 \pnum
 Let \tcode{i} be an object of type \tcode{I}. When \tcode{i} is in the domain of
 both pre- and post-increment, \tcode{i} is said to be \term{incrementable}.
@@ -1773,6 +1882,8 @@
 \oldconcept{Destructible} requirements\iref{utility.arg.requirements} and lvalues
 of type \tcode{X} are swappable\iref{swappable.requirements}, and
 
+\item \tcode{iterator_traits<X>::difference_type} is a signed integer type or \tcode{void}, and
+
 \item the expressions in \tref{iterator} are valid and have
 the indicated semantics.
 \end{itemize}
@@ -2841,7 +2952,7 @@
 \effects
 If \tcode{R} models \libconcept{SizedRange}, equivalent to:
 \begin{codeblock}
-return ranges::size(r);                                         // \ref{range.prim.size}
+return static_cast<range_difference_t<R>>(ranges::size(r));     // \ref{range.prim.size}
 \end{codeblock}
 Otherwise, equivalent to:
 \begin{codeblock}