Suggest how to fix with unconstrained type parameters

Unconstrained type parameters made no suggestion and it makes difficult
to know how to fix (#107295).

To make fixing easier, we output suggestions how to fix.

Author: kei519

compiler/rustc_hir/src/hir.rs

@@ -845,6 +845,61 @@ impl<'hir> Generics<'hir> {
             bound_span.with_lo(bounds[bound_pos - 1].span().hi())
         }
     }
+
+    pub fn span_for_param_removal(&self, param_index: usize) -> Span {
+        if param_index >= self.params.len() {
+            return self.span.shrink_to_hi();
+        }
+
+        let is_impl_generic = |par: &&GenericParam<'_>| match par.kind {
+            GenericParamKind::Type { .. }
+            | GenericParamKind::Const { .. }
+            | GenericParamKind::Lifetime { kind: LifetimeParamKind::Explicit } => true,
+            _ => false,
+        };
+
+        // Find the span of the type parameter.
+        if let Some(next) = self.params[param_index + 1..].iter().find(is_impl_generic) {
+            self.params[param_index].span.until(next.span)
+        } else if let Some(prev) = self.params[..param_index].iter().rfind(is_impl_generic) {
+            let mut prev_span = prev.span;
+            // Consider the span of the bounds with the previous generic parameter when there is.
+            if let Some(prev_bounds_span) = self.span_for_param_bounds(prev) {
+                prev_span = prev_span.to(prev_bounds_span);
+            }
+
+            // Consider the span of the bounds with the current generic parameter when there is.
+            prev_span.shrink_to_hi().to(
+                if let Some(cur_bounds_span) = self.span_for_param_bounds(&self.params[param_index])
+                {
+                    cur_bounds_span
+                } else {
+                    self.params[param_index].span
+                },
+            )
+        } else {
+            // Remove also angle brackets <> when there is just ONE generic parameter.
+            self.span
+        }
+    }
+
+    fn span_for_param_bounds(&self, param: &GenericParam<'hir>) -> Option<Span> {
+        self.predicates
+            .iter()
+            .find(|pred| {
+                if let WherePredicateKind::BoundPredicate(WhereBoundPredicate {
+                    origin: PredicateOrigin::GenericParam,
+                    bounded_ty,
+                    ..
+                }) = pred.kind
+                {
+                    bounded_ty.span == param.span
+                } else {
+                    false
+                }
+            })
+            .map(|pred| pred.span)
+    }
 }
 
 /// A single predicate in a where-clause.

compiler/rustc_hir_analysis/src/impl_wf_check.rs

@@ -13,9 +13,11 @@ use std::assert_matches::debug_assert_matches;
 use min_specialization::check_min_specialization;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
+use rustc_errors::{Applicability, Diag};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
-use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
+use rustc_hir::{Path, QPath, Ty, TyKind};
+use rustc_middle::ty::{self, GenericParamDef, TyCtxt, TypeVisitableExt};
 use rustc_span::ErrorGuaranteed;
 
 use crate::constrained_generic_params as cgp;
@@ -128,6 +130,21 @@ pub(crate) fn enforce_impl_lifetime_params_are_constrained(
     for param in &impl_generics.own_params {
         match param.kind {
             ty::GenericParamDefKind::Lifetime => {
+                let param_lt = cgp::Parameter::from(param.to_early_bound_region_data());
+                if lifetimes_in_associated_types.contains(&param_lt) // (*)
+                    && !input_parameters.contains(&param_lt)
+                {
+                    let mut diag = tcx.dcx().create_err(UnconstrainedGenericParameter {
+                        span: tcx.def_span(param.def_id),
+                        param_name: param.name,
+                        param_def_kind: tcx.def_descr(param.def_id),
+                        const_param_note: false,
+                        const_param_note2: false,
+                    });
+                    diag.code(E0207);
+                    suggest_to_remove_or_use_generic(tcx, &mut diag, impl_def_id, param);
+                    res = Err(diag.emit());
+                }
                 // This is a horrible concession to reality. I think it'd be
                 // better to just ban unconstrained lifetimes outright, but in
                 // practice people do non-hygienic macros like:
@@ -158,6 +175,7 @@ pub(crate) fn enforce_impl_lifetime_params_are_constrained(
                         const_param_note2: false,
                     });
                     diag.code(E0207);
+                    suggest_to_remove_or_use_generic(tcx, &mut diag, impl_def_id, param);
                     res = Err(diag.emit());
                 }
             }
@@ -229,8 +247,60 @@ pub(crate) fn enforce_impl_non_lifetime_params_are_constrained(
                 const_param_note2: const_param_note,
             });
             diag.code(E0207);
+            suggest_to_remove_or_use_generic(tcx, &mut diag, impl_def_id, &param);
             res = Err(diag.emit());
         }
     }
     res
 }
+
+fn suggest_to_remove_or_use_generic(
+    tcx: TyCtxt<'_>,
+    diag: &mut Diag<'_>,
+    impl_def_id: LocalDefId,
+    param: &GenericParamDef,
+) {
+    let node = tcx.hir_node_by_def_id(impl_def_id);
+    let hir_impl = node.expect_item().expect_impl();
+
+    let Some((index, _)) = hir_impl
+        .generics
+        .params
+        .iter()
+        .enumerate()
+        .find(|(_, par)| par.def_id.to_def_id() == param.def_id)
+    else {
+        return;
+    };
+
+    let mut suggestions = vec![];
+
+    // Suggestion for removing the type parameter.
+    suggestions.push(vec![(hir_impl.generics.span_for_param_removal(index), String::new())]);
+
+    // Suggestion for making use of the type parameter.
+    if let Some(path) = extract_ty_as_path(hir_impl.self_ty) {
+        let seg = path.segments.last().unwrap();
+        if let Some(args) = seg.args {
+            suggestions
+                .push(vec![(args.span().unwrap().shrink_to_hi(), format!(", {}", param.name))]);
+        } else {
+            suggestions.push(vec![(seg.ident.span.shrink_to_hi(), format!("<{}>", param.name))]);
+        }
+    }
+
+    diag.multipart_suggestions(
+        format!("either remove the type parameter {}, or make use of it, for example", param.name),
+        suggestions,
+        Applicability::MaybeIncorrect,
+    );
+}
+
+fn extract_ty_as_path<'hir>(ty: &Ty<'hir>) -> Option<&'hir Path<'hir>> {
+    match ty.kind {
+        TyKind::Path(QPath::Resolved(_, path)) => Some(path),
+        TyKind::Slice(ty) | TyKind::Array(ty, _) => extract_ty_as_path(ty),
+        TyKind::Ptr(ty) | TyKind::Ref(_, ty) => extract_ty_as_path(ty.ty),
+        _ => None,
+    }
+}