Rollup of 8 pull requests

compiler/rustc_abi/src/lib.rs

@@ -1057,6 +1057,32 @@ impl Scalar {
  }
 }
 
+rustc_index::newtype_index! {
+ /// The *source-order* index of a field in a variant.
+ ///
+ /// This is how most code after type checking refers to fields, rather than
+ /// using names (as names have hygiene complications and more complex lookup).
+ ///
+ /// Particularly for `repr(Rust)` types, this may not be the same as *layout* order.
+ /// (It is for `repr(C)` `struct`s, however.)
+ ///
+ /// For example, in the following types,
+ /// ```rust
+ /// # enum Never {}
+ /// # #[repr(u16)]
+ /// enum Demo1 {
+ /// Variant0 { a: Never, b: i32 } = 100,
+ /// Variant1 { c: u8, d: u64 } = 10,
+ /// }
+ /// struct Demo2 { e: u8, f: u16, g: u8 }
+ /// ```
+ /// `b` is `FieldIdx(1)` in `VariantIdx(0)`,
+ /// `d` is `FieldIdx(1)` in `VariantIdx(1)`, and
+ /// `f` is `FieldIdx(1)` in `VariantIdx(0)`.
+ #[derive(HashStable_Generic)]
+ pub struct FieldIdx {}
+}
+
 /// Describes how the fields of a type are located in memory.
 #[derive(PartialEq, Eq, Hash, Clone, Debug)]
 #[cfg_attr(feature = "nightly", derive(HashStable_Generic))]

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -9,15 +9,15 @@ use rustc_hir::GeneratorKind;
 use rustc_infer::infer::{LateBoundRegionConversionTime, TyCtxtInferExt};
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::{
- AggregateKind, Constant, FakeReadCause, Field, Local, LocalInfo, LocalKind, Location, Operand,
- Place, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator, TerminatorKind,
+ AggregateKind, Constant, FakeReadCause, Local, LocalInfo, LocalKind, Location, Operand, Place,
+ PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator, TerminatorKind,
 };
 use rustc_middle::ty::print::Print;
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
-use rustc_target::abi::VariantIdx;
+use rustc_target::abi::{FieldIdx, VariantIdx};
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use rustc_trait_selection::traits::{
  type_known_to_meet_bound_modulo_regions, Obligation, ObligationCause,
@@ -302,7 +302,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  fn describe_field(
  &self,
  place: PlaceRef<'tcx>,
- field: Field,
+ field: FieldIdx,
  including_tuple_field: IncludingTupleField,
  ) -> Option<String> {
  let place_ty = match place {
@@ -331,7 +331,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  fn describe_field_from_ty(
  &self,
  ty: Ty<'_>,
- field: Field,
+ field: FieldIdx,
  variant_index: Option<VariantIdx>,
  including_tuple_field: IncludingTupleField,
  ) -> Option<String> {

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -12,6 +12,7 @@ use rustc_middle::{
 use rustc_span::source_map::DesugaringKind;
 use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{sym, BytePos, Span};
+use rustc_target::abi::FieldIdx;
 
 use crate::diagnostics::BorrowedContentSource;
 use crate::MirBorrowckCtxt;
@@ -1275,7 +1276,7 @@ fn is_closure_or_generator(ty: Ty<'_>) -> bool {
 fn get_mut_span_in_struct_field<'tcx>(
  tcx: TyCtxt<'tcx>,
  ty: Ty<'tcx>,
- field: mir::Field,
+ field: FieldIdx,
 ) -> Option<Span> {
  // Expect our local to be a reference to a struct of some kind.
  if let ty::Ref(_, ty, _) = ty.kind()

compiler/rustc_borrowck/src/lib.rs

@@ -33,12 +33,13 @@ use rustc_middle::mir::{
  Place, PlaceElem, PlaceRef, VarDebugInfoContents,
 };
 use rustc_middle::mir::{AggregateKind, BasicBlock, BorrowCheckResult, BorrowKind};
-use rustc_middle::mir::{Field, ProjectionElem, Promoted, Rvalue, Statement, StatementKind};
 use rustc_middle::mir::{InlineAsmOperand, Terminator, TerminatorKind};
+use rustc_middle::mir::{ProjectionElem, Promoted, Rvalue, Statement, StatementKind};
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::{self, CapturedPlace, ParamEnv, RegionVid, TyCtxt};
 use rustc_session::lint::builtin::UNUSED_MUT;
 use rustc_span::{Span, Symbol};
+use rustc_target::abi::FieldIdx;
 
 use either::Either;
 use smallvec::SmallVec;
@@ -597,7 +598,7 @@ struct MirBorrowckCtxt<'cx, 'tcx> {
  used_mut: FxIndexSet<Local>,
  /// If the function we're checking is a closure, then we'll need to report back the list of
  /// mutable upvars that have been used. This field keeps track of them.
- used_mut_upvars: SmallVec<[Field; 8]>,
+ used_mut_upvars: SmallVec<[FieldIdx; 8]>,
  /// Region inference context. This contains the results from region inference and lets us e.g.
  /// find out which CFG points are contained in each borrow region.
  regioncx: Rc<RegionInferenceContext<'tcx>>,
@@ -2277,7 +2278,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  /// then returns the index of the field being projected. Note that this closure will always
  /// be `self` in the current MIR, because that is the only time we directly access the fields
  /// of a closure type.
- fn is_upvar_field_projection(&self, place_ref: PlaceRef<'tcx>) -> Option<Field> {
+ fn is_upvar_field_projection(&self, place_ref: PlaceRef<'tcx>) -> Option<FieldIdx> {
  path_utils::is_upvar_field_projection(self.infcx.tcx, &self.upvars, place_ref, self.body())
  }
 

compiler/rustc_borrowck/src/path_utils.rs

@@ -7,8 +7,9 @@ use crate::BorrowIndex;
 use crate::Upvar;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_middle::mir::BorrowKind;
-use rustc_middle::mir::{BasicBlock, Body, Field, Location, Place, PlaceRef, ProjectionElem};
+use rustc_middle::mir::{BasicBlock, Body, Location, Place, PlaceRef, ProjectionElem};
 use rustc_middle::ty::TyCtxt;
+use rustc_target::abi::FieldIdx;
 
 /// Returns `true` if the borrow represented by `kind` is
 /// allowed to be split into separate Reservation and
@@ -148,7 +149,7 @@ pub(crate) fn is_upvar_field_projection<'tcx>(
  upvars: &[Upvar<'tcx>],
  place_ref: PlaceRef<'tcx>,
  body: &Body<'tcx>,
-) -> Option<Field> {
+) -> Option<FieldIdx> {
  let mut place_ref = place_ref;
  let mut by_ref = false;
 

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -36,7 +36,7 @@ use rustc_middle::ty::{
 };
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::{Span, DUMMY_SP};
-use rustc_target::abi::FIRST_VARIANT;
+use rustc_target::abi::{FieldIdx, FIRST_VARIANT};
 use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
 use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
@@ -786,7 +786,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
  &mut self,
  parent: &dyn fmt::Debug,
  base_ty: PlaceTy<'tcx>,
- field: Field,
+ field: FieldIdx,
  location: Location,
  ) -> Result<Ty<'tcx>, FieldAccessError> {
  let tcx = self.tcx();

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -327,7 +327,7 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
  ArgKind::Spread(params) => {
  for (i, param) in params.into_iter().enumerate() {
  if let Some(param) = param {
- place.place_field(fx, mir::Field::new(i)).write_cvalue(fx, param);
+ place.place_field(fx, FieldIdx::new(i)).write_cvalue(fx, param);
  }
  }
  }
@@ -460,7 +460,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
  args.push(self_arg);
  for i in 0..tupled_arguments.len() {
  args.push(CallArgument {
- value: pack_arg.value.value_field(fx, mir::Field::new(i)),
+ value: pack_arg.value.value_field(fx, FieldIdx::new(i)),
  is_owned: pack_arg.is_owned,
  });
  }

compiler/rustc_codegen_cranelift/src/base.rs

@@ -797,7 +797,7 @@ fn codegen_stmt<'tcx>(
  let index = fx.bcx.ins().iconst(fx.pointer_type, field_index as i64);
  variant_dest.place_index(fx, index)
  } else {
- variant_dest.place_field(fx, mir::Field::new(field_index))
+ variant_dest.place_field(fx, FieldIdx::new(field_index))
  };
  to.write_cvalue(fx, operand);
  }

compiler/rustc_codegen_cranelift/src/discriminant.rs

@@ -26,7 +26,7 @@ pub(crate) fn codegen_set_discriminant<'tcx>(
  tag_encoding: TagEncoding::Direct,
  variants: _,
  } => {
- let ptr = place.place_field(fx, mir::Field::new(tag_field));
+ let ptr = place.place_field(fx, FieldIdx::new(tag_field));
  let to = layout.ty.discriminant_for_variant(fx.tcx, variant_index).unwrap().val;
  let to = if ptr.layout().abi.is_signed() {
  ty::ScalarInt::try_from_int(
@@ -47,7 +47,7 @@ pub(crate) fn codegen_set_discriminant<'tcx>(
  variants: _,
  } => {
  if variant_index != untagged_variant {
- let niche = place.place_field(fx, mir::Field::new(tag_field));
+ let niche = place.place_field(fx, FieldIdx::new(tag_field));
  let niche_type = fx.clif_type(niche.layout().ty).unwrap();
  let niche_value = variant_index.as_u32() - niche_variants.start().as_u32();
  let niche_value = (niche_value as u128).wrapping_add(niche_start);
@@ -107,7 +107,7 @@ pub(crate) fn codegen_get_discriminant<'tcx>(
  let cast_to = fx.clif_type(dest_layout.ty).unwrap();
 
  // Read the tag/niche-encoded discriminant from memory.
- let tag = value.value_field(fx, mir::Field::new(tag_field));
+ let tag = value.value_field(fx, FieldIdx::new(tag_field));
  let tag = tag.load_scalar(fx);
 
  // Decode the discriminant (specifically if it's niche-encoded).

compiler/rustc_codegen_cranelift/src/intrinsics/llvm_x86.rs

@@ -179,8 +179,8 @@ fn llvm_add_sub<'tcx>(
 
  // c + carry -> c + first intermediate carry or borrow respectively
  let int0 = crate::num::codegen_checked_int_binop(fx, bin_op, a, b);
- let c = int0.value_field(fx, mir::Field::new(0));
- let cb0 = int0.value_field(fx, mir::Field::new(1)).load_scalar(fx);
+ let c = int0.value_field(fx, FieldIdx::new(0));
+ let cb0 = int0.value_field(fx, FieldIdx::new(1)).load_scalar(fx);
 
  // c + carry -> c + second intermediate carry or borrow respectively
  let cb_in_as_u64 = fx.bcx.ins().uextend(types::I64, cb_in);

compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs

@@ -253,7 +253,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
  }
 
  ret.write_cvalue(fx, base);
- let ret_lane = ret.place_field(fx, mir::Field::new(idx.try_into().unwrap()));
+ let ret_lane = ret.place_field(fx, FieldIdx::new(idx.try_into().unwrap()));
  ret_lane.write_cvalue(fx, val);
  }
 

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -86,7 +86,7 @@ mod prelude {
  self, FloatTy, Instance, InstanceDef, IntTy, ParamEnv, Ty, TyCtxt, TypeAndMut,
  TypeFoldable, TypeVisitableExt, UintTy,
  };
- pub(crate) use rustc_target::abi::{Abi, Scalar, Size, VariantIdx, FIRST_VARIANT};
+ pub(crate) use rustc_target::abi::{Abi, FieldIdx, Scalar, Size, VariantIdx, FIRST_VARIANT};
 
  pub(crate) use rustc_data_structures::fx::FxHashMap;
 

compiler/rustc_codegen_cranelift/src/unsize.rs

@@ -147,8 +147,8 @@ pub(crate) fn coerce_unsized_into<'tcx>(
  assert_eq!(def_a, def_b);
 
  for i in 0..def_a.variant(FIRST_VARIANT).fields.len() {
- let src_f = src.value_field(fx, mir::Field::new(i));
- let dst_f = dst.place_field(fx, mir::Field::new(i));
+ let src_f = src.value_field(fx, FieldIdx::new(i));
+ let dst_f = dst.place_field(fx, FieldIdx::new(i));
 
  if dst_f.layout().is_zst() {
  continue;

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -10,7 +10,7 @@ fn codegen_field<'tcx>(
  base: Pointer,
  extra: Option<Value>,
  layout: TyAndLayout<'tcx>,
- field: mir::Field,
+ field: FieldIdx,
 ) -> (Pointer, TyAndLayout<'tcx>) {
  let field_offset = layout.fields.offset(field.index());
  let field_layout = layout.field(&*fx, field.index());
@@ -210,7 +210,7 @@ impl<'tcx> CValue<'tcx> {
  pub(crate) fn value_field(
  self,
  fx: &mut FunctionCx<'_, '_, 'tcx>,
- field: mir::Field,
+ field: FieldIdx,
  ) -> CValue<'tcx> {
  let layout = self.1;
  match self.0 {
@@ -687,7 +687,7 @@ impl<'tcx> CPlace<'tcx> {
  pub(crate) fn place_field(
  self,
  fx: &mut FunctionCx<'_, '_, 'tcx>,
- field: mir::Field,
+ field: FieldIdx,
  ) -> CPlace<'tcx> {
  let layout = self.layout();
 

compiler/rustc_codegen_cranelift/src/vtable.rs

@@ -50,7 +50,7 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
  if let Abi::Scalar(_) = arg.layout().abi {
  'descend_newtypes: while !arg.layout().ty.is_unsafe_ptr() && !arg.layout().ty.is_ref() {
  for i in 0..arg.layout().fields.count() {
- let field = arg.value_field(fx, mir::Field::new(i));
+ let field = arg.value_field(fx, FieldIdx::new(i));
  if !field.layout().is_zst() {
  // we found the one non-zero-sized field that is allowed
  // now find *its* non-zero-sized field, or stop if it's a
@@ -68,9 +68,9 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
  if ty.is_dyn_star() {
  let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap().ty);
  let dyn_star = CPlace::for_ptr(Pointer::new(arg.load_scalar(fx)), inner_layout);
- let ptr = dyn_star.place_field(fx, mir::Field::new(0)).to_ptr();
+ let ptr = dyn_star.place_field(fx, FieldIdx::new(0)).to_ptr();
  let vtable =
- dyn_star.place_field(fx, mir::Field::new(1)).to_cvalue(fx).load_scalar(fx);
+ dyn_star.place_field(fx, FieldIdx::new(1)).to_cvalue(fx).load_scalar(fx);
  break 'block (ptr, vtable);
  }
  }

compiler/rustc_codegen_llvm/messages.ftl

@@ -27,7 +27,8 @@ codegen_llvm_error_calling_dlltool =
  Error calling dlltool: {$error}
 
 codegen_llvm_dlltool_fail_import_library =
- Dlltool could not create import library: {$stdout}\n{$stderr}
+ Dlltool could not create import library: {$stdout}
+ {$stderr}
 
 codegen_llvm_target_feature_disable_or_enable =
  the target features {$features} must all be either enabled or disabled together

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs

@@ -6,15 +6,17 @@ use rustc_hir::def::CtorKind;
 use rustc_index::vec::IndexVec;
 use rustc_middle::{
  bug,
- mir::{Field, GeneratorLayout, GeneratorSavedLocal},
+ mir::{GeneratorLayout, GeneratorSavedLocal},
  ty::{
  self,
  layout::{IntegerExt, LayoutOf, PrimitiveExt, TyAndLayout},
  AdtDef, GeneratorSubsts, Ty, VariantDef,
  },
 };
 use rustc_span::Symbol;
-use rustc_target::abi::{HasDataLayout, Integer, Primitive, TagEncoding, VariantIdx, Variants};
+use rustc_target::abi::{
+ FieldIdx, HasDataLayout, Integer, Primitive, TagEncoding, VariantIdx, Variants,
+};
 use std::borrow::Cow;
 
 use crate::{
@@ -353,7 +355,7 @@ pub fn build_generator_variant_struct_type_di_node<'ll, 'tcx>(
  let state_specific_fields: SmallVec<_> = (0..variant_layout.fields.count())
  .map(|field_index| {
  let generator_saved_local = generator_layout.variant_fields[variant_index]
- [Field::from_usize(field_index)];
+ [FieldIdx::from_usize(field_index)];
  let field_name_maybe = state_specific_upvar_names[generator_saved_local];
  let field_name = field_name_maybe
  .as_ref()

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -8,7 +8,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
 use rustc_session::config::DebugInfo;
 use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{BytePos, Span};
-use rustc_target::abi::{Abi, Size, VariantIdx};
+use rustc_target::abi::{Abi, FieldIdx, Size, VariantIdx};
 
 use super::operand::{OperandRef, OperandValue};
 use super::place::PlaceRef;
@@ -79,7 +79,7 @@ impl<'tcx, S: Copy, L: Copy> DebugScope<S, L> {
 trait DebugInfoOffsetLocation<'tcx, Bx> {
  fn deref(&self, bx: &mut Bx) -> Self;
  fn layout(&self) -> TyAndLayout<'tcx>;
- fn project_field(&self, bx: &mut Bx, field: mir::Field) -> Self;
+ fn project_field(&self, bx: &mut Bx, field: FieldIdx) -> Self;
  fn downcast(&self, bx: &mut Bx, variant: VariantIdx) -> Self;
 }
 
@@ -94,7 +94,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> DebugInfoOffsetLocation<'tcx, Bx>
  self.layout
  }
 
- fn project_field(&self, bx: &mut Bx, field: mir::Field) -> Self {
+ fn project_field(&self, bx: &mut Bx, field: FieldIdx) -> Self {
  PlaceRef::project_field(*self, bx, field.index())
  }
 
@@ -116,7 +116,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> DebugInfoOffsetLocation<'tcx, Bx>
  *self
  }
 
- fn project_field(&self, bx: &mut Bx, field: mir::Field) -> Self {
+ fn project_field(&self, bx: &mut Bx, field: FieldIdx) -> Self {
  self.field(bx.cx(), field.index())
  }