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

@@ -13,9 +13,14 @@ 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::{
+    GenericParam, GenericParamKind, LifetimeParamKind, Path, PredicateOrigin, QPath, Ty, TyKind,
+    WhereBoundPredicate, WherePredicateKind,
+};
+use rustc_middle::ty::{self, GenericParamDef, TyCtxt, TypeVisitableExt};
 use rustc_span::ErrorGuaranteed;
 
 use crate::constrained_generic_params as cgp;
@@ -140,6 +145,7 @@ pub(crate) fn enforce_impl_lifetime_params_are_constrained(
                         const_param_note2: false,
                     });
                     diag.code(E0207);
+                    suggest_to_remove_or_use_generics(tcx, &mut diag, impl_def_id, param);
                     res = Err(diag.emit());
                 }
                 // (*) This is a horrible concession to reality. I think it'd be
@@ -229,8 +235,99 @@ pub(crate) fn enforce_impl_non_lifetime_params_are_constrained(
                 const_param_note2: const_param_note,
             });
             diag.code(E0207);
+            suggest_to_remove_or_use_generics(tcx, &mut diag, impl_def_id, &param);
             res = Err(diag.emit());
         }
     }
     res
 }
+
+fn suggest_to_remove_or_use_generics(
+    tcx: TyCtxt<'_>,
+    diag: &mut Diag<'_>,
+    impl_def_id: LocalDefId,
+    param: &GenericParamDef,
+) {
+    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 (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,
+    );
+}
+
+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,
+    }
+}