Account for -> ?Sized fn calls when deduplicating unsized local errors

Author: estebank

compiler/rustc_hir_typeck/src/expr.rs

@@ -596,7 +596,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.require_type_is_sized_deferred(
                 output,
                 call.map_or(expr.span, |e| e.span),
-                traits::SizedCallReturnType,
+                traits::SizedCallReturnType(call.map(|e| e.hir_id)),
             );
         }
 

compiler/rustc_middle/src/traits/mod.rs

@@ -293,7 +293,7 @@ pub enum ObligationCauseCode<'tcx> {
     /// Return type must be `Sized`.
     SizedReturnType,
     /// Return type of a call expression must be `Sized`.
-    SizedCallReturnType,
+    SizedCallReturnType(Option<hir::HirId>),
     /// Yield type must be `Sized`.
     SizedYieldType,
     /// Inline asm operand type must be `Sized`.

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -3257,7 +3257,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     err.help("unsized fn params are gated as an unstable feature");
                 }
             }
-            ObligationCauseCode::SizedReturnType | ObligationCauseCode::SizedCallReturnType => {
+            ObligationCauseCode::SizedReturnType | ObligationCauseCode::SizedCallReturnType(_) => {
                 err.note("the return type of a function must have a statically known size");
             }
             ObligationCauseCode::SizedYieldType => {

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -131,6 +131,14 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                             span = pat.span;
                         }
                     }
+                    ObligationCauseCode::SizedCallReturnType(Some(hir_id)) => {
+                        // This is a special case: when `fn foo() -> dyn Trait` and we call `foo()`
+                        // in the init of a `let` binding, we will already emit an unsized local
+                        // error, so we check for this case and unify the errors.
+                        if let hir::Node::Local(local) = self.tcx.parent_hir_node(*hir_id) {
+                            span = local.pat.span;
+                        }
+                    }
                     _ => {}
                 }
             }

tests/ui/sized/unsized-return.rs

@@ -6,6 +6,5 @@ fn foo() -> dyn T { //~ E0746
 
 fn main() {
     let x = foo(); //~ ERROR E0277
-    //~^ ERROR E0277
     let x: dyn T = foo(); //~ ERROR E0277
 }

tests/ui/sized/unsized-return.stderr

@@ -16,7 +16,7 @@ LL ~    Box::new(todo!())
    |
 
 error[E0277]: the size for values of type `dyn T` cannot be known at compilation time
-  --> $DIR/unsized-return.rs:10:12
+  --> $DIR/unsized-return.rs:9:12
    |
 LL |     let x: dyn T = foo();
    |            ^^^^^ doesn't have a size known at compile-time
@@ -39,16 +39,7 @@ LL |     let x = foo();
    = note: all local variables must have a statically known size
    = help: unsized locals are gated as an unstable feature
 
-error[E0277]: the size for values of type `(dyn T + 'static)` cannot be known at compilation time
-  --> $DIR/unsized-return.rs:8:13
-   |
-LL |     let x = foo();
-   |             ^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn T + 'static)`
-   = note: the return type of a function must have a statically known size
-
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0277, E0746.
 For more information about an error, try `rustc --explain E0277`.