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_analysis/src/impl_wf_check.rs

@@ -12,9 +12,14 @@ use std::assert_matches::debug_assert_matches;
 
 use min_specialization::check_min_specialization;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
 use rustc_errors::codes::*;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{
+    GenericParam, GenericParamKind, LifetimeParamKind, Path, PredicateOrigin, QPath, Ty, TyKind,
+    WhereBoundPredicate, WherePredicateKind,
+};
 use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 use rustc_span::ErrorGuaranteed;
 
@@ -121,6 +126,14 @@ fn enforce_impl_params_are_constrained(
         })
         .collect();
 
+    let node = tcx.hir().get_if_local(impl_def_id.into()).expect("cannot get `Node`");
+    let hir_impl = if let rustc_hir::Node::Item(item) = node {
+        if let rustc_hir::ItemKind::Impl(imp) = item.kind { Some(imp) } else { None }
+    } else {
+        None
+    }
+    .expect("cannot take `Impl` in a impl block");
+
     let mut res = Ok(());
     for param in &impl_generics.own_params {
         let err = match param.kind {
@@ -149,6 +162,79 @@ fn enforce_impl_params_are_constrained(
                 const_param_note2: const_param_note,
             });
             diag.code(E0207);
+
+            let (index, hir_param) = hir_impl
+                .generics
+                .params
+                .iter()
+                .enumerate()
+                .find(|(_, par)| par.name.ident().name == param.name)
+                .unwrap();
+            let mut suggestions = vec![];
+
+            let is_impl_generic = |par: &&GenericParam<'_>| match par.kind {
+                GenericParamKind::Type { .. }
+                | GenericParamKind::Const { .. }
+                | GenericParamKind::Lifetime { kind: LifetimeParamKind::Explicit } => true,
+                _ => false,
+            };
+            // Suggestion for removing the type parameter.
+            suggestions.push(vec![(
+                // Find the span of the type parameter.
+                if let Some(prev) = hir_impl.generics.params[..index].iter().rfind(is_impl_generic)
+                {
+                    let mut span = prev.span;
+
+                    // Consider the span of the bounds with the generic parameter when there is.
+                    if let Some(predicate) = hir_impl.generics.predicates.iter().find(|pred| {
+                        if let WherePredicateKind::BoundPredicate(WhereBoundPredicate {
+                            origin: PredicateOrigin::GenericParam,
+                            bounded_ty,
+                            ..
+                        }) = pred.kind
+                        {
+                            bounded_ty.span == prev.span
+                        } else {
+                            false
+                        }
+                    }) {
+                        span = span.to(predicate.span)
+                    };
+
+                    span.shrink_to_hi().to(hir_param.span)
+                } else if let Some(next) =
+                    hir_impl.generics.params[index + 1..].iter().find(is_impl_generic)
+                {
+                    hir_param.span.until(next.span)
+                } else {
+                    // Remove also angle brackets <> when there is just ONE generic parameter.
+                    hir_impl.generics.span
+                },
+                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,
+            );
             res = Err(diag.emit());
         }
     }
@@ -173,3 +259,12 @@ fn enforce_impl_params_are_constrained(
     // associated types. I believe this is sound, because lifetimes
     // used elsewhere are not projected back out.
 }
+
+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,
+    }
+}