Auto merge of rust-lang#126503 - matthiaskrgr:rollup-nwvz24q, r=matth…

…iaskrgr

Rollup of 7 pull requests

Successful merges:

 - rust-lang#125722 (Indicate in `non_local_defs` lint that the macro needs to change)
 - rust-lang#125829 (rustc_span: Add conveniences for working with span formats)
 - rust-lang#126192 (Various Redox OS fixes and add i686 Redox OS target)
 - rust-lang#126352 (ci: Update centos:7 to use vault repos)
 - rust-lang#126354 (Use `Variance` glob imported variants everywhere)
 - rust-lang#126469 (MIR Shl/Shr: the offset can be computed with rem_euclid)
 - rust-lang#126472 (build `libcxx-version` only when it doesn't exist)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -328,7 +328,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
  if let Some(annotation_index) = constant.user_ty {
  if let Err(terr) = self.cx.relate_type_and_user_type(
  constant.const_.ty(),
- ty::Variance::Invariant,
+ ty::Invariant,
  &UserTypeProjection { base: annotation_index, projs: vec![] },
  locations,
  ConstraintCategory::Boring,
@@ -451,7 +451,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
 
  if let Err(terr) = self.cx.relate_type_and_user_type(
  ty,
- ty::Variance::Invariant,
+ ty::Invariant,
  user_ty,
  Locations::All(*span),
  ConstraintCategory::TypeAnnotation,
@@ -1095,7 +1095,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  ) -> Result<(), NoSolution> {
  // Use this order of parameters because the sup type is usually the
  // "expected" type in diagnostics.
- self.relate_types(sup, ty::Variance::Contravariant, sub, locations, category)
+ self.relate_types(sup, ty::Contravariant, sub, locations, category)
  }
 
  #[instrument(skip(self, category), level = "debug")]
@@ -1106,7 +1106,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  locations: Locations,
  category: ConstraintCategory<'tcx>,
  ) -> Result<(), NoSolution> {
- self.relate_types(expected, ty::Variance::Invariant, found, locations, category)
+ self.relate_types(expected, ty::Invariant, found, locations, category)
  }
 
  #[instrument(skip(self), level = "debug")]
@@ -1146,7 +1146,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  trace!(?curr_projected_ty);
 
  let ty = curr_projected_ty.ty;
- self.relate_types(ty, v.xform(ty::Variance::Contravariant), a, locations, category)?;
+ self.relate_types(ty, v.xform(ty::Contravariant), a, locations, category)?;
 
  Ok(())
  }
@@ -1248,7 +1248,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  if let Some(annotation_index) = self.rvalue_user_ty(rv) {
  if let Err(terr) = self.relate_type_and_user_type(
  rv_ty,
- ty::Variance::Invariant,
+ ty::Invariant,
  &UserTypeProjection { base: annotation_index, projs: vec![] },
  location.to_locations(),
  ConstraintCategory::Boring,

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -50,14 +50,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  locations: Locations,
  category: ConstraintCategory<'tcx>,
  ) -> Result<(), NoSolution> {
- NllTypeRelating::new(
- self,
- locations,
- category,
- UniverseInfo::other(),
- ty::Variance::Invariant,
- )
- .relate(a, b)?;
+ NllTypeRelating::new(self, locations, category, UniverseInfo::other(), ty::Invariant)
+ .relate(a, b)?;
  Ok(())
  }
 }
@@ -106,15 +100,15 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
 
  fn ambient_covariance(&self) -> bool {
  match self.ambient_variance {
- ty::Variance::Covariant | ty::Variance::Invariant => true,
- ty::Variance::Contravariant | ty::Variance::Bivariant => false,
+ ty::Covariant | ty::Invariant => true,
+ ty::Contravariant | ty::Bivariant => false,
  }
  }
 
  fn ambient_contravariance(&self) -> bool {
  match self.ambient_variance {
- ty::Variance::Contravariant | ty::Variance::Invariant => true,
- ty::Variance::Covariant | ty::Variance::Bivariant => false,
+ ty::Contravariant | ty::Invariant => true,
+ ty::Covariant | ty::Bivariant => false,
  }
  }
 
@@ -336,11 +330,7 @@ impl<'bccx, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'bccx, 'tcx
 
  debug!(?self.ambient_variance);
  // In a bivariant context this always succeeds.
- let r = if self.ambient_variance == ty::Variance::Bivariant {
- Ok(a)
- } else {
- self.relate(a, b)
- };
+ let r = if self.ambient_variance == ty::Bivariant { Ok(a) } else { self.relate(a, b) };
 
  self.ambient_variance = old_ambient_variance;
 
@@ -474,7 +464,7 @@ impl<'bccx, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'bccx, 'tcx
  }
 
  match self.ambient_variance {
- ty::Variance::Covariant => {
+ ty::Covariant => {
  // Covariance, so we want `for<..> A <: for<..> B` --
  // therefore we compare any instantiation of A (i.e., A
  // instantiated with existentials) against every
@@ -489,7 +479,7 @@ impl<'bccx, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'bccx, 'tcx
  })?;
  }
 
- ty::Variance::Contravariant => {
+ ty::Contravariant => {
  // Contravariance, so we want `for<..> A :> for<..> B` --
  // therefore we compare every instantiation of A (i.e., A
  // instantiated with universals) against any
@@ -504,7 +494,7 @@ impl<'bccx, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'bccx, 'tcx
  })?;
  }
 
- ty::Variance::Invariant => {
+ ty::Invariant => {
  // Invariant, so we want `for<..> A == for<..> B` --
  // therefore we want `exists<..> A == for<..> B` and
  // `exists<..> B == for<..> A`.
@@ -525,7 +515,7 @@ impl<'bccx, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'bccx, 'tcx
  })?;
  }
 
- ty::Variance::Bivariant => {}
+ ty::Bivariant => {}
  }
 
  Ok(a)
@@ -584,23 +574,23 @@ impl<'bccx, 'tcx> PredicateEmittingRelation<'tcx> for NllTypeRelating<'_, 'bccx,
 
  fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
  self.register_predicates([ty::Binder::dummy(match self.ambient_variance {
- ty::Variance::Covariant => ty::PredicateKind::AliasRelate(
+ ty::Covariant => ty::PredicateKind::AliasRelate(
  a.into(),
  b.into(),
  ty::AliasRelationDirection::Subtype,
  ),
  // a :> b is b <: a
- ty::Variance::Contravariant => ty::PredicateKind::AliasRelate(
+ ty::Contravariant => ty::PredicateKind::AliasRelate(
  b.into(),
  a.into(),
  ty::AliasRelationDirection::Subtype,
  ),
- ty::Variance::Invariant => ty::PredicateKind::AliasRelate(
+ ty::Invariant => ty::PredicateKind::AliasRelate(
  a.into(),
  b.into(),
  ty::AliasRelationDirection::Equate,
  ),
- ty::Variance::Bivariant => {
+ ty::Bivariant => {
  unreachable!("cannot defer an alias-relate goal with Bivariant variance (yet?)")
  }
  })]);

compiler/rustc_const_eval/src/interpret/operator.rs

@@ -112,25 +112,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
  // Shift ops can have an RHS with a different numeric type.
  if matches!(bin_op, Shl | ShlUnchecked | Shr | ShrUnchecked) {
- let size = left.layout.size.bits();
+ let l_bits = left.layout.size.bits();
  // Compute the equivalent shift modulo `size` that is in the range `0..size`. (This is
  // the one MIR operator that does *not* directly map to a single LLVM operation.)
  let (shift_amount, overflow) = if right.layout.abi.is_signed() {
  let shift_amount = r_signed();
- let overflow = shift_amount < 0 || shift_amount >= i128::from(size);
- // Deliberately wrapping `as` casts: shift_amount *can* be negative, but the result
- // of the `as` will be equal modulo `size` (since it is a power of two).
- let masked_amount = (shift_amount as u128) % u128::from(size);
- assert_eq!(overflow, shift_amount != i128::try_from(masked_amount).unwrap());
- (masked_amount, overflow)
+ let rem = shift_amount.rem_euclid(l_bits.into());
+ // `rem` is guaranteed positive, so the `unwrap` cannot fail
+ (u128::try_from(rem).unwrap(), rem != shift_amount)
  } else {
  let shift_amount = r_unsigned();
- let overflow = shift_amount >= u128::from(size);
- let masked_amount = shift_amount % u128::from(size);
- assert_eq!(overflow, shift_amount != masked_amount);
- (masked_amount, overflow)
+ let rem = shift_amount.rem_euclid(l_bits.into());
+ (rem, rem != shift_amount)
  };
- let shift_amount = u32::try_from(shift_amount).unwrap(); // we masked so this will always fit
+ let shift_amount = u32::try_from(shift_amount).unwrap(); // we brought this in the range `0..size` so this will always fit
  // Compute the shifted result.
  let result = if left.layout.abi.is_signed() {
  let l = l_signed();

compiler/rustc_data_structures/src/flock.rs

@@ -9,6 +9,10 @@ cfg_match! {
  mod linux;
  use linux as imp;
  }
+ cfg(target_os = "redox") => {
+ mod linux;
+ use linux as imp;
+ }
  cfg(unix) => {
  mod unix;
  use unix as imp;

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -31,7 +31,7 @@ impl MutVisitor for Marker {
  // it's some advanced case with macro-generated macros. So if we cache the marked version
  // of that context once, we'll typically have a 100% cache hit rate after that.
  let Marker(expn_id, transparency, ref mut cache) = *self;
- span.update_ctxt(|ctxt| {
+ *span = span.map_ctxt(|ctxt| {
  *cache
  .entry(ctxt)
  .or_insert_with(|| ctxt.apply_mark(expn_id.to_expn_id(), transparency))

compiler/rustc_infer/src/infer/at.rs

@@ -212,16 +212,16 @@ impl<'a, 'tcx> At<'a, 'tcx> {
  T: ToTrace<'tcx>,
  {
  match variance {
- ty::Variance::Covariant => self.sub(define_opaque_types, expected, actual),
- ty::Variance::Invariant => self.eq(define_opaque_types, expected, actual),
- ty::Variance::Contravariant => self.sup(define_opaque_types, expected, actual),
+ ty::Covariant => self.sub(define_opaque_types, expected, actual),
+ ty::Invariant => self.eq(define_opaque_types, expected, actual),
+ ty::Contravariant => self.sup(define_opaque_types, expected, actual),
 
  // We could make this make sense but it's not readily
  // exposed and I don't feel like dealing with it. Note
  // that bivariance in general does a bit more than just
  // *nothing*, it checks that the types are the same
  // "modulo variance" basically.
- ty::Variance::Bivariant => panic!("Bivariant given to `relate()`"),
+ ty::Bivariant => panic!("Bivariant given to `relate()`"),
  }
  }
 

compiler/rustc_infer/src/infer/opaque_types/mod.rs

@@ -345,7 +345,7 @@ impl<'tcx> InferCtxt<'tcx> {
  .args
  .iter()
  .enumerate()
- .filter(|(i, _)| variances[*i] == ty::Variance::Invariant)
+ .filter(|(i, _)| variances[*i] == ty::Invariant)
  .filter_map(|(_, arg)| match arg.unpack() {
  GenericArgKind::Lifetime(r) => Some(r),
  GenericArgKind::Type(_) | GenericArgKind::Const(_) => None,
@@ -441,7 +441,7 @@ where
  let variances = self.tcx.variances_of(*def_id);
 
  for (v, s) in std::iter::zip(variances, args.iter()) {
- if *v != ty::Variance::Bivariant {
+ if *v != ty::Bivariant {
  s.visit_with(self);
  }
  }

compiler/rustc_infer/src/infer/outlives/for_liveness.rs

@@ -102,9 +102,7 @@ where
  };
 
  for (idx, s) in args.iter().enumerate() {
- if variances.map(|variances| variances[idx])
- != Some(ty::Variance::Bivariant)
- {
+ if variances.map(|variances| variances[idx]) != Some(ty::Bivariant) {
  s.visit_with(self);
  }
  }

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -83,16 +83,16 @@ impl<'tcx> InferCtxt<'tcx> {
  // mention `?0`.
  if self.next_trait_solver() {
  let (lhs, rhs, direction) = match instantiation_variance {
- ty::Variance::Invariant => {
+ ty::Invariant => {
  (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Equate)
  }
- ty::Variance::Covariant => {
+ ty::Covariant => {
  (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Subtype)
  }
- ty::Variance::Contravariant => {
+ ty::Contravariant => {
  (source_ty.into(), generalized_ty.into(), AliasRelationDirection::Subtype)
  }
- ty::Variance::Bivariant => unreachable!("bivariant generalization"),
+ ty::Bivariant => unreachable!("bivariant generalization"),
  };
 
  relation.register_predicates([ty::PredicateKind::AliasRelate(lhs, rhs, direction)]);
@@ -192,7 +192,7 @@ impl<'tcx> InferCtxt<'tcx> {
  relation.span(),
  relation.structurally_relate_aliases(),
  target_vid,
- ty::Variance::Invariant,
+ ty::Invariant,
  source_ct,
  )?;
 
@@ -210,14 +210,14 @@ impl<'tcx> InferCtxt<'tcx> {
  // generalized const and the source.
  if target_is_expected {
  relation.relate_with_variance(
- ty::Variance::Invariant,
+ ty::Invariant,
  ty::VarianceDiagInfo::default(),
  generalized_ct,
  source_ct,
  )?;
  } else {
  relation.relate_with_variance(
- ty::Variance::Invariant,
+ ty::Invariant,
  ty::VarianceDiagInfo::default(),
  source_ct,
  generalized_ct,
@@ -411,7 +411,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
  a_arg: ty::GenericArgsRef<'tcx>,
  b_arg: ty::GenericArgsRef<'tcx>,
  ) -> RelateResult<'tcx, ty::GenericArgsRef<'tcx>> {
- if self.ambient_variance == ty::Variance::Invariant {
+ if self.ambient_variance == ty::Invariant {
  // Avoid fetching the variance if we are in an invariant
  // context; no need, and it can induce dependency cycles
  // (e.g., #41849).
@@ -667,7 +667,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
  // structural.
  ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, args }) => {
  let args = self.relate_with_variance(
- ty::Variance::Invariant,
+ ty::Invariant,
  ty::VarianceDiagInfo::default(),
  args,
  args,

compiler/rustc_infer/src/infer/relate/glb.rs

@@ -94,12 +94,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Glb<'_, '_, 'tcx> {
  // When higher-ranked types are involved, computing the GLB is
  // very challenging, switch to invariance. This is obviously
  // overly conservative but works ok in practice.
- self.relate_with_variance(
- ty::Variance::Invariant,
- ty::VarianceDiagInfo::default(),
- a,
- b,
- )?;
+ self.relate_with_variance(ty::Invariant, ty::VarianceDiagInfo::default(), a, b)?;
  Ok(a)
  } else {
  Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))

compiler/rustc_infer/src/infer/relate/lub.rs

@@ -94,12 +94,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Lub<'_, '_, 'tcx> {
  // When higher-ranked types are involved, computing the LUB is
  // very challenging, switch to invariance. This is obviously
  // overly conservative but works ok in practice.
- self.relate_with_variance(
- ty::Variance::Invariant,
- ty::VarianceDiagInfo::default(),
- a,
- b,
- )?;
+ self.relate_with_variance(ty::Invariant, ty::VarianceDiagInfo::default(), a, b)?;
  Ok(a)
  } else {
  Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))