Revert "fix(elidable_lifetime_names): avoid overlapping spans in suggestions"

This reverts commit 25881bf.

Author: ada4a

clippy_lints/src/lifetimes.rs

@@ -856,89 +856,36 @@ fn elision_suggestions(
         .filter(|param| !param.is_elided_lifetime() && !param.is_impl_trait())
         .collect::<Vec<_>>();
 
-    if !elidable_lts
-        .iter()
-        .all(|lt| explicit_params.iter().any(|param| param.def_id == *lt))
-    {
-        return None;
-    }
-
-    let mut suggestions = if elidable_lts.is_empty() {
-        vec![]
-    } else if elidable_lts.len() == explicit_params.len() {
+    let mut suggestions = if elidable_lts.len() == explicit_params.len() {
         // if all the params are elided remove the whole generic block
         //
         // fn x<'a>() {}
         //     ^^^^
         vec![(generics.span, String::new())]
     } else {
-        match &explicit_params[..] {
-            // no params, nothing to elide
-            [] => unreachable!("handled by `elidable_lts.is_empty()`"),
-            [param] => {
-                if elidable_lts.contains(&param.def_id) {
-                    unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
+        elidable_lts
+            .iter()
+            .map(|&id| {
+                let pos = explicit_params.iter().position(|param| param.def_id == id)?;
+                let param = explicit_params.get(pos)?;
+
+                let span = if let Some(next) = explicit_params.get(pos + 1) {
+                    // fn x<'prev, 'a, 'next>() {}
+                    //             ^^^^
+                    param.span.until(next.span)
                 } else {
-                    unreachable!("handled by `elidable_lts.is_empty()`")
-                }
-            },
-            [_, _, ..] => {
-                // Given a list like `<'a, 'b, 'c, 'd, ..>`,
-                //
-                // If there is a cluster of elidable lifetimes at the beginning, say `'a` and `'b`, we should
-                // suggest removing them _and_ the trailing comma. The span for that is `a.span.until(c.span)`:
-                // <'a, 'b, 'c, 'd, ..> => <'a, 'b, 'c, 'd, ..>
-                //  ^^  ^^                  ^^^^^^^^
-                //
-                // And since we know that `'c` isn't elidable--otherwise it would've been in the cluster--we can go
-                // over all the lifetimes after it, and for each elidable one, add a suggestion spanning the
-                // lifetime itself and the comma before, because each individual suggestion is guaranteed to leave
-                // the list valid:
-                // <.., 'c, 'd, 'e, 'f, 'g, ..> => <.., 'c, 'd, 'e, 'f, 'g, ..>
-                //          ^^      ^^  ^^                ^^^^    ^^^^^^^^
-                //
-                // In case there is no such starting cluster, we only need to do the second part of the algorithm:
-                // <'a, 'b, 'c, 'd, 'e, 'f, 'g, ..> => <'a, 'b , 'c, 'd, 'e, 'f, 'g, ..>
-                //      ^^  ^^      ^^  ^^                ^^^^^^^^^    ^^^^^^^^
-
-                // Split off the starting cluster
-                // TODO: use `slice::split_once` once stabilized (github.com/rust-lang/rust/issues/112811):
-                // ```
-                // let Some(split) = explicit_params.split_once(|param| !elidable_lts.contains(&param.def_id)) else {
-                //     // there were no lifetime param that couldn't be elided
-                //     unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
-                // };
-                // match split { /* .. */ }
-                // ```
-                let Some(split_pos) = explicit_params
-                    .iter()
-                    .position(|param| !elidable_lts.contains(&param.def_id))
-                else {
-                    // there were no lifetime param that couldn't be elided
-                    unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
+                    // `pos` should be at least 1 here, because the param in position 0 would either have a `next`
+                    // param or would have taken the `elidable_lts.len() == explicit_params.len()` branch.
+                    let prev = explicit_params.get(pos - 1)?;
+
+                    // fn x<'prev, 'a>() {}
+                    //           ^^^^
+                    param.span.with_lo(prev.span.hi())
                 };
-                let split = explicit_params
-                    .split_at_checked(split_pos)
-                    .expect("got `split_pos` from `position` on the same Vec");
-
-                match split {
-                    ([..], []) => unreachable!("handled by `elidable_lts.len() == explicit_params.len()`"),
-                    ([], [_]) => unreachable!("handled by `explicit_params.len() == 1`"),
-                    (cluster, rest @ [rest_first, ..]) => {
-                        // the span for the cluster
-                        (cluster.first().map(|fw| fw.span.until(rest_first.span)).into_iter())
-                            // the span for the remaining lifetimes (calculations independent of the cluster)
-                            .chain(
-                                rest.array_windows()
-                                    .filter(|[_, curr]| elidable_lts.contains(&curr.def_id))
-                                    .map(|[prev, curr]| curr.span.with_lo(prev.span.hi())),
-                            )
-                            .map(|sp| (sp, String::new()))
-                            .collect()
-                    },
-                }
-            },
-        }
+
+                Some((span, String::new()))
+            })
+            .collect::<Option<Vec<_>>>()?
     };
 
     suggestions.extend(usages.iter().map(|&usage| {