Fix integer overflow in --parameter-scan near i32::MAX

src/parameter/range_step.rs

@@ -35,6 +35,7 @@ pub struct RangeStep<T> {
     state: T,
     end: T,
     step: T,
+    finished: bool,
 }
 
 impl<T: Numeric> RangeStep<T> {
@@ -53,6 +54,7 @@ impl<T: Numeric> RangeStep<T> {
                 state: start,
                 end,
                 step,
+                finished: false,
             }),
             _ => Err(ParameterScanError::TooLarge),
         }
@@ -63,16 +65,25 @@ impl<T: Numeric> Iterator for RangeStep<T> {
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.state > self.end {
+        if self.finished || self.state > self.end {
             return None;
         }
         let return_val = self.state;
-        self.state += self.step;
+        // new() capped the range at MAX_PARAMETERS steps, so `end - state` stays
+        // small and cannot overflow here, unlike a speculative `state + step`.
+        if self.end - self.state < self.step {
+            self.finished = true;
+        } else {
+            self.state += self.step;
+        }
 
         Some(return_val)
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.finished {
+            return (0, Some(0));
+        }
         range_step_size_hint(self.state, self.end, self.step)
     }
 }
@@ -120,6 +131,22 @@ mod tests {
         assert_eq!(param_range[10], Decimal::from(1));
     }
 
+    #[test]
+    fn does_not_overflow_near_type_max() {
+        let param_range: Vec<i32> = RangeStep::new(i32::MAX - 1, i32::MAX, 1).unwrap().collect();
+        assert_eq!(param_range, vec![i32::MAX - 1, i32::MAX]);
+    }
+
+    #[test]
+    fn size_hint_is_zero_once_exhausted() {
+        let mut it = RangeStep::new(i32::MAX - 1, i32::MAX, 1).unwrap();
+        assert_eq!(it.size_hint(), (2, Some(2)));
+        assert_eq!(it.next(), Some(i32::MAX - 1));
+        assert_eq!(it.next(), Some(i32::MAX));
+        assert_eq!(it.next(), None);
+        assert_eq!(it.size_hint(), (0, Some(0)));
+    }
+
     #[test]
     fn test_range_step_validate() {
         let result = RangeStep::new(0, 10, 3);