Rollup of 10 pull requests

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -691,7 +691,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
  // If the type is opaque/param/closure, and it is Fn or FnMut, let's suggest (mutably)
  // borrowing the type, since `&mut F: FnMut` iff `F: FnMut` and similarly for `Fn`.
- // These types seem reasonably opaque enough that they could be substituted with their
+ // These types seem reasonably opaque enough that they could be instantiated with their
  // borrowed variants in a function body when we see a move error.
  let borrow_level = match *ty.kind() {
  ty::Param(_) => tcx
@@ -3158,7 +3158,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  ) -> Option<AnnotatedBorrowFnSignature<'tcx>> {
  // Define a fallback for when we can't match a closure.
  let fallback = || {
- let is_closure = self.infcx.tcx.is_closure_or_coroutine(self.mir_def_id().to_def_id());
+ let is_closure = self.infcx.tcx.is_closure_like(self.mir_def_id().to_def_id());
  if is_closure {
  None
  } else {
@@ -3369,7 +3369,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  sig: ty::PolyFnSig<'tcx>,
  ) -> Option<AnnotatedBorrowFnSignature<'tcx>> {
  debug!("annotate_fn_sig: did={:?} sig={:?}", did, sig);
- let is_closure = self.infcx.tcx.is_closure_or_coroutine(did.to_def_id());
+ let is_closure = self.infcx.tcx.is_closure_like(did.to_def_id());
  let fn_hir_id = self.infcx.tcx.local_def_id_to_hir_id(did);
  let fn_decl = self.infcx.tcx.hir().fn_decl_by_hir_id(fn_hir_id)?;
 

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -67,7 +67,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  local,
  projection: [proj_base @ .., ProjectionElem::Field(upvar_index, _)],
  } => {
- debug_assert!(is_closure_or_coroutine(
+ debug_assert!(is_closure_like(
  Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty
  ));
 
@@ -126,9 +126,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  {
  item_msg = access_place_desc;
  debug_assert!(self.body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty.is_ref());
- debug_assert!(is_closure_or_coroutine(
- the_place_err.ty(self.body, self.infcx.tcx).ty
- ));
+ debug_assert!(is_closure_like(the_place_err.ty(self.body, self.infcx.tcx).ty));
 
  reason = if self.is_upvar_field_projection(access_place.as_ref()).is_some() {
  ", as it is a captured variable in a `Fn` closure".to_string()
@@ -389,7 +387,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  local,
  projection: [proj_base @ .., ProjectionElem::Field(upvar_index, _)],
  } => {
- debug_assert!(is_closure_or_coroutine(
+ debug_assert!(is_closure_like(
  Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty
  ));
 
@@ -1474,7 +1472,8 @@ fn suggest_ampmut<'tcx>(
  }
 }
 
-fn is_closure_or_coroutine(ty: Ty<'_>) -> bool {
+/// If the type is a `Coroutine`, `Closure`, or `CoroutineClosure`
+fn is_closure_like(ty: Ty<'_>) -> bool {
  ty.is_closure() || ty.is_coroutine() || ty.is_coroutine_closure()
 }
 

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -45,7 +45,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  /// be allowed:
  /// `fn f<'a: 'b, 'b: 'a>(x: *mut &'b i32) -> impl Sized + 'a { x }`
  ///
- /// Then we map the regions in both the type and the subst to their
+ /// Then we map the regions in both the type and the generic parameters to their
  /// `external_name` giving `concrete_type = &'a i32`,
  /// `args = ['static, 'a]`. This will then allow
  /// `infer_opaque_definition_from_instantiation` to determine that
@@ -77,9 +77,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  let args = opaque_type_key.args;
  debug!(?concrete_type, ?args);
 
- let mut subst_regions = vec![self.universal_regions.fr_static];
+ let mut arg_regions = vec![self.universal_regions.fr_static];
 
- let to_universal_region = |vid, subst_regions: &mut Vec<_>| {
+ let to_universal_region = |vid, arg_regions: &mut Vec<_>| {
  trace!(?vid);
  let scc = self.constraint_sccs.scc(vid);
  trace!(?scc);
@@ -88,11 +88,11 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  }) {
  Some(region) => {
  let vid = self.universal_regions.to_region_vid(region);
- subst_regions.push(vid);
+ arg_regions.push(vid);
  region
  }
  None => {
- subst_regions.push(vid);
+ arg_regions.push(vid);
  ty::Region::new_error_with_message(
  infcx.tcx,
  concrete_type.span,
@@ -106,10 +106,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  // This will ensure they get precedence when folding the regions in the concrete type.
  if let Some(&ci) = member_constraints.get(&opaque_type_key) {
  for &vid in self.member_constraints.choice_regions(ci) {
- to_universal_region(vid, &mut subst_regions);
+ to_universal_region(vid, &mut arg_regions);
  }
  }
- debug!(?subst_regions);
+ debug!(?arg_regions);
 
  // Next, insert universal regions from args, so we can translate regions that appear
  // in them but are not subject to member constraints, for instance closure args.
@@ -119,18 +119,18 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  return region;
  }
  let vid = self.to_region_vid(region);
- to_universal_region(vid, &mut subst_regions)
+ to_universal_region(vid, &mut arg_regions)
  });
  debug!(?universal_args);
- debug!(?subst_regions);
+ debug!(?arg_regions);
 
  // Deduplicate the set of regions while keeping the chosen order.
- let subst_regions = subst_regions.into_iter().collect::<FxIndexSet<_>>();
- debug!(?subst_regions);
+ let arg_regions = arg_regions.into_iter().collect::<FxIndexSet<_>>();
+ debug!(?arg_regions);
 
  let universal_concrete_type =
  infcx.tcx.fold_regions(concrete_type, |region, _| match *region {
- ty::ReVar(vid) => subst_regions
+ ty::ReVar(vid) => arg_regions
  .iter()
  .find(|ur_vid| self.eval_equal(vid, **ur_vid))
  .and_then(|ur_vid| self.definitions[*ur_vid].external_name)

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -29,7 +29,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  pub(super) fn check_signature_annotation(&mut self, body: &Body<'tcx>) {
  let mir_def_id = body.source.def_id().expect_local();
 
- if !self.tcx().is_closure_or_coroutine(mir_def_id.to_def_id()) {
+ if !self.tcx().is_closure_like(mir_def_id.to_def_id()) {
  return;
  }
 

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -479,7 +479,7 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  // `+multivalue` feature because the purpose of the wasm abi is to match
  // the WebAssembly specification, which has this feature. This won't be
  // needed when LLVM enables this `multivalue` feature by default.
- if !cx.tcx.is_closure_or_coroutine(instance.def_id()) {
+ if !cx.tcx.is_closure_like(instance.def_id()) {
  let abi = cx.tcx.fn_sig(instance.def_id()).skip_binder().abi();
  if abi == Abi::Wasm {
  function_features.push("+multivalue".to_string());

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -213,6 +213,7 @@ pub fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
  ("x86", "rdrand") => LLVMFeature::new("rdrnd"),
  ("x86", "bmi1") => LLVMFeature::new("bmi"),
  ("x86", "cmpxchg16b") => LLVMFeature::new("cx16"),
+ ("x86", "lahfsahf") => LLVMFeature::new("sahf"),
  ("aarch64", "rcpc2") => LLVMFeature::new("rcpc-immo"),
  ("aarch64", "dpb") => LLVMFeature::new("ccpp"),
  ("aarch64", "dpb2") => LLVMFeature::new("ccdp"),

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -229,7 +229,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  }
  sym::thread_local => codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL,
  sym::track_caller => {
- let is_closure = tcx.is_closure_or_coroutine(did.to_def_id());
+ let is_closure = tcx.is_closure_like(did.to_def_id());
 
  if !is_closure
  && let Some(fn_sig) = fn_sig()
@@ -274,7 +274,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  }
  }
  sym::target_feature => {
- if !tcx.is_closure_or_coroutine(did.to_def_id())
+ if !tcx.is_closure_like(did.to_def_id())
  && let Some(fn_sig) = fn_sig()
  && fn_sig.skip_binder().unsafety() == hir::Unsafety::Normal
  {
@@ -529,7 +529,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  // would result in this closure being compiled without the inherited target features, but this
  // is probably a poor usage of `#[inline(always)]` and easily avoided by not using the attribute.
  if tcx.features().target_feature_11
- && tcx.is_closure_or_coroutine(did.to_def_id())
+ && tcx.is_closure_like(did.to_def_id())
  && codegen_fn_attrs.inline != InlineAttr::Always
  {
  let owner_id = tcx.parent(did.to_def_id());

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -77,6 +77,8 @@ pub fn from_target_feature(
  Some(sym::aarch64_ver_target_feature) => rust_features.aarch64_ver_target_feature,
  Some(sym::csky_target_feature) => rust_features.csky_target_feature,
  Some(sym::loongarch_target_feature) => rust_features.loongarch_target_feature,
+ Some(sym::lahfsahf_target_feature) => rust_features.lahfsahf_target_feature,
+ Some(sym::prfchw_target_feature) => rust_features.prfchw_target_feature,
  Some(name) => bug!("unknown target feature gate {}", name),
  None => true,
  };

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -554,18 +554,20 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
  /// Call this on things you got out of the MIR (so it is as generic as the current
  /// stack frame), to bring it into the proper environment for this interpreter.
- pub(super) fn subst_from_current_frame_and_normalize_erasing_regions<
+ pub(super) fn instantiate_from_current_frame_and_normalize_erasing_regions<
  T: TypeFoldable<TyCtxt<'tcx>>,
  >(
  &self,
  value: T,
  ) -> Result<T, ErrorHandled> {
- self.subst_from_frame_and_normalize_erasing_regions(self.frame(), value)
+ self.instantiate_from_frame_and_normalize_erasing_regions(self.frame(), value)
  }
 
  /// Call this on things you got out of the MIR (so it is as generic as the provided
  /// stack frame), to bring it into the proper environment for this interpreter.
- pub(super) fn subst_from_frame_and_normalize_erasing_regions<T: TypeFoldable<TyCtxt<'tcx>>>(
+ pub(super) fn instantiate_from_frame_and_normalize_erasing_regions<
+ T: TypeFoldable<TyCtxt<'tcx>>,
+ >(
  &self,
  frame: &Frame<'mir, 'tcx, M::Provenance, M::FrameExtra>,
  value: T,
@@ -656,7 +658,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
  let layout = from_known_layout(self.tcx, self.param_env, layout, || {
  let local_ty = frame.body.local_decls[local].ty;
- let local_ty = self.subst_from_frame_and_normalize_erasing_regions(frame, local_ty)?;
+ let local_ty =
+ self.instantiate_from_frame_and_normalize_erasing_regions(frame, local_ty)?;
  self.layout_of(local_ty)
  })?;
 
@@ -791,8 +794,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  // Make sure all the constants required by this frame evaluate successfully (post-monomorphization check).
  if M::POST_MONO_CHECKS {
  for &const_ in &body.required_consts {
- let c =
- self.subst_from_current_frame_and_normalize_erasing_regions(const_.const_)?;
+ let c = self
+ .instantiate_from_current_frame_and_normalize_erasing_regions(const_.const_)?;
  c.eval(*self.tcx, self.param_env, Some(const_.span)).map_err(|err| {
  err.emit_note(*self.tcx);
  err

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -696,9 +696,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  trace!("eval_place_to_op: got {:?}", op);
  // Sanity-check the type we ended up with.
  if cfg!(debug_assertions) {
- let normalized_place_ty = self.subst_from_current_frame_and_normalize_erasing_regions(
- mir_place.ty(&self.frame().body.local_decls, *self.tcx).ty,
- )?;
+ let normalized_place_ty = self
+ .instantiate_from_current_frame_and_normalize_erasing_regions(
+ mir_place.ty(&self.frame().body.local_decls, *self.tcx).ty,
+ )?;
  if !mir_assign_valid_types(
  *self.tcx,
  self.param_env,
@@ -731,8 +732,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  &Copy(place) | &Move(place) => self.eval_place_to_op(place, layout)?,
 
  Constant(constant) => {
- let c =
- self.subst_from_current_frame_and_normalize_erasing_regions(constant.const_)?;
+ let c = self.instantiate_from_current_frame_and_normalize_erasing_regions(
+ constant.const_,
+ )?;
 
  // This can still fail:
  // * During ConstProp, with `TooGeneric` or since the `required_consts` were not all

compiler/rustc_const_eval/src/interpret/place.rs

@@ -542,9 +542,10 @@ where
  trace!("{:?}", self.dump_place(&place));
  // Sanity-check the type we ended up with.
  if cfg!(debug_assertions) {
- let normalized_place_ty = self.subst_from_current_frame_and_normalize_erasing_regions(
- mir_place.ty(&self.frame().body.local_decls, *self.tcx).ty,
- )?;
+ let normalized_place_ty = self
+ .instantiate_from_current_frame_and_normalize_erasing_regions(
+ mir_place.ty(&self.frame().body.local_decls, *self.tcx).ty,
+ )?;
  if !mir_assign_valid_types(
  *self.tcx,
  self.param_env,

compiler/rustc_const_eval/src/interpret/step.rs

@@ -235,7 +235,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  }
 
  NullaryOp(ref null_op, ty) => {
- let ty = self.subst_from_current_frame_and_normalize_erasing_regions(ty)?;
+ let ty = self.instantiate_from_current_frame_and_normalize_erasing_regions(ty)?;
  let layout = self.layout_of(ty)?;
  if let mir::NullOp::SizeOf | mir::NullOp::AlignOf = null_op
  && layout.is_unsized()
@@ -276,7 +276,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  Cast(cast_kind, ref operand, cast_ty) => {
  let src = self.eval_operand(operand, None)?;
  let cast_ty =
- self.subst_from_current_frame_and_normalize_erasing_regions(cast_ty)?;
+ self.instantiate_from_current_frame_and_normalize_erasing_regions(cast_ty)?;
  self.cast(&src, cast_kind, cast_ty, &dest)?;
  }
 

compiler/rustc_const_eval/src/interpret/terminator.rs

@@ -173,7 +173,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  Drop { place, target, unwind, replace: _ } => {
  let frame = self.frame();
  let ty = place.ty(&frame.body.local_decls, *self.tcx).ty;
- let ty = self.subst_from_frame_and_normalize_erasing_regions(frame, ty)?;
+ let ty = self.instantiate_from_frame_and_normalize_erasing_regions(frame, ty)?;
  let instance = Instance::resolve_drop_in_place(*self.tcx, ty);
  if let ty::InstanceDef::DropGlue(_, None) = instance.def {
  // This is the branch we enter if and only if the dropped type has no drop glue
@@ -672,8 +672,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  // Construct the destination place for this argument. At this point all
  // locals are still dead, so we cannot construct a `PlaceTy`.
  let dest = mir::Place::from(local);
- // `layout_of_local` does more than just the substitution we need to get the
- // type, but the result gets cached so this avoids calling the substitution
+ // `layout_of_local` does more than just the instantiation we need to get the
+ // type, but the result gets cached so this avoids calling the instantiation
  // query *again* the next time this local is accessed.
  let ty = self.layout_of_local(self.frame(), local, None)?.ty;
  if Some(local) == body.spread_arg {

compiler/rustc_const_eval/src/interpret/util.rs

@@ -19,11 +19,11 @@ where
  }
 
  struct FoundParam;
- struct UsedParamsNeedSubstVisitor<'tcx> {
+ struct UsedParamsNeedInstantiationVisitor<'tcx> {
  tcx: TyCtxt<'tcx>,
  }
 
- impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UsedParamsNeedSubstVisitor<'tcx> {
+ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UsedParamsNeedInstantiationVisitor<'tcx> {
  type BreakTy = FoundParam;
 
  fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
@@ -34,21 +34,22 @@ where
  match *ty.kind() {
  ty::Param(_) => ControlFlow::Break(FoundParam),
  ty::Closure(def_id, args)
+ | ty::CoroutineClosure(def_id, args, ..)
  | ty::Coroutine(def_id, args, ..)
  | ty::FnDef(def_id, args) => {
  let instance = ty::InstanceDef::Item(def_id);
  let unused_params = self.tcx.unused_generic_params(instance);
- for (index, subst) in args.into_iter().enumerate() {
+ for (index, arg) in args.into_iter().enumerate() {
  let index = index
  .try_into()
  .expect("more generic parameters than can fit into a `u32`");
  // Only recurse when generic parameters in fns, closures and coroutines
  // are used and have to be instantiated.
  //
- // Just in case there are closures or coroutines within this subst,
+ // Just in case there are closures or coroutines within this arg,
  // recurse.
- if unused_params.is_used(index) && subst.has_param() {
- return subst.visit_with(self);
+ if unused_params.is_used(index) && arg.has_param() {
+ return arg.visit_with(self);
  }
  }
  ControlFlow::Continue(())
@@ -65,7 +66,7 @@ where
  }
  }
 
- let mut vis = UsedParamsNeedSubstVisitor { tcx };
+ let mut vis = UsedParamsNeedInstantiationVisitor { tcx };
  if matches!(ty.visit_with(&mut vis), ControlFlow::Break(FoundParam)) {
  throw_inval!(TooGeneric);
  } else {