Auto merge of rust-lang#120651 - matthiaskrgr:rollup-o5qdp0n, r=matth…

…iaskrgr Rollup of 8 pull requests Successful merges: - rust-lang#120507 (Account for non-overlapping unmet trait bounds in suggestion) - rust-lang#120518 (riscv only supports split_debuginfo=off for now) - rust-lang#120521 (Make `NonZero` constructors generic.) - rust-lang#120527 (Switch OwnedStore handle count to AtomicU32) - rust-lang#120550 (Continue to borrowck even if there were previous errors) - rust-lang#120587 (miri: normalize struct tail in ABI compat check) - rust-lang#120590 (Remove unused args from functions) - rust-lang#120607 (fix rust-lang#120603 by adding a check in default_read_buf) Failed merges: - rust-lang#120575 (Simplify codegen diagnostic handling) r? `@ghost` `@rustbot` modify labels: rollup
rust-lang-ci · Feb 5, 2024 · d1110a4 · d1110a4
2 parents 4d87c4a c168f17
commit d1110a4
Show file tree

Hide file tree

Showing 258 changed files with 3,613 additions and 936 deletions.
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
@@ -110,14 110,16 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> &BorrowCheckResult<'_> {
  let (input_body, promoted) = tcx.mir_promoted(def);
  debug!("run query mir_borrowck: {}", tcx.def_path_str(def));
 
- if input_body.borrow().should_skip() {
- debug!("Skipping borrowck because of injected body");
  let input_body: &Body<'_> = &input_body.borrow();
 
  if input_body.should_skip() || input_body.tainted_by_errors.is_some() {
  debug!("Skipping borrowck because of injected body or tainted body");
  // Let's make up a borrowck result! Fun times!
  let result = BorrowCheckResult {
  concrete_opaque_types: FxIndexMap::default(),
  closure_requirements: None,
  used_mut_upvars: SmallVec::new(),
- tainted_by_errors: None,
  tainted_by_errors: input_body.tainted_by_errors,
  };
  return tcx.arena.alloc(result);
  }
@@ -126,7 128,6 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> &BorrowCheckResult<'_> {
 
  let infcx =
  tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(hir_owner.def_id)).build();
- let input_body: &Body<'_> = &input_body.borrow();
  let promoted: &IndexSlice<_, _> = &promoted.borrow();
  let opt_closure_req = do_mir_borrowck(&infcx, input_body, promoted, None).0;
  debug!("mir_borrowck done");

diff --git a/compiler/rustc_borrowck/src/nll.rs b/compiler/rustc_borrowck/src/nll.rs
@@ -184,7 184,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
 
  // Solve the region constraints.
  let (closure_region_requirements, nll_errors) =
- regioncx.solve(infcx, param_env, body, polonius_output.clone());
  regioncx.solve(infcx, body, polonius_output.clone());
 
  if !nll_errors.is_empty() {
  // Suppress unhelpful extra errors in `infer_opaque_types`.

diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -658,7 658,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  pub(super) fn solve(
  &mut self,
  infcx: &InferCtxt<'tcx>,
- param_env: ty::ParamEnv<'tcx>,
  body: &Body<'tcx>,
  polonius_output: Option<Rc<PoloniusOutput>>,
  ) -> (Option<ClosureRegionRequirements<'tcx>>, RegionErrors<'tcx>) {
@@ -674,7 673,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  // eagerly.
  let mut outlives_requirements = infcx.tcx.is_typeck_child(mir_def_id).then(Vec::new);
 
- self.check_type_tests(infcx, body, outlives_requirements.as_mut(), &mut errors_buffer);
  self.check_type_tests(infcx, outlives_requirements.as_mut(), &mut errors_buffer);
 
  debug!(?errors_buffer);
  debug!(?outlives_requirements);
@@ -932,7 931,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  fn check_type_tests(
  &self,
  infcx: &InferCtxt<'tcx>,
- body: &Body<'tcx>,
  mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
  errors_buffer: &mut RegionErrors<'tcx>,
  ) {
@@ -957,12 955,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  }
 
  if let Some(propagated_outlives_requirements) = &mut propagated_outlives_requirements {
- if self.try_promote_type_test(
- infcx,
- body,
- type_test,
- propagated_outlives_requirements,
- ) {
  if self.try_promote_type_test(infcx, type_test, propagated_outlives_requirements) {
  continue;
  }
  }
@@ -1016,7 1009,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  fn try_promote_type_test(
  &self,
  infcx: &InferCtxt<'tcx>,
- body: &Body<'tcx>,
  type_test: &TypeTest<'tcx>,
  propagated_outlives_requirements: &mut Vec<ClosureOutlivesRequirement<'tcx>>,
  ) -> bool {
@@ -1179,35 1171,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  Some(ClosureOutlivesSubject::Ty(ClosureOutlivesSubjectTy::bind(tcx, ty)))
  }
 
- /// Returns a universally quantified region that outlives the
- /// value of `r` (`r` may be existentially or universally
- /// quantified).
- ///
- /// Since `r` is (potentially) an existential region, it has some
- /// value which may include (a) any number of points in the CFG
- /// and (b) any number of `end('x)` elements of universally
- /// quantified regions. To convert this into a single universal
- /// region we do as follows:
- ///
- /// - Ignore the CFG points in `'r`. All universally quantified regions
- /// include the CFG anyhow.
- /// - For each `end('x)` element in `'r`, compute the mutual LUB, yielding
- /// a result `'y`.
- #[instrument(skip(self), level = "debug", ret)]
- pub(crate) fn universal_upper_bound(&self, r: RegionVid) -> RegionVid {
- debug!(r = %self.region_value_str(r));
-
- // Find the smallest universal region that contains all other
- // universal regions within `region`.
- let mut lub = self.universal_regions.fr_fn_body;
- let r_scc = self.constraint_sccs.scc(r);
- for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
- lub = self.universal_region_relations.postdom_upper_bound(lub, ur);
- }
-
- lub
- }
-
  /// Like `universal_upper_bound`, but returns an approximation more suitable
  /// for diagnostics. If `r` contains multiple disjoint universal regions
  /// (e.g. 'a and 'b in `fn foo<'a, 'b> { ... }`, we pick the lower-numbered region.

diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -217,7 217,6 @@ pub(crate) fn type_check<'mir, 'tcx>(
  CustomTypeOp::new(
  |ocx| {
  ocx.infcx.register_member_constraints(
- param_env,
  opaque_type_key,
  decl.hidden_type.ty,
  decl.hidden_type.span,

diff --git a/compiler/rustc_const_eval/src/interpret/terminator.rs b/compiler/rustc_const_eval/src/interpret/terminator.rs
@@ -373,7 373,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  if let (Some(caller), Some(callee)) = (pointee_ty(caller.ty)?, pointee_ty(callee.ty)?) {
  // This is okay if they have the same metadata type.
  let meta_ty = |ty: Ty<'tcx>| {
- let (meta, only_if_sized) = ty.ptr_metadata_ty(*self.tcx, |ty| ty);
  // Even if `ty` is normalized, the search for the unsized tail will project
  // to fields, which can yield non-normalized types. So we need to provide a
  // normalization function.
  let normalize = |ty| self.tcx.normalize_erasing_regions(self.param_env, ty);
  let (meta, only_if_sized) = ty.ptr_metadata_ty(*self.tcx, normalize);
  assert!(
  !only_if_sized,
  "there should be no more 'maybe has that metadata' types during interpretation"

diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -163,10 163,6 @@ impl Lifetime {
  (LifetimeSuggestionPosition::Normal, self.ident.span)
  }
  }
-
- pub fn is_static(&self) -> bool {
- self.res == LifetimeName::Static
- }
 }
 
 /// A `Path` is essentially Rust's notion of a name; for instance,

diff --git a/compiler/rustc_hir_analysis/src/astconv/bounds.rs b/compiler/rustc_hir_analysis/src/astconv/bounds.rs
@@ -243,9 243,7 @@ impl<'tcx> dyn AstConv<'tcx> '_ {
  speculative: bool,
  dup_bindings: &mut FxHashMap<DefId, Span>,
  path_span: Span,
- constness: ty::BoundConstness,
  only_self_bounds: OnlySelfBounds,
- polarity: ty::ImplPolarity,
  ) -> Result<(), ErrorGuaranteed> {
  // Given something like `U: SomeTrait<T = X>`, we want to produce a
  // predicate like `<U as SomeTrait>::T = X`. This is somewhat

diff --git a/compiler/rustc_hir_analysis/src/astconv/generics.rs b/compiler/rustc_hir_analysis/src/astconv/generics.rs
@@ -16,7 16,7 @@ use rustc_middle::ty::{
  self, GenericArgsRef, GenericParamDef, GenericParamDefKind, IsSuggestable, Ty, TyCtxt,
 };
 use rustc_session::lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS;
-use rustc_span::{symbol::kw, Span};
 use rustc_span::symbol::kw;
 use smallvec::SmallVec;
 
 /// Report an error that a generic argument did not match the generic parameter that was
@@ -404,7 404,6 @@ pub fn create_args_for_parent_generic_args<'tcx: 'a, 'a>(
 /// Used specifically for function calls.
 pub fn check_generic_arg_count_for_call(
  tcx: TyCtxt<'_>,
- span: Span,
  def_id: DefId,
  generics: &ty::Generics,
  seg: &hir::PathSegment<'_>,
@@ -418,25 417,14 @@ pub fn check_generic_arg_count_for_call(
  };
  let has_self = generics.parent.is_none() && generics.has_self;
 
- check_generic_arg_count(
- tcx,
- span,
- def_id,
- seg,
- generics,
- gen_args,
- gen_pos,
- has_self,
- seg.infer_args,
- )
  check_generic_arg_count(tcx, def_id, seg, generics, gen_args, gen_pos, has_self, seg.infer_args)
 }
 
 /// Checks that the correct number of generic arguments have been provided.
 /// This is used both for datatypes and function calls.
 #[instrument(skip(tcx, gen_pos), level = "debug")]
 pub(crate) fn check_generic_arg_count(
  tcx: TyCtxt<'_>,
- span: Span,
  def_id: DefId,
  seg: &hir::PathSegment<'_>,
  gen_params: &ty::Generics,

diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -12,7 12,7 @@ use crate::astconv::errors::prohibit_assoc_ty_binding;
 use crate::astconv::generics::{check_generic_arg_count, create_args_for_parent_generic_args};
 use crate::bounds::Bounds;
 use crate::collect::HirPlaceholderCollector;
-use crate::errors::{AmbiguousLifetimeBound, TypeofReservedKeywordUsed};
 use crate::errors::AmbiguousLifetimeBound;
 use crate::middle::resolve_bound_vars as rbv;
 use crate::require_c_abi_if_c_variadic;
 use rustc_ast::TraitObjectSyntax;
@@ -25,13 25,13 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Namespace, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{walk_generics, Visitor as _};
-use rustc_hir::{GenericArg, GenericArgs, OpaqueTyOrigin};
 use rustc_hir::{GenericArg, GenericArgs};
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::middle::stability::AllowUnstable;
 use rustc_middle::ty::{
- self, Const, GenericArgKind, GenericArgsRef, GenericParamDefKind, IsSuggestable, ParamEnv, Ty,
- TyCtxt, TypeVisitableExt,
  self, Const, GenericArgKind, GenericArgsRef, GenericParamDefKind, ParamEnv, Ty, TyCtxt,
  TypeVisitableExt,
 };
 use rustc_session::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS;
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -379,7 379,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
 
  let mut arg_count = check_generic_arg_count(
  tcx,
- span,
  def_id,
  seg,
  generics,
@@ -773,9 772,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  speculative,
  &mut dup_bindings,
  binding.span,
- constness,
  only_self_bounds,
- polarity,
  );
  // Okay to ignore `Err` because of `ErrorGuaranteed` (see above).
  }
@@ -2491,7 2488,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  let opaque_ty = tcx.hir().item(item_id);
 
  match opaque_ty.kind {
- hir::ItemKind::OpaqueTy(&hir::OpaqueTy { origin, .. }) => {
  hir::ItemKind::OpaqueTy(&hir::OpaqueTy { .. }) => {
  let local_def_id = item_id.owner_id.def_id;
  // If this is an RPITIT and we are using the new RPITIT lowering scheme, we
  // generate the def_id of an associated type for the trait and return as
@@ -2501,7 2498,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  } else {
  local_def_id.to_def_id()
  };
- self.impl_trait_ty_to_ty(def_id, lifetimes, origin, in_trait)
  self.impl_trait_ty_to_ty(def_id, lifetimes, in_trait)
  }
  ref i => bug!("`impl Trait` pointed to non-opaque type?? {:#?}", i),
  }
@@ -2537,21 2534,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
 
  Ty::new_array_with_const_len(tcx, self.ast_ty_to_ty(ty), length)
  }
- hir::TyKind::Typeof(e) => {
- let ty_erased = tcx.type_of(e.def_id).instantiate_identity();
- let ty = tcx.fold_regions(ty_erased, |r, _| {
- if r.is_erased() { tcx.lifetimes.re_static } else { r }
- });
- let span = ast_ty.span;
- let (ty, opt_sugg) = if let Some(ty) = ty.make_suggestable(tcx, false) {
- (ty, Some((span, Applicability::MachineApplicable)))
- } else {
- (ty, None)
- };
- tcx.dcx().emit_err(TypeofReservedKeywordUsed { span, ty, opt_sugg });
-
- ty
- }
  hir::TyKind::Typeof(e) => tcx.type_of(e.def_id).instantiate_identity(),
  hir::TyKind::Infer => {
  // Infer also appears as the type of arguments or return
  // values in an ExprKind::Closure, or as
@@ -2571,7 2554,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  &self,
  def_id: DefId,
  lifetimes: &[hir::GenericArg<'_>],
- origin: OpaqueTyOrigin,
  in_trait: bool,
  ) -> Ty<'tcx> {
  debug!("impl_trait_ty_to_ty(def_id={:?}, lifetimes={:?})", def_id, lifetimes);

diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -9,6 9,8 @@ use rustc_middle::ty::{self, ImplTraitInTraitData, IsSuggestable, Ty, TyCtxt, Ty
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, DUMMY_SP};
 
 use crate::errors::TypeofReservedKeywordUsed;
 
 use super::bad_placeholder;
 use super::ItemCtxt;
 pub use opaque::test_opaque_hidden_types;
@@ -39,8 41,18 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  {
  return tcx.types.usize;
  }
- Node::Ty(&hir::Ty { kind: TyKind::Typeof(ref e), .. }) if e.hir_id == hir_id => {
- return tcx.typeck(def_id).node_type(e.hir_id);
  Node::Ty(&hir::Ty { kind: TyKind::Typeof(ref e), span, .. }) if e.hir_id == hir_id => {
  let ty = tcx.typeck(def_id).node_type(e.hir_id);
  let ty = tcx.fold_regions(ty, |r, _| {
  if r.is_erased() { ty::Region::new_error_misc(tcx) } else { r }
  });
  let (ty, opt_sugg) = if let Some(ty) = ty.make_suggestable(tcx, false) {
  (ty, Some((span, Applicability::MachineApplicable)))
  } else {
  (ty, None)
  };
  tcx.dcx().emit_err(TypeofReservedKeywordUsed { span, ty, opt_sugg });
  return ty;
  }
  Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
  | Node::Item(&Item { kind: ItemKind::GlobalAsm(asm), .. })

diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
@@ -209,7 209,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
 
  tcx.ensure().check_unused_traits(());
 
- if let Some(reported) = tcx.dcx().has_errors() { Err(reported) } else { Ok(()) }
  Ok(())
 }
 
 /// A quasi-deprecated helper used in rustdoc and clippy to get

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -521,7 521,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  /// We must not attempt to select obligations after this method has run, or risk query cycle
  /// ICE.
  #[instrument(level = "debug", skip(self))]
- pub(in super::super) fn resolve_coroutine_interiors(&self, def_id: DefId) {
  pub(in super::super) fn resolve_coroutine_interiors(&self) {
  // Try selecting all obligations that are not blocked on inference variables.
  // Once we start unifying coroutine witnesses, trying to select obligations on them will
  // trigger query cycle ICEs, as doing so requires MIR.
@@ -1175,14 1175,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // parameter internally, but we don't allow users to specify the
  // parameter's value explicitly, so we have to do some error-
  // checking here.
- let arg_count = check_generic_arg_count_for_call(
- tcx,
- span,
- def_id,
- generics,
- seg,
- IsMethodCall::No,
- );
  let arg_count =
  check_generic_arg_count_for_call(tcx, def_id, generics, seg, IsMethodCall::No);
 
  if let ExplicitLateBound::Yes = arg_count.explicit_late_bound {
  explicit_late_bound = ExplicitLateBound::Yes;

diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
@@ -286,7 286,7 @@ fn typeck_with_fallback<'tcx>(
  debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
 
  // This must be the last thing before `report_ambiguity_errors`.
- fcx.resolve_coroutine_interiors(def_id.to_def_id());
  fcx.resolve_coroutine_interiors();
 
  debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
 

diff --git a/compiler/rustc_hir_typeck/src/mem_categorization.rs b/compiler/rustc_hir_typeck/src/mem_categorization.rs
@@ -436,7 436,8 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
  pub(crate) fn cat_rvalue(
  &self,
  hir_id: hir::HirId,
- span: Span,
  // FIXME: remove
  _span: Span,
  expr_ty: Ty<'tcx>,
  ) -> PlaceWithHirId<'tcx> {
  PlaceWithHirId::new(hir_id, expr_ty, PlaceBase::Rvalue, Vec::new())

diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -356,7 356,6 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
 
  let arg_count_correct = check_generic_arg_count_for_call(
  self.tcx,
- self.span,
  pick.item.def_id,
  generics,
  seg,