Make Ty::boxed_ty return an Option

[GrigorenkoPV]

Looks like a good place to use Rust's type system.

---

Most of

rust/compiler/rustc_middle/src/ty/sty.rs

Lines 971 to 1963 in 4ac7bcb

	/// Type utilities
	impl<'tcx> Ty<'tcx> {
	// It would be nicer if this returned the value instead of a reference,
	// like how `Predicate::kind` and `Region::kind` do. (It would result in
	// many fewer subsequent dereferences.) But that gives a small but
	// noticeable performance hit. See #126069 for details.
	#[inline(always)]
	pub fn kind(self) -> &'tcx TyKind<'tcx> {
	self.0.0
	}
	// FIXME(compiler-errors): Think about removing this.
	#[inline(always)]
	pub fn flags(self) -> TypeFlags {
	self.0.0.flags
	}
	#[inline]
	pub fn is_unit(self) -> bool {
	match self.kind() {
	Tuple(tys) => tys.is_empty(),
	_ => false,
	}
	}
	#[inline]
	pub fn is_never(self) -> bool {
	matches!(self.kind(), Never)
	}
	#[inline]
	pub fn is_primitive(self) -> bool {
	matches!(self.kind(), Bool | Char | Int(_) | Uint(_) | Float(_))
	}
	#[inline]
	pub fn is_adt(self) -> bool {
	matches!(self.kind(), Adt(..))
	}
	#[inline]
	pub fn is_ref(self) -> bool {
	matches!(self.kind(), Ref(..))
	}
	#[inline]
	pub fn is_ty_var(self) -> bool {
	matches!(self.kind(), Infer(TyVar(_)))
	}
	#[inline]
	pub fn ty_vid(self) -> Option<ty::TyVid> {
	match self.kind() {
	&Infer(TyVar(vid)) => Some(vid),
	_ => None,
	}
	}
	#[inline]
	pub fn is_ty_or_numeric_infer(self) -> bool {
	matches!(self.kind(), Infer(_))
	}
	#[inline]
	pub fn is_phantom_data(self) -> bool {
	if let Adt(def, _) = self.kind() { def.is_phantom_data() } else { false }
	}
	#[inline]
	pub fn is_bool(self) -> bool {
	*self.kind() == Bool
	}
	/// Returns `true` if this type is a `str`.
	#[inline]
	pub fn is_str(self) -> bool {
	*self.kind() == Str
	}
	#[inline]
	pub fn is_param(self, index: u32) -> bool {
	match self.kind() {
	ty::Param(ref data) => data.index == index,
	_ => false,
	}
	}
	#[inline]
	pub fn is_slice(self) -> bool {
	matches!(self.kind(), Slice(_))
	}
	#[inline]
	pub fn is_array_slice(self) -> bool {
	match self.kind() {
	Slice(_) => true,
	ty::RawPtr(ty, _) | Ref(_, ty, _) => matches!(ty.kind(), Slice(_)),
	_ => false,
	}
	}
	#[inline]
	pub fn is_array(self) -> bool {
	matches!(self.kind(), Array(..))
	}
	#[inline]
	pub fn is_simd(self) -> bool {
	match self.kind() {
	Adt(def, _) => def.repr().simd(),
	_ => false,
	}
	}
	pub fn sequence_element_type(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
	match self.kind() {
	Array(ty, _) | Slice(ty) => *ty,
	Str => tcx.types.u8,
	_ => bug!("`sequence_element_type` called on non-sequence value: {}", self),
	}
	}
	pub fn simd_size_and_type(self, tcx: TyCtxt<'tcx>) -> (u64, Ty<'tcx>) {
	match self.kind() {
	Adt(def, args) => {
	assert!(def.repr().simd(), "`simd_size_and_type` called on non-SIMD type");
	let variant = def.non_enum_variant();
	let f0_ty = variant.fields[FieldIdx::ZERO].ty(tcx, args);
	match f0_ty.kind() {
	// If the first field is an array, we assume it is the only field and its
	// elements are the SIMD components.
	Array(f0_elem_ty, f0_len) => {
	// FIXME(repr_simd): https://github.com/rust-lang/rust/pull/78863#discussion_r522784112
	// The way we evaluate the `N` in `[T; N]` here only works since we use
	// `simd_size_and_type` post-monomorphization. It will probably start to ICE
	// if we use it in generic code. See the `simd-array-trait` ui test.
	(f0_len.eval_target_usize(tcx, ParamEnv::empty()), *f0_elem_ty)
	}
	// Otherwise, the fields of this Adt are the SIMD components (and we assume they
	// all have the same type).
	_ => (variant.fields.len() as u64, f0_ty),
	}
	}
	_ => bug!("`simd_size_and_type` called on invalid type"),
	}
	}
	#[inline]
	pub fn is_mutable_ptr(self) -> bool {
	matches!(self.kind(), RawPtr(_, hir::Mutability::Mut) | Ref(_, _, hir::Mutability::Mut))
	}
	/// Get the mutability of the reference or `None` when not a reference
	#[inline]
	pub fn ref_mutability(self) -> Option<hir::Mutability> {
	match self.kind() {
	Ref(_, _, mutability) => Some(*mutability),
	_ => None,
	}
	}
	#[inline]
	pub fn is_unsafe_ptr(self) -> bool {
	matches!(self.kind(), RawPtr(_, _))
	}
	/// Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).
	#[inline]
	pub fn is_any_ptr(self) -> bool {
	self.is_ref() || self.is_unsafe_ptr() || self.is_fn_ptr()
	}
	#[inline]
	pub fn is_box(self) -> bool {
	match self.kind() {
	Adt(def, _) => def.is_box(),
	_ => false,
	}
	}
	/// Tests whether this is a Box definitely using the global allocator.
	///
	/// If the allocator is still generic, the answer is `false`, but it may
	/// later turn out that it does use the global allocator.
	#[inline]
	pub fn is_box_global(self, tcx: TyCtxt<'tcx>) -> bool {
	match self.kind() {
	Adt(def, args) if def.is_box() => {
	let Some(alloc) = args.get(1) else {
	// Single-argument Box is always global. (for "minicore" tests)
	return true;
	};
	alloc.expect_ty().ty_adt_def().is_some_and(|alloc_adt| {
	let global_alloc = tcx.require_lang_item(LangItem::GlobalAlloc, None);
	alloc_adt.did() == global_alloc
	})
	}
	_ => false,
	}
	}
	/// Panics if called on any type other than `Box<T>`.
	pub fn boxed_ty(self) -> Ty<'tcx> {
	match self.kind() {
	Adt(def, args) if def.is_box() => args.type_at(0),
	_ => bug!("`boxed_ty` is called on non-box type {:?}", self),
	}
	}
	/// A scalar type is one that denotes an atomic datum, with no sub-components.
	/// (A RawPtr is scalar because it represents a non-managed pointer, so its
	/// contents are abstract to rustc.)
	#[inline]
	pub fn is_scalar(self) -> bool {
	matches!(
	self.kind(),
	Bool | Char
	| Int(_)
	| Float(_)
	| Uint(_)
	| FnDef(..)
	| FnPtr(..)
	| RawPtr(_, _)
	| Infer(IntVar(_) | FloatVar(_))
	)
	}
	/// Returns `true` if this type is a floating point type.
	#[inline]
	pub fn is_floating_point(self) -> bool {
	matches!(self.kind(), Float(_) | Infer(FloatVar(_)))
	}
	#[inline]
	pub fn is_trait(self) -> bool {
	matches!(self.kind(), Dynamic(_, _, ty::Dyn))
	}
	#[inline]
	pub fn is_dyn_star(self) -> bool {
	matches!(self.kind(), Dynamic(_, _, ty::DynStar))
	}
	#[inline]
	pub fn is_enum(self) -> bool {
	matches!(self.kind(), Adt(adt_def, _) if adt_def.is_enum())
	}
	#[inline]
	pub fn is_union(self) -> bool {
	matches!(self.kind(), Adt(adt_def, _) if adt_def.is_union())
	}
	#[inline]
	pub fn is_closure(self) -> bool {
	matches!(self.kind(), Closure(..))
	}
	#[inline]
	pub fn is_coroutine(self) -> bool {
	matches!(self.kind(), Coroutine(..))
	}
	#[inline]
	pub fn is_coroutine_closure(self) -> bool {
	matches!(self.kind(), CoroutineClosure(..))
	}
	#[inline]
	pub fn is_integral(self) -> bool {
	matches!(self.kind(), Infer(IntVar(_)) | Int(_) | Uint(_))
	}
	#[inline]
	pub fn is_fresh_ty(self) -> bool {
	matches!(self.kind(), Infer(FreshTy(_)))
	}
	#[inline]
	pub fn is_fresh(self) -> bool {
	matches!(self.kind(), Infer(FreshTy(_) | FreshIntTy(_) | FreshFloatTy(_)))
	}
	#[inline]
	pub fn is_char(self) -> bool {
	matches!(self.kind(), Char)
	}
	#[inline]
	pub fn is_numeric(self) -> bool {
	self.is_integral() || self.is_floating_point()
	}
	#[inline]
	pub fn is_signed(self) -> bool {
	matches!(self.kind(), Int(_))
	}
	#[inline]
	pub fn is_ptr_sized_integral(self) -> bool {
	matches!(self.kind(), Int(ty::IntTy::Isize) | Uint(ty::UintTy::Usize))
	}
	#[inline]
	pub fn has_concrete_skeleton(self) -> bool {
	!matches!(self.kind(), Param(_) | Infer(_) | Error(_))
	}
	/// Checks whether a type recursively contains another type
	///
	/// Example: `Option<()>` contains `()`
	pub fn contains(self, other: Ty<'tcx>) -> bool {
	struct ContainsTyVisitor<'tcx>(Ty<'tcx>);
	impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ContainsTyVisitor<'tcx> {
	type Result = ControlFlow<()>;
	fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
	if self.0 == t { ControlFlow::Break(()) } else { t.super_visit_with(self) }
	}
	}
	let cf = self.visit_with(&mut ContainsTyVisitor(other));
	cf.is_break()
	}
	/// Checks whether a type recursively contains any closure
	///
	/// Example: `Option<{closure@file.rs:4:20}>` returns true
	pub fn contains_closure(self) -> bool {
	struct ContainsClosureVisitor;
	impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ContainsClosureVisitor {
	type Result = ControlFlow<()>;
	fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
	if let ty::Closure(..) = t.kind() {
	ControlFlow::Break(())
	} else {
	t.super_visit_with(self)
	}
	}
	}
	let cf = self.visit_with(&mut ContainsClosureVisitor);
	cf.is_break()
	}
	/// Returns the type and mutability of `*ty`.
	///
	/// The parameter `explicit` indicates if this is an *explicit* dereference.
	/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
	pub fn builtin_deref(self, explicit: bool) -> Option<Ty<'tcx>> {
	match *self.kind() {
	Adt(def, _) if def.is_box() => Some(self.boxed_ty()),
	Ref(_, ty, _) => Some(ty),
	RawPtr(ty, _) if explicit => Some(ty),
	_ => None,
	}
	}
	/// Returns the type of `ty[i]`.
	pub fn builtin_index(self) -> Option<Ty<'tcx>> {
	match self.kind() {
	Array(ty, _) | Slice(ty) => Some(*ty),
	_ => None,
	}
	}
	pub fn fn_sig(self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx> {
	match self.kind() {
	FnDef(def_id, args) => tcx.fn_sig(*def_id).instantiate(tcx, args),
	FnPtr(sig_tys, hdr) => sig_tys.with(*hdr),
	Error(_) => {
	// ignore errors (#54954)
	Binder::dummy(ty::FnSig {
	inputs_and_output: ty::List::empty(),
	c_variadic: false,
	safety: hir::Safety::Safe,
	abi: abi::Abi::Rust,
	})
	}
	Closure(..) => bug!(
	"to get the signature of a closure, use `args.as_closure().sig()` not `fn_sig()`",
	),
	_ => bug!("Ty::fn_sig() called on non-fn type: {:?}", self),
	}
	}
	#[inline]
	pub fn is_fn(self) -> bool {
	matches!(self.kind(), FnDef(..) | FnPtr(..))
	}
	#[inline]
	pub fn is_fn_ptr(self) -> bool {
	matches!(self.kind(), FnPtr(..))
	}
	#[inline]
	pub fn is_impl_trait(self) -> bool {
	matches!(self.kind(), Alias(ty::Opaque, ..))
	}
	#[inline]
	pub fn ty_adt_def(self) -> Option<AdtDef<'tcx>> {
	match self.kind() {
	Adt(adt, _) => Some(*adt),
	_ => None,
	}
	}
	/// Iterates over tuple fields.
	/// Panics when called on anything but a tuple.
	#[inline]
	pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>> {
	match self.kind() {
	Tuple(args) => args,
	_ => bug!("tuple_fields called on non-tuple: {self:?}"),
	}
	}
	/// If the type contains variants, returns the valid range of variant indices.
	//
	// FIXME: This requires the optimized MIR in the case of coroutines.
	#[inline]
	pub fn variant_range(self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>> {
	match self.kind() {
	TyKind::Adt(adt, _) => Some(adt.variant_range()),
	TyKind::Coroutine(def_id, args) => {
	Some(args.as_coroutine().variant_range(*def_id, tcx))
	}
	_ => None,
	}
	}
	/// If the type contains variants, returns the variant for `variant_index`.
	/// Panics if `variant_index` is out of range.
	//
	// FIXME: This requires the optimized MIR in the case of coroutines.
	#[inline]
	pub fn discriminant_for_variant(
	self,
	tcx: TyCtxt<'tcx>,
	variant_index: VariantIdx,
	) -> Option<Discr<'tcx>> {
	match self.kind() {
	TyKind::Adt(adt, _) if adt.is_enum() => {
	Some(adt.discriminant_for_variant(tcx, variant_index))
	}
	TyKind::Coroutine(def_id, args) => {
	Some(args.as_coroutine().discriminant_for_variant(*def_id, tcx, variant_index))
	}
	_ => None,
	}
	}
	/// Returns the type of the discriminant of this type.
	pub fn discriminant_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
	match self.kind() {
	ty::Adt(adt, _) if adt.is_enum() => adt.repr().discr_type().to_ty(tcx),
	ty::Coroutine(_, args) => args.as_coroutine().discr_ty(tcx),
	ty::Param(_) | ty::Alias(..) | ty::Infer(ty::TyVar(_)) => {
	let assoc_items = tcx.associated_item_def_ids(
	tcx.require_lang_item(hir::LangItem::DiscriminantKind, None),
	);
	Ty::new_projection_from_args(tcx, assoc_items[0], tcx.mk_args(&[self.into()]))
	}
	ty::Pat(ty, _) => ty.discriminant_ty(tcx),
	ty::Bool
	| ty::Char
	| ty::Int(_)
	| ty::Uint(_)
	| ty::Float(_)
	| ty::Adt(..)
	| ty::Foreign(_)
	| ty::Str
	| ty::Array(..)
	| ty::Slice(_)
	| ty::RawPtr(_, _)
	| ty::Ref(..)
	| ty::FnDef(..)
	| ty::FnPtr(..)
	| ty::Dynamic(..)
	| ty::Closure(..)
	| ty::CoroutineClosure(..)
	| ty::CoroutineWitness(..)
	| ty::Never
	| ty::Tuple(_)
	| ty::Error(_)
	| ty::Infer(IntVar(_) | FloatVar(_)) => tcx.types.u8,
	ty::Bound(..)
	| ty::Placeholder(_)
	| ty::Infer(FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
	bug!("`discriminant_ty` applied to unexpected type: {:?}", self)
	}
	}
	}
	/// Returns the type of the async destructor of this type.
	pub fn async_destructor_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
	match self.async_drop_glue_morphology(tcx) {
	AsyncDropGlueMorphology::Noop => {
	return Ty::async_destructor_combinator(tcx, LangItem::AsyncDropNoop)
	.instantiate_identity();
	}
	AsyncDropGlueMorphology::DeferredDropInPlace => {
	let drop_in_place =
	Ty::async_destructor_combinator(tcx, LangItem::AsyncDropDeferredDropInPlace)
	.instantiate(tcx, &[self.into()]);
	return Ty::async_destructor_combinator(tcx, LangItem::AsyncDropFuse)
	.instantiate(tcx, &[drop_in_place.into()]);
	}
	AsyncDropGlueMorphology::Custom => (),
	}
	match *self.kind() {
	ty::Param(_) | ty::Alias(..) | ty::Infer(ty::TyVar(_)) => {
	let assoc_items = tcx
	.associated_item_def_ids(tcx.require_lang_item(LangItem::AsyncDestruct, None));
	Ty::new_projection(tcx, assoc_items[0], [self])
	}
	ty::Array(elem_ty, _) | ty::Slice(elem_ty) => {
	let dtor = Ty::async_destructor_combinator(tcx, LangItem::AsyncDropSlice)
	.instantiate(tcx, &[elem_ty.into()]);
	Ty::async_destructor_combinator(tcx, LangItem::AsyncDropFuse)
	.instantiate(tcx, &[dtor.into()])
	}
	ty::Adt(adt_def, args) if adt_def.is_enum() || adt_def.is_struct() => self
	.adt_async_destructor_ty(
	tcx,
	adt_def.variants().iter().map(|v| v.fields.iter().map(|f| f.ty(tcx, args))),
	),
	ty::Tuple(tys) => self.adt_async_destructor_ty(tcx, iter::once(tys)),
	ty::Closure(_, args) => {
	self.adt_async_destructor_ty(tcx, iter::once(args.as_closure().upvar_tys()))
	}
	ty::CoroutineClosure(_, args) => self
	.adt_async_destructor_ty(tcx, iter::once(args.as_coroutine_closure().upvar_tys())),
	ty::Adt(adt_def, _) => {
	assert!(adt_def.is_union());
	let surface_drop = self.surface_async_dropper_ty(tcx).unwrap();
	Ty::async_destructor_combinator(tcx, LangItem::AsyncDropFuse)
	.instantiate(tcx, &[surface_drop.into()])
	}
	ty::Bound(..)
	| ty::Foreign(_)
	| ty::Placeholder(_)
	| ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
	bug!("`async_destructor_ty` applied to unexpected type: {self:?}")
	}
	_ => bug!("`async_destructor_ty` is not yet implemented for type: {self:?}"),
	}
	}
	fn adt_async_destructor_ty<I>(self, tcx: TyCtxt<'tcx>, variants: I) -> Ty<'tcx>
	where
	I: Iterator + ExactSizeIterator,
	I::Item: IntoIterator<Item = Ty<'tcx>>,
	{
	debug_assert_eq!(self.async_drop_glue_morphology(tcx), AsyncDropGlueMorphology::Custom);
	let defer = Ty::async_destructor_combinator(tcx, LangItem::AsyncDropDefer);
	let chain = Ty::async_destructor_combinator(tcx, LangItem::AsyncDropChain);
	let noop =
	Ty::async_destructor_combinator(tcx, LangItem::AsyncDropNoop).instantiate_identity();
	let either = Ty::async_destructor_combinator(tcx, LangItem::AsyncDropEither);
	let variants_dtor = variants
	.into_iter()
	.map(|variant| {
	variant
	.into_iter()
	.map(|ty| defer.instantiate(tcx, &[ty.into()]))
	.reduce(|acc, next| chain.instantiate(tcx, &[acc.into(), next.into()]))
	.unwrap_or(noop)
	})
	.reduce(|other, matched| {
	either.instantiate(tcx, &[other.into(), matched.into(), self.into()])
	})
	.unwrap();
	let dtor = if let Some(dropper_ty) = self.surface_async_dropper_ty(tcx) {
	Ty::async_destructor_combinator(tcx, LangItem::AsyncDropChain)
	.instantiate(tcx, &[dropper_ty.into(), variants_dtor.into()])
	} else {
	variants_dtor
	};
	Ty::async_destructor_combinator(tcx, LangItem::AsyncDropFuse)
	.instantiate(tcx, &[dtor.into()])
	}
	fn surface_async_dropper_ty(self, tcx: TyCtxt<'tcx>) -> Option<Ty<'tcx>> {
	let adt_def = self.ty_adt_def()?;
	let dropper = adt_def
	.async_destructor(tcx)
	.map(|_| LangItem::SurfaceAsyncDropInPlace)
	.or_else(|| adt_def.destructor(tcx).map(|_| LangItem::AsyncDropSurfaceDropInPlace))?;
	Some(Ty::async_destructor_combinator(tcx, dropper).instantiate(tcx, &[self.into()]))
	}
	fn async_destructor_combinator(
	tcx: TyCtxt<'tcx>,
	lang_item: LangItem,
	) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
	tcx.fn_sig(tcx.require_lang_item(lang_item, None))
	.map_bound(|fn_sig| fn_sig.output().no_bound_vars().unwrap())
	}
	/// Returns the type of metadata for (potentially fat) pointers to this type,
	/// or the struct tail if the metadata type cannot be determined.
	pub fn ptr_metadata_ty_or_tail(
	self,
	tcx: TyCtxt<'tcx>,
	normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
	) -> Result<Ty<'tcx>, Ty<'tcx>> {
	let tail = tcx.struct_tail_raw(self, normalize, || {});
	match tail.kind() {
	// Sized types
	ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
	| ty::Uint(_)
	| ty::Int(_)
	| ty::Bool
	| ty::Float(_)
	| ty::FnDef(..)
	| ty::FnPtr(..)
	| ty::RawPtr(..)
	| ty::Char
	| ty::Ref(..)
	| ty::Coroutine(..)
	| ty::CoroutineWitness(..)
	| ty::Array(..)
	| ty::Closure(..)
	| ty::CoroutineClosure(..)
	| ty::Never
	| ty::Error(_)
	// Extern types have metadata = ().
	| ty::Foreign(..)
	// `dyn*` has metadata = ().
	| ty::Dynamic(_, _, ty::DynStar)
	// If returned by `struct_tail_raw` this is a unit struct
	// without any fields, or not a struct, and therefore is Sized.
	| ty::Adt(..)
	// If returned by `struct_tail_raw` this is the empty tuple,
	// a.k.a. unit type, which is Sized
	| ty::Tuple(..) => Ok(tcx.types.unit),
	ty::Str | ty::Slice(_) => Ok(tcx.types.usize),
	ty::Dynamic(_, _, ty::Dyn) => {
	let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, None);
	Ok(tcx.type_of(dyn_metadata).instantiate(tcx, &[tail.into()]))
	}
	// We don't know the metadata of `self`, but it must be equal to the
	// metadata of `tail`.
	ty::Param(_) | ty::Alias(..) => Err(tail),
	ty::Infer(ty::TyVar(_))
	| ty::Pat(..)
	| ty::Bound(..)
	| ty::Placeholder(..)
	| ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => bug!(
	"`ptr_metadata_ty_or_tail` applied to unexpected type: {self:?} (tail = {tail:?})"
	),
	}
	}
	/// Returns the type of metadata for (potentially fat) pointers to this type.
	/// Causes an ICE if the metadata type cannot be determined.
	pub fn ptr_metadata_ty(
	self,
	tcx: TyCtxt<'tcx>,
	normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
	) -> Ty<'tcx> {
	match self.ptr_metadata_ty_or_tail(tcx, normalize) {
	Ok(metadata) => metadata,
	Err(tail) => bug!(
	"`ptr_metadata_ty` failed to get metadata for type: {self:?} (tail = {tail:?})"
	),
	}
	}
	/// Given a pointer or reference type, returns the type of the *pointee*'s
	/// metadata. If it can't be determined exactly (perhaps due to still
	/// being generic) then a projection through `ptr::Pointee` will be returned.
	///
	/// This is particularly useful for getting the type of the result of
	/// [`UnOp::PtrMetadata`](crate::mir::UnOp::PtrMetadata).
	///
	/// Panics if `self` is not dereferencable.
	#[track_caller]
	pub fn pointee_metadata_ty_or_projection(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
	let Some(pointee_ty) = self.builtin_deref(true) else {
	bug!("Type {self:?} is not a pointer or reference type")
	};
	if pointee_ty.is_trivially_sized(tcx) {
	tcx.types.unit
	} else {
	match pointee_ty.ptr_metadata_ty_or_tail(tcx, |x| x) {
	Ok(metadata_ty) => metadata_ty,
	Err(tail_ty) => {
	let Some(metadata_def_id) = tcx.lang_items().metadata_type() else {
	bug!("No metadata_type lang item while looking at {self:?}")
	};
	Ty::new_projection(tcx, metadata_def_id, [tail_ty])
	}
	}
	}
	}
	/// When we create a closure, we record its kind (i.e., what trait
	/// it implements, constrained by how it uses its borrows) into its
	/// [`ty::ClosureArgs`] or [`ty::CoroutineClosureArgs`] using a type
	/// parameter. This is kind of a phantom type, except that the
	/// most convenient thing for us to are the integral types. This
	/// function converts such a special type into the closure
	/// kind. To go the other way, use [`Ty::from_closure_kind`].
	///
	/// Note that during type checking, we use an inference variable
	/// to represent the closure kind, because it has not yet been
	/// inferred. Once upvar inference (in `rustc_hir_analysis/src/check/upvar.rs`)
	/// is complete, that type variable will be unified with one of
	/// the integral types.
	///
	/// ```rust,ignore (snippet of compiler code)
	/// if let TyKind::Closure(def_id, args) = closure_ty.kind()
	/// && let Some(closure_kind) = args.as_closure().kind_ty().to_opt_closure_kind()
	/// {
	/// println!("{closure_kind:?}");
	/// } else if let TyKind::CoroutineClosure(def_id, args) = closure_ty.kind()
	/// && let Some(closure_kind) = args.as_coroutine_closure().kind_ty().to_opt_closure_kind()
	/// {
	/// println!("{closure_kind:?}");
	/// }
	/// ```
	///
	/// After upvar analysis, you should instead use [`ty::ClosureArgs::kind()`]
	/// or [`ty::CoroutineClosureArgs::kind()`] to assert that the `ClosureKind`
	/// has been constrained instead of manually calling this method.
	///
	/// ```rust,ignore (snippet of compiler code)
	/// if let TyKind::Closure(def_id, args) = closure_ty.kind()
	/// {
	/// println!("{:?}", args.as_closure().kind());
	/// } else if let TyKind::CoroutineClosure(def_id, args) = closure_ty.kind()
	/// {
	/// println!("{:?}", args.as_coroutine_closure().kind());
	/// }
	/// ```
	pub fn to_opt_closure_kind(self) -> Option<ty::ClosureKind> {
	match self.kind() {
	Int(int_ty) => match int_ty {
	ty::IntTy::I8 => Some(ty::ClosureKind::Fn),
	ty::IntTy::I16 => Some(ty::ClosureKind::FnMut),
	ty::IntTy::I32 => Some(ty::ClosureKind::FnOnce),
	_ => bug!("cannot convert type `{:?}` to a closure kind", self),
	},
	// "Bound" types appear in canonical queries when the
	// closure type is not yet known, and `Placeholder` and `Param`
	// may be encountered in generic `AsyncFnKindHelper` goals.
	Bound(..) | Placeholder(_) | Param(_) | Infer(_) => None,
	Error(_) => Some(ty::ClosureKind::Fn),
	_ => bug!("cannot convert type `{:?}` to a closure kind", self),
	}
	}
	/// Inverse of [`Ty::to_opt_closure_kind`]. See docs on that method
	/// for explanation of the relationship between `Ty` and [`ty::ClosureKind`].
	pub fn from_closure_kind(tcx: TyCtxt<'tcx>, kind: ty::ClosureKind) -> Ty<'tcx> {
	match kind {
	ty::ClosureKind::Fn => tcx.types.i8,
	ty::ClosureKind::FnMut => tcx.types.i16,
	ty::ClosureKind::FnOnce => tcx.types.i32,
	}
	}
	/// Like [`Ty::to_opt_closure_kind`], but it caps the "maximum" closure kind
	/// to `FnMut`. This is because although we have three capability states,
	/// `AsyncFn`/`AsyncFnMut`/`AsyncFnOnce`, we only need to distinguish two coroutine
	/// bodies: by-ref and by-value.
	///
	/// See the definition of `AsyncFn` and `AsyncFnMut` and the `CallRefFuture`
	/// associated type for why we don't distinguish [`ty::ClosureKind::Fn`] and
	/// [`ty::ClosureKind::FnMut`] for the purpose of the generated MIR bodies.
	///
	/// This method should be used when constructing a `Coroutine` out of a
	/// `CoroutineClosure`, when the `Coroutine`'s `kind` field is being populated
	/// directly from the `CoroutineClosure`'s `kind`.
	pub fn from_coroutine_closure_kind(tcx: TyCtxt<'tcx>, kind: ty::ClosureKind) -> Ty<'tcx> {
	match kind {
	ty::ClosureKind::Fn | ty::ClosureKind::FnMut => tcx.types.i16,
	ty::ClosureKind::FnOnce => tcx.types.i32,
	}
	}
	/// Fast path helper for testing if a type is `Sized`.
	///
	/// Returning true means the type is known to be sized. Returning
	/// `false` means nothing -- could be sized, might not be.
	///
	/// Note that we could never rely on the fact that a type such as `[_]` is
	/// trivially `!Sized` because we could be in a type environment with a
	/// bound such as `[_]: Copy`. A function with such a bound obviously never
	/// can be called, but that doesn't mean it shouldn't typecheck. This is why
	/// this method doesn't return `Option<bool>`.
	pub fn is_trivially_sized(self, tcx: TyCtxt<'tcx>) -> bool {
	match self.kind() {
	ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
	| ty::Uint(_)
	| ty::Int(_)
	| ty::Bool
	| ty::Float(_)
	| ty::FnDef(..)
	| ty::FnPtr(..)
	| ty::RawPtr(..)
	| ty::Char
	| ty::Ref(..)
	| ty::Coroutine(..)
	| ty::CoroutineWitness(..)
	| ty::Array(..)
	| ty::Pat(..)
	| ty::Closure(..)
	| ty::CoroutineClosure(..)
	| ty::Never
	| ty::Error(_)
	| ty::Dynamic(_, _, ty::DynStar) => true,
	ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
	ty::Tuple(tys) => tys.last().map_or(true, |ty| ty.is_trivially_sized(tcx)),
	ty::Adt(def, args) => def
	.sized_constraint(tcx)
	.map_or(true, |ty| ty.instantiate(tcx, args).is_trivially_sized(tcx)),
	ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) | ty::Bound(..) => false,
	ty::Infer(ty::TyVar(_)) => false,
	ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
	bug!("`is_trivially_sized` applied to unexpected type: {:?}", self)
	}
	}
	}
	/// Fast path helper for primitives which are always `Copy` and which
	/// have a side-effect-free `Clone` impl.
	///
	/// Returning true means the type is known to be pure and `Copy+Clone`.
	/// Returning `false` means nothing -- could be `Copy`, might not be.
	///
	/// This is mostly useful for optimizations, as these are the types
	/// on which we can replace cloning with dereferencing.
	pub fn is_trivially_pure_clone_copy(self) -> bool {
	match self.kind() {
	ty::Bool | ty::Char | ty::Never => true,
	// These aren't even `Clone`
	ty::Str | ty::Slice(..) | ty::Foreign(..) | ty::Dynamic(..) => false,
	ty::Infer(ty::InferTy::FloatVar(_) | ty::InferTy::IntVar(_))
	| ty::Int(..)
	| ty::Uint(..)
	| ty::Float(..) => true,
	// ZST which can't be named are fine.
	ty::FnDef(..) => true,
	ty::Array(element_ty, _len) => element_ty.is_trivially_pure_clone_copy(),
	// A 100-tuple isn't "trivial", so doing this only for reasonable sizes.
	ty::Tuple(field_tys) => {
	field_tys.len() <= 3 && field_tys.iter().all(Self::is_trivially_pure_clone_copy)
	}
	ty::Pat(ty, _) => ty.is_trivially_pure_clone_copy(),
	// Sometimes traits aren't implemented for every ABI or arity,
	// because we can't be generic over everything yet.
	ty::FnPtr(..) => false,
	// Definitely absolutely not copy.
	ty::Ref(_, _, hir::Mutability::Mut) => false,
	// The standard library has a blanket Copy impl for shared references and raw pointers,
	// for all unsized types.
	ty::Ref(_, _, hir::Mutability::Not) | ty::RawPtr(..) => true,
	ty::Coroutine(..) | ty::CoroutineWitness(..) => false,
	// Might be, but not "trivial" so just giving the safe answer.
	ty::Adt(..) | ty::Closure(..) | ty::CoroutineClosure(..) => false,
	// Needs normalization or revealing to determine, so no is the safe answer.
	ty::Alias(..) => false,
	ty::Param(..) | ty::Infer(..) | ty::Error(..) => false,
	ty::Bound(..) | ty::Placeholder(..) => {
	bug!("`is_trivially_pure_clone_copy` applied to unexpected type: {:?}", self);
	}
	}
	}
	/// If `self` is a primitive, return its [`Symbol`].
	pub fn primitive_symbol(self) -> Option<Symbol> {
	match self.kind() {
	ty::Bool => Some(sym::bool),
	ty::Char => Some(sym::char),
	ty::Float(f) => match f {
	ty::FloatTy::F16 => Some(sym::f16),
	ty::FloatTy::F32 => Some(sym::f32),
	ty::FloatTy::F64 => Some(sym::f64),
	ty::FloatTy::F128 => Some(sym::f128),
	},
	ty::Int(f) => match f {
	ty::IntTy::Isize => Some(sym::isize),
	ty::IntTy::I8 => Some(sym::i8),
	ty::IntTy::I16 => Some(sym::i16),
	ty::IntTy::I32 => Some(sym::i32),
	ty::IntTy::I64 => Some(sym::i64),
	ty::IntTy::I128 => Some(sym::i128),
	},
	ty::Uint(f) => match f {
	ty::UintTy::Usize => Some(sym::usize),
	ty::UintTy::U8 => Some(sym::u8),
	ty::UintTy::U16 => Some(sym::u16),
	ty::UintTy::U32 => Some(sym::u32),
	ty::UintTy::U64 => Some(sym::u64),
	ty::UintTy::U128 => Some(sym::u128),
	},
	_ => None,
	}
	}
	pub fn is_c_void(self, tcx: TyCtxt<'_>) -> bool {
	match self.kind() {
	ty::Adt(adt, _) => tcx.is_lang_item(adt.did(), LangItem::CVoid),
	_ => false,
	}
	}
	/// Returns `true` when the outermost type cannot be further normalized,
	/// resolved, or instantiated. This includes all primitive types, but also
	/// things like ADTs and trait objects, since even if their arguments or
	/// nested types may be further simplified, the outermost [`TyKind`] or
	/// type constructor remains the same.
	pub fn is_known_rigid(self) -> bool {
	match self.kind() {
	Bool
	| Char
	| Int(_)
	| Uint(_)
	| Float(_)
	| Adt(_, _)
	| Foreign(_)
	| Str
	| Array(_, _)
	| Pat(_, _)
	| Slice(_)
	| RawPtr(_, _)
	| Ref(_, _, _)
	| FnDef(_, _)
	| FnPtr(..)
	| Dynamic(_, _, _)
	| Closure(_, _)
	| CoroutineClosure(_, _)
	| Coroutine(_, _)
	| CoroutineWitness(..)
	| Never
	| Tuple(_) => true,
	Error(_) | Infer(_) | Alias(_, _) | Param(_) | Bound(_, _) | Placeholder(_) => false,
	}
	}
	}

looks like it could be moved to TyKind (then I guess Ty should be made to deref to TyKind).

[rustbot]

r? @Nadrieril

rustbot has assigned @Nadrieril.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

[rustbot]

Some changes occurred to MIR optimizations

cc @rust-lang/wg-mir-opt

Some changes occurred in src/tools/clippy

cc @rust-lang/clippy

Some changes occurred to the CTFE / Miri engine

cc @rust-lang/miri

[compiler-errors]

Looks fine other than some nits and please rename boxed_ty_unchecked to expect_boxed_ty.

[GrigorenkoPV]

@rustbot author

Until I unbreak clippy

[GrigorenkoPV]

@rustbot ready

[compiler-errors]

@bors r+ rollup

[bors]

📌 Commit f6e8a84 has been approved by compiler-errors

It is now in the queue for this repository.