Delay all sized checks

Author: compiler-errors

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

@@ -1398,7 +1398,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
              (_, ty)| {
                 let ty = self.resolve_vars_if_possible(ty);
                 same &=
-                    !matches!(ty.kind(), ty::Error(_))
+                    !ty.references_error()
                         && last_ty.map_or(true, |last_ty| {
                             // FIXME: ideally we would use `can_coerce` here instead, but `typeck` comes
                             // *after* in the dependency graph.

compiler/rustc_typeck/src/check/expr.rs

@@ -582,7 +582,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 infer::LateBoundRegionConversionTime::FnCall,
                 fn_sig.output(),
             );
-            self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
+            self.require_type_is_sized(output, expr.span, traits::SizedReturnType);
         }
 
         // We always require that the type provided as the value for

compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

@@ -13,7 +13,6 @@ use rustc_errors::{Applicability, Diagnostic, ErrorGuaranteed, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ExprKind, GenericArg, Node, QPath};
 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
 use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
@@ -437,19 +436,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         code: traits::ObligationCauseCode<'tcx>,
     ) {
         if !ty.references_error() {
-            let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
-            self.require_type_meets(ty, span, code, lang_item);
+            if let Some(deferred_sized_obligations) =
+                &mut *self.deferred_sized_obligations.borrow_mut()
+            {
+                deferred_sized_obligations.push((ty, span, code));
+            } else {
+                self.require_type_is_sized_eager(ty, span, code);
+            }
         }
     }
 
-    pub fn require_type_is_sized_deferred(
+    pub fn require_type_is_sized_eager(
         &self,
         ty: Ty<'tcx>,
         span: Span,
         code: traits::ObligationCauseCode<'tcx>,
     ) {
+        let ty = self.normalize_associated_types_in(span, ty);
         if !ty.references_error() {
-            self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
+            let lang_item = self.tcx.require_lang_item(hir::LangItem::Sized, None);
+            self.require_type_meets(ty, span, code, lang_item);
         }
     }
 

compiler/rustc_typeck/src/check/inherited.rs

@@ -38,7 +38,7 @@ pub struct Inherited<'a, 'tcx> {
     // Some additional `Sized` obligations badly affect type inference.
     // These obligations are added in a later stage of typeck.
     pub(super) deferred_sized_obligations:
-        RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
+        RefCell<Option<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>>,
 
     // When we process a call like `c()` where `c` is a closure type,
     // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
@@ -117,7 +117,7 @@ impl<'a, 'tcx> Inherited<'a, 'tcx> {
             infcx,
             fulfillment_cx: RefCell::new(<dyn TraitEngine<'_>>::new(tcx)),
             locals: RefCell::new(Default::default()),
-            deferred_sized_obligations: RefCell::new(Vec::new()),
+            deferred_sized_obligations: RefCell::new(Some(Vec::new())),
             deferred_call_resolutions: RefCell::new(Default::default()),
             deferred_cast_checks: RefCell::new(Vec::new()),
             deferred_transmute_checks: RefCell::new(Vec::new()),

compiler/rustc_typeck/src/check/mod.rs

@@ -450,6 +450,10 @@ fn typeck_with_fallback<'tcx>(
             fcx
         };
 
+        for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().take().unwrap() {
+            fcx.require_type_is_sized_eager(ty, span, code);
+        }
+
         let fallback_has_occurred = fcx.type_inference_fallback();
 
         // Even though coercion casts provide type hints, we check casts after fallback for
@@ -466,11 +470,6 @@ fn typeck_with_fallback<'tcx>(
         fcx.resolve_rvalue_scopes(def_id.to_def_id());
         fcx.resolve_generator_interiors(def_id.to_def_id());
 
-        for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
-            let ty = fcx.normalize_ty(span, ty);
-            fcx.require_type_is_sized(ty, span, code);
-        }
-
         fcx.select_all_obligations_or_error();
 
         if !fcx.infcx.is_tainted_by_errors() {

src/test/ui/asm/type-check-1.rs

@@ -24,11 +24,9 @@ fn main() {
         //~^ ERROR the size for values of type `[u64]` cannot be known at compilation time
         //~| ERROR cannot use value of type `[u64]` for inline assembly
         asm!("{}", out(reg) v[..]);
-        //~^ ERROR the size for values of type `[u64]` cannot be known at compilation time
-        //~| ERROR cannot use value of type `[u64]` for inline assembly
+        //~^ ERROR cannot use value of type `[u64]` for inline assembly
         asm!("{}", inout(reg) v[..]);
-        //~^ ERROR the size for values of type `[u64]` cannot be known at compilation time
-        //~| ERROR cannot use value of type `[u64]` for inline assembly
+        //~^ ERROR cannot use value of type `[u64]` for inline assembly
 
         // Constants must be... constant
 

src/test/ui/asm/type-check-1.stderr

@@ -1,5 +1,5 @@
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/type-check-1.rs:42:26
+  --> $DIR/type-check-1.rs:40:26
    |
 LL |         let x = 0;
    |         ----- help: consider using `const` instead of `let`: `const x`
@@ -8,7 +8,7 @@ LL |         asm!("{}", const x);
    |                          ^ non-constant value
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/type-check-1.rs:45:36
+  --> $DIR/type-check-1.rs:43:36
    |
 LL |         let x = 0;
    |         ----- help: consider using `const` instead of `let`: `const x`
@@ -17,7 +17,7 @@ LL |         asm!("{}", const const_foo(x));
    |                                    ^ non-constant value
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/type-check-1.rs:48:36
+  --> $DIR/type-check-1.rs:46:36
    |
 LL |         let x = 0;
    |         ----- help: consider using `const` instead of `let`: `const x`
@@ -26,7 +26,7 @@ LL |         asm!("{}", const const_bar(x));
    |                                    ^ non-constant value
 
 error: invalid `sym` operand
-  --> $DIR/type-check-1.rs:50:24
+  --> $DIR/type-check-1.rs:48:24
    |
 LL |         asm!("{}", sym x);
    |                        ^ is a local variable
@@ -54,24 +54,6 @@ LL |         asm!("{}", in(reg) v[..]);
    = help: the trait `Sized` is not implemented for `[u64]`
    = note: all inline asm arguments must have a statically known size
 
-error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
-  --> $DIR/type-check-1.rs:26:29
-   |
-LL |         asm!("{}", out(reg) v[..]);
-   |                             ^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `[u64]`
-   = note: all inline asm arguments must have a statically known size
-
-error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
-  --> $DIR/type-check-1.rs:29:31
-   |
-LL |         asm!("{}", inout(reg) v[..]);
-   |                               ^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `[u64]`
-   = note: all inline asm arguments must have a statically known size
-
 error: cannot use value of type `[u64]` for inline assembly
   --> $DIR/type-check-1.rs:23:28
    |
@@ -89,21 +71,21 @@ LL |         asm!("{}", out(reg) v[..]);
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `[u64]` for inline assembly
-  --> $DIR/type-check-1.rs:29:31
+  --> $DIR/type-check-1.rs:28:31
    |
 LL |         asm!("{}", inout(reg) v[..]);
    |                               ^^^^^
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error[E0308]: mismatched types
-  --> $DIR/type-check-1.rs:58:26
+  --> $DIR/type-check-1.rs:56:26
    |
 LL |         asm!("{}", const 0f32);
    |                          ^^^^ expected integer, found `f32`
 
 error[E0308]: mismatched types
-  --> $DIR/type-check-1.rs:60:26
+  --> $DIR/type-check-1.rs:58:26
    |
 LL |         asm!("{}", const 0 as *mut u8);
    |                          ^^^^^^^^^^^^ expected integer, found *-ptr
@@ -112,7 +94,7 @@ LL |         asm!("{}", const 0 as *mut u8);
            found raw pointer `*mut u8`
 
 error[E0308]: mismatched types
-  --> $DIR/type-check-1.rs:62:26
+  --> $DIR/type-check-1.rs:60:26
    |
 LL |         asm!("{}", const &0);
    |                          ^^ expected integer, found `&{integer}`
@@ -124,21 +106,21 @@ LL +         asm!("{}", const 0);
    |
 
 error[E0308]: mismatched types
-  --> $DIR/type-check-1.rs:76:25
+  --> $DIR/type-check-1.rs:74:25
    |
 LL | global_asm!("{}", const 0f32);
    |                         ^^^^ expected integer, found `f32`
 
 error[E0308]: mismatched types
-  --> $DIR/type-check-1.rs:78:25
+  --> $DIR/type-check-1.rs:76:25
    |
 LL | global_asm!("{}", const 0 as *mut u8);
    |                         ^^^^^^^^^^^^ expected integer, found *-ptr
    |
    = note:     expected type `{integer}`
            found raw pointer `*mut u8`
 
-error: aborting due to 17 previous errors
+error: aborting due to 15 previous errors
 
 Some errors have detailed explanations: E0277, E0308, E0435.
 For more information about an error, try `rustc --explain E0277`.

src/test/ui/associated-types/associated-types-path-2.rs

@@ -29,12 +29,14 @@ pub fn f1_uint_uint() {
     f1(2u32, 4u32);
     //~^ ERROR `u32: Foo` is not satisfied
     //~| ERROR `u32: Foo` is not satisfied
+    //~| ERROR `u32: Foo` is not satisfied
 }
 
 pub fn f1_uint_int() {
     f1(2u32, 4i32);
     //~^ ERROR `u32: Foo` is not satisfied
     //~| ERROR `u32: Foo` is not satisfied
+    //~| ERROR `u32: Foo` is not satisfied
 }
 
 pub fn f2_int() {

src/test/ui/associated-types/associated-types-path-2.stderr

@@ -31,21 +31,24 @@ note: required by a bound in `f1`
 LL | pub fn f1<T: Foo>(a: T, x: T::A) {}
    |              ^^^ required by this bound in `f1`
 
+error[E0277]: the trait bound `u32: Foo` is not satisfied
+  --> $DIR/associated-types-path-2.rs:29:5
+   |
+LL |     f1(2u32, 4u32);
+   |     ^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `u32`
+   |
+   = help: the trait `Foo` is implemented for `i32`
+
 error[E0277]: the trait bound `u32: Foo` is not satisfied
   --> $DIR/associated-types-path-2.rs:29:14
    |
 LL |     f1(2u32, 4u32);
    |              ^^^^ the trait `Foo` is not implemented for `u32`
    |
    = help: the trait `Foo` is implemented for `i32`
-   = help: unsized fn params are gated as an unstable feature
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL |     f1(2u32, &4u32);
-   |              +
 
 error[E0277]: the trait bound `u32: Foo` is not satisfied
-  --> $DIR/associated-types-path-2.rs:35:8
+  --> $DIR/associated-types-path-2.rs:36:8
    |
 LL |     f1(2u32, 4i32);
    |     -- ^^^^ the trait `Foo` is not implemented for `u32`
@@ -60,20 +63,23 @@ LL | pub fn f1<T: Foo>(a: T, x: T::A) {}
    |              ^^^ required by this bound in `f1`
 
 error[E0277]: the trait bound `u32: Foo` is not satisfied
-  --> $DIR/associated-types-path-2.rs:35:14
+  --> $DIR/associated-types-path-2.rs:36:5
    |
 LL |     f1(2u32, 4i32);
-   |              ^^^^ the trait `Foo` is not implemented for `u32`
+   |     ^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `u32`
    |
    = help: the trait `Foo` is implemented for `i32`
-   = help: unsized fn params are gated as an unstable feature
-help: function arguments must have a statically known size, borrowed types always have a known size
+
+error[E0277]: the trait bound `u32: Foo` is not satisfied
+  --> $DIR/associated-types-path-2.rs:36:14
    |
-LL |     f1(2u32, &4i32);
-   |              +
+LL |     f1(2u32, 4i32);
+   |              ^^^^ the trait `Foo` is not implemented for `u32`
+   |
+   = help: the trait `Foo` is implemented for `i32`
 
 error[E0308]: mismatched types
-  --> $DIR/associated-types-path-2.rs:41:18
+  --> $DIR/associated-types-path-2.rs:43:18
    |
 LL |     let _: i32 = f2(2i32);
    |            ---   ^^^^^^^^ expected `i32`, found `u32`
@@ -85,7 +91,7 @@ help: you can convert a `u32` to an `i32` and panic if the converted value doesn
 LL |     let _: i32 = f2(2i32).try_into().unwrap();
    |                          ++++++++++++++++++++
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
 Some errors have detailed explanations: E0277, E0308.
 For more information about an error, try `rustc --explain E0277`.

src/test/ui/error-codes/E0282.rs

@@ -1,3 +1,3 @@
 fn main() {
-    let x = "hello".chars().rev().collect(); //~ ERROR E0282
+    let x = "hello".chars().rev().collect(); //~ ERROR E0283
 }

src/test/ui/error-codes/E0282.stderr

@@ -1,14 +1,20 @@
-error[E0282]: type annotations needed
+error[E0283]: type annotations needed
   --> $DIR/E0282.rs:2:9
    |
 LL |     let x = "hello".chars().rev().collect();
-   |         ^
+   |         ^                         ------- type must be known at this point
    |
-help: consider giving `x` an explicit type
+   = note: cannot satisfy `_: FromIterator<char>`
+note: required by a bound in `collect`
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
    |
-LL |     let x: _ = "hello".chars().rev().collect();
-   |          +++
+LL |     fn collect<B: FromIterator<Self::Item>>(self) -> B
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `collect`
+help: consider specifying the type argument in the function call
+   |
+LL |     let x = "hello".chars().rev().collect::<B>();
+   |                                          +++++
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0283`.

src/test/ui/generator/sized-yield.stderr

@@ -1,16 +1,3 @@
-error[E0277]: the size for values of type `str` cannot be known at compilation time
-  --> $DIR/sized-yield.rs:8:26
-   |
-LL |      let mut gen = move || {
-   |  __________________________^
-LL | |
-LL | |        yield s[..];
-LL | |    };
-   | |____^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `str`
-   = note: the yield type of a generator must have a statically known size
-
 error[E0277]: the size for values of type `str` cannot be known at compilation time
   --> $DIR/sized-yield.rs:12:23
    |
@@ -24,6 +11,19 @@ note: required by a bound in `GeneratorState`
 LL | pub enum GeneratorState<Y, R> {
    |                         ^ required by this bound in `GeneratorState`
 
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/sized-yield.rs:8:26
+   |
+LL |      let mut gen = move || {
+   |  __________________________^
+LL | |
+LL | |        yield s[..];
+LL | |    };
+   | |____^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `str`
+   = note: the yield type of a generator must have a statically known size
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

src/test/ui/impl-trait/rpit-not-sized.stderr

@@ -3,6 +3,9 @@ error[E0277]: the size for values of type `impl ?Sized` cannot be known at compi
    |
 LL | fn foo() -> impl ?Sized {
    |             ^^^^^^^^^^^ doesn't have a size known at compile-time
+LL |
+LL |     ()
+   |     -- this returned value is of type `()`
    |
    = help: the trait `Sized` is not implemented for `impl ?Sized`
    = note: the return type of a function must have a statically known size