Silence "missing dyn" error if "!Sized type" error is already emitted

estebank · estebank · commit f60ded9135c8 · 2024-03-23T17:56:48.000Z
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
@@ -132,8 +132,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     ],
                     Applicability::MachineApplicable,
                 );
-            } else if is_downgradable {
-                // We'll emit the object safety error already, with a structured suggestion.
+            }
+            if is_downgradable
+                && (matches!(self_ty.kind, hir::TyKind::TraitObject(_, _, TraitObjectSyntax::None))
+                    || !is_object_safe)
+            {
+                // We'll emit the object safety or `!Sized` error already, with a structured
+                // suggestion.
                 diag.downgrade_to_delayed_bug();
             }
             return true;
@@ -163,6 +168,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     diag.downgrade_to_delayed_bug();
                 }
             } else {
+                if let hir::TyKind::TraitObject(.., TraitObjectSyntax::None) = self_ty.kind
+                    && is_downgradable
+                {
+                    // We'll emit a `Sized` error already, with a structured suggestion.
+                    diag.downgrade_to_delayed_bug();
+                }
                 let sugg = if let hir::TyKind::TraitObject([_, _, ..], _, _) = self_ty.kind {
                     // There are more than one trait bound, we need surrounding parentheses.
                     vec![
diff --git a/tests/ui/traits/bound/not-on-bare-trait-2021.rs b/tests/ui/traits/bound/not-on-bare-trait-2021.rs
@@ -6,14 +6,25 @@ trait Foo {
 // This should emit the less confusing error, not the more confusing one.
 
 fn foo(_x: Foo + Send) {
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR size for values of type
+    //~^ ERROR size for values of type
 }
 fn bar(x: Foo) -> Foo {
+    //~^ ERROR size for values of type
+    x
+}
+fn bat(x: &Foo) -> Foo {
+    //~^ ERROR return type cannot have an unboxed trait object
+    //~| ERROR trait objects must include the `dyn` keyword
+    x
+}
+fn bae(x: &Foo) -> &Foo {
     //~^ ERROR trait objects must include the `dyn` keyword
     //~| ERROR trait objects must include the `dyn` keyword
-    //~| ERROR size for values of type
     x
 }
+fn qux() -> Foo {
+    //~^ ERROR return type cannot have an unboxed trait object
+    todo!()
+}
 
 fn main() {}
diff --git a/tests/ui/traits/bound/not-on-bare-trait-2021.stderr b/tests/ui/traits/bound/not-on-bare-trait-2021.stderr
@@ -16,7 +16,7 @@ LL | fn foo(_x: &(dyn Foo + Send)) {
    |            +++++           +
 
 error[E0277]: the size for values of type `(dyn Foo + 'static)` cannot be known at compilation time
-  --> $DIR/not-on-bare-trait-2021.rs:12:11
+  --> $DIR/not-on-bare-trait-2021.rs:11:11
    |
 LL | fn bar(x: Foo) -> Foo {
    |           ^^^ doesn't have a size known at compile-time
@@ -32,60 +32,79 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn bar(x: &dyn Foo) -> Foo {
    |           ++++
 
-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not-on-bare-trait-2021.rs:8:12
+error[E0746]: return type cannot have an unboxed trait object
+  --> $DIR/not-on-bare-trait-2021.rs:15:20
    |
-LL | fn foo(_x: Foo + Send) {
-   |            ^^^^^^^^^^
+LL | fn bat(x: &Foo) -> Foo {
+   |                    ^^^ doesn't have a size known at compile-time
    |
-help: use a new generic type parameter, constrained by `Foo + Send`
+help: return an `impl Trait` instead of a `dyn Trait`
    |
-LL | fn foo<T: Foo + Send>(_x: T) {
-   |       +++++++++++++++     ~
-help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+LL | fn bat(x: &Foo) -> impl Foo {
+   |                    ++++
+help: alternatively, box the return type to make a boxed trait object, and wrap all of the returned values in `Box::new`
    |
-LL | fn foo(_x: impl Foo + Send) {
-   |            ++++
-help: alternatively, use a trait object to accept any type that implements `Foo + Send`, accessing its methods at runtime using dynamic dispatch
+LL ~ fn bat(x: &Foo) -> Box<dyn Foo> {
+LL |
+LL |
+LL ~     Box::new(x)
    |
-LL | fn foo(_x: &(dyn Foo + Send)) {
-   |            +++++           +
+help: finally, you might be able to borrow from the function's argument
+   |
+LL | fn bat(x: &Foo) -> &dyn Foo {
+   |                    ++++
 
-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not-on-bare-trait-2021.rs:12:11
+error[E0746]: return type cannot have an unboxed trait object
+  --> $DIR/not-on-bare-trait-2021.rs:25:13
    |
-LL | fn bar(x: Foo) -> Foo {
-   |           ^^^
+LL | fn qux() -> Foo {
+   |             ^^^ doesn't have a size known at compile-time
    |
-help: use a new generic type parameter, constrained by `Foo`
+help: return an `impl Trait` instead of a `dyn Trait`
    |
-LL | fn bar<T: Foo>(x: T) -> Foo {
-   |       ++++++++    ~
-help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+LL | fn qux() -> impl Foo {
+   |             ++++
+help: alternatively, box the return type to make a boxed trait object, and wrap all of the returned values in `Box::new`
    |
-LL | fn bar(x: impl Foo) -> Foo {
-   |           ++++
-help: alternatively, use a trait object to accept any type that implements `Foo`, accessing its methods at runtime using dynamic dispatch
+LL ~ fn qux() -> Box<dyn Foo> {
+LL |
+LL ~     Box::new(todo!())
    |
-LL | fn bar(x: &dyn Foo) -> Foo {
-   |           ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not-on-bare-trait-2021.rs:12:19
+  --> $DIR/not-on-bare-trait-2021.rs:15:12
    |
-LL | fn bar(x: Foo) -> Foo {
-   |                   ^^^
+LL | fn bat(x: &Foo) -> Foo {
+   |            ^^^
+   |
+help: add `dyn` keyword before this trait
+   |
+LL | fn bat(x: &dyn Foo) -> Foo {
+   |            +++
+
+error[E0782]: trait objects must include the `dyn` keyword
+  --> $DIR/not-on-bare-trait-2021.rs:20:12
+   |
+LL | fn bae(x: &Foo) -> &Foo {
+   |            ^^^
+   |
+help: add `dyn` keyword before this trait
+   |
+LL | fn bae(x: &dyn Foo) -> &Foo {
+   |            +++
+
+error[E0782]: trait objects must include the `dyn` keyword
+  --> $DIR/not-on-bare-trait-2021.rs:20:21
    |
-help: use `impl Foo` to return an opaque type, as long as you return a single underlying type
+LL | fn bae(x: &Foo) -> &Foo {
+   |                     ^^^
    |
-LL | fn bar(x: Foo) -> impl Foo {
-   |                   ++++
-help: alternatively, you can return a boxed trait object
+help: add `dyn` keyword before this trait
    |
-LL | fn bar(x: Foo) -> Box<dyn Foo> {
-   |                   +++++++    +
+LL | fn bae(x: &Foo) -> &dyn Foo {
+   |                     +++
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-Some errors have detailed explanations: E0277, E0782.
+Some errors have detailed explanations: E0277, E0746, E0782.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/bound/not-on-bare-trait.rs b/tests/ui/traits/bound/not-on-bare-trait.rs
@@ -12,5 +12,28 @@ fn foo(_x: Foo + Send) {
 fn bar(_x: (dyn Foo + Send)) {
     //~^ ERROR the size for values of type
 }
+fn bat(x: &Foo) -> Foo {
+    //~^ ERROR return type cannot have an unboxed trait object
+    //~| WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN this is accepted in the current edition
+    //~| WARN this is accepted in the current edition
+    //~| WARN this is accepted in the current edition
+    x
+}
+fn bae(x: &Foo) -> &Foo {
+    //~^ WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN this is accepted in the current edition
+    //~| WARN this is accepted in the current edition
+    x
+}
+fn qux() -> Foo {
+    //~^ ERROR return type cannot have an unboxed trait object
+    //~| WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN this is accepted in the current edition
+    todo!()
+}
 
 fn main() {}
diff --git a/tests/ui/traits/bound/not-on-bare-trait.stderr b/tests/ui/traits/bound/not-on-bare-trait.stderr
@@ -12,6 +12,71 @@ help: if this is an object-safe trait, use `dyn`
 LL | fn foo(_x: dyn Foo + Send) {
    |            +++
 
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/not-on-bare-trait.rs:15:12
+   |
+LL | fn bat(x: &Foo) -> Foo {
+   |            ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is an object-safe trait, use `dyn`
+   |
+LL | fn bat(x: &dyn Foo) -> Foo {
+   |            +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/not-on-bare-trait.rs:15:20
+   |
+LL | fn bat(x: &Foo) -> Foo {
+   |                    ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is an object-safe trait, use `dyn`
+   |
+LL | fn bat(x: &Foo) -> dyn Foo {
+   |                    +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/not-on-bare-trait.rs:25:12
+   |
+LL | fn bae(x: &Foo) -> &Foo {
+   |            ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is an object-safe trait, use `dyn`
+   |
+LL | fn bae(x: &dyn Foo) -> &Foo {
+   |            +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/not-on-bare-trait.rs:25:21
+   |
+LL | fn bae(x: &Foo) -> &Foo {
+   |                     ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is an object-safe trait, use `dyn`
+   |
+LL | fn bae(x: &Foo) -> &dyn Foo {
+   |                     +++
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/not-on-bare-trait.rs:32:13
+   |
+LL | fn qux() -> Foo {
+   |             ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is an object-safe trait, use `dyn`
+   |
+LL | fn qux() -> dyn Foo {
+   |             +++
+
 error[E0277]: the size for values of type `(dyn Foo + Send + 'static)` cannot be known at compilation time
   --> $DIR/not-on-bare-trait.rs:7:12
    |
@@ -46,6 +111,63 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn bar(_x: (&(dyn Foo + Send))) {
    |             ++              +
 
-error: aborting due to 2 previous errors; 1 warning emitted
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/not-on-bare-trait.rs:15:20
+   |
+LL | fn bat(x: &Foo) -> Foo {
+   |                    ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: if this is an object-safe trait, use `dyn`
+   |
+LL | fn bat(x: &Foo) -> dyn Foo {
+   |                    +++
+
+error[E0746]: return type cannot have an unboxed trait object
+  --> $DIR/not-on-bare-trait.rs:15:20
+   |
+LL | fn bat(x: &Foo) -> Foo {
+   |                    ^^^ doesn't have a size known at compile-time
+   |
+help: return an `impl Trait` instead of a `dyn Trait`
+   |
+LL | fn bat(x: &Foo) -> impl Foo {
+   |                    ++++
+help: alternatively, box the return type to make a boxed trait object, and wrap all of the returned values in `Box::new`
+   |
+LL ~ fn bat(x: &Foo) -> Box<dyn Foo> {
+LL |
+ ...
+LL |
+LL ~     Box::new(x)
+   |
+help: finally, you might be able to borrow from the function's argument
+   |
+LL | fn bat(x: &Foo) -> &dyn Foo {
+   |                    ++++
+
+error[E0746]: return type cannot have an unboxed trait object
+  --> $DIR/not-on-bare-trait.rs:32:13
+   |
+LL | fn qux() -> Foo {
+   |             ^^^ doesn't have a size known at compile-time
+   |
+help: return an `impl Trait` instead of a `dyn Trait`
+   |
+LL | fn qux() -> impl Foo {
+   |             ++++
+help: alternatively, box the return type to make a boxed trait object, and wrap all of the returned values in `Box::new`
+   |
+LL ~ fn qux() -> Box<dyn Foo> {
+LL |
+LL |
+LL |
+LL ~     Box::new(todo!())
+   |
+
+error: aborting due to 4 previous errors; 7 warnings emitted
 
-For more information about this error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0277, E0746.
+For more information about an error, try `rustc --explain E0277`.
