Rollup merge of rust-lang#127987 - estebank:impl-trait-sugg, r=cjgillot

matthiaskrgr · web-flow · commit 89798e906428 · 2024-07-20T07:13:46.000+02:00
More accurate suggestion for `-&gt; Box&lt;dyn Trait&gt;` or `-&gt; impl Trait`

When encountering `-&gt; Trait`, suggest `-&gt; Box&lt;dyn Trait&gt;` (instead of `-&gt; Box&lt;Trait&gt;`.

If there's a single returned type within the `fn`, suggest `-&gt; impl Trait`.
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1793,25 +1793,42 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         err.children.clear();
 
         let span = obligation.cause.span;
-        if let Ok(snip) = self.tcx.sess.source_map().span_to_snippet(span)
+        let body = self.tcx.hir().body_owned_by(obligation.cause.body_id);
+
+        let mut visitor = ReturnsVisitor::default();
+        visitor.visit_body(&body);
+
+        let (pre, impl_span) = if let Ok(snip) = self.tcx.sess.source_map().span_to_snippet(span)
             && snip.starts_with("dyn ")
         {
-            err.span_suggestion(
-                span.with_hi(span.lo() + BytePos(4)),
-                "return an `impl Trait` instead of a `dyn Trait`, \
-                if all returned values are the same type",
+            ("", span.with_hi(span.lo() + BytePos(4)))
+        } else {
+            ("dyn ", span.shrink_to_lo())
+        };
+        let alternatively = if visitor
+            .returns
+            .iter()
+            .map(|expr| self.typeck_results.as_ref().unwrap().expr_ty_adjusted_opt(expr))
+            .collect::<FxHashSet<_>>()
+            .len()
+            <= 1
+        {
+            err.span_suggestion_verbose(
+                impl_span,
+                "consider returning an `impl Trait` instead of a `dyn Trait`",
                 "impl ",
                 Applicability::MaybeIncorrect,
             );
-        }
-
-        let body = self.tcx.hir().body_owned_by(obligation.cause.body_id);
-
-        let mut visitor = ReturnsVisitor::default();
-        visitor.visit_body(&body);
+            "alternatively, "
+        } else {
+            err.help("if there were a single returned type, you could use `impl Trait` instead");
+            ""
+        };
 
-        let mut sugg =
-            vec![(span.shrink_to_lo(), "Box<".to_string()), (span.shrink_to_hi(), ">".to_string())];
+        let mut sugg = vec![
+            (span.shrink_to_lo(), format!("Box<{pre}")),
+            (span.shrink_to_hi(), ">".to_string()),
+        ];
         sugg.extend(visitor.returns.into_iter().flat_map(|expr| {
             let span =
                 expr.span.find_ancestor_in_same_ctxt(obligation.cause.span).unwrap_or(expr.span);
@@ -1837,7 +1854,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         }));
 
         err.multipart_suggestion(
-            "box the return type, and wrap all of the returned values in `Box::new`",
+            format!(
+                "{alternatively}box the return type, and wrap all of the returned values in \
+                 `Box::new`",
+            ),
             sugg,
             Applicability::MaybeIncorrect,
         );
diff --git a/tests/ui/error-codes/E0746.stderr b/tests/ui/error-codes/E0746.stderr
@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn foo() -> dyn Trait { Struct }
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn foo() -> impl Trait { Struct }
    |             ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL | fn foo() -> Box<dyn Trait> { Box::new(Struct) }
    |             ++++         +   +++++++++      +
@@ -19,10 +19,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bar() -> dyn Trait {
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn bar() -> impl Trait {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn bar() -> Box<dyn Trait> {
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
@@ -48,22 +48,26 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bap() -> Trait { Struct }
    |             ^^^^^ doesn't have a size known at compile-time
    |
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: consider returning an `impl Trait` instead of a `dyn Trait`
+   |
+LL | fn bap() -> impl Trait { Struct }
+   |             ++++
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
-LL | fn bap() -> Box<Trait> { Box::new(Struct) }
-   |             ++++     +   +++++++++      +
+LL | fn bap() -> Box<dyn Trait> { Box::new(Struct) }
+   |             +++++++      +   +++++++++      +
 
 error[E0746]: return type cannot have an unboxed trait object
   --> $DIR/dyn-trait-return-should-be-impl-trait.rs:15:13
    |
 LL | fn ban() -> dyn Trait { Struct }
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn ban() -> impl Trait { Struct }
    |             ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL | fn ban() -> Box<dyn Trait> { Box::new(Struct) }
    |             ++++         +   +++++++++      +
@@ -74,11 +78,11 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bak() -> dyn Trait { unimplemented!() }
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn bak() -> impl Trait { unimplemented!() }
    |             ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL | fn bak() -> Box<dyn Trait> { Box::new(unimplemented!()) }
    |             ++++         +   +++++++++                +
@@ -89,10 +93,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bal() -> dyn Trait {
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn bal() -> impl Trait {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn bal() -> Box<dyn Trait> {
@@ -108,10 +109,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bax() -> dyn Trait {
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn bax() -> impl Trait {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn bax() -> Box<dyn Trait> {
@@ -263,10 +261,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bat() -> dyn Trait {
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn bat() -> impl Trait {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn bat() -> Box<dyn Trait> {
@@ -282,10 +277,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn bay() -> dyn Trait {
    |             ^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn bay() -> impl Trait {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn bay() -> Box<dyn Trait> {
diff --git a/tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.stderr b/tests/ui/impl-trait/object-unsafe-trait-in-return-position-dyn-trait.stderr
@@ -54,10 +54,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn car() -> dyn NotObjectSafe {
    |             ^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn car() -> impl NotObjectSafe {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn car() -> Box<dyn NotObjectSafe> {
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
@@ -171,11 +171,11 @@ 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
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn hat() -> impl std::fmt::Display {
    |             ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn hat() -> Box<dyn std::fmt::Display> {
 LL |     match 13 {
@@ -192,11 +192,11 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn pug() -> dyn std::fmt::Display {
    |             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn pug() -> impl std::fmt::Display {
    |             ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn pug() -> Box<dyn std::fmt::Display> {
 LL |     match 13 {
@@ -211,10 +211,7 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn man() -> dyn std::fmt::Display {
    |             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
-   |
-LL | fn man() -> impl std::fmt::Display {
-   |             ~~~~
+   = help: if there were a single returned type, you could use `impl Trait` instead
 help: box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn man() -> Box<dyn std::fmt::Display> {
diff --git a/tests/ui/issues/issue-18107.stderr b/tests/ui/issues/issue-18107.stderr
@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object
 LL |     dyn AbstractRenderer
    |     ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL |     impl AbstractRenderer
    |     ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~     Box<dyn AbstractRenderer>
 LL |
diff --git a/tests/ui/unsized/box-instead-of-dyn-fn.stderr b/tests/ui/unsized/box-instead-of-dyn-fn.stderr
@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> dyn Fn() + 'a {
    |                                                        ^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> impl Fn() + 'a {
    |                                                        ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL ~ fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> Box<dyn Fn() + 'a> {
 LL |
diff --git a/tests/ui/unsized/issue-91801.stderr b/tests/ui/unsized/issue-91801.stderr
@@ -4,10 +4,14 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Validator<'a> {
    |                                                                             ^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
-LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Box<Validator<'a>> {
-   |                                                                             ++++             +
+LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> impl Validator<'a> {
+   |                                                                             ++++
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
+   |
+LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Box<dyn Validator<'a>> {
+   |                                                                             +++++++              +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/unsized/issue-91803.stderr b/tests/ui/unsized/issue-91803.stderr
@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn or<'a>(first: &'static dyn Foo<'a>) -> dyn Foo<'a> {
    |                                           ^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
+help: consider returning an `impl Trait` instead of a `dyn Trait`
    |
 LL | fn or<'a>(first: &'static dyn Foo<'a>) -> impl Foo<'a> {
    |                                           ~~~~
-help: box the return type, and wrap all of the returned values in `Box::new`
+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
    |
 LL | fn or<'a>(first: &'static dyn Foo<'a>) -> Box<dyn Foo<'a>> {
    |                                           ++++           +

Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`4`	`4`	`LL \| fn foo() -> dyn Trait { Struct }`
`5`	`5`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`6`	`6`	`\|`
`7`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`7`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`8`	`8`	`\|`
`9`	`9`	`LL \| fn foo() -> impl Trait { Struct }`
`10`	`10`	`\| ~~~~`
`11`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`11`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`12`	`12`	`\|`
`13`	`13`	`LL \| fn foo() -> Box<dyn Trait> { Box::new(Struct) }`
`14`	`14`	`\| ++++ + +++++++++ +`
`@@ -19,10 +19,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`19`	`19`	`LL \| fn bar() -> dyn Trait {`
`20`	`20`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`21`	`21`	`\|`
`22`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`23`		`- \|`
`24`		`-LL \| fn bar() -> impl Trait {`
`25`		`- \| ~~~~`
	`22`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`26`	`23`	help: box the return type, and wrap all of the returned values in `Box::new`
`27`	`24`	`\|`
`28`	`25`	`LL ~ fn bar() -> Box<dyn Trait> {`
Original file line number	Diff line number	Diff line change
`@@ -48,22 +48,26 @@ error[E0746]: return type cannot have an unboxed trait object`
`48`	`48`	`LL \| fn bap() -> Trait { Struct }`
`49`	`49`	`\| ^^^^^ doesn't have a size known at compile-time`
`50`	`50`	`\|`
`51`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`51`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
	`52`	`+ \|`
	`53`	`+LL \| fn bap() -> impl Trait { Struct }`
	`54`	`+ \| ++++`
	`55`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`52`	`56`	`\|`
`53`		`-LL \| fn bap() -> Box<Trait> { Box::new(Struct) }`
`54`		`- \| ++++ + +++++++++ +`
	`57`	`+LL \| fn bap() -> Box<dyn Trait> { Box::new(Struct) }`
	`58`	`+ \| +++++++ + +++++++++ +`
`55`	`59`
`56`	`60`	`error[E0746]: return type cannot have an unboxed trait object`
`57`	`61`	`--> $DIR/dyn-trait-return-should-be-impl-trait.rs:15:13`
`58`	`62`	`\|`
`59`	`63`	`LL \| fn ban() -> dyn Trait { Struct }`
`60`	`64`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`61`	`65`	`\|`
`62`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`66`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`63`	`67`	`\|`
`64`	`68`	`LL \| fn ban() -> impl Trait { Struct }`
`65`	`69`	`\| ~~~~`
`66`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`70`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`67`	`71`	`\|`
`68`	`72`	`LL \| fn ban() -> Box<dyn Trait> { Box::new(Struct) }`
`69`	`73`	`\| ++++ + +++++++++ +`
`@@ -74,11 +78,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`74`	`78`	`LL \| fn bak() -> dyn Trait { unimplemented!() }`
`75`	`79`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`76`	`80`	`\|`
`77`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`81`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`78`	`82`	`\|`
`79`	`83`	`LL \| fn bak() -> impl Trait { unimplemented!() }`
`80`	`84`	`\| ~~~~`
`81`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`85`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`82`	`86`	`\|`
`83`	`87`	`LL \| fn bak() -> Box<dyn Trait> { Box::new(unimplemented!()) }`
`84`	`88`	`\| ++++ + +++++++++ +`
`@@ -89,10 +93,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`89`	`93`	`LL \| fn bal() -> dyn Trait {`
`90`	`94`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`91`	`95`	`\|`
`92`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`93`		`- \|`
`94`		`-LL \| fn bal() -> impl Trait {`
`95`		`- \| ~~~~`
	`96`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`96`	`97`	help: box the return type, and wrap all of the returned values in `Box::new`
`97`	`98`	`\|`
`98`	`99`	`LL ~ fn bal() -> Box<dyn Trait> {`
`@@ -108,10 +109,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`108`	`109`	`LL \| fn bax() -> dyn Trait {`
`109`	`110`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`110`	`111`	`\|`
`111`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`112`		`- \|`
`113`		`-LL \| fn bax() -> impl Trait {`
`114`		`- \| ~~~~`
	`112`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`115`	`113`	help: box the return type, and wrap all of the returned values in `Box::new`
`116`	`114`	`\|`
`117`	`115`	`LL ~ fn bax() -> Box<dyn Trait> {`
`@@ -263,10 +261,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`263`	`261`	`LL \| fn bat() -> dyn Trait {`
`264`	`262`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`265`	`263`	`\|`
`266`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`267`		`- \|`
`268`		`-LL \| fn bat() -> impl Trait {`
`269`		`- \| ~~~~`
	`264`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`270`	`265`	help: box the return type, and wrap all of the returned values in `Box::new`
`271`	`266`	`\|`
`272`	`267`	`LL ~ fn bat() -> Box<dyn Trait> {`
`@@ -282,10 +277,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`282`	`277`	`LL \| fn bay() -> dyn Trait {`
`283`	`278`	`\| ^^^^^^^^^ doesn't have a size known at compile-time`
`284`	`279`	`\|`
`285`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`286`		`- \|`
`287`		`-LL \| fn bay() -> impl Trait {`
`288`		`- \| ~~~~`
	`280`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`289`	`281`	help: box the return type, and wrap all of the returned values in `Box::new`
`290`	`282`	`\|`
`291`	`283`	`LL ~ fn bay() -> Box<dyn Trait> {`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`54`	`54`	`LL \| fn car() -> dyn NotObjectSafe {`
`55`	`55`	`\| ^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time`
`56`	`56`	`\|`
`57`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`58`		`- \|`
`59`		`-LL \| fn car() -> impl NotObjectSafe {`
`60`		`- \| ~~~~`
	`57`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`61`	`58`	help: box the return type, and wrap all of the returned values in `Box::new`
`62`	`59`	`\|`
`63`	`60`	`LL ~ fn car() -> Box<dyn NotObjectSafe> {`
Original file line number	Diff line number	Diff line change
`@@ -171,11 +171,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`171`	`171`	`LL \| fn hat() -> dyn std::fmt::Display {`
`172`	`172`	`\| ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time`
`173`	`173`	`\|`
`174`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`174`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`175`	`175`	`\|`
`176`	`176`	`LL \| fn hat() -> impl std::fmt::Display {`
`177`	`177`	`\| ~~~~`
`178`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`178`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`179`	`179`	`\|`
`180`	`180`	`LL ~ fn hat() -> Box<dyn std::fmt::Display> {`
`181`	`181`	`LL \| match 13 {`
`@@ -192,11 +192,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`192`	`192`	`LL \| fn pug() -> dyn std::fmt::Display {`
`193`	`193`	`\| ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time`
`194`	`194`	`\|`
`195`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`195`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`196`	`196`	`\|`
`197`	`197`	`LL \| fn pug() -> impl std::fmt::Display {`
`198`	`198`	`\| ~~~~`
`199`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`199`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`200`	`200`	`\|`
`201`	`201`	`LL ~ fn pug() -> Box<dyn std::fmt::Display> {`
`202`	`202`	`LL \| match 13 {`
`@@ -211,10 +211,7 @@ error[E0746]: return type cannot have an unboxed trait object`
`211`	`211`	`LL \| fn man() -> dyn std::fmt::Display {`
`212`	`212`	`\| ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time`
`213`	`213`	`\|`
`214`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
`215`		`- \|`
`216`		`-LL \| fn man() -> impl std::fmt::Display {`
`217`		`- \| ~~~~`
	`214`	+ = help: if there were a single returned type, you could use `impl Trait` instead
`218`	`215`	help: box the return type, and wrap all of the returned values in `Box::new`
`219`	`216`	`\|`
`220`	`217`	`LL ~ fn man() -> Box<dyn std::fmt::Display> {`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`4`	`4`	`LL \| dyn AbstractRenderer`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time`
`6`	`6`	`\|`
`7`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`7`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`8`	`8`	`\|`
`9`	`9`	`LL \| impl AbstractRenderer`
`10`	`10`	`\| ~~~~`
`11`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`11`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`12`	`12`	`\|`
`13`	`13`	`LL ~ Box<dyn AbstractRenderer>`
`14`	`14`	`LL \|`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`4`	`4`	`LL \| fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> dyn Fn() + 'a {`
`5`	`5`	`\| ^^^^^^^^^^^^^ doesn't have a size known at compile-time`
`6`	`6`	`\|`
`7`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`7`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`8`	`8`	`\|`
`9`	`9`	`LL \| fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> impl Fn() + 'a {`
`10`	`10`	`\| ~~~~`
`11`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`11`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`12`	`12`	`\|`
`13`	`13`	`LL ~ fn print_on_or_the_other<'a>(a: i32, b: &'a String) -> Box<dyn Fn() + 'a> {`
`14`	`14`	`LL \|`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ error[E0746]: return type cannot have an unboxed trait object`
`4`	`4`	`LL \| fn or<'a>(first: &'static dyn Foo<'a>) -> dyn Foo<'a> {`
`5`	`5`	`\| ^^^^^^^^^^^ doesn't have a size known at compile-time`
`6`	`6`	`\|`
`7`		-help: return an `impl Trait` instead of a `dyn Trait`, if all returned values are the same type
	`7`	+help: consider returning an `impl Trait` instead of a `dyn Trait`
`8`	`8`	`\|`
`9`	`9`	`LL \| fn or<'a>(first: &'static dyn Foo<'a>) -> impl Foo<'a> {`
`10`	`10`	`\| ~~~~`
`11`		-help: box the return type, and wrap all of the returned values in `Box::new`
	`11`	+help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
`12`	`12`	`\|`
`13`	`13`	`LL \| fn or<'a>(first: &'static dyn Foo<'a>) -> Box<dyn Foo<'a>> {`
`14`	`14`	`\| ++++ +`