Fix PadUsing::next_back (2) PadUsing counts elements_from_next and elements_from_next_back

Remove fold/rfold: Correctness is more important than performance.
Maybe we can come back and re-implement them later.

Fixes: #1065

Author: Takashiidobe

src/pad_tail.rs

@@ -1,4 +1,3 @@
-use crate::size_hint;
 use std::iter::{Fuse, FusedIterator};
 
 /// An iterator adaptor that pads a sequence to a minimum length by filling
@@ -11,28 +10,36 @@ use std::iter::{Fuse, FusedIterator};
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct PadUsing<I, F> {
     iter: Fuse<I>,
-    min: usize,
-    pos: usize,
+    elements_from_next: usize,
+    elements_from_next_back: usize,
+    elements_required: usize,
     filler: F,
 }
 
 impl<I, F> std::fmt::Debug for PadUsing<I, F>
 where
     I: std::fmt::Debug,
 {
-    debug_fmt_fields!(PadUsing, iter, min, pos);
+    debug_fmt_fields!(
+        PadUsing,
+        iter,
+        elements_from_next,
+        elements_from_next_back,
+        elements_required
+    );
 }
 
 /// Create a new `PadUsing` iterator.
-pub fn pad_using<I, F>(iter: I, min: usize, filler: F) -> PadUsing<I, F>
+pub fn pad_using<I, F>(iter: I, elements_required: usize, filler: F) -> PadUsing<I, F>
 where
     I: Iterator,
     F: FnMut(usize) -> I::Item,
 {
     PadUsing {
         iter: iter.fuse(),
-        min,
-        pos: 0,
+        elements_from_next: 0,
+        elements_from_next_back: 0,
+        elements_required,
         filler,
     }
 }
@@ -46,38 +53,34 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match self.iter.next() {
-            None => {
-                if self.pos < self.min {
-                    let e = Some((self.filler)(self.pos));
-                    self.pos += 1;
-                    e
-                } else {
-                    None
-                }
-            }
-            e => {
-                self.pos += 1;
-                e
-            }
+        let total_consumed = self.elements_from_next + self.elements_from_next_back;
+
+        if total_consumed >= self.elements_required {
+            self.iter.next()
+        } else if let Some(e) = self.iter.next() {
+            self.elements_from_next += 1;
+            Some(e)
+        } else {
+            let e = (self.filler)(self.elements_from_next);
+            self.elements_from_next += 1;
+            Some(e)
         }
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let tail = self.min.saturating_sub(self.pos);
-        size_hint::max(self.iter.size_hint(), (tail, Some(tail)))
-    }
+        let total_consumed = self.elements_from_next + self.elements_from_next_back;
+
+        if total_consumed >= self.elements_required {
+            return self.iter.size_hint();
+        }
+
+        let elements_remaining = self.elements_required - total_consumed;
+        let (low, high) = self.iter.size_hint();
+
+        let lower_bound = low.max(elements_remaining);
+        let upper_bound = high.map(|h| h.max(elements_remaining));
 
-    fn fold<B, G>(self, mut init: B, mut f: G) -> B
-    where
-        G: FnMut(B, Self::Item) -> B,
-    {
-        let mut pos = self.pos;
-        init = self.iter.fold(init, |acc, item| {
-            pos += 1;
-            f(acc, item)
-        });
-        (pos..self.min).map(self.filler).fold(init, f)
+        (lower_bound, upper_bound)
     }
 }
 
@@ -87,25 +90,24 @@ where
     F: FnMut(usize) -> I::Item,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
-        if self.min == 0 {
-            self.iter.next_back()
-        } else if self.iter.len() >= self.min {
-            self.min -= 1;
-            self.iter.next_back()
-        } else {
-            self.min -= 1;
-            Some((self.filler)(self.min))
+        let total_consumed = self.elements_from_next + self.elements_from_next_back;
+
+        if total_consumed >= self.elements_required {
+            return self.iter.next_back();
         }
-    }
 
-    fn rfold<B, G>(self, mut init: B, mut f: G) -> B
-    where
-        G: FnMut(B, Self::Item) -> B,
-    {
-        init = (self.iter.len()..self.min)
-            .map(self.filler)
-            .rfold(init, &mut f);
-        self.iter.rfold(init, f)
+        let elements_remaining = self.elements_required - total_consumed;
+        self.elements_from_next_back += 1;
+
+        if self.iter.len() < elements_remaining {
+            Some((self.filler)(
+                self.elements_required - self.elements_from_next_back,
+            ))
+        } else {
+            let item = self.iter.next_back();
+            debug_assert!(item.is_some()); // If this triggers, we should not have incremented elements_from_next_back, and the input iterator mistakenly reported that it would be able to produce at least elements_remaining items.
+            item
+        }
     }
 }