Silence unsized types errors in some expressions

When encountering an unsized E0277 error on a method that returns `Self` silence that error as it a prior unsized error will have been emitted when constructing the value of `Self`.

On E0227 unsized error caused on a bare trait associated function with object safety violations, silence it.

Author: estebank

compiler/rustc_hir_typeck/src/expr.rs

@@ -591,7 +591,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.require_type_is_sized_deferred(
                 output,
                 call.map_or(expr.span, |e| e.span),
-                ObligationCauseCode::SizedCallReturnType,
+                ObligationCauseCode::SizedCallReturnType(did),
             );
         }
 

compiler/rustc_middle/src/traits/mod.rs

@@ -284,7 +284,7 @@ pub enum ObligationCauseCode<'tcx> {
     /// Return type must be `Sized`.
     SizedReturnType,
     /// Return type of a call expression must be `Sized`.
-    SizedCallReturnType,
+    SizedCallReturnType(DefId),
     /// Yield type must be `Sized`.
     SizedYieldType,
     /// Inline asm operand type must be `Sized`.

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -3081,7 +3081,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     err.help("unsized fn params are gated as an unstable feature");
                 }
             }
-            ObligationCauseCode::SizedReturnType | ObligationCauseCode::SizedCallReturnType => {
+            ObligationCauseCode::SizedReturnType | ObligationCauseCode::SizedCallReturnType(_) => {
                 err.note("the return type of a function must have a statically known size");
             }
             ObligationCauseCode::SizedYieldType => {

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -48,7 +48,7 @@ use rustc_middle::ty::{
 use rustc_middle::{bug, span_bug};
 use rustc_session::Limit;
 use rustc_span::def_id::LOCAL_CRATE;
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{kw, sym};
 use rustc_span::{BytePos, ExpnKind, Span, Symbol, DUMMY_SP};
 use std::borrow::Cow;
 use std::fmt;
@@ -638,6 +638,32 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                             err.span_label(span, explanation);
                         }
 
+                        if Some(trait_ref.def_id()) == self.tcx.lang_items().sized_trait() {
+                            if !self.tcx.object_safety_violations(trait_ref.def_id()).is_empty() {
+                                match (
+                                    obligation.cause.code(),
+                                    trait_ref.skip_binder().self_ty().kind(),
+                                ) {
+                                    (
+                                        ObligationCauseCode::WhereClauseInExpr(..),
+                                        ty::Dynamic(..),
+                                    ) => {
+                                        return err.delay_as_bug();
+                                    }
+                                    (ObligationCauseCode::SizedCallReturnType(did), _) => {
+                                        let fn_sig = self.tcx.fn_sig(did);
+                                        let ret_kind =
+                                            fn_sig.skip_binder().output().skip_binder().kind();
+                                        if let ty::Param(param_ty) = ret_kind
+                                            && param_ty.name == kw::SelfUpper
+                                        {
+                                            return err.delay_as_bug();
+                                        }
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
                         if let ObligationCauseCode::Coercion { source, target } =
                             *obligation.cause.code().peel_derives()
                         {

tests/ui/dyn-keyword/trait-missing-dyn-in-qualified-path.edition2018.stderr

@@ -21,16 +21,6 @@ LL |     let x: u32 = <Default>::default();
    = note: the trait cannot be made into an object because it requires `Self: Sized`
    = 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>
 
-error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time
-  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19
-   |
-LL |     let x: u32 = <Default>::default();
-   |                   ^^^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `dyn Default`
-note: required by a bound in `default`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
-
 error[E0308]: mismatched types
   --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:18
    |
@@ -52,16 +42,7 @@ LL |     let x: u32 = <Default>::default();
    = note: the trait cannot be made into an object because it requires `Self: Sized`
    = 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>
 
-error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time
-  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:18
-   |
-LL |     let x: u32 = <Default>::default();
-   |                  ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `dyn Default`
-   = note: the return type of a function must have a statically known size
-
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors; 1 warning emitted
 
-Some errors have detailed explanations: E0038, E0277, E0308.
+Some errors have detailed explanations: E0038, E0308.
 For more information about an error, try `rustc --explain E0038`.

tests/ui/dyn-keyword/trait-missing-dyn-in-qualified-path.rs

@@ -8,7 +8,5 @@ fn main() {
     //[edition2018]~| WARNING this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
     //[edition2018]~| ERROR trait `Default` cannot be made into an object
     //[edition2018]~| ERROR trait `Default` cannot be made into an object
-    //[edition2018]~| ERROR the size for values of type `dyn Default` cannot be known at compilation time
-    //[edition2018]~| ERROR the size for values of type `dyn Default` cannot be known at compilation time
     //[edition2018]~| ERROR mismatched types
 }

tests/ui/traits/bad-sized.rs

@@ -5,5 +5,4 @@ pub fn main() {
     //~^ ERROR only auto traits can be used as additional traits in a trait object
     //~| ERROR the size for values of type
     //~| ERROR the size for values of type
-    //~| ERROR the size for values of type
 }

tests/ui/traits/bad-sized.stderr

@@ -19,16 +19,6 @@ LL |     let x: Vec<dyn Trait + Sized> = Vec::new();
 note: required by an implicit `Sized` bound in `Vec`
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
 
-error[E0277]: the size for values of type `dyn Trait` cannot be known at compilation time
-  --> $DIR/bad-sized.rs:4:37
-   |
-LL |     let x: Vec<dyn Trait + Sized> = Vec::new();
-   |                                     ^^^^^^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `dyn Trait`
-note: required by a bound in `Vec::<T>::new`
-  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-
 error[E0277]: the size for values of type `dyn Trait` cannot be known at compilation time
   --> $DIR/bad-sized.rs:4:37
    |
@@ -39,7 +29,7 @@ LL |     let x: Vec<dyn Trait + Sized> = Vec::new();
 note: required by an implicit `Sized` bound in `Vec`
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0225, E0277.
 For more information about an error, try `rustc --explain E0225`.