Auto merge of #97315 - Dylan-DPC:rollup-2wee2oz, r=Dylan-DPC

Rollup of 4 pull requests Successful merges: - #96129 (Document rounding for floating-point primitive operations and string parsing) - #97286 (Add new eslint rule to prevent whitespace before function call paren) - #97292 (Lifetime variance fixes for rustc) - #97309 (Add some regression tests for #90400) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup

Author: bors

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1,5 +1,6 @@
 use either::Either;
 use rustc_const_eval::util::CallKind;
+use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed, MultiSpan};
 use rustc_hir as hir;
@@ -1622,10 +1623,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  location: Location,
  mpi: MovePathIndex,
  ) -> (Vec<MoveSite>, Vec<Location>) {
- fn predecessor_locations<'a>(
- body: &'a mir::Body<'_>,
+ fn predecessor_locations<'tcx, 'a>(
+ body: &'a mir::Body<'tcx>,
  location: Location,
- ) -> impl Iterator<Item = Location> + 'a {
+ ) -> impl Iterator<Item = Location> + Captures<'tcx> + 'a {
  if location.statement_index == 0 {
  let predecessors = body.predecessors()[location.block].to_vec();
  Either::Left(predecessors.into_iter().map(move |bb| body.terminator_loc(bb)))

compiler/rustc_borrowck/src/member_constraints.rs

@@ -1,3 +1,4 @@
+use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_index::vec::IndexVec;
 use rustc_middle::infer::MemberConstraint;
@@ -140,11 +141,13 @@ where
  }
 }
 
-impl<R> MemberConstraintSet<'_, R>
+impl<'tcx, R> MemberConstraintSet<'tcx, R>
 where
  R: Copy + Hash + Eq,
 {
- pub(crate) fn all_indices(&self) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ {
+ pub(crate) fn all_indices(
+ &self,
+ ) -> impl Iterator<Item = NllMemberConstraintIndex> + Captures<'tcx> + '_ {
  self.constraints.indices()
  }
 
@@ -154,7 +157,7 @@ where
  pub(crate) fn indices(
  &self,
  member_region_vid: R,
- ) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ {
+ ) -> impl Iterator<Item = NllMemberConstraintIndex> + Captures<'tcx> + '_ {
  let mut next = self.first_constraints.get(&member_region_vid).cloned();
  std::iter::from_fn(move || -> Option<NllMemberConstraintIndex> {
  if let Some(current) = next {

compiler/rustc_borrowck/src/type_check/liveness/polonius.rs

@@ -10,17 +10,17 @@ use super::TypeChecker;
 type VarPointRelation = Vec<(Local, LocationIndex)>;
 type PathPointRelation = Vec<(MovePathIndex, LocationIndex)>;
 
-struct UseFactsExtractor<'me> {
+struct UseFactsExtractor<'me, 'tcx> {
  var_defined_at: &'me mut VarPointRelation,
  var_used_at: &'me mut VarPointRelation,
  location_table: &'me LocationTable,
  var_dropped_at: &'me mut VarPointRelation,
- move_data: &'me MoveData<'me>,
+ move_data: &'me MoveData<'tcx>,
  path_accessed_at_base: &'me mut PathPointRelation,
 }
 
 // A Visitor to walk through the MIR and extract point-wise facts
-impl UseFactsExtractor<'_> {
+impl UseFactsExtractor<'_, '_> {
  fn location_to_index(&self, location: Location) -> LocationIndex {
  self.location_table.mid_index(location)
  }
@@ -53,7 +53,7 @@ impl UseFactsExtractor<'_> {
  }
 }
 
-impl Visitor<'_> for UseFactsExtractor<'_> {
+impl<'a, 'tcx> Visitor<'tcx> for UseFactsExtractor<'a, 'tcx> {
  fn visit_local(&mut self, &local: &Local, context: PlaceContext, location: Location) {
  match def_use::categorize(context) {
  Some(DefUse::Def) => self.insert_def(local, location),
@@ -63,7 +63,7 @@ impl Visitor<'_> for UseFactsExtractor<'_> {
  }
  }
 
- fn visit_place(&mut self, place: &Place<'_>, context: PlaceContext, location: Location) {
+ fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
  self.super_place(place, context, location);
  match context {
  PlaceContext::NonMutatingUse(_) => {
@@ -82,11 +82,11 @@ impl Visitor<'_> for UseFactsExtractor<'_> {
  }
 }
 
-pub(super) fn populate_access_facts<'tcx>(
- typeck: &mut TypeChecker<'_, 'tcx>,
+pub(super) fn populate_access_facts<'a, 'tcx>(
+ typeck: &mut TypeChecker<'a, 'tcx>,
  body: &Body<'tcx>,
  location_table: &LocationTable,
- move_data: &MoveData<'_>,
+ move_data: &MoveData<'tcx>,
  dropped_at: &mut Vec<(Local, Location)>,
 ) {
  debug!("populate_access_facts()");

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -197,7 +197,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  size: Size,
  align: Align,
  kind: MemoryKind<M::MemoryKind>,
- ) -> InterpResult<'static, Pointer<M::PointerTag>> {
+ ) -> InterpResult<'tcx, Pointer<M::PointerTag>> {
  let alloc = Allocation::uninit(size, align, M::PANIC_ON_ALLOC_FAIL)?;
  Ok(self.allocate_raw_ptr(alloc, kind))
  }
@@ -402,7 +402,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  msg: CheckInAllocMsg,
  alloc_size: impl FnOnce(AllocId, Size, M::TagExtra) -> InterpResult<'tcx, (Size, Align, T)>,
  ) -> InterpResult<'tcx, Option<T>> {
- fn check_offset_align(offset: u64, align: Align) -> InterpResult<'static> {
+ fn check_offset_align<'tcx>(offset: u64, align: Align) -> InterpResult<'tcx> {
  if offset % align.bytes() == 0 {
  Ok(())
  } else {
@@ -654,7 +654,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  &self,
  id: AllocId,
  liveness: AllocCheck,
- ) -> InterpResult<'static, (Size, Align)> {
+ ) -> InterpResult<'tcx, (Size, Align)> {
  // # Regular allocations
  // Don't use `self.get_raw` here as that will
  // a) cause cycles in case `id` refers to a static

compiler/rustc_const_eval/src/interpret/place.rs

@@ -1011,7 +1011,7 @@ where
  &mut self,
  layout: TyAndLayout<'tcx>,
  kind: MemoryKind<M::MemoryKind>,
- ) -> InterpResult<'static, MPlaceTy<'tcx, M::PointerTag>> {
+ ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> {
  let ptr = self.allocate_ptr(layout.size, layout.align.abi, kind)?;
  Ok(MPlaceTy::from_aligned_ptr(ptr.into(), layout))
  }

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/util.rs

@@ -98,7 +98,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
  &self,
  anon_region: Region<'tcx>,
  replace_region: Region<'tcx>,
- ) -> Option<AnonymousParamInfo<'_>> {
+ ) -> Option<AnonymousParamInfo<'tcx>> {
  find_param_with_region(self.tcx(), anon_region, replace_region)
  }
 

compiler/rustc_middle/src/mir/interpret/allocation.rs

@@ -171,7 +171,7 @@ impl<Tag> Allocation<Tag> {
 
  /// Try to create an Allocation of `size` bytes, failing if there is not enough memory
  /// available to the compiler to do so.
- pub fn uninit(size: Size, align: Align, panic_on_fail: bool) -> InterpResult<'static, Self> {
+ pub fn uninit<'tcx>(size: Size, align: Align, panic_on_fail: bool) -> InterpResult<'tcx, Self> {
  let bytes = Box::<[u8]>::try_new_zeroed_slice(size.bytes_usize()).map_err(|_| {
  // This results in an error that can happen non-deterministically, since the memory
  // available to the compiler can change between runs. Normally queries are always

compiler/rustc_middle/src/mir/interpret/value.rs

@@ -397,90 +397,90 @@ impl<'tcx, Tag: Provenance> Scalar<Tag> {
  /// Converts the scalar to produce an unsigned integer of the given size.
  /// Fails if the scalar is a pointer.
  #[inline]
- pub fn to_uint(self, size: Size) -> InterpResult<'static, u128> {
+ pub fn to_uint(self, size: Size) -> InterpResult<'tcx, u128> {
  self.to_bits(size)
  }
 
  /// Converts the scalar to produce a `u8`. Fails if the scalar is a pointer.
- pub fn to_u8(self) -> InterpResult<'static, u8> {
+ pub fn to_u8(self) -> InterpResult<'tcx, u8> {
  self.to_uint(Size::from_bits(8)).map(|v| u8::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce a `u16`. Fails if the scalar is a pointer.
- pub fn to_u16(self) -> InterpResult<'static, u16> {
+ pub fn to_u16(self) -> InterpResult<'tcx, u16> {
  self.to_uint(Size::from_bits(16)).map(|v| u16::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce a `u32`. Fails if the scalar is a pointer.
- pub fn to_u32(self) -> InterpResult<'static, u32> {
+ pub fn to_u32(self) -> InterpResult<'tcx, u32> {
  self.to_uint(Size::from_bits(32)).map(|v| u32::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce a `u64`. Fails if the scalar is a pointer.
- pub fn to_u64(self) -> InterpResult<'static, u64> {
+ pub fn to_u64(self) -> InterpResult<'tcx, u64> {
  self.to_uint(Size::from_bits(64)).map(|v| u64::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce a `u128`. Fails if the scalar is a pointer.
- pub fn to_u128(self) -> InterpResult<'static, u128> {
+ pub fn to_u128(self) -> InterpResult<'tcx, u128> {
  self.to_uint(Size::from_bits(128))
  }
 
  /// Converts the scalar to produce a machine-pointer-sized unsigned integer.
  /// Fails if the scalar is a pointer.
- pub fn to_machine_usize(self, cx: &impl HasDataLayout) -> InterpResult<'static, u64> {
+ pub fn to_machine_usize(self, cx: &impl HasDataLayout) -> InterpResult<'tcx, u64> {
  let b = self.to_uint(cx.data_layout().pointer_size)?;
  Ok(u64::try_from(b).unwrap())
  }
 
  /// Converts the scalar to produce a signed integer of the given size.
  /// Fails if the scalar is a pointer.
  #[inline]
- pub fn to_int(self, size: Size) -> InterpResult<'static, i128> {
+ pub fn to_int(self, size: Size) -> InterpResult<'tcx, i128> {
  let b = self.to_bits(size)?;
  Ok(size.sign_extend(b) as i128)
  }
 
  /// Converts the scalar to produce an `i8`. Fails if the scalar is a pointer.
- pub fn to_i8(self) -> InterpResult<'static, i8> {
+ pub fn to_i8(self) -> InterpResult<'tcx, i8> {
  self.to_int(Size::from_bits(8)).map(|v| i8::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce an `i16`. Fails if the scalar is a pointer.
- pub fn to_i16(self) -> InterpResult<'static, i16> {
+ pub fn to_i16(self) -> InterpResult<'tcx, i16> {
  self.to_int(Size::from_bits(16)).map(|v| i16::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce an `i32`. Fails if the scalar is a pointer.
- pub fn to_i32(self) -> InterpResult<'static, i32> {
+ pub fn to_i32(self) -> InterpResult<'tcx, i32> {
  self.to_int(Size::from_bits(32)).map(|v| i32::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce an `i64`. Fails if the scalar is a pointer.
- pub fn to_i64(self) -> InterpResult<'static, i64> {
+ pub fn to_i64(self) -> InterpResult<'tcx, i64> {
  self.to_int(Size::from_bits(64)).map(|v| i64::try_from(v).unwrap())
  }
 
  /// Converts the scalar to produce an `i128`. Fails if the scalar is a pointer.
- pub fn to_i128(self) -> InterpResult<'static, i128> {
+ pub fn to_i128(self) -> InterpResult<'tcx, i128> {
  self.to_int(Size::from_bits(128))
  }
 
  /// Converts the scalar to produce a machine-pointer-sized signed integer.
  /// Fails if the scalar is a pointer.
- pub fn to_machine_isize(self, cx: &impl HasDataLayout) -> InterpResult<'static, i64> {
+ pub fn to_machine_isize(self, cx: &impl HasDataLayout) -> InterpResult<'tcx, i64> {
  let b = self.to_int(cx.data_layout().pointer_size)?;
  Ok(i64::try_from(b).unwrap())
  }
 
  #[inline]
- pub fn to_f32(self) -> InterpResult<'static, Single> {
+ pub fn to_f32(self) -> InterpResult<'tcx, Single> {
  // Going through `u32` to check size and truncation.
  Ok(Single::from_bits(self.to_u32()?.into()))
  }
 
  #[inline]
- pub fn to_f64(self) -> InterpResult<'static, Double> {
+ pub fn to_f64(self) -> InterpResult<'tcx, Double> {
  // Going through `u64` to check size and truncation.
  Ok(Double::from_bits(self.to_u64()?.into()))
  }
@@ -534,7 +534,7 @@ impl<Tag> ScalarMaybeUninit<Tag> {
  }
 
  #[inline]
- pub fn check_init(self) -> InterpResult<'static, Scalar<Tag>> {
+ pub fn check_init<'tcx>(self) -> InterpResult<'tcx, Scalar<Tag>> {
  match self {
  ScalarMaybeUninit::Scalar(scalar) => Ok(scalar),
  ScalarMaybeUninit::Uninit => throw_ub!(InvalidUninitBytes(None)),

compiler/rustc_middle/src/mir/mod.rs

@@ -13,6 +13,7 @@ use crate::ty::subst::{GenericArg, InternalSubsts, Subst, SubstsRef};
 use crate::ty::{self, List, Ty, TyCtxt};
 use crate::ty::{AdtDef, InstanceDef, Region, ScalarInt, UserTypeAnnotationIndex};
 
+use rustc_data_structures::captures::Captures;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID};
@@ -484,7 +485,7 @@ impl<'tcx> Body<'tcx> {
 
  /// Returns an iterator over all user-declared mutable locals.
  #[inline]
- pub fn mut_vars_iter<'a>(&'a self) -> impl Iterator<Item = Local> + 'a {
+ pub fn mut_vars_iter<'a>(&'a self) -> impl Iterator<Item = Local> + Captures<'tcx> + 'a {
  (self.arg_count + 1..self.local_decls.len()).filter_map(move |index| {
  let local = Local::new(index);
  let decl = &self.local_decls[local];
@@ -498,7 +499,9 @@ impl<'tcx> Body<'tcx> {
 
  /// Returns an iterator over all user-declared mutable arguments and locals.
  #[inline]
- pub fn mut_vars_and_args_iter<'a>(&'a self) -> impl Iterator<Item = Local> + 'a {
+ pub fn mut_vars_and_args_iter<'a>(
+ &'a self,
+ ) -> impl Iterator<Item = Local> + Captures<'tcx> + 'a {
  (1..self.local_decls.len()).filter_map(move |index| {
  let local = Local::new(index);
  let decl = &self.local_decls[local];

compiler/rustc_middle/src/mir/patch.rs

@@ -192,7 +192,7 @@ impl<'tcx> MirPatch<'tcx> {
  }
  }
 
- pub fn source_info_for_location(&self, body: &Body<'_>, loc: Location) -> SourceInfo {
+ pub fn source_info_for_location(&self, body: &Body<'tcx>, loc: Location) -> SourceInfo {
  let data = match loc.block.index().checked_sub(body.basic_blocks().len()) {
  Some(new) => &self.new_blocks[new],
  None => &body[loc.block],