Fix late-bound ICE

compiler/rustc_typeck/src/check/check.rs

@@ -208,8 +208,8 @@ pub(super) fn check_fn<'a, 'tcx>(
         // case that a newcomer might make, returning a bare trait, and in that case we populate
         // the tail expression's type so that the suggestion will be correct, but ignore all other
         // possible cases.
-        fcx.check_expr(&body.value);
         fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
+        fcx.check_expr(&body.value);
     } else {
         fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
         fcx.check_return_expr(&body.value, false);

src/test/ui/impl-trait/dyn-trait-return-should-be-impl-trait.stderr

@@ -102,18 +102,6 @@ LL |     }
 LL ~     Box::new(42)
    |
 
-error[E0308]: `if` and `else` have incompatible types
-  --> $DIR/dyn-trait-return-should-be-impl-trait.rs:29:9
-   |
-LL | /     if true {
-LL | |         Struct
-   | |         ------ expected because of this
-LL | |     } else {
-LL | |         42
-   | |         ^^ expected struct `Struct`, found integer
-LL | |     }
-   | |_____- `if` and `else` have incompatible types
-
 error[E0746]: return type cannot have an unboxed trait object
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:25:13
    |
@@ -133,6 +121,18 @@ LL |     } else {
 LL ~         Box::new(42)
    |
 
+error[E0308]: `if` and `else` have incompatible types
+  --> $DIR/dyn-trait-return-should-be-impl-trait.rs:29:9
+   |
+LL | /     if true {
+LL | |         Struct
+   | |         ------ expected because of this
+LL | |     } else {
+LL | |         42
+   | |         ^^ expected struct `Struct`, found integer
+LL | |     }
+   | |_____- `if` and `else` have incompatible types
+
 error[E0308]: mismatched types
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:34:16
    |

src/test/ui/impl-trait/point-to-type-err-cause-on-impl-trait-return.stderr

@@ -236,19 +236,37 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn hat() -> dyn std::fmt::Display {
    |             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-   = note: for information on trait objects, see <https://doc.rust-lang.org/book/ch17-02-trait-objects.html#using-trait-objects-that-allow-for-values-of-different-types>
-   = note: if all the returned values were of the same type you could use `impl std::fmt::Display` as the return type
-   = note: for information on `impl Trait`, see <https://doc.rust-lang.org/book/ch10-02-traits.html#returning-types-that-implement-traits>
-   = note: you can create a new `enum` with a variant for each returned type
-help: return a boxed trait object instead
+help: use some type `T` that is `T: Sized` as the return type if all return paths have the same type
    |
-LL ~ fn hat() -> Box<dyn std::fmt::Display> {
-LL |     match 13 {
-LL |         0 => {
-LL ~             return Box::new(0i32);
-LL |         }
-LL |         _ => {
- ...
+LL | fn hat() -> T {
+   |             ~
+help: use `impl std::fmt::Display` as the return type if all return paths have the same type but you want to expose only the trait in the signature
+   |
+LL | fn hat() -> impl std::fmt::Display {
+   |             ~~~~~~~~~~~~~~~~~~~~~~
+help: use a boxed trait object if all return paths implement trait `std::fmt::Display`
+   |
+LL | fn hat() -> Box<dyn std::fmt::Display> {
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0746]: return type cannot have an unboxed trait object
+  --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:77:13
+   |
+LL | fn pug() -> dyn std::fmt::Display {
+   |             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+help: use some type `T` that is `T: Sized` as the return type if all return paths have the same type
+   |
+LL | fn pug() -> T {
+   |             ~
+help: use `impl std::fmt::Display` as the return type if all return paths have the same type but you want to expose only the trait in the signature
+   |
+LL | fn pug() -> impl std::fmt::Display {
+   |             ~~~~~~~~~~~~~~~~~~~~~~
+help: use a boxed trait object if all return paths implement trait `std::fmt::Display`
+   |
+LL | fn pug() -> Box<dyn std::fmt::Display> {
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error[E0308]: `match` arms have incompatible types
   --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:80:14
@@ -262,25 +280,6 @@ LL | |         _ => 2u32,
 LL | |     }
    | |_____- `match` arms have incompatible types
 
-error[E0746]: return type cannot have an unboxed trait object
-  --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:77:13
-   |
-LL | fn pug() -> dyn std::fmt::Display {
-   |             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
-   |
-   = note: for information on trait objects, see <https://doc.rust-lang.org/book/ch17-02-trait-objects.html#using-trait-objects-that-allow-for-values-of-different-types>
-   = note: if all the returned values were of the same type you could use `impl std::fmt::Display` as the return type
-   = note: for information on `impl Trait`, see <https://doc.rust-lang.org/book/ch10-02-traits.html#returning-types-that-implement-traits>
-   = note: you can create a new `enum` with a variant for each returned type
-help: return a boxed trait object instead
-   |
-LL ~ fn pug() -> Box<dyn std::fmt::Display> {
-LL |     match 13 {
-LL ~         0 => Box::new(0i32),
-LL ~         1 => Box::new(1u32),
-LL ~         _ => Box::new(2u32),
-   |
-
 error[E0308]: `if` and `else` have incompatible types
   --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:89:9
    |

src/test/ui/unsized/expect_unsized_return_sized.rs

@@ -0,0 +1,8 @@
+// compile-flags: --crate-type lib
+trait Foo<'x> {}
+
+fn or<'a>(first: dyn Foo<'a>) -> dyn Foo<'a> {
+    //~^ ERROR: the size for values of type `(dyn Foo<'a> + 'static)` cannot be known at compilation time [E0277]
+    //~| ERROR: return type cannot have an unboxed trait object [E0746]
+    return Box::new(0);
+}

src/test/ui/unsized/expect_unsized_return_sized.stderr

@@ -0,0 +1,36 @@
+error[E0277]: the size for values of type `(dyn Foo<'a> + 'static)` cannot be known at compilation time
+  --> $DIR/expect_unsized_return_sized.rs:4:11
+   |
+LL | fn or<'a>(first: dyn Foo<'a>) -> dyn Foo<'a> {
+   |           ^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `(dyn Foo<'a> + 'static)`
+   = help: unsized fn params are gated as an unstable feature
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn or<'a>(first: &dyn Foo<'a>) -> dyn Foo<'a> {
+   |                  +
+
+error[E0746]: return type cannot have an unboxed trait object
+  --> $DIR/expect_unsized_return_sized.rs:4:34
+   |
+LL | fn or<'a>(first: dyn Foo<'a>) -> dyn Foo<'a> {
+   |                                  ^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+help: use some type `T` that is `T: Sized` as the return type if all return paths have the same type
+   |
+LL | fn or<'a>(first: dyn Foo<'a>) -> T {
+   |                                  ~
+help: use `impl Foo<'a>` as the return type if all return paths have the same type but you want to expose only the trait in the signature
+   |
+LL | fn or<'a>(first: dyn Foo<'a>) -> impl Foo<'a> {
+   |                                  ~~~~~~~~~~~~
+help: use a boxed trait object if all return paths implement trait `Foo<'a>`
+   |
+LL | fn or<'a>(first: dyn Foo<'a>) -> Box<dyn Foo<'a>> {
+   |                                  ~~~~~~~~~~~~~~~~
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0277, E0746.
+For more information about an error, try `rustc --explain E0277`.