Skip to content

Commit ee8c9d3

Browse files
borsbors
committed
Auto merge of rust-lang#116737 - matthiaskrgr:rollup-jftlnmt, r=matthiaskrgr
Rollup of 6 pull requests Successful merges: - rust-lang#115439 (rustdoc: hide `#[repr(transparent)]` if it isn't part of the public ABI) - rust-lang#116591 (Don't accidentally detect the commit hash as an `fadd` instruction) - rust-lang#116603 (Reorganize `bootstrap/Cargo.toml`) - rust-lang#116715 (Prevent more spurious unreachable pattern lints) - rust-lang#116723 (Fix broken build on ESP-IDF caused by rust-lang#115108) - rust-lang#116730 (Add some unsoundness tests for opaques capturing hidden regions not in substs) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 8de6f99 + 77b578f commit ee8c9d3

35 files changed

+434
-161
lines changed

‎compiler/rustc_middle/src/thir.rs

+26-5
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,12 @@ use rustc_middle::middle::region;
1919
use rustc_middle::mir::interpret::AllocId;
2020
use rustc_middle::mir::{self, BinOp, BorrowKind, FakeReadCause, Mutability, UnOp};
2121
use rustc_middle::ty::adjustment::PointerCoercion;
22-
use rustc_middle::ty::GenericArgsRef;
23-
use rustc_middle::ty::{self, AdtDef, FnSig, List, Ty, UpvarArgs};
24-
use rustc_middle::ty::{CanonicalUserType, CanonicalUserTypeAnnotation};
22+
use rustc_middle::ty::{
23+
self, AdtDef, CanonicalUserType, CanonicalUserTypeAnnotation, FnSig, GenericArgsRef, List, Ty,
24+
UpvarArgs,
25+
};
2526
use rustc_span::def_id::LocalDefId;
26-
use rustc_span::{sym, Span, Symbol, DUMMY_SP};
27+
use rustc_span::{sym, ErrorGuaranteed, Span, Symbol, DUMMY_SP};
2728
use rustc_target::abi::{FieldIdx, VariantIdx};
2829
use rustc_target::asm::InlineAsmRegOrRegClass;
2930
use std::fmt;
@@ -632,7 +633,7 @@ impl<'tcx> Pat<'tcx> {
632633

633634
use PatKind::*;
634635
match &self.kind {
635-
Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } => {}
636+
Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } | Error(_) => {}
636637
AscribeUserType { subpattern, .. }
637638
| Binding { subpattern: Some(subpattern), .. }
638639
| Deref { subpattern } => subpattern.walk_(it),
@@ -647,6 +648,21 @@ impl<'tcx> Pat<'tcx> {
647648
}
648649
}
649650

651+
/// Whether the pattern has a `PatKind::Error` nested within.
652+
pub fn pat_error_reported(&self) -> Result<(), ErrorGuaranteed> {
653+
let mut error = None;
654+
self.walk(|pat| {
655+
if let PatKind::Error(e) = pat.kind && error.is_none() {
656+
error = Some(e);
657+
}
658+
error.is_none()
659+
});
660+
match error {
661+
None => Ok(()),
662+
Some(e) => Err(e),
663+
}
664+
}
665+
650666
/// Walk the pattern in left-to-right order.
651667
///
652668
/// If you always want to recurse, prefer this method over `walk`.
@@ -771,6 +787,10 @@ pub enum PatKind<'tcx> {
771787
Or {
772788
pats: Box<[Box<Pat<'tcx>>]>,
773789
},
790+
791+
/// An error has been encountered during lowering. We probably shouldn't report more lints
792+
/// related to this pattern.
793+
Error(ErrorGuaranteed),
774794
}
775795

776796
#[derive(Clone, Debug, PartialEq, HashStable, TypeVisitable)]
@@ -934,6 +954,7 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
934954
}
935955
Ok(())
936956
}
957+
PatKind::Error(_) => write!(f, "<error>"),
937958
}
938959
}
939960
}

‎compiler/rustc_middle/src/thir/visit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -226,7 +226,7 @@ pub fn walk_pat<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, pat: &Pat<'
226226
is_primary: _,
227227
name: _,
228228
} => visitor.visit_pat(&subpattern),
229-
Binding { .. } | Wild => {}
229+
Binding { .. } | Wild | Error(_) => {}
230230
Variant { subpatterns, adt_def: _, args: _, variant_index: _ } | Leaf { subpatterns } => {
231231
for subpattern in subpatterns {
232232
visitor.visit_pat(&subpattern.pattern);

‎compiler/rustc_mir_build/src/build/matches/mod.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -814,7 +814,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
814814
}
815815
}
816816

817-
PatKind::Constant { .. } | PatKind::Range { .. } | PatKind::Wild => {}
817+
PatKind::Constant { .. }
818+
| PatKind::Range { .. }
819+
| PatKind::Wild
820+
| PatKind::Error(_) => {}
818821

819822
PatKind::Deref { ref subpattern } => {
820823
self.visit_primary_bindings(subpattern, pattern_user_ty.deref(), f);

‎compiler/rustc_mir_build/src/build/matches/simplify.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -168,7 +168,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
168168
Ok(())
169169
}
170170

171-
PatKind::Wild => {
171+
PatKind::Wild | PatKind::Error(_) => {
172172
// nothing left to do
173173
Ok(())
174174
}

‎compiler/rustc_mir_build/src/build/matches/test.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
7777
| PatKind::Wild
7878
| PatKind::Binding { .. }
7979
| PatKind::Leaf { .. }
80-
| PatKind::Deref { .. } => self.error_simplifiable(match_pair),
80+
| PatKind::Deref { .. }
81+
| PatKind::Error(_) => self.error_simplifiable(match_pair),
8182
}
8283
}
8384

@@ -111,7 +112,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
111112
| PatKind::Binding { .. }
112113
| PatKind::AscribeUserType { .. }
113114
| PatKind::Leaf { .. }
114-
| PatKind::Deref { .. } => {
115+
| PatKind::Deref { .. }
116+
| PatKind::Error(_) => {
115117
// don't know how to add these patterns to a switch
116118
false
117119
}

‎compiler/rustc_mir_build/src/check_unsafety.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -224,7 +224,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
224224
PatKind::Wild |
225225
// these just wrap other patterns
226226
PatKind::Or { .. } |
227-
PatKind::AscribeUserType { .. } => {}
227+
PatKind::AscribeUserType { .. } |
228+
PatKind::Error(_) => {}
228229
}
229230
};
230231

‎compiler/rustc_mir_build/src/thir/pattern/check_match.rs

+26-8
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ use rustc_hir::HirId;
1919
use rustc_middle::thir::visit::{self, Visitor};
2020
use rustc_middle::thir::*;
2121
use rustc_middle::ty::print::with_no_trimmed_paths;
22-
use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt};
22+
use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
2323
use rustc_session::lint::builtin::{
2424
BINDINGS_WITH_VARIANT_NAME, IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS,
2525
};
@@ -231,6 +231,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
231231
if let LetSource::None = source {
232232
return;
233233
}
234+
if let Err(err) = pat.pat_error_reported() {
235+
self.error = Err(err);
236+
return;
237+
}
234238
self.check_patterns(pat, Refutable);
235239
let mut cx = self.new_cx(self.lint_level, true);
236240
let tpat = self.lower_pattern(&mut cx, pat);
@@ -252,6 +256,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
252256
self.with_lint_level(arm.lint_level, |this| {
253257
this.check_patterns(&arm.pattern, Refutable);
254258
});
259+
if let Err(err) = arm.pattern.pat_error_reported() {
260+
self.error = Err(err);
261+
return;
262+
}
255263
}
256264

257265
let tarms: Vec<_> = arms
@@ -334,7 +342,8 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
334342
// and record chain members that aren't let exprs.
335343
let mut chain_refutabilities = Vec::new();
336344

337-
let add = |expr: ExprId, mut local_lint_level| {
345+
let mut error = Ok(());
346+
let mut add = |expr: ExprId, mut local_lint_level| {
338347
// `local_lint_level` is the lint level enclosing the pattern inside `expr`.
339348
let mut expr = &self.thir[expr];
340349
debug!(?expr, ?local_lint_level, "add");
@@ -348,6 +357,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
348357
debug!(?expr, ?local_lint_level, "after scopes");
349358
match expr.kind {
350359
ExprKind::Let { box ref pat, expr: _ } => {
360+
if let Err(err) = pat.pat_error_reported() {
361+
error = Err(err);
362+
return None;
363+
}
351364
let mut ncx = self.new_cx(local_lint_level, true);
352365
let tpat = self.lower_pattern(&mut ncx, pat);
353366
let refutable = !is_let_irrefutable(&mut ncx, local_lint_level, tpat);
@@ -380,6 +393,11 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
380393
debug!(?chain_refutabilities);
381394
chain_refutabilities.reverse();
382395

396+
if error.is_err() {
397+
self.error = error;
398+
return;
399+
}
400+
383401
// Third, emit the actual warnings.
384402
if chain_refutabilities.iter().all(|r| matches!(*r, Some((_, false)))) {
385403
// The entire chain is made up of irrefutable `let` statements
@@ -426,6 +444,12 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
426444

427445
#[instrument(level = "trace", skip(self))]
428446
fn check_irrefutable(&mut self, pat: &Pat<'tcx>, origin: &str, sp: Option<Span>) {
447+
// If we got errors while lowering, don't emit anything more.
448+
if let Err(err) = pat.pat_error_reported() {
449+
self.error = Err(err);
450+
return;
451+
}
452+
429453
let mut cx = self.new_cx(self.lint_level, false);
430454

431455
let pattern = self.lower_pattern(&mut cx, pat);
@@ -682,12 +706,6 @@ fn non_exhaustive_match<'p, 'tcx>(
682706
arms: &[ArmId],
683707
expr_span: Span,
684708
) -> ErrorGuaranteed {
685-
for &arm in arms {
686-
if let Err(err) = thir[arm].pattern.error_reported() {
687-
return err;
688-
}
689-
}
690-
691709
let is_empty_match = arms.is_empty();
692710
let non_empty_enum = match scrut_ty.kind() {
693711
ty::Adt(def, _) => def.is_enum() && !def.variants().is_empty(),

‎compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

+7-15
Original file line numberDiff line numberDiff line change
@@ -196,9 +196,7 @@ impl<'tcx> ConstToPat<'tcx> {
196196
};
197197
// All branches above emitted an error. Don't print any more lints.
198198
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
199-
let kind = PatKind::Constant {
200-
value: mir::Const::Ty(ty::Const::new_error(self.tcx(), e, cv.ty())),
201-
};
199+
let kind = PatKind::Error(e);
202200
return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
203201
} else if !self.saw_const_match_lint.get() {
204202
if let Some(mir_structural_match_violation) = mir_structural_match_violation {
@@ -351,15 +349,15 @@ impl<'tcx> ConstToPat<'tcx> {
351349
let e = tcx.sess.emit_err(InvalidPattern { span, non_sm_ty: ty });
352350
self.saw_const_match_error.set(Some(e));
353351
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
354-
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
352+
PatKind::Error(e)
355353
}
356354
ty::Adt(adt_def, _) if !self.type_marked_structural(ty) => {
357355
debug!("adt_def {:?} has !type_marked_structural for cv.ty: {:?}", adt_def, ty,);
358356
let err = TypeNotStructural { span, non_sm_ty: ty };
359357
let e = tcx.sess.emit_err(err);
360358
self.saw_const_match_error.set(Some(e));
361359
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
362-
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
360+
PatKind::Error(e)
363361
}
364362
ty::Adt(adt_def, args) if adt_def.is_enum() => {
365363
let (&variant_index, fields) = cv.unwrap_branch().split_first().unwrap();
@@ -434,17 +432,13 @@ impl<'tcx> ConstToPat<'tcx> {
434432
} else {
435433
if let Some(e) = self.saw_const_match_error.get() {
436434
// We already errored. Signal that in the pattern, so that follow up errors can be silenced.
437-
PatKind::Constant {
438-
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
439-
}
435+
PatKind::Error(e)
440436
} else {
441437
let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
442438
let e = tcx.sess.emit_err(err);
443439
self.saw_const_match_error.set(Some(e));
444440
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
445-
PatKind::Constant {
446-
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
447-
}
441+
PatKind::Error(e)
448442
}
449443
}
450444
}
@@ -456,9 +450,7 @@ impl<'tcx> ConstToPat<'tcx> {
456450
let err = UnsizedPattern { span, non_sm_ty: *pointee_ty };
457451
let e = tcx.sess.emit_err(err);
458452
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
459-
PatKind::Constant {
460-
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
461-
}
453+
PatKind::Error(e)
462454
} else {
463455
let old = self.behind_reference.replace(true);
464456
// `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
@@ -489,7 +481,7 @@ impl<'tcx> ConstToPat<'tcx> {
489481
let e = tcx.sess.emit_err(err);
490482
self.saw_const_match_error.set(Some(e));
491483
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
492-
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
484+
PatKind::Error(e)
493485
}
494486
};
495487

‎compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs

+4
Original file line numberDiff line numberDiff line change
@@ -1525,6 +1525,10 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
15251525
let pats = expand_or_pat(pat);
15261526
fields = Fields::from_iter(cx, pats.into_iter().map(mkpat));
15271527
}
1528+
PatKind::Error(_) => {
1529+
ctor = Opaque;
1530+
fields = Fields::empty();
1531+
}
15281532
}
15291533
DeconstructedPat::new(ctor, fields, pat.ty, pat.span)
15301534
}

0 commit comments

Comments
 (0)