Avoid potential for ICE by not stashing delayed as bug error and silence more redundant errors

Instead of calling `dowgrade_to_delayed_bug` and then stashing a diagnostic, we either stash the diagnostic or we `delay_as_bug` it.

Remove unnecessary restriction of silencing of knock down errors on bare trait objects in edition >=2021.

Author: estebank

compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

@@ -61,16 +61,31 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             let label = "add `dyn` keyword before this trait";
             let mut diag =
                 rustc_errors::struct_span_code_err!(tcx.dcx(), self_ty.span, E0782, "{}", msg);
-            if self_ty.span.can_be_used_for_suggestions()
-                && !self.maybe_suggest_impl_trait(self_ty, &mut diag)
-            {
-                // FIXME: Only emit this suggestion if the trait is object safe.
-                diag.multipart_suggestion_verbose(label, sugg, Applicability::MachineApplicable);
+            let mut downgrade = false;
+            if self_ty.span.can_be_used_for_suggestions() {
+                let (non_object_safe, should_downgrade) =
+                    self.maybe_suggest_impl_trait(self_ty, &mut diag);
+                downgrade = should_downgrade;
+                if !non_object_safe {
+                    // Only emit this suggestion if the trait is object safe.
+                    diag.multipart_suggestion_verbose(
+                        label,
+                        sugg,
+                        Applicability::MachineApplicable,
+                    );
+                }
             }
             // Check if the impl trait that we are considering is an impl of a local trait.
             self.maybe_suggest_blanket_trait_impl(self_ty, &mut diag);
             self.maybe_suggest_assoc_ty_bound(self_ty, &mut diag);
-            diag.stash(self_ty.span, StashKey::TraitMissingMethod)
+            if downgrade {
+                // FIXME: Delayed bugs and stashing are not compatible, so we paper over it here by
+                // consuming the diagnostic without emitting it, instead of downgrading it.
+                diag.delay_as_bug();
+                None
+            } else {
+                diag.stash(self_ty.span, StashKey::TraitMissingMethod)
+            }
         } else {
             tcx.node_span_lint(BARE_TRAIT_OBJECTS, self_ty.hir_id, self_ty.span, |lint| {
                 lint.primary_message("trait objects without an explicit `dyn` are deprecated");
@@ -153,7 +168,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     }
 
     /// Make sure that we are in the condition to suggest `impl Trait`.
-    fn maybe_suggest_impl_trait(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) -> bool {
+    ///
+    /// Returns whether a suggestion was provided and whether the error itself should not be emitted
+    fn maybe_suggest_impl_trait(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) -> (bool, bool) {
         let tcx = self.tcx();
         let parent_id = tcx.hir().get_parent_item(self_ty.hir_id).def_id;
         // FIXME: If `type_alias_impl_trait` is enabled, also look for `Trait0<Ty = Trait1>`
@@ -168,13 +185,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 owner_id,
                 ..
             }) => (sig, generics, Some(tcx.parent(owner_id.to_def_id()))),
-            _ => return false,
+            _ => return (false, false),
         };
         let Ok(trait_name) = tcx.sess.source_map().span_to_snippet(self_ty.span) else {
-            return false;
+            return (false, false);
         };
         let impl_sugg = vec![(self_ty.span.shrink_to_lo(), "impl ".to_string())];
         let mut is_downgradable = true;
+        let mut downgrade = false;
         let is_object_safe = match self_ty.kind {
             hir::TyKind::TraitObject(objects, ..) => {
                 objects.iter().all(|o| match o.trait_ref.path.res {
@@ -214,9 +232,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
             } else if is_downgradable {
                 // We'll emit the object safety error already, with a structured suggestion.
-                diag.downgrade_to_delayed_bug();
+                downgrade = true;
             }
-            return true;
+            return (true, downgrade);
         }
         for ty in sig.decl.inputs {
             if ty.hir_id != self_ty.hir_id {
@@ -240,7 +258,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 diag.note(format!("`{trait_name}` it is not object safe, so it can't be `dyn`"));
                 if is_downgradable {
                     // We'll emit the object safety error already, with a structured suggestion.
-                    diag.downgrade_to_delayed_bug();
+                    downgrade = true;
                 }
             } else {
                 let sugg = if let hir::TyKind::TraitObject([_, _, ..], _, _) = self_ty.kind {
@@ -261,9 +279,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     Applicability::MachineApplicable,
                 );
             }
-            return true;
+            return (true, downgrade);
         }
-        false
+        (false, downgrade)
     }
 
     fn maybe_suggest_assoc_ty_bound(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2081,16 +2081,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
             hir::TyKind::TraitObject(bounds, lifetime, repr) => {
                 if let Some(guard) = self.prohibit_or_lint_bare_trait_object_ty(hir_ty, in_path) {
-                    if let hir::Node::Item(_) | hir::Node::TraitItem(_) | hir::Node::ImplItem(_) =
-                        tcx.parent_hir_node(hir_ty.hir_id)
-                    {
-                        // `tests/ui/suggestions/issue-116434-2021.rs` and others would otherwise
-                        // fail with no error beign emitted. We restrict the silencing only to
-                        // expressions, as those *will* emit the error *and* also produce further
-                        // knock-down errors.
-                    } else {
-                        return Ty::new_error(tcx, guard);
-                    }
+                    return Ty::new_error(tcx, guard);
                 }
 
                 let repr = match repr {

tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.rs

@@ -5,21 +5,18 @@ trait A: Sized {
     //~^ ERROR trait objects must include the `dyn` keyword
     //~| ERROR trait objects must include the `dyn` keyword
     //~| ERROR associated item referring to unboxed trait object for its own trait
-    //~| ERROR the trait `A` cannot be made into an object
 }
 trait B {
     fn f(b: B) -> B;
     //~^ ERROR trait objects must include the `dyn` keyword
     //~| ERROR trait objects must include the `dyn` keyword
     //~| ERROR associated item referring to unboxed trait object for its own trait
-    //~| ERROR the trait `B` cannot be made into an object
 }
 trait C {
     fn f(&self, c: C) -> C;
     //~^ ERROR trait objects must include the `dyn` keyword
     //~| ERROR trait objects must include the `dyn` keyword
     //~| ERROR associated item referring to unboxed trait object for its own trait
-    //~| ERROR the trait `C` cannot be made into an object
 }
 
 fn main() {}

tests/ui/suggestions/object-unsafe-trait-should-use-self-2021-without-dyn.stderr

@@ -11,22 +11,8 @@ help: you might have meant to use `Self` to refer to the implementing type
 LL |     fn f(a: Self) -> Self;
    |             ~~~~     ~~~~
 
-error[E0038]: the trait `A` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
-   |
-LL |     fn f(a: A) -> A;
-   |             ^ `A` cannot be made into an object
-   |
-note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:3:10
-   |
-LL | trait A: Sized {
-   |       -  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait cannot be made into an object...
-
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
+  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:10:13
    |
 LL | trait B {
    |       - in this trait
@@ -38,30 +24,8 @@ help: you might have meant to use `Self` to refer to the implementing type
 LL |     fn f(b: Self) -> Self;
    |             ~~~~     ~~~~
 
-error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
-   |
-LL |     fn f(b: B) -> B;
-   |             ^ `B` cannot be made into an object
-   |
-note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:8
-   |
-LL | trait B {
-   |       - this trait cannot be made into an object...
-LL |     fn f(b: B) -> B;
-   |        ^ ...because associated function `f` has no `self` parameter
-help: consider turning `f` into a method by giving it a `&self` argument
-   |
-LL |     fn f(&self, b: B) -> B;
-   |          ++++++
-help: alternatively, consider constraining `f` so it does not apply to trait objects
-   |
-LL |     fn f(b: B) -> B where Self: Sized;
-   |                     +++++++++++++++++
-
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
+  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:16:20
    |
 LL | trait C {
    |       - in this trait
@@ -73,22 +37,6 @@ help: you might have meant to use `Self` to refer to the implementing type
 LL |     fn f(&self, c: Self) -> Self;
    |                    ~~~~     ~~~~
 
-error[E0038]: the trait `C` cannot be made into an object
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
-   |
-LL |     fn f(&self, c: C) -> C;
-   |          -----     ^ `C` cannot be made into an object
-   |          |
-   |          help: consider changing method `f`'s `self` parameter to be `&self` (notice the capitalization): `&Self`
-   |
-note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:10
-   |
-LL | trait C {
-   |       - this trait cannot be made into an object...
-LL |     fn f(&self, c: C) -> C;
-   |          ^^^^^ ...because method `f`'s `self` parameter cannot be dispatched on
-
 error[E0782]: trait objects must include the `dyn` keyword
   --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:4:13
    |
@@ -117,7 +65,7 @@ LL |     fn f(a: A) -> impl A;
    |                   ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:13
+  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:10:13
    |
 LL |     fn f(b: B) -> B;
    |             ^
@@ -133,7 +81,7 @@ LL |     fn f(b: impl B) -> B;
    |             ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:11:19
+  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:10:19
    |
 LL |     fn f(b: B) -> B;
    |                   ^
@@ -144,7 +92,7 @@ LL |     fn f(b: B) -> impl B;
    |                   ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:20
+  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:16:20
    |
 LL |     fn f(&self, c: C) -> C;
    |                    ^
@@ -160,7 +108,7 @@ LL |     fn f(&self, c: impl C) -> C;
    |                    ++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:18:26
+  --> $DIR/object-unsafe-trait-should-use-self-2021-without-dyn.rs:16:26
    |
 LL |     fn f(&self, c: C) -> C;
    |                          ^
@@ -170,7 +118,6 @@ help: `C` is not object safe, use `impl C` to return an opaque type, as long as
 LL |     fn f(&self, c: C) -> impl C;
    |                          ++++
 
-error: aborting due to 12 previous errors
+error: aborting due to 9 previous errors
 
-Some errors have detailed explanations: E0038, E0782.
-For more information about an error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.

tests/ui/traits/bound/not-on-bare-trait-2021.rs

@@ -7,12 +7,10 @@ trait Foo {
 
 fn foo(_x: Foo + Send) {
     //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR size for values of type
 }
 fn bar(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
 }
 

tests/ui/traits/bound/not-on-bare-trait-2021.stderr

@@ -1,37 +1,3 @@
-error[E0277]: the size for values of type `(dyn Foo + Send + 'static)` cannot be known at compilation time
-  --> $DIR/not-on-bare-trait-2021.rs:8:8
-   |
-LL | fn foo(_x: Foo + Send) {
-   |        ^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Foo + Send + 'static)`
-   = help: unsized fn params are gated as an unstable feature
-help: you can use `impl Trait` as the argument type
-   |
-LL | fn foo(_x: impl Foo + Send) {
-   |            ++++
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-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:8
-   |
-LL | fn bar(x: Foo) -> Foo {
-   |        ^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Foo + 'static)`
-   = help: unsized fn params are gated as an unstable feature
-help: you can use `impl Trait` as the argument type
-   |
-LL | fn bar(x: impl Foo) -> Foo {
-   |           ++++
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-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
    |
@@ -52,7 +18,7 @@ LL | fn foo(_x: &(dyn Foo + Send)) {
    |            +++++           +
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not-on-bare-trait-2021.rs:12:11
+  --> $DIR/not-on-bare-trait-2021.rs:11:11
    |
 LL | fn bar(x: Foo) -> Foo {
    |           ^^^
@@ -71,7 +37,7 @@ 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:11:19
    |
 LL | fn bar(x: Foo) -> Foo {
    |                   ^^^
@@ -85,7 +51,6 @@ help: alternatively, you can return an owned trait object
 LL | fn bar(x: Foo) -> Box<dyn Foo> {
    |                   +++++++    +
 
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0277, E0782.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0782`.

tests/ui/traits/issue-106072.rs

@@ -1,6 +1,4 @@
-#[derive(Clone)] //~  trait objects must include the `dyn` keyword
-//~^ ERROR: the size for values of type `(dyn Foo + 'static)` cannot be known
-//~| ERROR: return type cannot have an unboxed trait object
+#[derive(Clone)] //~ERROR trait objects must include the `dyn` keyword
 struct Foo;
-trait Foo {} //~ the name `Foo` is defined multiple times
+trait Foo {} //~ERROR the name `Foo` is defined multiple times
 fn main() {}

tests/ui/traits/issue-106072.stderr

@@ -1,5 +1,5 @@
 error[E0428]: the name `Foo` is defined multiple times
-  --> $DIR/issue-106072.rs:5:1
+  --> $DIR/issue-106072.rs:3:1
    |
 LL | struct Foo;
    | ----------- previous definition of the type `Foo` here
@@ -8,25 +8,6 @@ LL | trait Foo {}
    |
    = note: `Foo` must be defined only once in the type namespace of this module
 
-error[E0277]: the size for values of type `(dyn Foo + 'static)` cannot be known at compilation time
-  --> $DIR/issue-106072.rs:1:10
-   |
-LL | #[derive(Clone)]
-   |          ^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Foo + 'static)`
-note: required by a bound in `Clone`
-  --> $SRC_DIR/core/src/clone.rs:LL:COL
-   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0746]: return type cannot have an unboxed trait object
-  --> $DIR/issue-106072.rs:1:10
-   |
-LL | #[derive(Clone)]
-   |          ^^^^^ doesn't have a size known at compile-time
-   |
-   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0782]: trait objects must include the `dyn` keyword
   --> $DIR/issue-106072.rs:1:10
    |
@@ -35,7 +16,7 @@ LL | #[derive(Clone)]
    |
    = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0277, E0428, E0746, E0782.
-For more information about an error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0428, E0782.
+For more information about an error, try `rustc --explain E0428`.