Shrink TyKind::FnPtr.

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -3989,7 +3989,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  } else {
  let ty = self.infcx.tcx.type_of(self.mir_def_id()).instantiate_identity();
  match ty.kind() {
- ty::FnDef(_, _) | ty::FnPtr(_) => self.annotate_fn_sig(
+ ty::FnDef(_, _) | ty::FnPtr(..) => self.annotate_fn_sig(
  self.mir_def_id(),
  self.infcx.tcx.fn_sig(self.mir_def_id()).instantiate_identity(),
  ),

compiler/rustc_borrowck/src/lib.rs

@@ -1644,7 +1644,7 @@ impl<'mir, 'tcx> MirBorrowckCtxt<'_, 'mir, '_, 'tcx> {
  | ty::Pat(_, _)
  | ty::Slice(_)
  | ty::FnDef(_, _)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Dynamic(_, _, _)
  | ty::Closure(_, _)
  | ty::CoroutineClosure(_, _)
@@ -1689,7 +1689,7 @@ impl<'mir, 'tcx> MirBorrowckCtxt<'_, 'mir, '_, 'tcx> {
  | ty::RawPtr(_, _)
  | ty::Ref(_, _, _)
  | ty::FnDef(_, _)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Dynamic(_, _, _)
  | ty::CoroutineWitness(..)
  | ty::Never

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1364,7 +1364,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  debug!("func_ty.kind: {:?}", func_ty.kind());
 
  let sig = match func_ty.kind() {
- ty::FnDef(..) | ty::FnPtr(_) => func_ty.fn_sig(tcx),
+ ty::FnDef(..) | ty::FnPtr(..) => func_ty.fn_sig(tcx),
  _ => {
  span_mirbug!(self, term, "call to non-function {:?}", func_ty);
  return;
@@ -2420,7 +2420,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  let ty_left = left.ty(body, tcx);
  match ty_left.kind() {
  // Types with regions are comparable if they have a common super-type.
- ty::RawPtr(_, _) | ty::FnPtr(_) => {
+ ty::RawPtr(_, _) | ty::FnPtr(..) => {
  let ty_right = right.ty(body, tcx);
  let common_ty = self.infcx.next_ty_var(body.source_info(location).span);
  self.sub_types(

compiler/rustc_codegen_cranelift/src/common.rs

@@ -69,7 +69,7 @@ fn clif_type_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<types::Typ
  FloatTy::F64 => types::F64,
  FloatTy::F128 => unimplemented!("f16_f128"),
  },
- ty::FnPtr(_) => pointer_ty(tcx),
+ ty::FnPtr(..) => pointer_ty(tcx),
  ty::RawPtr(pointee_ty, _) | ty::Ref(_, pointee_ty, _) => {
  if has_ptr_meta(tcx, *pointee_ty) {
  return None;

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -872,7 +872,7 @@ pub(crate) fn assert_assignable<'tcx>(
  (ty::Ref(_, a, _), ty::RawPtr(b, _)) | (ty::RawPtr(a, _), ty::Ref(_, b, _)) => {
  assert_assignable(fx, *a, *b, limit - 1);
  }
- (ty::FnPtr(_), ty::FnPtr(_)) => {
+ (ty::FnPtr(..), ty::FnPtr(..)) => {
  let from_sig = fx.tcx.normalize_erasing_late_bound_regions(
  ParamEnv::reveal_all(),
  from_ty.fn_sig(fx.tcx),

compiler/rustc_codegen_gcc/src/type_of.rs

@@ -213,9 +213,8 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
  // NOTE: we cannot remove this match like in the LLVM codegen because the call
  // to fn_ptr_backend_type handle the on-stack attribute.
  // TODO(antoyo): find a less hackish way to hande the on-stack attribute.
- ty::FnPtr(sig) => {
- cx.fn_ptr_backend_type(cx.fn_abi_of_fn_ptr(sig, ty::List::empty()))
- }
+ ty::FnPtr(sig_tys, hdr) => cx
+ .fn_ptr_backend_type(cx.fn_abi_of_fn_ptr(sig_tys.with(hdr), ty::List::empty())),
  _ => self.scalar_gcc_type_at(cx, scalar, Size::ZERO),
  };
  cx.scalar_types.borrow_mut().insert(self.ty, ty);

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -456,7 +456,7 @@ pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll D
  {
  build_pointer_or_reference_di_node(cx, t, t.boxed_ty(), unique_type_id)
  }
- ty::FnDef(..) | ty::FnPtr(_) => build_subroutine_type_di_node(cx, unique_type_id),
+ ty::FnDef(..) | ty::FnPtr(..) => build_subroutine_type_di_node(cx, unique_type_id),
  ty::Closure(..) => build_closure_env_di_node(cx, unique_type_id),
  ty::CoroutineClosure(..) => build_closure_env_di_node(cx, unique_type_id),
  ty::Coroutine(..) => enums::build_coroutine_di_node(cx, unique_type_id),

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -331,7 +331,7 @@ fn push_debuginfo_type_name<'tcx>(
  output.push(')');
  }
  }
- ty::FnDef(..) | ty::FnPtr(_) => {
+ ty::FnDef(..) | ty::FnPtr(..) => {
  // We've encountered a weird 'recursive type'
  // Currently, the only way to generate such a type
  // is by using 'impl trait':

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -846,7 +846,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  ),
  None,
  ),
- ty::FnPtr(_) => (None, Some(callee.immediate())),
+ ty::FnPtr(..) => (None, Some(callee.immediate())),
  _ => bug!("{} is not callable", callee.layout.ty),
  };
 

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -170,7 +170,7 @@ struct LocalReturnTyVisitor<'ck, 'mir, 'tcx> {
 impl<'ck, 'mir, 'tcx> TypeVisitor<TyCtxt<'tcx>> for LocalReturnTyVisitor<'ck, 'mir, 'tcx> {
  fn visit_ty(&mut self, t: Ty<'tcx>) {
  match t.kind() {
- ty::FnPtr(_) => {}
+ ty::FnPtr(..) => {}
  ty::Ref(_, _, hir::Mutability::Mut) => {
  self.checker.check_op(ops::mut_ref::MutRef(self.kind));
  t.super_visit_with(self)
@@ -725,7 +725,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  let (mut callee, mut fn_args) = match *fn_ty.kind() {
  ty::FnDef(def_id, fn_args) => (def_id, fn_args),
 
- ty::FnPtr(_) => {
+ ty::FnPtr(..) => {
  self.check_op(ops::FnCallIndirect);
  return;
  }

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -132,7 +132,7 @@ fn const_to_valtree_inner<'tcx>(
 
  // Technically we could allow function pointers (represented as `ty::Instance`), but this is not guaranteed to
  // agree with runtime equality tests.
- ty::FnPtr(_) => Err(ValTreeCreationError::NonSupportedType(ty)),
+ ty::FnPtr(..) => Err(ValTreeCreationError::NonSupportedType(ty)),
 
  ty::Ref(_, _, _) => {
  let derefd_place = ecx.deref_pointer(place)?;
@@ -353,7 +353,7 @@ pub fn valtree_to_const_value<'tcx>(
  | ty::CoroutineClosure(..)
  | ty::Coroutine(..)
  | ty::CoroutineWitness(..)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Str
  | ty::Slice(_)
  | ty::Dynamic(..) => bug!("no ValTree should have been created for type {:?}", ty.kind()),

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -97,7 +97,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  CastKind::PointerCoercion(PointerCoercion::UnsafeFnPointer) => {
  let src = self.read_immediate(src)?;
  match cast_ty.kind() {
- ty::FnPtr(_) => {
+ ty::FnPtr(..) => {
  // No change to value
  self.write_immediate(*src, dest)?;
  }
@@ -230,7 +230,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  src: &ImmTy<'tcx, M::Provenance>,
  cast_to: TyAndLayout<'tcx>,
  ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
- assert_matches!(src.layout.ty.kind(), ty::RawPtr(_, _) | ty::FnPtr(_));
+ assert_matches!(src.layout.ty.kind(), ty::RawPtr(_, _) | ty::FnPtr(..));
  assert!(cast_to.ty.is_integral());
 
  let scalar = src.to_scalar();

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -79,7 +79,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
  | ty::RawPtr(_, _)
  | ty::Ref(_, _, _)
  | ty::FnDef(_, _)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Dynamic(_, _, _)
  | ty::Closure(_, _)
  | ty::CoroutineClosure(_, _)

compiler/rustc_const_eval/src/interpret/stack.rs

@@ -483,7 +483,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  | ty::Bool
  | ty::Float(_)
  | ty::FnDef(..)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::RawPtr(..)
  | ty::Char
  | ty::Ref(..)

compiler/rustc_const_eval/src/interpret/step.rs

@@ -424,7 +424,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  self.tcx.mk_type_list_from_iter(extra_args.iter().map(|arg| arg.layout().ty));
 
  let (callee, fn_abi, with_caller_location) = match *func.layout.ty.kind() {
- ty::FnPtr(_sig) => {
+ ty::FnPtr(..) => {
  let fn_ptr = self.read_pointer(&func)?;
  let fn_val = self.get_ptr_fn(fn_ptr)?;
  (fn_val, self.fn_abi_of_fn_ptr(fn_sig_binder, extra_args)?, false)

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -616,7 +616,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
  self.check_safe_pointer(value, PointerKind::Ref(*mutbl))?;
  Ok(true)
  }
- ty::FnPtr(_sig) => {
+ ty::FnPtr(..) => {
  let value = self.read_scalar(value, ExpectedKind::FnPtr)?;
 
  // If we check references recursively, also check that this points to a function.

compiler/rustc_const_eval/src/util/type_name.rs

@@ -35,7 +35,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
  | ty::Slice(_)
  | ty::RawPtr(_, _)
  | ty::Ref(_, _, _)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Never
  | ty::Tuple(_)
  | ty::Dynamic(_, _, _) => self.pretty_print_type(ty),

compiler/rustc_hir_analysis/src/check/intrinsicck.rs

@@ -66,7 +66,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
  ty::Float(FloatTy::F32) => Some(InlineAsmType::F32),
  ty::Float(FloatTy::F64) => Some(InlineAsmType::F64),
  ty::Float(FloatTy::F128) => Some(InlineAsmType::F128),
- ty::FnPtr(_) => Some(asm_ty_isize),
+ ty::FnPtr(..) => Some(asm_ty_isize),
  ty::RawPtr(ty, _) if self.is_thin_ptr_ty(ty) => Some(asm_ty_isize),
  ty::Adt(adt, args) if adt.repr().simd() => {
  let fields = &adt.non_enum_variant().fields;

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -951,7 +951,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
  } else {
  let mut diag = match ty.kind() {
  ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Error(_) => return Ok(()),
- ty::FnPtr(_) => tcx.dcx().struct_span_err(
+ ty::FnPtr(..) => tcx.dcx().struct_span_err(
  hir_ty.span,
  "using function pointers as const generic parameters is forbidden",
  ),

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -172,7 +172,7 @@ impl<'tcx> InherentCollect<'tcx> {
  | ty::RawPtr(_, _)
  | ty::Ref(..)
  | ty::Never
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Tuple(..) => self.check_primitive_impl(id, self_ty),
  ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, _) | ty::Param(_) => {
  Err(self.tcx.dcx().emit_err(errors::InherentNominal { span: item_span }))

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -317,8 +317,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
  self.add_constraint(current, data.index, variance);
  }
 
- ty::FnPtr(sig) => {
- self.add_constraints_from_sig(current, sig, variance);
+ ty::FnPtr(sig_tys, hdr) => {
+ self.add_constraints_from_sig(current, sig_tys.with(hdr), variance);
  }
 
  ty::Error(_) => {

compiler/rustc_hir_typeck/src/callee.rs

@@ -137,7 +137,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
  // If the callee is a bare function or a closure, then we're all set.
  match *adjusted_ty.kind() {
- ty::FnDef(..) | ty::FnPtr(_) => {
+ ty::FnDef(..) | ty::FnPtr(..) => {
  let adjustments = self.adjust_steps(autoderef);
  self.apply_adjustments(callee_expr, adjustments);
  return Some(CallStep::Builtin(adjusted_ty));
@@ -467,7 +467,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  (fn_sig, Some(def_id))
  }
  // FIXME(effects): these arms should error because we can't enforce them
- ty::FnPtr(sig) => (sig, None),
+ ty::FnPtr(sig_tys, hdr) => (sig_tys.with(hdr), None),
  _ => {
  for arg in arg_exprs {
  self.check_expr(arg);

compiler/rustc_hir_typeck/src/closure.rs

@@ -336,9 +336,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  .into_iter()
  .map(|obl| (obl.predicate, obl.cause.span)),
  ),
- ty::FnPtr(sig) => match closure_kind {
+ ty::FnPtr(sig_tys, hdr) => match closure_kind {
  hir::ClosureKind::Closure => {
- let expected_sig = ExpectedSig { cause_span: None, sig };
+ let expected_sig = ExpectedSig { cause_span: None, sig: sig_tys.with(hdr) };
  (Some(expected_sig), Some(ty::ClosureKind::Fn))
  }
  hir::ClosureKind::Coroutine(_) | hir::ClosureKind::CoroutineClosure(_) => {

compiler/rustc_hir_typeck/src/coercion.rs

@@ -225,10 +225,10 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
  // items to drop the unsafe qualifier.
  self.coerce_from_fn_item(a, b)
  }
- ty::FnPtr(a_f) => {
+ ty::FnPtr(a_sig_tys, a_hdr) => {
  // We permit coercion of fn pointers to drop the
  // unsafe qualifier.
- self.coerce_from_fn_pointer(a, a_f, b)
+ self.coerce_from_fn_pointer(a, a_sig_tys.with(a_hdr), b)
  }
  ty::Closure(closure_def_id_a, args_a) => {
  // Non-capturing closures are coercible to
@@ -788,9 +788,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
  self.commit_if_ok(|snapshot| {
  let outer_universe = self.infcx.universe();
 
- let result = if let ty::FnPtr(fn_ty_b) = b.kind()
- && let (hir::Safety::Safe, hir::Safety::Unsafe) =
- (fn_ty_a.safety(), fn_ty_b.safety())
+ let result = if let ty::FnPtr(_, hdr_b) = b.kind()
+ && let (hir::Safety::Safe, hir::Safety::Unsafe) = (fn_ty_a.safety(), hdr_b.safety)
  {
  let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(fn_ty_a);
  self.unify_and(unsafe_a, b, to_unsafe)
@@ -842,7 +841,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
  debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);
 
  match b.kind() {
- ty::FnPtr(b_sig) => {
+ ty::FnPtr(_, b_hdr) => {
  let a_sig = a.fn_sig(self.tcx);
  if let ty::FnDef(def_id, _) = *a.kind() {
  // Intrinsics are not coercible to function pointers
@@ -852,7 +851,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
  // Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396).
 
- if b_sig.safety() == hir::Safety::Safe
+ if b_hdr.safety == hir::Safety::Safe
  && !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
  {
  return Err(TypeError::TargetFeatureCast(def_id));
@@ -910,7 +909,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
  //
  // All we care here is if any variable is being captured and not the exact paths,
  // so we check `upvars_mentioned` for root variables being captured.
- ty::FnPtr(fn_ty)
+ ty::FnPtr(_, hdr)
  if self
  .tcx
  .upvars_mentioned(closure_def_id_a.expect_local())
@@ -923,7 +922,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
  // or
  // `unsafe fn(arg0,arg1,...) -> _`
  let closure_sig = args_a.as_closure().sig();
- let safety = fn_ty.safety();
+ let safety = hdr.safety;
  let pointer_ty =
  Ty::new_fn_ptr(self.tcx, self.tcx.signature_unclosure(closure_sig, safety));
  debug!("coerce_closure_to_fn(a={:?}, b={:?}, pty={:?})", a, b, pointer_ty);

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -1527,7 +1527,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  ty::Int(_) | ty::Uint(_) => Some(ty),
  ty::Char => Some(tcx.types.u8),
  ty::RawPtr(..) => Some(tcx.types.usize),
- ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
+ ty::FnDef(..) | ty::FnPtr(..) => Some(tcx.types.usize),
  _ => None,
  });
  opt_ty.unwrap_or_else(|| self.next_int_var())

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -604,7 +604,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  expected: Ty<'tcx>,
  found: Ty<'tcx>,
  ) -> bool {
- if let (ty::FnPtr(_), ty::Closure(def_id, _)) = (expected.kind(), found.kind()) {
+ if let (ty::FnPtr(..), ty::Closure(def_id, _)) = (expected.kind(), found.kind()) {
  if let Some(upvars) = self.tcx.upvars_mentioned(*def_id) {
  // Report upto four upvars being captured to reduce the amount error messages
  // reported back to the user.

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -50,7 +50,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // Not all of these (e.g., unsafe fns) implement `FnOnce`,
  // so we look for these beforehand.
  // FIXME(async_closures): These don't impl `FnOnce` by default.
- ty::Closure(..) | ty::FnDef(..) | ty::FnPtr(_) => true,
+ ty::Closure(..) | ty::FnDef(..) | ty::FnPtr(..) => true,
  // If it's not a simple function, look for things which implement `FnOnce`.
  _ => {
  let Some(fn_once) = tcx.lang_items().fn_once_trait() else {

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -438,7 +438,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
  | ty::RawPtr(..)
  | ty::Ref(..)
  | ty::FnDef(..)
- | ty::FnPtr(_)
+ | ty::FnPtr(..)
  | ty::Dynamic(..)
  | ty::Never
  | ty::Tuple(..)

compiler/rustc_lint/src/types.rs

@@ -1025,7 +1025,7 @@ fn ty_is_known_nonnull<'tcx>(
  let ty = tcx.try_normalize_erasing_regions(param_env, ty).unwrap_or(ty);
 
  match ty.kind() {
- ty::FnPtr(_) => true,
+ ty::FnPtr(..) => true,
  ty::Ref(..) => true,
  ty::Adt(def, _) if def.is_box() && matches!(mode, CItemKind::Definition) => true,
  ty::Adt(def, args) if def.repr().transparent() && !def.is_union() => {
@@ -1476,7 +1476,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
  ty::Array(inner_ty, _) => self.check_type_for_ffi(cache, inner_ty),
 
- ty::FnPtr(sig) => {
+ ty::FnPtr(sig_tys, hdr) => {
+ let sig = sig_tys.with(hdr);
  if self.is_internal_abi(sig.abi()) {
  return FfiUnsafe {
  ty,
@@ -1712,8 +1713,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  type Result = ControlFlow<Ty<'tcx>>;
 
  fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
- if let ty::FnPtr(sig) = ty.kind()
- && !self.visitor.is_internal_abi(sig.abi())
+ if let ty::FnPtr(_, hdr) = ty.kind()
+ && !self.visitor.is_internal_abi(hdr.abi)
  {
  self.tys.push(ty);
  }