Make error message less awkward

compiler-errors · compiler-errors · commit 0d907c17a825 · 2025-02-03T19:00:22.000Z
diff --git a/compiler/rustc_hir_typeck/src/check.rs b/compiler/rustc_hir_typeck/src/check.rs
@@ -117,17 +117,17 @@ pub(super) fn check_fn<'a, 'tcx>(
 
     fcx.typeck_results.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
 
-    let return_or_body_span = match decl.output {
-        hir::FnRetTy::DefaultReturn(_) => body.value.span,
-        hir::FnRetTy::Return(ty) => ty.span,
-    };
-
     // We checked the root's ret ty during wfcheck, but not the child.
     if fcx.tcx.is_typeck_child(fn_def_id.to_def_id()) {
+        let return_or_body_span = match decl.output {
+            hir::FnRetTy::DefaultReturn(_) => body.value.span,
+            hir::FnRetTy::Return(ty) => ty.span,
+        };
+
         fcx.require_type_is_sized(
             declared_ret_ty,
             return_or_body_span,
-            ObligationCauseCode::WellFormed(None),
+            ObligationCauseCode::SizedReturnType,
         );
     }
 
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1765,7 +1765,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         };
 
         err.code(E0746);
-        err.primary_message("return type cannot have an unboxed trait object");
+        err.primary_message("return type cannot be a trait object without pointer indirection");
         err.children.clear();
 
         let span = obligation.cause.span;
diff --git a/tests/ui/error-codes/E0746.stderr b/tests/ui/error-codes/E0746.stderr
@@ -1,4 +1,4 @@
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/E0746.rs:8:13
    |
 LL | fn foo() -> dyn Trait { Struct }
@@ -13,7 +13,7 @@ help: alternatively, box the return type, and wrap all of the returned values in
 LL | fn foo() -> Box<dyn Trait> { Box::new(Struct) }
    |             ++++         +   +++++++++      +
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/E0746.rs:11:13
    |
 LL | fn bar() -> dyn Trait {
diff --git a/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.rs b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.rs
@@ -20,7 +20,7 @@ impl DynIncompatible for B {
 }
 
 fn car() -> dyn DynIncompatible { //~ ERROR the trait `DynIncompatible` is not dyn compatible
-//~^ ERROR return type cannot have an unboxed trait object
+//~^ ERROR return type cannot be a trait object without pointer indirection
     if true {
         return A;
     }
diff --git a/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.stderr b/tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.stderr
@@ -26,7 +26,7 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
 LL |     fn foo() -> Self where Self: Sized;
    |                      +++++++++++++++++
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:13
    |
 LL | fn car() -> dyn DynIncompatible {
diff --git a/tests/ui/impl-trait/dyn-trait-return-should-be-impl-trait.stderr b/tests/ui/impl-trait/dyn-trait-return-should-be-impl-trait.stderr
@@ -18,7 +18,7 @@ LL | fn bar() -> (usize, dyn Trait) { (42, Struct) }
    = note: required because it appears within the type `(usize, (dyn Trait + 'static))`
    = note: the return type of a function must have a statically known size
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:15:13
    |
 LL | fn bap() -> Trait { Struct }
@@ -33,7 +33,7 @@ help: alternatively, box the return type, and wrap all of the returned values in
 LL | fn bap() -> Box<dyn Trait> { Box::new(Struct) }
    |             +++++++      +   +++++++++      +
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:17:13
    |
 LL | fn ban() -> dyn Trait { Struct }
@@ -48,7 +48,7 @@ help: alternatively, box the return type, and wrap all of the returned values in
 LL | fn ban() -> Box<dyn Trait> { Box::new(Struct) }
    |             ++++         +   +++++++++      +
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:19:13
    |
 LL | fn bak() -> dyn Trait { unimplemented!() }
@@ -63,7 +63,7 @@ help: alternatively, box the return type, and wrap all of the returned values in
 LL | fn bak() -> Box<dyn Trait> { Box::new(unimplemented!()) }
    |             ++++         +   +++++++++                +
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:21:13
    |
 LL | fn bal() -> dyn Trait {
@@ -82,7 +82,7 @@ LL |     }
 LL ~     Box::new(42)
    |
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:27:13
    |
 LL | fn bax() -> dyn Trait {
@@ -101,7 +101,7 @@ LL |     } else {
 LL ~         Box::new(42)
    |
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:62:13
    |
 LL | fn bat() -> dyn Trait {
@@ -120,7 +120,7 @@ LL |     }
 LL ~     Box::new(42)
    |
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:68:13
    |
 LL | fn bay() -> dyn Trait {
diff --git a/tests/ui/impl-trait/point-to-type-err-cause-on-impl-trait-return.rs b/tests/ui/impl-trait/point-to-type-err-cause-on-impl-trait-return.rs
@@ -63,7 +63,7 @@ fn dog() -> impl std::fmt::Display {
     }
 }
 
-fn hat() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed trait object
+fn hat() -> dyn std::fmt::Display { //~ ERROR return type cannot be a trait object without pointer indirection
     match 13 {
         0 => {
             return 0i32;
@@ -74,15 +74,15 @@ fn hat() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed
     }
 }
 
-fn pug() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed trait object
+fn pug() -> dyn std::fmt::Display { //~ ERROR return type cannot be a trait object without pointer indirection
     match 13 {
         0 => 0i32,
         1 => 1u32,
         _ => 2u32,
     }
 }
 
-fn man() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed trait object
+fn man() -> dyn std::fmt::Display { //~ ERROR return type cannot be a trait object without pointer indirection
     if false {
         0i32
     } else {
diff --git a/tests/ui/impl-trait/point-to-type-err-cause-on-impl-trait-return.stderr b/tests/ui/impl-trait/point-to-type-err-cause-on-impl-trait-return.stderr
@@ -1,4 +1,4 @@
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:66:13
    |
 LL | fn hat() -> dyn std::fmt::Display {
@@ -19,7 +19,7 @@ LL |         _ => {
 LL ~             Box::new(1u32)
    |
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:77:13
    |
 LL | fn pug() -> dyn std::fmt::Display {
@@ -38,7 +38,7 @@ LL ~         1 => Box::new(1u32),
 LL ~         _ => Box::new(2u32),
    |
 
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:85:13
    |
 LL | fn man() -> dyn std::fmt::Display {
diff --git a/tests/ui/issues/issue-18107.rs b/tests/ui/issues/issue-18107.rs
@@ -2,7 +2,7 @@ pub trait AbstractRenderer {}
 
 fn _create_render(_: &()) ->
     dyn AbstractRenderer
-//~^ ERROR return type cannot have an unboxed trait object
+//~^ ERROR return type cannot be a trait object without pointer indirection
 {
     match 0 {
         _ => unimplemented!()
diff --git a/tests/ui/issues/issue-18107.stderr b/tests/ui/issues/issue-18107.stderr
@@ -1,4 +1,4 @@
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/issue-18107.rs:4:5
    |
 LL |     dyn AbstractRenderer
diff --git a/tests/ui/unsized/box-instead-of-dyn-fn.rs b/tests/ui/unsized/box-instead-of-dyn-fn.rs
@@ -3,7 +3,7 @@ use std::fmt::Debug;
 // Test to suggest boxing the return type, and the closure branch of the `if`
 
 fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> dyn Fn() + 'a {
-    //~^ ERROR return type cannot have an unboxed trait object
+    //~^ ERROR return type cannot be a trait object without pointer indirection
     if a % 2 == 0 {
         move || println!("{a}")
     } else {
diff --git a/tests/ui/unsized/box-instead-of-dyn-fn.stderr b/tests/ui/unsized/box-instead-of-dyn-fn.stderr
@@ -1,4 +1,4 @@
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/box-instead-of-dyn-fn.rs:5:56
    |
 LL | fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> dyn Fn() + 'a {
diff --git a/tests/ui/unsized/issue-91801.rs b/tests/ui/unsized/issue-91801.rs
@@ -6,7 +6,7 @@ pub static ALL_VALIDATORS: &[(&'static str, &'static Validator)] =
     &[("validate that credits and debits balance", &validate_something)];
 
 fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Validator<'a> {
-    //~^ ERROR return type cannot have an unboxed trait object
+    //~^ ERROR return type cannot be a trait object without pointer indirection
     return Box::new(move |something: &'_ Something| -> Result<(), ()> {
         first(something).or_else(|_| second(something))
     });
diff --git a/tests/ui/unsized/issue-91801.stderr b/tests/ui/unsized/issue-91801.stderr
@@ -1,4 +1,4 @@
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/issue-91801.rs:8:77
    |
 LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Validator<'a> {
diff --git a/tests/ui/unsized/issue-91803.rs b/tests/ui/unsized/issue-91803.rs
@@ -1,7 +1,7 @@
 trait Foo<'a> {}
 
 fn or<'a>(first: &'static dyn Foo<'a>) -> dyn Foo<'a> {
-    //~^ ERROR return type cannot have an unboxed trait object
+    //~^ ERROR return type cannot be a trait object without pointer indirection
     return Box::new(panic!());
 }
 
diff --git a/tests/ui/unsized/issue-91803.stderr b/tests/ui/unsized/issue-91803.stderr
@@ -1,4 +1,4 @@
-error[E0746]: return type cannot have an unboxed trait object
+error[E0746]: return type cannot be a trait object without pointer indirection
   --> $DIR/issue-91803.rs:3:43
    |
 LL | fn or<'a>(first: &'static dyn Foo<'a>) -> dyn Foo<'a> {

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-error[E0746]: return type cannot have an unboxed trait object`
	`1`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`2`	`2`	`--> $DIR/E0746.rs:8:13`
`3`	`3`	`\|`
`4`	`4`	`LL \| fn foo() -> dyn Trait { Struct }`
`@@ -13,7 +13,7 @@ help: alternatively, box the return type, and wrap all of the returned values in`
`13`	`13`	`LL \| fn foo() -> Box<dyn Trait> { Box::new(Struct) }`
`14`	`14`	`\| ++++ + +++++++++ +`
`15`	`15`
`16`		`-error[E0746]: return type cannot have an unboxed trait object`
	`16`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`17`	`17`	`--> $DIR/E0746.rs:11:13`
`18`	`18`	`\|`
`19`	`19`	`LL \| fn bar() -> dyn Trait {`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ impl DynIncompatible for B {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	fn car() -> dyn DynIncompatible { //~ ERROR the trait `DynIncompatible` is not dyn compatible
`23`		`-//~^ ERROR return type cannot have an unboxed trait object`
	`23`	`+//~^ ERROR return type cannot be a trait object without pointer indirection`
`24`	`24`	`if true {`
`25`	`25`	`return A;`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
@@ -26,7 +26,7 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
`26`	`26`	`LL \| fn foo() -> Self where Self: Sized;`
`27`	`27`	`\| +++++++++++++++++`
`28`	`28`
`29`		`-error[E0746]: return type cannot have an unboxed trait object`
	`29`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`30`	`30`	`--> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:13`
`31`	`31`	`\|`
`32`	`32`	`LL \| fn car() -> dyn DynIncompatible {`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ LL \| fn bar() -> (usize, dyn Trait) { (42, Struct) }`
`18`	`18`	= note: required because it appears within the type `(usize, (dyn Trait + 'static))`
`19`	`19`	`= note: the return type of a function must have a statically known size`
`20`	`20`
`21`		`-error[E0746]: return type cannot have an unboxed trait object`
	`21`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`22`	`22`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:15:13`
`23`	`23`	`\|`
`24`	`24`	`LL \| fn bap() -> Trait { Struct }`
`@@ -33,7 +33,7 @@ help: alternatively, box the return type, and wrap all of the returned values in`
`33`	`33`	`LL \| fn bap() -> Box<dyn Trait> { Box::new(Struct) }`
`34`	`34`	`\| +++++++ + +++++++++ +`
`35`	`35`
`36`		`-error[E0746]: return type cannot have an unboxed trait object`
	`36`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`37`	`37`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:17:13`
`38`	`38`	`\|`
`39`	`39`	`LL \| fn ban() -> dyn Trait { Struct }`
`@@ -48,7 +48,7 @@ help: alternatively, box the return type, and wrap all of the returned values in`
`48`	`48`	`LL \| fn ban() -> Box<dyn Trait> { Box::new(Struct) }`
`49`	`49`	`\| ++++ + +++++++++ +`
`50`	`50`
`51`		`-error[E0746]: return type cannot have an unboxed trait object`
	`51`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`52`	`52`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:19:13`
`53`	`53`	`\|`
`54`	`54`	`LL \| fn bak() -> dyn Trait { unimplemented!() }`
`@@ -63,7 +63,7 @@ help: alternatively, box the return type, and wrap all of the returned values in`
`63`	`63`	`LL \| fn bak() -> Box<dyn Trait> { Box::new(unimplemented!()) }`
`64`	`64`	`\| ++++ + +++++++++ +`
`65`	`65`
`66`		`-error[E0746]: return type cannot have an unboxed trait object`
	`66`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`67`	`67`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:21:13`
`68`	`68`	`\|`
`69`	`69`	`LL \| fn bal() -> dyn Trait {`
`@@ -82,7 +82,7 @@ LL \| }`
`82`	`82`	`LL ~ Box::new(42)`
`83`	`83`	`\|`
`84`	`84`
`85`		`-error[E0746]: return type cannot have an unboxed trait object`
	`85`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`86`	`86`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:27:13`
`87`	`87`	`\|`
`88`	`88`	`LL \| fn bax() -> dyn Trait {`
`@@ -101,7 +101,7 @@ LL \| } else {`
`101`	`101`	`LL ~ Box::new(42)`
`102`	`102`	`\|`
`103`	`103`
`104`		`-error[E0746]: return type cannot have an unboxed trait object`
	`104`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`105`	`105`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:62:13`
`106`	`106`	`\|`
`107`	`107`	`LL \| fn bat() -> dyn Trait {`
`@@ -120,7 +120,7 @@ LL \| }`
`120`	`120`	`LL ~ Box::new(42)`
`121`	`121`	`\|`
`122`	`122`
`123`		`-error[E0746]: return type cannot have an unboxed trait object`
	`123`	`+error[E0746]: return type cannot be a trait object without pointer indirection`
`124`	`124`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:68:13`
`125`	`125`	`\|`
`126`	`126`	`LL \| fn bay() -> dyn Trait {`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ fn dog() -> impl std::fmt::Display {`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`-fn hat() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed trait object`
	`66`	`+fn hat() -> dyn std::fmt::Display { //~ ERROR return type cannot be a trait object without pointer indirection`
`67`	`67`	`match 13 {`
`68`	`68`	`0 => {`
`69`	`69`	`return 0i32;`
`@@ -74,15 +74,15 @@ fn hat() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`		`-fn pug() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed trait object`
	`77`	`+fn pug() -> dyn std::fmt::Display { //~ ERROR return type cannot be a trait object without pointer indirection`
`78`	`78`	`match 13 {`
`79`	`79`	`0 => 0i32,`
`80`	`80`	`1 => 1u32,`
`81`	`81`	`_ => 2u32,`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`-fn man() -> dyn std::fmt::Display { //~ ERROR return type cannot have an unboxed trait object`
	`85`	`+fn man() -> dyn std::fmt::Display { //~ ERROR return type cannot be a trait object without pointer indirection`
`86`	`86`	`if false {`
`87`	`87`	`0i32`
`88`	`88`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ pub trait AbstractRenderer {}`
`2`	`2`
`3`	`3`	`fn _create_render(_: &()) ->`
`4`	`4`	`dyn AbstractRenderer`
`5`		`-//~^ ERROR return type cannot have an unboxed trait object`
	`5`	`+//~^ ERROR return type cannot be a trait object without pointer indirection`
`6`	`6`	`{`
`7`	`7`	`match 0 {`
`8`	`8`	`_ => unimplemented!()`