nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-08 13:02:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #111863 - compiler-errors:check-more-mir, r=b-naber

Browse Source 
Don't skip mir typeck if body has errors

Comment says:

```
// if verifier failed, don't do further checks to avoid ICEs
```

But there are no ICEs to be found. The comment is quite old, so perhaps something fixed it... maybe because the MIR typechecker is delaying span bugs rather than panicking via eager bugs? IDK

I'm generally inclined to fix the ICEs themselves that were to arise from this, rather than just totally skipping large parts of the compiler that have impacts on downstream logic (namely, our opaque type results are affected). Anyways, this happens on the error path, so it shouldn't really matter.

Fixes this hack: https://github.com/rust-lang/rust/pull/111853/files#r1201501540
This commit is contained in:
Matthias Krüger 2023-05-24 21:36:58 +02:00 committed by GitHub
commit 680f8b8efe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 9 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
compiler/rustc_borrowck/src/type_check/mod.rs
View File

@ -183,17 +183,10 @@ pub(crate) fn type_check<'mir, 'tcx>(
&mut borrowck_context, &mut borrowck_context,
); );
let errors_reported = { let mut verifier = TypeVerifier::new(&mut checker, promoted);
let mut verifier = TypeVerifier::new(&mut checker, promoted); verifier.visit_body(&body);
verifier.visit_body(&body);
verifier.errors_reported
};
if !errors_reported {
// if verifier failed, don't do further checks to avoid ICEs
checker.typeck_mir(body);
}
checker.typeck_mir(body);
checker.equate_inputs_and_outputs(&body, universal_regions, &normalized_inputs_and_output); checker.equate_inputs_and_outputs(&body, universal_regions, &normalized_inputs_and_output);
checker.check_signature_annotation(&body); checker.check_signature_annotation(&body);
@ -294,7 +287,6 @@ struct TypeVerifier<'a, 'b, 'tcx> {
cx: &'a mut TypeChecker<'b, 'tcx>, cx: &'a mut TypeChecker<'b, 'tcx>,
promoted: &'b IndexSlice<Promoted, Body<'tcx>>, promoted: &'b IndexSlice<Promoted, Body<'tcx>>,
last_span: Span, last_span: Span,
errors_reported: bool,
} }
impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> { impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
@ -383,13 +375,11 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
}; };
}; };
if !self.errors_reported { let promoted_body = &self.promoted[promoted];
let promoted_body = &self.promoted[promoted]; self.sanitize_promoted(promoted_body, location);
self.sanitize_promoted(promoted_body, location);
let promoted_ty = promoted_body.return_ty(); let promoted_ty = promoted_body.return_ty();
check_err(self, promoted_body, ty, promoted_ty); check_err(self, promoted_body, ty, promoted_ty);
}
} else { } else {
self.cx.ascribe_user_type( self.cx.ascribe_user_type(
constant.literal.ty(), constant.literal.ty(),
@ -483,9 +473,6 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
for local_decl in &body.local_decls { for local_decl in &body.local_decls {
self.sanitize_type(local_decl, local_decl.ty); self.sanitize_type(local_decl, local_decl.ty);
} }
if self.errors_reported {
return;
}
self.super_body(body); self.super_body(body);
} }
} }
@ -495,7 +482,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
cx: &'a mut TypeChecker<'b, 'tcx>, cx: &'a mut TypeChecker<'b, 'tcx>,
promoted: &'b IndexSlice<Promoted, Body<'tcx>>, promoted: &'b IndexSlice<Promoted, Body<'tcx>>,
) -> Self { ) -> Self {
TypeVerifier { promoted, last_span: cx.body.span, cx, errors_reported: false } TypeVerifier { promoted, last_span: cx.body.span, cx }
} }
fn body(&self) -> &Body<'tcx> { fn body(&self) -> &Body<'tcx> {
@ -529,7 +516,6 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
for elem in place.projection.iter() { for elem in place.projection.iter() {
if place_ty.variant_index.is_none() { if place_ty.variant_index.is_none() {
if let Err(guar) = place_ty.ty.error_reported() { if let Err(guar) = place_ty.ty.error_reported() {
assert!(self.errors_reported);
return PlaceTy::from_ty(self.tcx().ty_error(guar)); return PlaceTy::from_ty(self.tcx().ty_error(guar));
} }
} }
@ -593,10 +579,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
self.visit_body(&promoted_body); self.visit_body(&promoted_body);
if !self.errors_reported { self.cx.typeck_mir(promoted_body);
// if verifier failed, don't do further checks to avoid ICEs
self.cx.typeck_mir(promoted_body);
}
self.cx.body = parent_body; self.cx.body = parent_body;
// Merge the outlives constraints back in, at the given location. // Merge the outlives constraints back in, at the given location.
@ -762,7 +745,6 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
} }
fn error(&mut self) -> Ty<'tcx> { fn error(&mut self) -> Ty<'tcx> {
self.errors_reported = true;
self.tcx().ty_error_misc() self.tcx().ty_error_misc()
} }