Rollup merge of rust-lang#149027 - reddevilmidzy:suggest, r=madsmtm

JonathanBrouwer · web-flow · commit 5cb42db463ae · 2026-02-28T09:37:39.000+01:00
Improve cross-crate trait impl param mismatch suggestions resolve: rust-lang#106999
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -1,5 +1,6 @@
 use core::ops::ControlFlow;
 use std::borrow::Cow;
+use std::cmp::Ordering;
 use std::iter;
 
 use hir::def_id::{DefId, DefIdMap, LocalDefId};
@@ -18,7 +19,7 @@ use rustc_middle::ty::{
     Upcast,
 };
 use rustc_middle::{bug, span_bug};
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{BytePos, DUMMY_SP, Span};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::regions::InferCtxtRegionExt;
@@ -1795,6 +1796,105 @@ fn compare_number_of_method_arguments<'tcx>(
             ),
         );
 
+        // Only emit verbose suggestions when the trait span isn’t local (e.g., cross-crate).
+        if !trait_m.def_id.is_local() {
+            let trait_sig = tcx.fn_sig(trait_m.def_id);
+            let trait_arg_idents = tcx.fn_arg_idents(trait_m.def_id);
+            let sm = tcx.sess.source_map();
+            // Find the span of the space between the parentheses in a method.
+            // fn foo(...) {}
+            //        ^^^
+            let impl_inputs_span = if let (Some(first), Some(last)) =
+                (impl_m_sig.decl.inputs.first(), impl_m_sig.decl.inputs.last())
+            {
+                // We have inputs; construct the span from those.
+                // fn foo( a: i32, b: u32 ) {}
+                //        ^^^^^^^^^^^^^^^^
+                let arg_idents = tcx.fn_arg_idents(impl_m.def_id);
+                let first_lo = arg_idents
+                    .get(0)
+                    .and_then(|id| id.map(|id| id.span.lo()))
+                    .unwrap_or(first.span.lo());
+                Some(impl_m_sig.span.with_lo(first_lo).with_hi(last.span.hi()))
+            } else {
+                // We have no inputs; construct the span to the left of the last parenthesis
+                // fn foo( ) {}
+                //        ^
+                // FIXME: Keep spans for function parentheses around to make this more robust.
+                sm.span_to_snippet(impl_m_sig.span).ok().and_then(|s| {
+                    let right_paren = s.as_bytes().iter().rposition(|&b| b == b')')?;
+                    let pos = impl_m_sig.span.lo() + BytePos(right_paren as u32);
+                    Some(impl_m_sig.span.with_lo(pos).with_hi(pos))
+                })
+            };
+            let suggestion = match trait_number_args.cmp(&impl_number_args) {
+                Ordering::Greater => {
+                    // Span is right before the end parenthesis:
+                    // fn foo(a: i32 ) {}
+                    //              ^
+                    let trait_inputs = trait_sig.skip_binder().inputs().skip_binder();
+                    let missing = trait_inputs
+                        .iter()
+                        .enumerate()
+                        .skip(impl_number_args)
+                        .map(|(idx, ty)| {
+                            let name = trait_arg_idents
+                                .get(idx)
+                                .and_then(|ident| *ident)
+                                .map(|ident| ident.to_string())
+                                .unwrap_or_else(|| "_".to_string());
+                            format!("{name}: {ty}")
+                        })
+                        .collect::<Vec<_>>();
+
+                    if missing.is_empty() {
+                        None
+                    } else {
+                        impl_inputs_span.map(|s| {
+                            let span = s.shrink_to_hi();
+                            let prefix = if impl_number_args == 0 { "" } else { ", " };
+                            let replacement = format!("{prefix}{}", missing.join(", "));
+                            (
+                                span,
+                                format!(
+                                    "add the missing parameter{} from the trait",
+                                    pluralize!(trait_number_args - impl_number_args)
+                                ),
+                                replacement,
+                            )
+                        })
+                    }
+                }
+                Ordering::Less => impl_inputs_span.and_then(|full| {
+                    // Span of the arguments that there are too many of:
+                    // fn foo(a: i32, b: u32) {}
+                    //              ^^^^^^^^
+                    let lo = if trait_number_args == 0 {
+                        full.lo()
+                    } else {
+                        impl_m_sig
+                            .decl
+                            .inputs
+                            .get(trait_number_args - 1)
+                            .map(|arg| arg.span.hi())?
+                    };
+                    let span = full.with_lo(lo);
+                    Some((
+                        span,
+                        format!(
+                            "remove the extra parameter{} to match the trait",
+                            pluralize!(impl_number_args - trait_number_args)
+                        ),
+                        String::new(),
+                    ))
+                }),
+                Ordering::Equal => unreachable!(),
+            };
+            if let Some((span, msg, replacement)) = suggestion {
+                err.span_suggestion_verbose(span, msg, replacement, Applicability::MaybeIncorrect);
+            }
+        }
+
         return Err(err.emit_unless_delay(delay));
     }
 
diff --git a/tests/ui/fn/issue-39259.stderr b/tests/ui/fn/issue-39259.stderr
@@ -17,6 +17,10 @@ LL |     fn call(&self) -> u32 {
    |             ^^^^^ expected 2 parameters, found 1
    |
    = note: `call` from trait: `extern "rust-call" fn(&Self, Args) -> <Self as FnOnce<Args>>::Output`
+help: add the missing parameter from the trait
+   |
+LL |     fn call(&self, args: Args) -> u32 {
+   |                  ++++++++++++
 
 error[E0277]: expected a `FnMut(u32)` closure, found `S`
   --> $DIR/issue-39259.rs:6:25
diff --git a/tests/ui/impl-trait/trait_type.stderr b/tests/ui/impl-trait/trait_type.stderr
@@ -19,6 +19,10 @@ LL |    fn fmt(&self) -> () { }
    |           ^^^^^ expected 2 parameters, found 1
    |
    = note: `fmt` from trait: `fn(&Self, &mut Formatter<'_>) -> Result<(), std::fmt::Error>`
+help: add the missing parameter from the trait
+   |
+LL |    fn fmt(&self, f: &mut Formatter<'_>) -> () { }
+   |                +++++++++++++++++++++++
 
 error[E0186]: method `fmt` has a `&self` declaration in the trait, but not in the impl
   --> $DIR/trait_type.rs:17:4
diff --git a/tests/ui/suggestions/auxiliary/trait-impl-params.rs b/tests/ui/suggestions/auxiliary/trait-impl-params.rs
@@ -0,0 +1,19 @@
+//@ edition:2018
+pub trait Foo {
+    fn foo(a: i32, b: u32);
+}
+
+pub trait Bar {
+    fn no_params();
+    fn has_self(&self);
+    fn has_two_self(self: &Self, other: &Self);
+}
+
+pub trait Baz<T> {
+    fn generic_no_params<U: Baz<()>>();
+    fn generic_one_param<U: Baz<()>>(a: U);
+}
+
+pub trait NonIdentArguments {
+    fn pattern_types_in_arguments(_: i32, (_a, _b): (i32, i32)) {}
+}
diff --git a/tests/ui/suggestions/trait-impl-param-mismatched-cross-crate.fixed b/tests/ui/suggestions/trait-impl-param-mismatched-cross-crate.fixed
@@ -0,0 +1,64 @@
+//@ run-rustfix
+//@ aux-build:trait-impl-params.rs
+//@ edition:2018
+//! Tests cross-crate trait impl param mismatch suggestions (keep aliases when matching,
+//! append missing; replace otherwise).
+//! regression test for https://github.com/rust-lang/rust/issues/106999
+
+#![allow(unused)]
+extern crate trait_impl_params;
+
+use trait_impl_params::{Bar, Baz, Foo, NonIdentArguments};
+
+struct MyStruct1;
+impl Foo for MyStruct1 {
+    fn foo(a: i32, b: u32) {}
+    //~^ ERROR: method `foo` has 0 parameters but the declaration in trait `foo` has 2
+    //~| HELP: add the missing parameters from the trait
+}
+
+struct MyStruct2;
+type AliasOfI32 = i32;
+impl Foo for MyStruct2 {
+    fn foo(a: AliasOfI32, b: u32) {}
+    //~^ ERROR: method `foo` has 1 parameter but the declaration in trait `foo` has 2
+    //~| HELP: add the missing parameter from the trait
+}
+
+struct MyStruct3;
+type AliasOfU32 = u32;
+impl Foo for MyStruct3 {
+    fn foo(a: AliasOfI32, b: AliasOfU32) {} // Ok
+}
+
+struct MyStruct4;
+impl Bar for MyStruct4 {
+    fn no_params() {}
+    //~^ ERROR: method `no_params` has 1 parameter but the declaration in trait `no_params` has 0
+    //~| HELP: remove the extra parameter to match the trait
+    fn has_self(&self) {}
+    //~^ ERROR: method `has_self` has 2 parameters but the declaration in trait `has_self` has 1
+    //~| HELP: remove the extra parameter to match the trait
+    fn has_two_self(self: &Self, other: &Self) {}
+    //~^ ERROR: method `has_two_self` has 1 parameter but the declaration in trait `has_two_self` has 2
+    //~| HELP: add the missing parameter from the trait
+}
+
+struct MyStruct5;
+impl NonIdentArguments for MyStruct5 {
+    fn pattern_types_in_arguments(_: i32, _: (i32, i32)) {}
+    //~^ ERROR: method `pattern_types_in_arguments` has 0 parameters but the declaration in trait
+    //~| HELP: add the missing parameters from the trait
+}
+
+struct MyStruct6;
+impl Baz<()> for MyStruct6 {
+    fn generic_no_params<U: Baz<()>>() {}
+    //~^ ERROR: method `generic_no_params` has 1 parameter but the declaration in trait
+    //~| HELP: remove the extra parameter to match the trait
+    fn generic_one_param<U: Baz<()>>(a: U) {}
+    //~^ ERROR: method `generic_one_param` has 0 parameters but the declaration in trait
+    //~| HELP: add the missing parameter from the trait
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/trait-impl-param-mismatched-cross-crate.rs b/tests/ui/suggestions/trait-impl-param-mismatched-cross-crate.rs
@@ -0,0 +1,64 @@
+//@ run-rustfix
+//@ aux-build:trait-impl-params.rs
+//@ edition:2018
+//! Tests cross-crate trait impl param mismatch suggestions (keep aliases when matching,
+//! append missing; replace otherwise).
+//! regression test for https://github.com/rust-lang/rust/issues/106999
+
+#![allow(unused)]
+extern crate trait_impl_params;
+
+use trait_impl_params::{Bar, Baz, Foo, NonIdentArguments};
+
+struct MyStruct1;
+impl Foo for MyStruct1 {
+    fn foo() {}
+    //~^ ERROR: method `foo` has 0 parameters but the declaration in trait `foo` has 2
+    //~| HELP: add the missing parameters from the trait
+}
+
+struct MyStruct2;
+type AliasOfI32 = i32;
+impl Foo for MyStruct2 {
+    fn foo(a: AliasOfI32) {}
+    //~^ ERROR: method `foo` has 1 parameter but the declaration in trait `foo` has 2
+    //~| HELP: add the missing parameter from the trait
+}
+
+struct MyStruct3;
+type AliasOfU32 = u32;
+impl Foo for MyStruct3 {
+    fn foo(a: AliasOfI32, b: AliasOfU32) {} // Ok
+}
+
+struct MyStruct4;
+impl Bar for MyStruct4 {
+    fn no_params(x: i32) {}
+    //~^ ERROR: method `no_params` has 1 parameter but the declaration in trait `no_params` has 0
+    //~| HELP: remove the extra parameter to match the trait
+    fn has_self(&self, y: i32) {}
+    //~^ ERROR: method `has_self` has 2 parameters but the declaration in trait `has_self` has 1
+    //~| HELP: remove the extra parameter to match the trait
+    fn has_two_self(self: &Self) {}
+    //~^ ERROR: method `has_two_self` has 1 parameter but the declaration in trait `has_two_self` has 2
+    //~| HELP: add the missing parameter from the trait
+}
+
+struct MyStruct5;
+impl NonIdentArguments for MyStruct5 {
+    fn pattern_types_in_arguments() {}
+    //~^ ERROR: method `pattern_types_in_arguments` has 0 parameters but the declaration in trait
+    //~| HELP: add the missing parameters from the trait
+}
+
+struct MyStruct6;
+impl Baz<()> for MyStruct6 {
+    fn generic_no_params<U: Baz<()>>(a: U) {}
+    //~^ ERROR: method `generic_no_params` has 1 parameter but the declaration in trait
+    //~| HELP: remove the extra parameter to match the trait
+    fn generic_one_param<U: Baz<()>>() {}
+    //~^ ERROR: method `generic_one_param` has 0 parameters but the declaration in trait
+    //~| HELP: add the missing parameter from the trait
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/trait-impl-param-mismatched-cross-crate.stderr b/tests/ui/suggestions/trait-impl-param-mismatched-cross-crate.stderr
@@ -0,0 +1,102 @@
+error[E0050]: method `foo` has 0 parameters but the declaration in trait `foo` has 2
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:15:5
+   |
+LL |     fn foo() {}
+   |     ^^^^^^^^ expected 2 parameters, found 0
+   |
+   = note: `foo` from trait: `fn(i32, u32)`
+help: add the missing parameters from the trait
+   |
+LL |     fn foo(a: i32, b: u32) {}
+   |            ++++++++++++++
+
+error[E0050]: method `foo` has 1 parameter but the declaration in trait `foo` has 2
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:23:15
+   |
+LL |     fn foo(a: AliasOfI32) {}
+   |               ^^^^^^^^^^ expected 2 parameters, found 1
+   |
+   = note: `foo` from trait: `fn(i32, u32)`
+help: add the missing parameter from the trait
+   |
+LL |     fn foo(a: AliasOfI32, b: u32) {}
+   |                         ++++++++
+
+error[E0050]: method `no_params` has 1 parameter but the declaration in trait `no_params` has 0
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:36:21
+   |
+LL |     fn no_params(x: i32) {}
+   |                     ^^^ expected 0 parameters, found 1
+   |
+   = note: `no_params` from trait: `fn()`
+help: remove the extra parameter to match the trait
+   |
+LL -     fn no_params(x: i32) {}
+LL +     fn no_params() {}
+   |
+
+error[E0050]: method `has_self` has 2 parameters but the declaration in trait `has_self` has 1
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:39:17
+   |
+LL |     fn has_self(&self, y: i32) {}
+   |                 ^^^^^^^^^^^^^ expected 1 parameter, found 2
+   |
+   = note: `has_self` from trait: `fn(&Self)`
+help: remove the extra parameter to match the trait
+   |
+LL -     fn has_self(&self, y: i32) {}
+LL +     fn has_self(&self) {}
+   |
+
+error[E0050]: method `has_two_self` has 1 parameter but the declaration in trait `has_two_self` has 2
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:42:27
+   |
+LL |     fn has_two_self(self: &Self) {}
+   |                           ^^^^^ expected 2 parameters, found 1
+   |
+   = note: `has_two_self` from trait: `fn(&Self, &Self)`
+help: add the missing parameter from the trait
+   |
+LL |     fn has_two_self(self: &Self, other: &Self) {}
+   |                                ++++++++++++++
+
+error[E0050]: method `pattern_types_in_arguments` has 0 parameters but the declaration in trait `pattern_types_in_arguments` has 2
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:49:5
+   |
+LL |     fn pattern_types_in_arguments() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 2 parameters, found 0
+   |
+   = note: `pattern_types_in_arguments` from trait: `fn(i32, (i32, i32))`
+help: add the missing parameters from the trait
+   |
+LL |     fn pattern_types_in_arguments(_: i32, _: (i32, i32)) {}
+   |                                   +++++++++++++++++++++
+
+error[E0050]: method `generic_no_params` has 1 parameter but the declaration in trait `generic_no_params` has 0
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:56:41
+   |
+LL |     fn generic_no_params<U: Baz<()>>(a: U) {}
+   |                                         ^ expected 0 parameters, found 1
+   |
+   = note: `generic_no_params` from trait: `fn()`
+help: remove the extra parameter to match the trait
+   |
+LL -     fn generic_no_params<U: Baz<()>>(a: U) {}
+LL +     fn generic_no_params<U: Baz<()>>() {}
+   |
+
+error[E0050]: method `generic_one_param` has 0 parameters but the declaration in trait `generic_one_param` has 1
+  --> $DIR/trait-impl-param-mismatched-cross-crate.rs:59:5
+   |
+LL |     fn generic_one_param<U: Baz<()>>() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 1 parameter, found 0
+   |
+   = note: `generic_one_param` from trait: `fn(U)`
+help: add the missing parameter from the trait
+   |
+LL |     fn generic_one_param<U: Baz<()>>(a: U) {}
+   |                                      ++++
+
+error: aborting due to 8 previous errors
+
+For more information about this error, try `rustc --explain E0050`.
