remove explicit lifetime bounds that can be inferred

Author: Lukas Markeffsky

library/alloc/src/borrow.rs

@@ -176,7 +176,7 @@ where
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "Cow")]
-pub enum Cow<'a, B: ?Sized + 'a>
+pub enum Cow<'a, B: ?Sized>
 where
     B: ToOwned,
 {

library/alloc/src/collections/binary_heap.rs

@@ -277,7 +277,7 @@ pub struct BinaryHeap<T> {
 ///
 /// [`peek_mut`]: BinaryHeap::peek_mut
 #[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
-pub struct PeekMut<'a, T: 'a + Ord> {
+pub struct PeekMut<'a, T: Ord> {
     heap: &'a mut BinaryHeap<T>,
     sift: bool,
 }
@@ -1226,7 +1226,7 @@ impl<T> BinaryHeap<T> {
 /// (because it was moved from or duplicated).
 /// In drop, `Hole` will restore the slice by filling the hole
 /// position with the value that was originally removed.
-struct Hole<'a, T: 'a> {
+struct Hole<'a, T> {
     data: &'a mut [T],
     elt: ManuallyDrop<T>,
     pos: usize,
@@ -1301,7 +1301,7 @@ impl<T> Drop for Hole<'_, T> {
 /// [`iter`]: BinaryHeap::iter
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
+pub struct Iter<'a, T> {
     iter: slice::Iter<'a, T>,
 }
 
@@ -1476,7 +1476,7 @@ unsafe impl<T: Ord> TrustedLen for IntoIterSorted<T> {}
 /// [`drain`]: BinaryHeap::drain
 #[stable(feature = "drain", since = "1.6.0")]
 #[derive(Debug)]
-pub struct Drain<'a, T: 'a> {
+pub struct Drain<'a, T> {
     iter: vec::Drain<'a, T>,
 }
 

library/alloc/src/collections/btree/map.rs

@@ -369,7 +369,7 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
 ///
 /// [`iter_mut`]: BTreeMap::iter_mut
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IterMut<'a, K: 'a, V: 'a> {
+pub struct IterMut<'a, K, V> {
     range: LazyLeafRange<marker::ValMut<'a>, K, V>,
     length: usize,
 
@@ -547,7 +547,7 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Range<'_, K, V> {
 /// [`range_mut`]: BTreeMap::range_mut
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "btree_range", since = "1.17.0")]
-pub struct RangeMut<'a, K: 'a, V: 'a> {
+pub struct RangeMut<'a, K, V> {
     inner: LeafRange<marker::ValMut<'a>, K, V>,
 
     // Be invariant in `K` and `V`

library/alloc/src/collections/btree/map/entry.rs

@@ -19,8 +19,8 @@ use Entry::*;
 #[cfg_attr(not(test), rustc_diagnostic_item = "BTreeEntry")]
 pub enum Entry<
     'a,
-    K: 'a,
-    V: 'a,
+    K,
+    V,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
 > {
     /// A vacant entry.
@@ -100,7 +100,7 @@ impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_,
 ///
 /// Contains the occupied entry, and the value that was not inserted.
 #[unstable(feature = "map_try_insert", issue = "82766")]
-pub struct OccupiedError<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
+pub struct OccupiedError<'a, K, V, A: Allocator + Clone = Global> {
     /// The entry in the map that was already occupied.
     pub entry: OccupiedEntry<'a, K, V, A>,
     /// The value which was not inserted, because the entry was already occupied.

library/alloc/src/collections/btree/set.rs

@@ -135,7 +135,7 @@ impl<T: Clone, A: Allocator + Clone> Clone for BTreeSet<T, A> {
 /// [`iter`]: BTreeSet::iter
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
+pub struct Iter<'a, T> {
     iter: Keys<'a, T, SetValZST>,
 }
 
@@ -171,7 +171,7 @@ pub struct IntoIter<
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[derive(Debug)]
 #[stable(feature = "btree_range", since = "1.17.0")]
-pub struct Range<'a, T: 'a> {
+pub struct Range<'a, T> {
     iter: super::map::Range<'a, T, SetValZST>,
 }
 
@@ -186,12 +186,12 @@ pub struct Range<'a, T: 'a> {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Difference<
     'a,
-    T: 'a,
+    T,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
 > {
     inner: DifferenceInner<'a, T, A>,
 }
-enum DifferenceInner<'a, T: 'a, A: Allocator + Clone> {
+enum DifferenceInner<'a, T, A: Allocator + Clone> {
     Stitch {
         // iterate all of `self` and some of `other`, spotting matches along the way
         self_iter: Iter<'a, T>,
@@ -240,7 +240,7 @@ impl<T: fmt::Debug, A: Allocator + Clone> fmt::Debug for Difference<'_, T, A> {
 #[must_use = "this returns the difference as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct SymmetricDifference<'a, T: 'a>(MergeIterInner<Iter<'a, T>>);
+pub struct SymmetricDifference<'a, T>(MergeIterInner<Iter<'a, T>>);
 
 #[stable(feature = "collection_debug", since = "1.17.0")]
 impl<T: fmt::Debug> fmt::Debug for SymmetricDifference<'_, T> {
@@ -260,12 +260,12 @@ impl<T: fmt::Debug> fmt::Debug for SymmetricDifference<'_, T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Intersection<
     'a,
-    T: 'a,
+    T,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
 > {
     inner: IntersectionInner<'a, T, A>,
 }
-enum IntersectionInner<'a, T: 'a, A: Allocator + Clone> {
+enum IntersectionInner<'a, T, A: Allocator + Clone> {
     Stitch {
         // iterate similarly sized sets jointly, spotting matches along the way
         a: Iter<'a, T>,
@@ -312,7 +312,7 @@ impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A> {
 #[must_use = "this returns the union as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Union<'a, T: 'a>(MergeIterInner<Iter<'a, T>>);
+pub struct Union<'a, T>(MergeIterInner<Iter<'a, T>>);
 
 #[stable(feature = "collection_debug", since = "1.17.0")]
 impl<T: fmt::Debug> fmt::Debug for Union<'_, T> {
@@ -1290,7 +1290,6 @@ pub struct DrainFilter<
     F,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
 > where
-    T: 'a,
     F: 'a + FnMut(&T) -> bool,
 {
     pred: F,

library/alloc/src/collections/linked_list.rs

@@ -66,7 +66,7 @@ struct Node<T> {
 /// documentation for more.
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
+pub struct Iter<'a, T> {
     head: Option<NonNull<Node<T>>>,
     tail: Option<NonNull<Node<T>>>,
     len: usize,
@@ -102,7 +102,7 @@ impl<T> Clone for Iter<'_, T> {
 /// documentation for more.
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IterMut<'a, T: 'a> {
+pub struct IterMut<'a, T> {
     head: Option<NonNull<Node<T>>>,
     tail: Option<NonNull<Node<T>>>,
     len: usize,
@@ -1139,7 +1139,7 @@ impl<T> FusedIterator for IterMut<'_, T> {}
 ///
 /// When created, cursors start at the front of the list, or the "ghost" non-element if the list is empty.
 #[unstable(feature = "linked_list_cursors", issue = "58533")]
-pub struct Cursor<'a, T: 'a> {
+pub struct Cursor<'a, T> {
     index: usize,
     current: Option<NonNull<Node<T>>>,
     list: &'a LinkedList<T>,
@@ -1171,7 +1171,7 @@ impl<T: fmt::Debug> fmt::Debug for Cursor<'_, T> {
 /// To accommodate this, there is a "ghost" non-element that yields `None` between the head and
 /// tail of the list.
 #[unstable(feature = "linked_list_cursors", issue = "58533")]
-pub struct CursorMut<'a, T: 'a> {
+pub struct CursorMut<'a, T> {
     index: usize,
     current: Option<NonNull<Node<T>>>,
     list: &'a mut LinkedList<T>,
@@ -1702,7 +1702,7 @@ impl<'a, T> CursorMut<'a, T> {
 
 /// An iterator produced by calling `drain_filter` on LinkedList.
 #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-pub struct DrainFilter<'a, T: 'a, F: 'a>
+pub struct DrainFilter<'a, T, F: 'a>
 where
     F: FnMut(&mut T) -> bool,
 {

library/alloc/src/collections/vec_deque/drain.rs

@@ -17,7 +17,7 @@ use super::{count, wrap_index, VecDeque};
 #[stable(feature = "drain", since = "1.6.0")]
 pub struct Drain<
     'a,
-    T: 'a,
+    T,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
 > {
     after_tail: usize,

library/alloc/src/collections/vec_deque/iter.rs

@@ -12,7 +12,7 @@ use super::{count, wrap_index, RingSlices};
 ///
 /// [`iter`]: super::VecDeque::iter
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
+pub struct Iter<'a, T> {
     ring: &'a [MaybeUninit<T>],
     tail: usize,
     head: usize,

library/alloc/src/collections/vec_deque/iter_mut.rs

@@ -11,7 +11,7 @@ use super::{count, wrap_index, RingSlices};
 ///
 /// [`iter_mut`]: super::VecDeque::iter_mut
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IterMut<'a, T: 'a> {
+pub struct IterMut<'a, T> {
     // Internal safety invariant: the entire slice is dereferenceable.
     ring: *mut [T],
     tail: usize,

library/alloc/src/vec/drain.rs

@@ -21,7 +21,7 @@ use super::Vec;
 #[stable(feature = "drain", since = "1.6.0")]
 pub struct Drain<
     'a,
-    T: 'a,
+    T,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global,
 > {
     /// Index of tail to preserve