From 3f2159fda5019f5b599dd3cdf53f430878e82ed2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Wed, 6 Mar 2024 23:41:50 +0000 Subject: [PATCH 1/2] Add test for #117846 --- .../expr-type-error-plus-sized-obligation.rs | 22 ++++++++++++++ ...pr-type-error-plus-sized-obligation.stderr | 30 +++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 tests/ui/sized/expr-type-error-plus-sized-obligation.rs create mode 100644 tests/ui/sized/expr-type-error-plus-sized-obligation.stderr diff --git a/tests/ui/sized/expr-type-error-plus-sized-obligation.rs b/tests/ui/sized/expr-type-error-plus-sized-obligation.rs new file mode 100644 index 0000000000000..4c76d2d24882e --- /dev/null +++ b/tests/ui/sized/expr-type-error-plus-sized-obligation.rs @@ -0,0 +1,22 @@ +#![allow(warnings)] + +fn issue_117846_repro() { + let (a, _) = if true { //~ ERROR E0277 + produce() + } else { + (Vec::new(), &[]) //~ ERROR E0308 + }; + + accept(&a); +} + +struct Foo; +struct Bar; + +fn produce() -> (Vec, &'static [Bar]) { + todo!() +} + +fn accept(c: &[Foo]) {} + +fn main() {} diff --git a/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr b/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr new file mode 100644 index 0000000000000..6a2810be10791 --- /dev/null +++ b/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr @@ -0,0 +1,30 @@ +error[E0308]: `if` and `else` have incompatible types + --> $DIR/expr-type-error-plus-sized-obligation.rs:7:9 + | +LL | let (a, _) = if true { + | __________________- +LL | | produce() + | | --------- expected because of this +LL | | } else { +LL | | (Vec::new(), &[]) + | | ^^^^^^^^^^^^^^^^^ expected `(Vec, &[Bar])`, found `(Vec<_>, &[_; 0])` +LL | | }; + | |_____- `if` and `else` have incompatible types + | + = note: expected tuple `(Vec, &[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 + +Some errors have detailed explanations: E0277, E0308. +For more information about an error, try `rustc --explain E0277`. From b1575b71d48a6452d2ff65b5fbb63858388b925b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Thu, 7 Mar 2024 00:08:56 +0000 Subject: [PATCH 2/2] 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. --- .../rustc_hir_typeck/src/fn_ctxt/_impl.rs | 15 +++++++++++- .../rustc_hir_typeck/src/fn_ctxt/checks.rs | 24 +++++++++++++++++++ .../rustc_middle/src/ty/typeck_results.rs | 5 ++++ .../src/traits/error_reporting/suggestions.rs | 10 ++++++++ .../expr-type-error-plus-sized-obligation.rs | 2 +- ...pr-type-error-plus-sized-obligation.stderr | 15 ++---------- 6 files changed, 56 insertions(+), 15 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs index dd44fdd889328..1d885b801d987 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs +++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs @@ -138,7 +138,20 @@ 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.get(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) + 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); diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs index 536d44a0ccb85..5c56c6acd2791 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs +++ b/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, + } + + 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); } diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs index 4287b382604ee..d8541f4b25a53 100644 --- a/compiler/rustc_middle/src/ty/typeck_results.rs +++ b/compiler/rustc_middle/src/ty/typeck_results.rs @@ -568,6 +568,11 @@ impl<'a, V> LocalTableInContextMut<'a, V> { self.data.get_mut(&id.local_id) } + pub fn get(&mut self, id: hir::HirId) -> Option<&V> { + validate_hir_id_for_typeck_results(self.hir_owner, id); + self.data.get(&id.local_id) + } + pub fn entry(&mut self, id: hir::HirId) -> Entry<'_, hir::ItemLocalId, V> { validate_hir_id_for_typeck_results(self.hir_owner, id); self.data.entry(id.local_id) diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 067ca883bd8ad..f4f60b2a8a0c3 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -2954,6 +2954,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( diff --git a/tests/ui/sized/expr-type-error-plus-sized-obligation.rs b/tests/ui/sized/expr-type-error-plus-sized-obligation.rs index 4c76d2d24882e..a96beeecab947 100644 --- a/tests/ui/sized/expr-type-error-plus-sized-obligation.rs +++ b/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 diff --git a/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr b/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr index 6a2810be10791..9cf477fbd4187 100644 --- a/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr +++ b/tests/ui/sized/expr-type-error-plus-sized-obligation.stderr @@ -14,17 +14,6 @@ LL | | }; = note: expected tuple `(Vec, &[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`.