Merge bounds_span_for_suggestions_with_parentheses into bounds_span_for_suggestion

Author: long-long-float

compiler/rustc_hir/src/hir.rs

@@ -644,24 +644,10 @@ impl<'hir> Generics<'hir> {
         })
     }
 
-    pub fn bounds_span_for_suggestions(&self, param_def_id: LocalDefId) -> Option<Span> {
-        self.bounds_for_param(param_def_id).flat_map(|bp| bp.bounds.iter().rev()).find_map(
-            |bound| {
-                // We include bounds that come from a `#[derive(_)]` but point at the user's code,
-                // as we use this method to get a span appropriate for suggestions.
-                let bs = bound.span();
-                bs.can_be_used_for_suggestions().then(|| bs.shrink_to_hi())
-            },
-        )
-    }
-
     /// Returns bounds span for suggestions.
-    /// If the span including lifetime bound needs parentheses, it returns a tuple of a span to be surrounded by parentheses and true.
+    /// If the span including lifetime bound needs parentheses, it returns a span to the open parenthese at the second item.
     /// e.g. `dyn Future<Output = ()> + 'static` needs parentheses `(dyn Future<Output = ()>) + 'static`
-    pub fn bounds_span_for_suggestions_with_parentheses(
-        &self,
-        param_def_id: LocalDefId,
-    ) -> Option<(Span, bool)> {
+    pub fn bounds_span_for_suggestions(&self, param_def_id: LocalDefId) -> Option<(Span, Option<Span>)> {
         fn get_inner_ty<'a, 'b>(bound: &'a GenericBound<'b>) -> Option<&'a Ty<'b>> {
             match bound {
                 GenericBound::Trait(data, _) => {
@@ -695,10 +681,12 @@ impl<'hir> Generics<'hir> {
 
                 span_for_parentheses.map_or_else(
                     || {
+                        // We include bounds that come from a `#[derive(_)]` but point at the user's code,
+                        // as we use this method to get a span appropriate for suggestions.
                         let bs = bound.span();
-                        bs.can_be_used_for_suggestions().then(|| (bs.shrink_to_hi(), false))
+                        bs.can_be_used_for_suggestions().then(|| (bs.shrink_to_hi(), None))
                     },
-                    |span| Some((span, true)),
+                    |span| Some((span.shrink_to_hi(), Some(span.shrink_to_lo()))),
                 )
             },
         )

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -3275,14 +3275,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 param.name.ident(),
                             ));
                             let bounds_span = hir_generics.bounds_span_for_suggestions(def_id);
-                            if rcvr_ty.is_ref() && param.is_impl_trait() && bounds_span.is_some() {
+                            if rcvr_ty.is_ref() && param.is_impl_trait() && let Some((bounds_span, _)) = bounds_span {
                                 err.multipart_suggestions(
                                     msg,
                                     candidates.iter().map(|t| {
                                         vec![
                                             (param.span.shrink_to_lo(), "(".to_string()),
                                             (
-                                                bounds_span.unwrap(),
+                                                bounds_span,
                                                 format!(" + {})", self.tcx.def_path_str(t.def_id)),
                                             ),
                                         ]
@@ -3292,7 +3292,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 return;
                             }
 
-                            let (sp, introducer) = if let Some(span) = bounds_span {
+                            let (sp, introducer) = if let Some((span, _)) = bounds_span {
                                 (span, Introducer::Plus)
                             } else if let Some(colon_span) = param.colon_span {
                                 (colon_span.shrink_to_hi(), Introducer::Nothing)

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -2403,13 +2403,12 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     // We do this to avoid suggesting code that ends up as `T: 'a'b`,
                     // instead we suggest `T: 'a + 'b` in that case.
                     let hir_generics = self.tcx.hir().get_generics(scope).unwrap();
-                    let sugg_span = match hir_generics
-                        .bounds_span_for_suggestions_with_parentheses(def_id)
+                    let sugg_span = match hir_generics.bounds_span_for_suggestions(def_id)
                     {
-                        Some((span, needs_parentheses)) => Some((span, true, needs_parentheses)),
+                        Some((span, open_paren_sp)) => Some((span, true, open_paren_sp)),
                         // If `param` corresponds to `Self`, no usable suggestion span.
                         None if generics.has_self && param.index == 0 => None,
-                        None => Some((self.tcx.def_span(def_id).shrink_to_hi(), false, false)),
+                        None => Some((self.tcx.def_span(def_id).shrink_to_hi(), false, None)),
                     };
                     (scope, sugg_span)
                 }
@@ -2432,15 +2431,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             let mut suggs = vec![];
             let lt_name = self.suggest_name_region(sub, &mut suggs);
 
-            if let Some((sp, has_lifetimes, needs_parentheses)) = type_param_sugg_span
+            if let Some((sp, has_lifetimes, open_paren_sp)) = type_param_sugg_span
                 && suggestion_scope == type_scope
             {
                 let suggestion =
                     if has_lifetimes { format!(" + {lt_name}") } else { format!(": {lt_name}") };
 
-                if needs_parentheses {
-                    suggs.push((sp.shrink_to_lo(), "(".to_string()));
-                    suggs.push((sp.shrink_to_hi(), format!("){suggestion}")));
+                if let Some(open_paren_sp) = open_paren_sp {
+                    suggs.push((open_paren_sp, "(".to_string()));
+                    suggs.push((sp, format!("){suggestion}")));
                 } else {
                     suggs.push((sp, suggestion))
                 }

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -328,7 +328,7 @@ pub fn suggest_constraining_type_params<'a>(
         //          --
         //          |
         //          replace with: `T: Bar +`
-        if let Some(span) = generics.bounds_span_for_suggestions(param.def_id) {
+        if let Some((span, _)) = generics.bounds_span_for_suggestions(param.def_id) {
             suggest_restrict(span, true);
             continue;
         }

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -2929,7 +2929,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             _ => {}
         };
         // Didn't add an indirection suggestion, so add a general suggestion to relax `Sized`.
-        let (span, separator) = if let Some(s) = generics.bounds_span_for_suggestions(param.def_id)
+        let (span, separator) = if let Some((s, _)) = generics.bounds_span_for_suggestions(param.def_id)
         {
             (s, " +")
         } else {