Move verbose logic to a function

Author: ShoyuVanilla

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -13,8 +13,8 @@ use rustc_errors::{AddToDiagnostic, Applicability, Diag, ErrorGuaranteed, MultiS
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, GenericBound, GenericParamKind, Item, ItemKind, Lifetime, LifetimeName,
-    LifetimeParamKind, MissingLifetimeKind, Node, TyKind,
+    self as hir, GenericBound, GenericParam, GenericParamKind, Item, ItemKind, Lifetime,
+    LifetimeName, LifetimeParamKind, MissingLifetimeKind, Node, TyKind,
 };
 use rustc_middle::ty::{
     self, AssocItemContainer, StaticLifetimeVisitor, Ty, TyCtxt, TypeSuperVisitable, TypeVisitor,
@@ -356,87 +356,8 @@ pub fn suggest_new_region_bound(
                     // introducing a new lifetime `'a` or making use of one from existing named lifetimes if any
                     if let Some(id) = scope_def_id
                         && let Some(generics) = tcx.hir().get_generics(id)
-                        && let mut spans_suggs = {
-                            fn finish_bracket(
-                                suggs: &mut Vec<(Span, String)>,
-                                name: &str,
-                                bracket_span: &mut Option<Span>,
-                                brackets: &mut usize,
-                            ) {
-                                if let Some(span) = bracket_span.take() {
-                                    let sugg: String = std::iter::once("<")
-                                        .chain(
-                                            std::iter::repeat(name)
-                                                .take(*brackets)
-                                                .intersperse(", "),
-                                        )
-                                        .chain([">"])
-                                        .collect();
-                                    suggs.push((span.shrink_to_hi(), sugg));
-                                    *brackets = 0;
-                                }
-                            }
-                            let mut spans_suggs = Vec::new();
-                            let mut bracket_span = None::<Span>;
-                            let mut brackets = 0;
-                            for p in generics.params {
-                                if let GenericParamKind::Lifetime {
-                                    kind: LifetimeParamKind::Elided(kind),
-                                } = p.kind
-                                {
-                                    match kind {
-                                        MissingLifetimeKind::Underscore => {
-                                            finish_bracket(
-                                                &mut spans_suggs,
-                                                name,
-                                                &mut bracket_span,
-                                                &mut brackets,
-                                            );
-                                            spans_suggs.push((p.span, name.to_string()));
-                                        }
-                                        MissingLifetimeKind::Ampersand => {
-                                            finish_bracket(
-                                                &mut spans_suggs,
-                                                name,
-                                                &mut bracket_span,
-                                                &mut brackets,
-                                            );
-                                            spans_suggs
-                                                .push((p.span.shrink_to_hi(), format!("{name} ")));
-                                        }
-                                        MissingLifetimeKind::Comma => {
-                                            finish_bracket(
-                                                &mut spans_suggs,
-                                                name,
-                                                &mut bracket_span,
-                                                &mut brackets,
-                                            );
-                                            spans_suggs
-                                                .push((p.span.shrink_to_hi(), format!("{name}, ")));
-                                        }
-                                        MissingLifetimeKind::Brackets => {
-                                            if bracket_span.is_some_and(|span| span != p.span) {
-                                                finish_bracket(
-                                                    &mut spans_suggs,
-                                                    name,
-                                                    &mut bracket_span,
-                                                    &mut brackets,
-                                                );
-                                            }
-                                            bracket_span = Some(p.span);
-                                            brackets += 1;
-                                        }
-                                    }
-                                }
-                            }
-                            finish_bracket(
-                                &mut spans_suggs,
-                                name,
-                                &mut bracket_span,
-                                &mut brackets,
-                            );
-                            spans_suggs
-                        }
+                        && let mut spans_suggs =
+                            make_lifetime_spans_suggs(name, generics.params.iter())
                         && spans_suggs.len() > 1
                     {
                         let use_lt = if existing_lt_name == None {
@@ -498,6 +419,57 @@ pub fn suggest_new_region_bound(
     }
 }
 
+fn make_lifetime_spans_suggs<'a>(
+    name: &str,
+    generic_params: impl Iterator<Item = &'a GenericParam<'a>>,
+) -> Vec<(Span, String)> {
+    let mut spans_suggs = Vec::new();
+    let mut bracket_span = None;
+    let mut consecutive_brackets = 0;
+
+    let mut process_consecutive_brackets =
+        |span: Option<Span>, spans_suggs: &mut Vec<(Span, String)>| {
+            if span
+                .is_some_and(|span| bracket_span.map_or(true, |bracket_span| span == bracket_span))
+            {
+                consecutive_brackets += 1;
+            } else if let Some(bracket_span) = bracket_span.take() {
+                let sugg = std::iter::once("<")
+                    .chain(std::iter::repeat(name).take(consecutive_brackets).intersperse(", "))
+                    .chain([">"])
+                    .collect();
+                spans_suggs.push((bracket_span.shrink_to_hi(), sugg));
+                consecutive_brackets = 0;
+            }
+            bracket_span = span;
+        };
+
+    for p in generic_params {
+        if let GenericParamKind::Lifetime { kind: LifetimeParamKind::Elided(kind) } = p.kind {
+            match kind {
+                MissingLifetimeKind::Underscore => {
+                    process_consecutive_brackets(None, &mut spans_suggs);
+                    spans_suggs.push((p.span, name.to_string()))
+                }
+                MissingLifetimeKind::Ampersand => {
+                    process_consecutive_brackets(None, &mut spans_suggs);
+                    spans_suggs.push((p.span.shrink_to_hi(), format!("{name} ")));
+                }
+                MissingLifetimeKind::Comma => {
+                    process_consecutive_brackets(None, &mut spans_suggs);
+                    spans_suggs.push((p.span.shrink_to_hi(), format!("{name}, ")));
+                }
+                MissingLifetimeKind::Brackets => {
+                    process_consecutive_brackets(Some(p.span), &mut spans_suggs);
+                }
+            }
+        }
+    }
+    process_consecutive_brackets(None, &mut spans_suggs);
+
+    spans_suggs
+}
+
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     pub fn get_impl_ident_and_self_ty_from_trait(
         tcx: TyCtxt<'tcx>,