Don't suggest changing ret ty for trait methods

Author: sjwang05

compiler/rustc_hir_typeck/src/demand.rs

@@ -1178,41 +1178,39 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expr: &hir::Expr<'_>,
         expected: Ty<'_>,
     ) {
-        let (def_id, ident, callee_str) = if let hir::ExprKind::Call(fun, _) = expr.kind
+        let (def_id, ident) = if let hir::ExprKind::Call(fun, _) = expr.kind
             && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = fun.kind
-            && let hir::def::Res::Def(def_kind, def_id) = path.res
-            && !matches!(def_kind, hir::def::DefKind::Ctor(..))
+            && let hir::def::Res::Def(_, def_id) = path.res
         {
-            (def_id, path.segments[0].ident, "function")
+            (def_id, path.segments[0].ident)
         } else if let hir::ExprKind::MethodCall(method, ..) = expr.kind
             && let Some(def_id) = self.typeck_results.borrow().type_dependent_def_id(expr.hir_id)
-            && !matches!(self.tcx.def_kind(def_id), hir::def::DefKind::Ctor(..))
         {
-            (def_id, method.ident, "method")
+            (def_id, method.ident)
         } else {
             return;
         };
+        if !matches!(self.tcx.def_kind(def_id), hir::def::DefKind::AssocFn | hir::def::DefKind::Fn)
+        {
+            return;
+        }
         err.span_note(
             self.tcx.def_span(def_id),
-            format!("the {callee_str} {ident} is defined here"),
+            format!("the {} {ident} is defined here", self.tcx.def_descr(def_id)),
         );
 
         if let Some(local_did) = def_id.as_local()
             && let Some(node) = self.tcx.opt_hir_node(self.tcx.local_def_id_to_hir_id(local_did))
-            && let hir::Node::TraitItem(hir::TraitItem {
-                kind: hir::TraitItemKind::Fn(sig, ..),
-                ..
-            })
-            | hir::Node::ImplItem(hir::ImplItem {
-                kind: hir::ImplItemKind::Fn(sig, ..), ..
-            })
-            | hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(sig, ..), .. }) = node
+            && !matches!(node, hir::Node::TraitItem(..))
+            && let Some(sig) = node.fn_sig()
             && let ret_span = sig.decl.output.span()
             && !ret_span.from_expansion()
             && expected.has_concrete_skeleton()
         {
-            let sugg =
-                if ret_span.is_empty() { format!("-> {expected}") } else { format!("{expected}") };
+            let sugg = match sig.decl.output {
+                hir::FnRetTy::DefaultReturn(..) => format!("-> {expected}"),
+                hir::FnRetTy::Return(..) => format!("{expected}"),
+            };
             err.span_suggestion(
                 ret_span,
                 format!("consider changing {ident}'s return type"),

tests/ui/associated-type-bounds/do-not-look-at-parent-item-in-suggestion-for-type-param-of-current-assoc-item.stderr

@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/do-not-look-at-parent-item-in-suggestion-for-type-param-of-current-assoc-item.rs:24:37
    |
-LL |     fn identify(&self) -> Self::Id;
-   |                           -------- help: consider changing identify's return type: `&I`
-...
 LL |         let _low = self.lows.remove(low.identify()).unwrap();
    |                              ------ ^^^^^^^^^^^^^^ expected `&I`, found associated type
    |                              |

tests/ui/associated-types/associated-types-eq-3.stderr

@@ -17,10 +17,6 @@ help: consider constraining the associated type `<I as Foo>::A` to `Bar`
    |
 LL | fn foo2<I: Foo<A = Bar>>(x: I) {
    |               +++++++++
-help: consider changing boo's return type
-   |
-LL |     fn boo(&self) -> Bar;
-   |                      ~~~
 
 error[E0271]: type mismatch resolving `<isize as Foo>::A == Bar`
   --> $DIR/associated-types-eq-3.rs:38:10

tests/ui/impl-trait/equality2.stderr

@@ -43,7 +43,7 @@ LL |     let _: i32 = Leak::leak(hide(0_i32));
    |
    = note:         expected type `i32`
            found associated type `<impl Foo as Leak>::T`
-note: the function Leak is defined here
+note: the method Leak is defined here
   --> $DIR/equality2.rs:13:5
    |
 LL |     fn leak(self) -> Self::T;
@@ -52,10 +52,6 @@ help: consider constraining the associated type `<impl Foo as Leak>::T` to `i32`
    |
 LL | fn hide<T: Foo>(x: T) -> impl Foo<T = i32> {
    |                                  +++++++++
-help: consider changing Leak's return type
-   |
-LL |     fn leak(self) -> i32;
-   |                      ~~~
 
 error[E0308]: mismatched types
   --> $DIR/equality2.rs:38:10

tests/ui/impl-trait/in-trait/opaque-in-impl-is-opaque.stderr

@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/opaque-in-impl-is-opaque.rs:14:19
    |
-LL |     fn bar(&self) -> impl Display;
-   |                      ------------ help: consider changing bar's return type: `&str`
-...
 LL |     fn bar(&self) -> impl Display {
    |                      ------------ the found opaque type
 ...

tests/ui/issues/issue-22684.stderr

@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/issue-22684.rs:17:17
    |
-LL |         fn bar(&self) -> bool { true }
-   |                          ---- help: consider changing bar's return type: `()`
-...
 LL |     let _: () = foo::Foo.bar();
    |            --   ^^^^^^^^^^^^^^ expected `()`, found `bool`
    |            |

tests/ui/methods/method-ambig-one-trait-unknown-int-type.stderr

@@ -45,10 +45,6 @@ help: you can convert an `isize` to a `usize` and panic if the converted value d
    |
 LL |     let y: usize = x.foo().try_into().unwrap();
    |                           ++++++++++++++++++++
-help: consider changing foo's return type
-   |
-LL |     fn foo(&self) -> usize;
-   |                      ~~~~~
 
 error: aborting due to 3 previous errors
 

tests/ui/specialization/specialization-default-types.stderr

@@ -24,9 +24,6 @@ LL |         Box::new(self)
 error[E0308]: mismatched types
   --> $DIR/specialization-default-types.rs:25:5
    |
-LL |     fn generate(self) -> Self::Output;
-   |                          ------------ help: consider changing Example's return type: `Box<T>`
-...
 LL | fn trouble<T>(t: T) -> Box<T> {
    |                        ------ expected `Box<T>` because of return type
 LL |     Example::generate(t)
@@ -36,7 +33,7 @@ LL |     Example::generate(t)
            found associated type `<T as Example>::Output`
    = help: consider constraining the associated type `<T as Example>::Output` to `Box<T>`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
-note: the function Example is defined here
+note: the method Example is defined here
   --> $DIR/specialization-default-types.rs:9:5
    |
 LL |     fn generate(self) -> Self::Output;

tests/ui/suggestions/box-future-wrong-output.stderr

@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/box-future-wrong-output.rs:20:39
    |
-LL |     fn boxed<'a>(self) -> BoxFuture<'a, Self::Output>
-   |                           --------------------------- help: consider changing boxed's return type: `Pin<Box<(dyn Future<Output = bool> + Send + 'static)>>`
-...
 LL |     let _: BoxFuture<'static, bool> = async {}.boxed();
    |            ------------------------   ^^^^^^^^^^^^^^^^ expected `bool`, found `()`
    |            |

tests/ui/suggestions/trait-with-missing-associated-type-restriction-fixable.fixed

@@ -4,7 +4,7 @@
 trait Trait<T = Self> {
     type A;
 
-    fn func(&self) -> usize;
+    fn func(&self) -> Self::A;
 }
 
 struct S<T>(T);