Implement some trivial size_hints for various iterators

This also implements ExactSizeIterator where applicable. Addresses most of the Iterator traits mentioned in #23708.

Author: Phlosioneer

src/libcore/char.rs

@@ -902,6 +902,11 @@ impl<I: Iterator<Item = u8>> Iterator for DecodeUtf8<I> {
  }
  })
  }
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.0.size_hint()
+ }
 }
 
 #[unstable(feature = "decode_utf8", issue = "33906")]

src/libcore/iter/traits.rs

@@ -901,6 +901,10 @@ impl<I, T, E> Iterator for ResultShunt<I, E>
  None => None,
  }
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
 }
 
 #[stable(feature = "iter_arith_traits_result", since="1.16.0")]

src/libcore/option.rs

@@ -1188,6 +1188,11 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
  None => None,
  }
  }
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
  }
 
  let mut adapter = Adapter { iter: iter.into_iter(), found_none: false };

src/librustc/hir/pat_util.rs

@@ -31,6 +31,10 @@ impl<I> Iterator for EnumerateAndAdjust<I> where I: Iterator {
  (if i < self.gap_pos { i } else { i + self.gap_len }, elem)
  })
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.enumerate.size_hint()
+ }
 }
 
 pub trait EnumerateAndAdjustIterator {

src/librustc/mir/traversal.rs

@@ -77,8 +77,18 @@ impl<'a, 'tcx> Iterator for Preorder<'a, 'tcx> {
 
  None
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ // All the blocks, minus the number of blocks we've visited.
+ let remaining = self.mir.basic_blocks().len() - self.visited.count();
+
+ // We will visit all remaining blocks exactly once.
+ (remaining, Some(remaining))
+ }
 }
 
+impl<'a, 'tcx> ExactSizeIterator for Preorder<'a, 'tcx> {}
+
 /// Postorder traversal of a graph.
 ///
 /// Postorder traversal is when each node is visited after all of it's
@@ -210,8 +220,18 @@ impl<'a, 'tcx> Iterator for Postorder<'a, 'tcx> {
 
  next.map(|(bb, _)| (bb, &self.mir[bb]))
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ // All the blocks, minus the number of blocks we've visited.
+ let remaining = self.mir.basic_blocks().len() - self.visited.count();
+
+ // We will visit all remaining blocks exactly once.
+ (remaining, Some(remaining))
+ }
 }
 
+impl<'a, 'tcx> ExactSizeIterator for Postorder<'a, 'tcx> {}
+
 /// Reverse postorder traversal of a graph
 ///
 /// Reverse postorder is the reverse order of a postorder traversal.
@@ -276,4 +296,10 @@ impl<'a, 'tcx> Iterator for ReversePostorder<'a, 'tcx> {
 
  self.blocks.get(self.idx).map(|&bb| (bb, &self.mir[bb]))
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.idx, Some(self.idx))
+ }
 }
+
+impl<'a, 'tcx> ExactSizeIterator for ReversePostorder<'a, 'tcx> {}

src/librustc/session/search_paths.rs

@@ -78,4 +78,11 @@ impl<'a> Iterator for Iter<'a> {
  }
  }
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ // This iterator will never return more elements than the base iterator;
+ // but it can ignore all the remaining elements.
+ let (_, upper) = self.iter.size_hint();
+ (0, upper)
+ }
 }

src/librustc/traits/util.rs

@@ -347,6 +347,11 @@ impl<'tcx,I:Iterator<Item=ty::Predicate<'tcx>>> Iterator for FilterToTraits<I> {
  }
  }
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let (_, upper) = self.base_iterator.size_hint();
+ (0, upper)
+ }
 }
 
 ///////////////////////////////////////////////////////////////////////////

src/librustc_data_structures/bitvec.rs

@@ -132,6 +132,11 @@ impl<'a> Iterator for BitVectorIter<'a> {
  self.idx += offset + 1;
  return Some(self.idx - 1);
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let (_, upper) = self.iter.size_hint();
+ (0, upper)
+ }
 }
 
 impl FromIterator<bool> for BitVector {

src/librustc_data_structures/graph/mod.rs

@@ -334,6 +334,11 @@ impl<'g, N: Debug, E: Debug> Iterator for AdjacentEdges<'g, N, E> {
  self.next = edge.next_edge[self.direction.repr];
  Some((edge_index, edge))
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ // At most, all the edges in the graph.
+ (0, Some(self.graph.len_edges()))
+ }
 }
 
 pub struct DepthFirstTraversal<'g, N, E>
@@ -383,8 +388,16 @@ impl<'g, N: Debug, E: Debug> Iterator for DepthFirstTraversal<'g, N, E> {
  }
  next
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ // We will visit every node in the graph exactly once.
+ let remaining = self.graph.len_nodes() - self.visited.count();
+ (remaining, Some(remaining))
+ }
 }
 
+impl<'g, N: Debug, E: Debug> ExactSizeIterator for DepthFirstTraversal<'g, N, E> {}
+
 impl<E> Edge<E> {
  pub fn source(&self) -> NodeIndex {
  self.source

src/librustc_driver/pretty.rs

@@ -584,6 +584,13 @@ impl<'a, 'hir> Iterator for NodesMatchingUII<'a, 'hir> {
  &mut NodesMatchingSuffix(ref mut iter) => iter.next(),
  }
  }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ match self {
+ &NodesMatchingDirect(ref iter) => iter.size_hint(),
+ &NodesMatchingSuffix(ref iter) => iter.size_hint(),
+ }
+ }
 }
 
 impl UserIdentifiedItem {