Silence unecessary !Sized binding error

When gathering locals, we introduce a `Sized` obligation for each
binding in the pattern. *After* doing so, we typecheck the init
expression. If this has a type failure, we store `{type error}`, for
both the expression and the pattern. But later we store an inference
variable for the pattern.

We now avoid any override of an existing type on a hir node when they've
already been marked as `{type error}`, and on E0277, when it comes from
`VariableType` we silence the error in support of the type error.

Fix #117846.

Author: estebank

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -138,7 +138,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     #[inline]
     pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
         debug!("write_ty({:?}, {:?}) in fcx {}", id, self.resolve_vars_if_possible(ty), self.tag());
-        self.typeck_results.borrow_mut().node_types_mut().insert(id, ty);
+        let mut typeck = self.typeck_results.borrow_mut();
+        let mut node_ty = typeck.node_types_mut();
+        if let Some(ty) = node_ty.remove(id)
+            && let Err(e) = ty.error_reported()
+        {
+            // Do not overwrite nodes that were already marked as `{type error}`. This allows us to
+            // silence unnecessary errors from obligations that were set earlier than a type error
+            // was produced, but that is overwritten by later analysis. This happens in particular
+            // for `Sized` obligations introduced in gather_locals. (#117846)
+            node_ty.insert(id, ty);
+            self.set_tainted_by_errors(e);
+            return;
+        }
+
+        node_ty.insert(id, ty);
 
         if let Err(e) = ty.error_reported() {
             self.set_tainted_by_errors(e);

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -1892,11 +1892,35 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         pat: &'tcx hir::Pat<'tcx>,
         ty: Ty<'tcx>,
     ) {
+        struct V<'tcx> {
+            tcx: TyCtxt<'tcx>,
+            pat_hir_ids: Vec<hir::HirId>,
+        }
+
+        impl<'tcx> Visitor<'tcx> for V<'tcx> {
+            type NestedFilter = rustc_middle::hir::nested_filter::All;
+
+            fn nested_visit_map(&mut self) -> Self::Map {
+                self.tcx.hir()
+            }
+
+            fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
+                self.pat_hir_ids.push(p.hir_id);
+                hir::intravisit::walk_pat(self, p);
+            }
+        }
         if let Err(guar) = ty.error_reported() {
             // Override the types everywhere with `err()` to avoid knock on errors.
             let err = Ty::new_error(self.tcx, guar);
             self.write_ty(hir_id, err);
             self.write_ty(pat.hir_id, err);
+            let mut visitor = V { tcx: self.tcx, pat_hir_ids: vec![] };
+            hir::intravisit::walk_pat(&mut visitor, pat);
+            // Mark all the subpatterns as `{type error}` as well. This allows errors for specific
+            // subpatterns to be silenced.
+            for hir_id in visitor.pat_hir_ids {
+                self.write_ty(hir_id, err);
+            }
             self.locals.borrow_mut().insert(hir_id, err);
             self.locals.borrow_mut().insert(pat.hir_id, err);
         }

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

@@ -2915,6 +2915,16 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 }
             }
             ObligationCauseCode::VariableType(hir_id) => {
+                if let Some(typeck_results) = &self.typeck_results
+                    && let Some(ty) = typeck_results.node_type_opt(hir_id)
+                    && let ty::Error(_) = ty.kind()
+                {
+                    err.note(format!(
+                        "`{predicate}` isn't satisfied, but the type of this pattern is \
+                         `{{type error}}`",
+                    ));
+                    err.downgrade_to_delayed_bug();
+                }
                 match tcx.parent_hir_node(hir_id) {
                     Node::Local(hir::Local { ty: Some(ty), .. }) => {
                         err.span_suggestion_verbose(

tests/ui/sized/expr-type-error-plus-sized-obligation.rs

@@ -1,7 +1,7 @@
 #![allow(warnings)]
 
 fn issue_117846_repro() {
-    let (a, _) = if true { //~ ERROR E0277
+    let (a, _) = if true {
         produce()
     } else {
         (Vec::new(), &[]) //~ ERROR E0308

tests/ui/sized/expr-type-error-plus-sized-obligation.stderr

@@ -14,17 +14,6 @@ LL | |     };
    = note: expected tuple `(Vec<Foo>, &[Bar])`
               found tuple `(Vec<_>, &[_; 0])`
 
-error[E0277]: the size for values of type `[Foo]` cannot be known at compilation time
-  --> $DIR/expr-type-error-plus-sized-obligation.rs:4:10
-   |
-LL |     let (a, _) = if true {
-   |          ^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `[Foo]`
-   = note: all local variables must have a statically known size
-   = help: unsized locals are gated as an unstable feature
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0277, E0308.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0308`.