Struct rustc_target::abi::TyAndLayout

pub struct TyAndLayout<'a, Ty> {
    pub ty: Ty,
    pub layout: Layout<'a>,
}

The layout of a type, alongside the type itself. Provides various type traversal APIs (e.g., recursing into fields).

Note that the layout is NOT guaranteed to always be identical to that obtained from layout_of(ty), as we need to produce layouts for which Rust types do not exist, such as enum variants or synthetic fields of enums (i.e., discriminants) and fat pointers.

Fields

ty: Ty

layout: Layout<'a>

Implementations

impl<'a, Ty> TyAndLayout<'a, Ty>

fn is_aggregate(&self) -> bool

Returns true if this is an aggregate type (including a ScalarPair!)

pub fn homogeneous_aggregate<C>( &self, cx: &C, ) -> Result<HomogeneousAggregate, Heterogeneous>

where Ty: TyAbiInterface<'a, C> + Copy,

Returns Homogeneous if this layout is an aggregate containing fields of only a single type (e.g., (u32, u32)). Such aggregates are often special-cased in ABIs.

Note: We generally ignore 1-ZST fields when computing this value (see #56877).

This is public so that it can be used in unit tests, but should generally only be relevant to the ABI details of specific targets.

impl<'a, Ty> TyAndLayout<'a, Ty>

pub fn for_variant<C>(self, cx: &C, variant_index: VariantIdx) -> Self

where Ty: TyAbiInterface<'a, C>,

pub fn field<C>(self, cx: &C, i: usize) -> Self

where Ty: TyAbiInterface<'a, C>,

pub fn pointee_info_at<C>(self, cx: &C, offset: Size) -> Option<PointeeInfo>

where Ty: TyAbiInterface<'a, C>,

pub fn is_single_fp_element<C>(self, cx: &C) -> bool

where Ty: TyAbiInterface<'a, C>, C: HasDataLayout,

pub fn is_adt<C>(self) -> bool

where Ty: TyAbiInterface<'a, C>,

pub fn is_never<C>(self) -> bool

where Ty: TyAbiInterface<'a, C>,

pub fn is_tuple<C>(self) -> bool

where Ty: TyAbiInterface<'a, C>,

pub fn is_unit<C>(self) -> bool

where Ty: TyAbiInterface<'a, C>,

pub fn is_transparent<C>(self) -> bool

where Ty: TyAbiInterface<'a, C>,

pub fn non_1zst_field<C>(&self, cx: &C) -> Option<(usize, Self)>

where Ty: TyAbiInterface<'a, C> + Copy,

Finds the one field that is not a 1-ZST. Returns None if there are multiple non-1-ZST fields or only 1-ZST-fields.

Methods from Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>>

pub fn is_unsized(&self) -> bool

Returns true if the layout corresponds to an unsized type.

pub fn is_sized(&self) -> bool

pub fn is_1zst(&self) -> bool

Returns true if the type is sized and a 1-ZST (meaning it has size 0 and alignment 1).

pub fn is_zst(&self) -> bool

Returns true if the type is a ZST and not unsized.

Note that this does not imply that the type is irrelevant for layout! It can still have non-trivial alignment constraints. You probably want to use is_1zst instead.

pub fn eq_abi(&self, other: &LayoutS<FieldIdx, VariantIdx>) -> bool

Checks if these two Layout are equal enough to be considered “the same for all function call ABIs”. Note however that real ABIs depend on more details that are not reflected in the Layout; the PassMode need to be compared as well. Also note that we assume aggregates are passed via PassMode::Indirect or PassMode::Cast; more strict checks would otherwise be required.

Trait Implementations

impl<'a, Ty: Clone> Clone for TyAndLayout<'a, Ty>

fn clone(&self) -> TyAndLayout<'a, Ty>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, Ty: Display> Debug for TyAndLayout<'a, Ty>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, Ty> Deref for TyAndLayout<'a, Ty>

type Target = &'a LayoutS<FieldIdx, VariantIdx>

The resulting type after dereferencing.

fn deref(&self) -> &&'a LayoutS<FieldIdx, VariantIdx>

Dereferences the value.

impl<'a, Ty: Hash> Hash for TyAndLayout<'a, Ty>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, Ty, __CTX> HashStable<__CTX> for TyAndLayout<'a, Ty>

where __CTX: HashStableContext, Ty: HashStable<__CTX>,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<'a, Ty: PartialEq> PartialEq for TyAndLayout<'a, Ty>

fn eq(&self, other: &TyAndLayout<'a, Ty>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, Ty: Copy> Copy for TyAndLayout<'a, Ty>

impl<'a, Ty: Eq> Eq for TyAndLayout<'a, Ty>

impl<'a, Ty> StructuralPartialEq for TyAndLayout<'a, Ty>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.