Use consistent style for elided lifetimes in functions

Author: shepmaster

compiler/rustc_data_structures/src/sso/map.rs

@@ -132,13 +132,13 @@ impl<K, V> SsoHashMap<K, V> {
     /// with mutable references to the values.
     /// The iterator element type is `(&'a K, &'a mut V)`.
     #[inline]
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&'_ K, &'_ mut V)> {
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)> {
         self.into_iter()
     }
 
     /// An iterator visiting all keys in arbitrary order.
     /// The iterator element type is `&'a K`.
-    pub fn keys(&self) -> impl Iterator<Item = &'_ K> {
+    pub fn keys(&self) -> impl Iterator<Item = &K> {
         match self {
             SsoHashMap::Array(array) => Either::Left(array.iter().map(|(k, _v)| k)),
             SsoHashMap::Map(map) => Either::Right(map.keys()),
@@ -147,7 +147,7 @@ impl<K, V> SsoHashMap<K, V> {
 
     /// An iterator visiting all values in arbitrary order.
     /// The iterator element type is `&'a V`.
-    pub fn values(&self) -> impl Iterator<Item = &'_ V> {
+    pub fn values(&self) -> impl Iterator<Item = &V> {
         match self {
             SsoHashMap::Array(array) => Either::Left(array.iter().map(|(_k, v)| v)),
             SsoHashMap::Map(map) => Either::Right(map.values()),
@@ -156,7 +156,7 @@ impl<K, V> SsoHashMap<K, V> {
 
     /// An iterator visiting all values mutably in arbitrary order.
     /// The iterator element type is `&'a mut V`.
-    pub fn values_mut(&mut self) -> impl Iterator<Item = &'_ mut V> {
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
         match self {
             SsoHashMap::Array(array) => Either::Left(array.iter_mut().map(|(_k, v)| v)),
             SsoHashMap::Map(map) => Either::Right(map.values_mut()),

compiler/rustc_infer/src/infer/snapshot/undo_log.rs

@@ -164,7 +164,7 @@ impl<'tcx> InferCtxtUndoLogs<'tcx> {
     pub(crate) fn region_constraints_in_snapshot(
         &self,
         s: &Snapshot<'tcx>,
-    ) -> impl Iterator<Item = &'_ region_constraints::UndoLog<'tcx>> + Clone {
+    ) -> impl Iterator<Item = &region_constraints::UndoLog<'tcx>> + Clone {
         self.logs[s.undo_len..].iter().filter_map(|log| match log {
             UndoLog::RegionConstraintCollector(log) => Some(log),
             _ => None,

compiler/rustc_middle/src/ty/list.rs

@@ -121,7 +121,7 @@ impl<H, T> RawList<H, T> {
     //
     // This would be weird, as `self.into_iter` iterates over `T` directly.
     #[inline(always)]
-    pub fn iter(&self) -> <&'_ RawList<H, T> as IntoIterator>::IntoIter
+    pub fn iter(&self) -> <&RawList<H, T> as IntoIterator>::IntoIter
     where
         T: Copy,
     {

library/core/src/str/mod.rs

@@ -1914,7 +1914,7 @@ impl str {
     /// ```
     #[stable(feature = "str_split_once", since = "1.52.0")]
     #[inline]
-    pub fn split_once<P: Pattern>(&self, delimiter: P) -> Option<(&'_ str, &'_ str)> {
+    pub fn split_once<P: Pattern>(&self, delimiter: P) -> Option<(&str, &str)> {
         let (start, end) = delimiter.into_searcher(self).next_match()?;
         // SAFETY: `Searcher` is known to return valid indices.
         unsafe { Some((self.get_unchecked(..start), self.get_unchecked(end..))) }
@@ -1932,7 +1932,7 @@ impl str {
     /// ```
     #[stable(feature = "str_split_once", since = "1.52.0")]
     #[inline]
-    pub fn rsplit_once<P: Pattern>(&self, delimiter: P) -> Option<(&'_ str, &'_ str)>
+    pub fn rsplit_once<P: Pattern>(&self, delimiter: P) -> Option<(&str, &str)>
     where
         for<'a> P::Searcher<'a>: ReverseSearcher<'a>,
     {

library/std/src/collections/hash/map.rs

@@ -1039,7 +1039,7 @@ where
     pub fn get_disjoint_mut<Q: ?Sized, const N: usize>(
         &mut self,
         ks: [&Q; N],
-    ) -> [Option<&'_ mut V>; N]
+    ) -> [Option<&mut V>; N]
     where
         K: Borrow<Q>,
         Q: Hash + Eq,
@@ -1106,7 +1106,7 @@ where
     pub unsafe fn get_disjoint_unchecked_mut<Q: ?Sized, const N: usize>(
         &mut self,
         ks: [&Q; N],
-    ) -> [Option<&'_ mut V>; N]
+    ) -> [Option<&mut V>; N]
     where
         K: Borrow<Q>,
         Q: Hash + Eq,