Point to where missing return type should go

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -1189,7 +1189,7 @@ fn report_trait_method_mismatch<'tcx>(
                     let ap = Applicability::MachineApplicable;
                     match sig.decl.output {
                         hir::FnRetTy::DefaultReturn(sp) => {
-                            let sugg = format!("-> {} ", trait_sig.output());
+                            let sugg = format!(" -> {}", trait_sig.output());
                             diag.span_suggestion_verbose(sp, msg, sugg, ap);
                         }
                         hir::FnRetTy::Return(hir_ty) => {

compiler/rustc_hir_typeck/src/errors.rs

@@ -110,7 +110,7 @@ pub struct AddressOfTemporaryTaken {
 pub enum AddReturnTypeSuggestion {
     #[suggestion(
         hir_typeck_add_return_type_add,
-        code = "-> {found} ",
+        code = " -> {found}",
         applicability = "machine-applicable"
     )]
     Add {
@@ -120,7 +120,7 @@ pub enum AddReturnTypeSuggestion {
     },
     #[suggestion(
         hir_typeck_add_return_type_missing_here,
-        code = "-> _ ",
+        code = " -> _",
         applicability = "has-placeholders"
     )]
     MissingHere {

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -782,8 +782,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
             hir::FnRetTy::Return(hir_ty) => {
-                let span = hir_ty.span;
-
                 if let hir::TyKind::OpaqueDef(item_id, ..) = hir_ty.kind
                     && let hir::Node::Item(hir::Item {
                         kind: hir::ItemKind::OpaqueTy(op_ty),
@@ -799,14 +797,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     debug!(?found);
                     if found.is_suggestable(self.tcx, false) {
                         if term.span.is_empty() {
-                            err.subdiagnostic(errors::AddReturnTypeSuggestion::Add { span, found: found.to_string() });
+                            err.subdiagnostic(errors::AddReturnTypeSuggestion::Add { span: term.span, found: found.to_string() });
                             return true;
                         } else {
-                            err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other { span, expected });
+                            err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other { span: term.span, expected });
                         }
                     }
-                }
+                } else {
-
                     // Only point to return type if the expected type is the return type, as if they
                     // are not, the expectation must have been caused by something else.
                     debug!("return type {:?}", hir_ty);
@@ -815,14 +812,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     debug!("expected type {:?}", expected);
                     let bound_vars = self.tcx.late_bound_vars(hir_ty.hir_id.owner.into());
                     let ty = Binder::bind_with_vars(ty, bound_vars);
-                let ty = self.normalize(span, ty);
+                    let ty = self.normalize(hir_ty.span, ty);
                     let ty = self.tcx.erase_late_bound_regions(ty);
                     if self.can_coerce(expected, ty) {
-                    err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other { span, expected });
+                        err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other { span: hir_ty.span, expected });
                         self.try_suggest_return_impl_trait(err, expected, ty, fn_id);
                         return true;
                     }
                 }
+            }
             _ => {}
         }
         false

compiler/rustc_infer/src/errors/mod.rs

@@ -194,13 +194,13 @@ impl<'a> SourceKindMultiSuggestion<'a> {
         data: &'a FnRetTy<'a>,
         should_wrap_expr: Option<Span>,
     ) -> Self {
-        let (arrow, post) = match data {
+        let arrow = match data {
-            FnRetTy::DefaultReturn(_) => ("-> ", " "),
+            FnRetTy::DefaultReturn(_) => " -> ",
-            _ => ("", ""),
+            _ => "",
         };
         let (start_span, start_span_code, end_span) = match should_wrap_expr {
-            Some(end_span) => (data.span(), format!("{arrow}{ty_info}{post}{{ "), Some(end_span)),
+            Some(end_span) => (data.span(), format!("{arrow}{ty_info} {{"), Some(end_span)),
-            None => (data.span(), format!("{arrow}{ty_info}{post}"), None),
+            None => (data.span(), format!("{arrow}{ty_info}"), None),
         };
         Self::ClosureReturn { start_span, start_span_code, end_span }
     }

compiler/rustc_parse/src/parser/ty.rs

@@ -247,7 +247,7 @@ impl<'a> Parser<'a> {
             )?;
             FnRetTy::Ty(ty)
         } else {
-            FnRetTy::Default(self.token.span.shrink_to_lo())
+            FnRetTy::Default(self.prev_token.span.shrink_to_hi())
         })
     }
 

tests/ui/closures/binder/implicit-return.stderr

@@ -1,5 +1,5 @@
 error: implicit types in closure signatures are forbidden when `for<...>` is present
-  --> $DIR/implicit-return.rs:4:34
+  --> $DIR/implicit-return.rs:4:33
    |
 LL |     let _f = for<'a> |_: &'a ()| {};
    |              -------            ^

tests/ui/closures/binder/implicit-stuff.stderr

@@ -41,7 +41,7 @@ LL |     let _ = for<'a> |x: &'a ()| -> &() { x };
    |                                    ^ explicit lifetime name needed here
 
 error: implicit types in closure signatures are forbidden when `for<...>` is present
-  --> $DIR/implicit-stuff.rs:5:22
+  --> $DIR/implicit-stuff.rs:5:21
    |
 LL |     let _ = for<> || {};
    |             -----   ^

tests/ui/compare-method/bad-self-type.stderr

@@ -28,7 +28,7 @@ LL |     fn foo(self);
               found signature `fn(Box<MyFuture>)`
 
 error[E0053]: method `bar` has an incompatible type for trait
-  --> $DIR/bad-self-type.rs:24:18
+  --> $DIR/bad-self-type.rs:24:17
    |
 LL |     fn bar(self) {}
    |                 ^ expected `Option<()>`, found `()`

tests/ui/impl-trait/in-trait/refine.stderr

@@ -30,7 +30,7 @@ LL |     fn bar() {}
    = note: add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
 help: replace the return type so that it matches the trait
    |
-LL |     fn bar() -> impl Sized {}
+LL |     fn bar()-> impl Sized  {}
    |             +++++++++++++
 
 error: impl trait in impl method signature does not match trait method signature

tests/ui/lang-items/start_lang_item_args.missing_ret.stderr

@@ -1,5 +1,5 @@
 error[E0308]: lang item `start` function has wrong type
-  --> $DIR/start_lang_item_args.rs:29:84
+  --> $DIR/start_lang_item_args.rs:29:83
    |
 LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8, _sigpipe: u8) {}
    |                                                                                   ^ expected `isize`, found `()`

tests/ui/parser/recover-quantified-closure.stderr

@@ -25,7 +25,7 @@ LL |     for <Foo>::Bar in x {}
    = help: consider removing `for<...>`
 
 error: implicit types in closure signatures are forbidden when `for<...>` is present
-  --> $DIR/recover-quantified-closure.rs:2:25
+  --> $DIR/recover-quantified-closure.rs:2:24
    |
 LL |     for<'a> |x: &'a u8| *x + 1;
    |     -------            ^

tests/ui/suggestions/suggest-ret-on-async-w-late.fixed

@@ -0,0 +1,14 @@
+// edition: 2021
+// run-rustfix
+
+#![allow(unused)]
+
+// Make sure we don't ICE when suggesting a return type
+// for an async fn that has late-bound vars...
+
+async fn ice(_: &i32) -> bool {
+    true
+    //~^ ERROR mismatched types
+}
+
+fn main() {}

tests/ui/suggestions/suggest-ret-on-async-w-late.rs

@@ -1,4 +1,7 @@
 // edition: 2021
+// run-rustfix
+
+#![allow(unused)]
 
 // Make sure we don't ICE when suggesting a return type
 // for an async fn that has late-bound vars...

tests/ui/suggestions/suggest-ret-on-async-w-late.stderr

@@ -1,8 +1,8 @@
 error[E0308]: mismatched types
-  --> $DIR/suggest-ret-on-async-w-late.rs:7:5
+  --> $DIR/suggest-ret-on-async-w-late.rs:10:5
    |
 LL | async fn ice(_: &i32) {
-   | --------------------- help: try adding a return type: `-> bool`
+   |                      - help: try adding a return type: `-> bool`
 LL |     true
    |     ^^^^ expected `()`, found `bool`
 

tests/ui/typeck/issue-90027-async-fn-return-suggestion.stderr

@@ -2,7 +2,7 @@ error[E0308]: mismatched types
   --> $DIR/issue-90027-async-fn-return-suggestion.rs:4:5
    |
 LL | async fn hello() {
-   | ---------------- help: try adding a return type: `-> i32`
+   |                 - help: try adding a return type: `-> i32`
 LL |     0
    |     ^ expected `()`, found integer
 
@@ -10,7 +10,7 @@ error[E0308]: mismatched types
   --> $DIR/issue-90027-async-fn-return-suggestion.rs:9:5
    |
 LL | async fn world() -> () {
-   | ---------------------- expected `()` because of return type
+   |                     -- expected `()` because of return type
 LL |     0
    |     ^ expected `()`, found integer