Improve trait impl missing-parameter suggestions

Author: reddevilmidzy

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -1694,8 +1694,15 @@ fn compare_number_of_method_arguments<'tcx>(
 ) -> Result<(), ErrorGuaranteed> {
     let impl_m_fty = tcx.fn_sig(impl_m.def_id);
     let trait_m_fty = tcx.fn_sig(trait_m.def_id);
-    let trait_number_args = trait_m_fty.skip_binder().inputs().skip_binder().len();
-    let impl_number_args = impl_m_fty.skip_binder().inputs().skip_binder().len();
+    let trait_inputs = trait_m_fty.skip_binder().inputs().skip_binder();
+    let impl_inputs = impl_m_fty.skip_binder().inputs().skip_binder();
+    let trait_number_args = trait_inputs.len();
+    let impl_number_args = impl_inputs.len();
+    let params_prefix_match = impl_inputs
+        .iter()
+        .zip(trait_inputs)
+        .take(impl_number_args.min(trait_number_args))
+        .all(|(impl_ty, trait_ty)| impl_ty == trait_ty);
 
     if trait_number_args != impl_number_args {
         let trait_sig = trait_m.def_id.as_local().and_then(|def_id| {
@@ -1765,28 +1772,6 @@ fn compare_number_of_method_arguments<'tcx>(
         );
 
         let sm = tcx.sess.source_map();
-
-        fn find_param_bounds(snippet: &str) -> Option<(usize, usize)> {
-            let start = snippet.find('(')?;
-            let mut depth = 1usize;
-            let bytes = snippet.as_bytes();
-            let mut i = start + 1;
-            while i < bytes.len() {
-                match bytes[i] {
-                    b'(' => depth += 1,
-                    b')' => {
-                        depth -= 1;
-                        if depth == 0 {
-                            return Some((start + 1, i));
-                        }
-                    }
-                    _ => {}
-                }
-                i += 1;
-            }
-            None
-        }
-
         let impl_inputs_span = (!impl_m_sig.span.is_dummy())
             .then(|| {
                 sm.span_to_snippet(impl_m_sig.span).ok().and_then(|snippet| {
@@ -1799,7 +1784,28 @@ fn compare_number_of_method_arguments<'tcx>(
             })
             .flatten();
 
-        let suggestion = trait_sig
+        let missing_params = (trait_number_args > impl_number_args && params_prefix_match)
+            .then(|| {
+                trait_sig
+                    .as_ref()
+                    .and_then(|(_, trait_sig)| {
+                        sm.span_to_snippet(trait_sig.span).ok().and_then(|snippet| {
+                            find_param_bounds(&snippet).and_then(|(lo_rel, hi_rel)| {
+                                tail_params(&snippet[lo_rel..hi_rel], impl_number_args)
+                            })
+                        })
+                    })
+                    .or_else(|| {
+                        let signature = trait_m.signature(tcx);
+                        find_param_bounds(&signature).and_then(|(lo, hi)| {
+                            tail_params(&signature[lo..hi].trim(), impl_number_args)
+                        })
+                    })
+            })
+            .flatten();
+
+        let full_suggestion = trait_sig
+            .as_ref()
             .and_then(|(_, trait_sig)| {
                 sm.span_to_snippet(trait_sig.span).ok().and_then(|snippet| {
                     find_param_bounds(&snippet)
@@ -1811,7 +1817,15 @@ fn compare_number_of_method_arguments<'tcx>(
                 find_param_bounds(&signature).map(|(lo, hi)| signature[lo..hi].trim().to_string())
             });
 
-        if let (Some(span), Some(suggestion)) = (impl_inputs_span, suggestion) {
+        if let (Some(span), Some(missing)) = (impl_inputs_span, missing_params) {
+            let sep = if impl_number_args == 0 { "" } else { ", " };
+            err.span_suggestion_verbose(
+                span.shrink_to_hi(),
+                "add the missing parameter from the trait",
+                format!("{sep}{missing}"),
+                Applicability::MaybeIncorrect,
+            );
+        } else if let (Some(span), Some(suggestion)) = (impl_inputs_span, full_suggestion) {
             err.span_suggestion_verbose(
                 span,
                 "modify the signature to match the trait definition",
@@ -1826,6 +1840,53 @@ fn compare_number_of_method_arguments<'tcx>(
     Ok(())
 }
 
+fn find_param_bounds(snippet: &str) -> Option<(usize, usize)> {
+    let start = snippet.find('(')?;
+    let mut depth = 1usize;
+    let bytes = snippet.as_bytes();
+    let mut i = start + 1;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'(' => depth += 1,
+            b')' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some((start + 1, i));
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+
+fn split_top_level_params(params: &str) -> Vec<String> {
+    let mut depth = 0usize;
+    let mut start = 0;
+    let mut out = Vec::new();
+    for (idx, ch) in params.char_indices() {
+        match ch {
+            '(' | '<' | '[' | '{' => depth += 1,
+            ')' | '>' | ']' | '}' => depth = depth.saturating_sub(1),
+            ',' if depth == 0 => {
+                out.push(params[start..idx].trim().to_string());
+                start = idx + 1;
+            }
+            _ => {}
+        }
+    }
+    if start < params.len() {
+        out.push(params[start..].trim().to_string());
+    }
+    out
+}
+
+fn tail_params(params: &str, skip: usize) -> Option<String> {
+    let parts = split_top_level_params(params);
+    (parts.len() > skip).then(|| parts.into_iter().skip(skip).collect::<Vec<_>>().join(", "))
+}
+
 fn compare_synthetic_generics<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_m: ty::AssocItem,

tests/ui/impl-trait/in-trait/method-signature-matches.too_few.stderr

@@ -7,7 +7,7 @@ LL |     fn come_on_a_little_more_effort(_: (), _: (), _: ()) -> impl Sized;
 LL |     fn come_on_a_little_more_effort() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 3 parameters, found 0
    |
-help: modify the signature to match the trait definition
+help: add the missing parameter from the trait
    |
 LL |     fn come_on_a_little_more_effort(_: (), _: (), _: ()) {}
    |                                     +++++++++++++++++++

tests/ui/suggestions/trait-impl-mismatched-with-alias.rs

@@ -0,0 +1,23 @@
+//! Tests that alias type suggestions when trait impl mismatched
+
+trait Foo {
+    fn foo(a: i32, b: u32);
+}
+
+type AliasOfI32 = i32;
+impl Foo for () {
+    fn foo(a: AliasOfI32) {}
+    //~^ ERROR: method `foo` has 1 parameter but the declaration in trait `Foo::foo` has 2
+}
+
+type AliasOfU32 = u32;
+impl Foo for u32 {
+    fn foo(a: AliasOfU32) {}
+    //~^ ERROR: method `foo` has 1 parameter but the declaration in trait `Foo::foo` has 2
+}
+
+impl Foo for bool {
+    fn foo(a: AliasOfI32, b: AliasOfU32) {} // Ok
+}
+
+fn main() {}

tests/ui/suggestions/trait-impl-mismatched-with-alias.stderr

@@ -0,0 +1,32 @@
+error[E0050]: method `foo` has 1 parameter but the declaration in trait `Foo::foo` has 2
+  --> $DIR/trait-impl-mismatched-with-alias.rs:9:15
+   |
+LL |     fn foo(a: i32, b: u32);
+   |               ----------- trait requires 2 parameters
+...
+LL |     fn foo(a: AliasOfI32) {}
+   |               ^^^^^^^^^^ expected 2 parameters, found 1
+   |
+help: add the missing parameter from the trait
+   |
+LL |     fn foo(a: AliasOfI32, b: u32) {}
+   |                         ++++++++
+
+error[E0050]: method `foo` has 1 parameter but the declaration in trait `Foo::foo` has 2
+  --> $DIR/trait-impl-mismatched-with-alias.rs:15:15
+   |
+LL |     fn foo(a: i32, b: u32);
+   |               ----------- trait requires 2 parameters
+...
+LL |     fn foo(a: AliasOfU32) {}
+   |               ^^^^^^^^^^ expected 2 parameters, found 1
+   |
+help: modify the signature to match the trait definition
+   |
+LL -     fn foo(a: AliasOfU32) {}
+LL +     fn foo(a: i32, b: u32) {}
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0050`.