Auto merge of rust-lang#116737 - matthiaskrgr:rollup-jftlnmt, r=matth…

…iaskrgr 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
rust-lang-ci · Oct 14, 2023 · ee8c9d3 · ee8c9d3
2 parents 8de6f99 77b578f
commit ee8c9d3
Show file tree

Hide file tree

Showing 35 changed files with 434 additions and 161 deletions.
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
@@ -19,11 19,12 @@ use rustc_middle::middle::region;
 use rustc_middle::mir::interpret::AllocId;
 use rustc_middle::mir::{self, BinOp, BorrowKind, FakeReadCause, Mutability, UnOp};
 use rustc_middle::ty::adjustment::PointerCoercion;
-use rustc_middle::ty::GenericArgsRef;
-use rustc_middle::ty::{self, AdtDef, FnSig, List, Ty, UpvarArgs};
-use rustc_middle::ty::{CanonicalUserType, CanonicalUserTypeAnnotation};
 use rustc_middle::ty::{
  self, AdtDef, CanonicalUserType, CanonicalUserTypeAnnotation, FnSig, GenericArgsRef, List, Ty,
  UpvarArgs,
 };
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_span::{sym, ErrorGuaranteed, Span, Symbol, DUMMY_SP};
 use rustc_target::abi::{FieldIdx, VariantIdx};
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use std::fmt;
@@ -632,7 633,7 @@ impl<'tcx> Pat<'tcx> {
 
  use PatKind::*;
  match &self.kind {
- Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } => {}
  Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } | Error(_) => {}
  AscribeUserType { subpattern, .. }
  | Binding { subpattern: Some(subpattern), .. }
  | Deref { subpattern } => subpattern.walk_(it),
@@ -647,6 648,21 @@ impl<'tcx> Pat<'tcx> {
  }
  }
 
  /// Whether the pattern has a `PatKind::Error` nested within.
  pub fn pat_error_reported(&self) -> Result<(), ErrorGuaranteed> {
  let mut error = None;
  self.walk(|pat| {
  if let PatKind::Error(e) = pat.kind && error.is_none() {
  error = Some(e);
  }
  error.is_none()
  });
  match error {
  None => Ok(()),
  Some(e) => Err(e),
  }
  }
 
  /// Walk the pattern in left-to-right order.
  ///
  /// If you always want to recurse, prefer this method over `walk`.
@@ -771,6 787,10 @@ pub enum PatKind<'tcx> {
  Or {
  pats: Box<[Box<Pat<'tcx>>]>,
  },
 
  /// An error has been encountered during lowering. We probably shouldn't report more lints
  /// related to this pattern.
  Error(ErrorGuaranteed),
 }
 
 #[derive(Clone, Debug, PartialEq, HashStable, TypeVisitable)]
@@ -934,6 954,7 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
  }
  Ok(())
  }
  PatKind::Error(_) => write!(f, "<error>"),
  }
  }
 }

diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
@@ -226,7 226,7 @@ pub fn walk_pat<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, pat: &Pat<'
  is_primary: _,
  name: _,
  } => visitor.visit_pat(&subpattern),
- Binding { .. } | Wild => {}
  Binding { .. } | Wild | Error(_) => {}
  Variant { subpatterns, adt_def: _, args: _, variant_index: _ } | Leaf { subpatterns } => {
  for subpattern in subpatterns {
  visitor.visit_pat(&subpattern.pattern);

diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs
@@ -814,7 814,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  }
  }
 
- PatKind::Constant { .. } | PatKind::Range { .. } | PatKind::Wild => {}
  PatKind::Constant { .. }
  | PatKind::Range { .. }
  | PatKind::Wild
  | PatKind::Error(_) => {}
 
  PatKind::Deref { ref subpattern } => {
  self.visit_primary_bindings(subpattern, pattern_user_ty.deref(), f);

diff --git a/compiler/rustc_mir_build/src/build/matches/simplify.rs b/compiler/rustc_mir_build/src/build/matches/simplify.rs
@@ -168,7 168,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  Ok(())
  }
 
- PatKind::Wild => {
  PatKind::Wild | PatKind::Error(_) => {
  // nothing left to do
  Ok(())
  }

diff --git a/compiler/rustc_mir_build/src/build/matches/test.rs b/compiler/rustc_mir_build/src/build/matches/test.rs
@@ -77,7 77,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  | PatKind::Wild
  | PatKind::Binding { .. }
  | PatKind::Leaf { .. }
- | PatKind::Deref { .. } => self.error_simplifiable(match_pair),
  | PatKind::Deref { .. }
  | PatKind::Error(_) => self.error_simplifiable(match_pair),
  }
  }
 
@@ -111,7 112,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  | PatKind::Binding { .. }
  | PatKind::AscribeUserType { .. }
  | PatKind::Leaf { .. }
- | PatKind::Deref { .. } => {
  | PatKind::Deref { .. }
  | PatKind::Error(_) => {
  // don't know how to add these patterns to a switch
  false
  }

diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -224,7 224,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
  PatKind::Wild |
  // these just wrap other patterns
  PatKind::Or { .. } |
- PatKind::AscribeUserType { .. } => {}
  PatKind::AscribeUserType { .. } |
  PatKind::Error(_) => {}
  }
  };
 

diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -19,7 19,7 @@ use rustc_hir::HirId;
 use rustc_middle::thir::visit::{self, Visitor};
 use rustc_middle::thir::*;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
 use rustc_session::lint::builtin::{
  BINDINGS_WITH_VARIANT_NAME, IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS,
 };
@@ -231,6 231,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
  if let LetSource::None = source {
  return;
  }
  if let Err(err) = pat.pat_error_reported() {
  self.error = Err(err);
  return;
  }
  self.check_patterns(pat, Refutable);
  let mut cx = self.new_cx(self.lint_level, true);
  let tpat = self.lower_pattern(&mut cx, pat);
@@ -252,6 256,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
  self.with_lint_level(arm.lint_level, |this| {
  this.check_patterns(&arm.pattern, Refutable);
  });
  if let Err(err) = arm.pattern.pat_error_reported() {
  self.error = Err(err);
  return;
  }
  }
 
  let tarms: Vec<_> = arms
@@ -334,7 342,8 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
  // and record chain members that aren't let exprs.
  let mut chain_refutabilities = Vec::new();
 
- let add = |expr: ExprId, mut local_lint_level| {
  let mut error = Ok(());
  let mut add = |expr: ExprId, mut local_lint_level| {
  // `local_lint_level` is the lint level enclosing the pattern inside `expr`.
  let mut expr = &self.thir[expr];
  debug!(?expr, ?local_lint_level, "add");
@@ -348,6 357,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
  debug!(?expr, ?local_lint_level, "after scopes");
  match expr.kind {
  ExprKind::Let { box ref pat, expr: _ } => {
  if let Err(err) = pat.pat_error_reported() {
  error = Err(err);
  return None;
  }
  let mut ncx = self.new_cx(local_lint_level, true);
  let tpat = self.lower_pattern(&mut ncx, pat);
  let refutable = !is_let_irrefutable(&mut ncx, local_lint_level, tpat);
@@ -380,6 393,11 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
  debug!(?chain_refutabilities);
  chain_refutabilities.reverse();
 
  if error.is_err() {
  self.error = error;
  return;
  }
 
  // Third, emit the actual warnings.
  if chain_refutabilities.iter().all(|r| matches!(*r, Some((_, false)))) {
  // The entire chain is made up of irrefutable `let` statements
@@ -426,6 444,12 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
 
  #[instrument(level = "trace", skip(self))]
  fn check_irrefutable(&mut self, pat: &Pat<'tcx>, origin: &str, sp: Option<Span>) {
  // If we got errors while lowering, don't emit anything more.
  if let Err(err) = pat.pat_error_reported() {
  self.error = Err(err);
  return;
  }
 
  let mut cx = self.new_cx(self.lint_level, false);
 
  let pattern = self.lower_pattern(&mut cx, pat);
@@ -682,12 706,6 @@ fn non_exhaustive_match<'p, 'tcx>(
  arms: &[ArmId],
  expr_span: Span,
 ) -> ErrorGuaranteed {
- for &arm in arms {
- if let Err(err) = thir[arm].pattern.error_reported() {
- return err;
- }
- }
-
  let is_empty_match = arms.is_empty();
  let non_empty_enum = match scrut_ty.kind() {
  ty::Adt(def, _) => def.is_enum() && !def.variants().is_empty(),

diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -196,9 196,7 @@ impl<'tcx> ConstToPat<'tcx> {
  };
  // All branches above emitted an error. Don't print any more lints.
  // We errored. Signal that in the pattern, so that follow up errors can be silenced.
- let kind = PatKind::Constant {
- value: mir::Const::Ty(ty::Const::new_error(self.tcx(), e, cv.ty())),
- };
  let kind = PatKind::Error(e);
  return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
  } else if !self.saw_const_match_lint.get() {
  if let Some(mir_structural_match_violation) = mir_structural_match_violation {
@@ -351,15 349,15 @@ impl<'tcx> ConstToPat<'tcx> {
  let e = tcx.sess.emit_err(InvalidPattern { span, non_sm_ty: ty });
  self.saw_const_match_error.set(Some(e));
  // We errored. Signal that in the pattern, so that follow up errors can be silenced.
- PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
  PatKind::Error(e)
  }
  ty::Adt(adt_def, _) if !self.type_marked_structural(ty) => {
  debug!("adt_def {:?} has !type_marked_structural for cv.ty: {:?}", adt_def, ty,);
  let err = TypeNotStructural { span, non_sm_ty: ty };
  let e = tcx.sess.emit_err(err);
  self.saw_const_match_error.set(Some(e));
  // We errored. Signal that in the pattern, so that follow up errors can be silenced.
- PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
  PatKind::Error(e)
  }
  ty::Adt(adt_def, args) if adt_def.is_enum() => {
  let (&variant_index, fields) = cv.unwrap_branch().split_first().unwrap();
@@ -434,17 432,13 @@ impl<'tcx> ConstToPat<'tcx> {
  } else {
  if let Some(e) = self.saw_const_match_error.get() {
  // We already errored. Signal that in the pattern, so that follow up errors can be silenced.
- PatKind::Constant {
- value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
- }
  PatKind::Error(e)
  } else {
  let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
  let e = tcx.sess.emit_err(err);
  self.saw_const_match_error.set(Some(e));
  // We errored. Signal that in the pattern, so that follow up errors can be silenced.
- PatKind::Constant {
- value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
- }
  PatKind::Error(e)
  }
  }
  }
@@ -456,9 450,7 @@ impl<'tcx> ConstToPat<'tcx> {
  let err = UnsizedPattern { span, non_sm_ty: *pointee_ty };
  let e = tcx.sess.emit_err(err);
  // We errored. Signal that in the pattern, so that follow up errors can be silenced.
- PatKind::Constant {
- value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
- }
  PatKind::Error(e)
  } else {
  let old = self.behind_reference.replace(true);
  // `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
@@ -489,7 481,7 @@ impl<'tcx> ConstToPat<'tcx> {
  let e = tcx.sess.emit_err(err);
  self.saw_const_match_error.set(Some(e));
  // We errored. Signal that in the pattern, so that follow up errors can be silenced.
- PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
  PatKind::Error(e)
  }
  };
 

diff --git a/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs
@@ -1525,6 1525,10 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
  let pats = expand_or_pat(pat);
  fields = Fields::from_iter(cx, pats.into_iter().map(mkpat));
  }
  PatKind::Error(_) => {
  ctor = Opaque;
  fields = Fields::empty();
  }
  }
  DeconstructedPat::new(ctor, fields, pat.ty, pat.span)
  }