Struct LayoutCalculator 

pub struct LayoutCalculator<Cx> {
    pub cx: Cx,
}

Fields

cx: Cx

Implementations

impl<Cx: HasDataLayout> LayoutCalculator<Cx>

pub fn new(cx: Cx) -> Self

pub fn layout_of_array_like<FieldIdx: Idx, VariantIdx: Idx, F>( &self, element: &LayoutData<FieldIdx, VariantIdx>, count_if_sized: Option<u64>, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

pub fn layout_of_scalable_vector_type<FieldIdx, VariantIdx, F>( &self, element: F, count: u64, number_of_vectors: NumScalableVectors, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: AsRef<LayoutData<FieldIdx, VariantIdx>> + Debug,

pub fn layout_of_simd_type<FieldIdx, VariantIdx, F>( &self, element: F, count: u64, repr_packed: bool, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: AsRef<LayoutData<FieldIdx, VariantIdx>> + Debug,

pub fn layout_of_coroutine<'a, F, VariantIdx, FieldIdx, LocalIdx>( &self, local_layouts: &IndexSlice<LocalIdx, F>, prefix_layouts: IndexVec<FieldIdx, F>, variant_fields: &IndexSlice<VariantIdx, IndexVec<FieldIdx, LocalIdx>>, storage_conflicts: &BitMatrix<LocalIdx, LocalIdx>, tag_to_layout: impl Fn(Scalar) -> F, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy, VariantIdx: Idx, FieldIdx: Idx, LocalIdx: Idx,

Compute the layout for a coroutine.

This uses dedicated code instead of Self::layout_of_struct_or_enum, as coroutine fields may be shared between multiple variants (see the coroutine module for details).

pub fn layout_of_univariant<'a, FieldIdx, VariantIdx, F>( &self, fields: &IndexSlice<FieldIdx, F>, repr: &ReprOptions, kind: StructKind, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy,

Compute the layout for a univariant (see Variants::Single).

As a consumer of rustc_abi, you should only use this method for non-ADTs. For structs and univariant enums, use Self::layout_of_struct instead (it uses this function internally).

pub fn layout_of_struct_or_enum<'a, FieldIdx, VariantIdx, F>( &self, repr: &ReprOptions, variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>, is_enum: bool, niche_optimizations: NicheOptimizations, discr_range_of_repr: impl Fn(RangeFrom<i128>, RangeToInclusive<u128>) -> (Integer, bool), discriminants: impl Iterator<Item = (VariantIdx, u128)>, always_sized: bool, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy,

pub fn layout_of_union<'a, FieldIdx, VariantIdx, F>( &self, repr: &ReprOptions, variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy,

fn layout_of_struct<'a, FieldIdx, VariantIdx, F>( &self, repr: &ReprOptions, variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>, variant_idx: VariantIdx, is_enum: bool, niche_optimizations: NicheOptimizations, always_sized: bool, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy,

Calculate the layout for a struct, or a single-variant enum.

They are the same thing, if you think about it (Typechecking will reject discriminant-sizing attrs.)

fn layout_of_enum<'a, FieldIdx, VariantIdx, F>( &self, repr: &ReprOptions, variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>, discr_range_of_repr: impl Fn(RangeFrom<i128>, RangeToInclusive<u128>) -> (Integer, bool), discriminants: impl Iterator<Item = (VariantIdx, u128)>, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy,

fn layout_of_univariant_biased<'a, FieldIdx, VariantIdx, F>( &self, fields: &IndexSlice<FieldIdx, F>, repr: &ReprOptions, kind: StructKind, niche_bias: NicheBias, ) -> Result<LayoutData<FieldIdx, VariantIdx>, LayoutCalculatorError<F>>

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug + Copy,

fn format_field_niches<'a, FieldIdx, VariantIdx, F>( &self, layout: &LayoutData<FieldIdx, VariantIdx>, fields: &IndexSlice<FieldIdx, F>, ) -> String

where FieldIdx: Idx, VariantIdx: Idx, F: Deref<Target = &'a LayoutData<FieldIdx, VariantIdx>> + Debug,

Trait Implementations

impl<Cx: Clone> Clone for LayoutCalculator<Cx>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Cx: Copy> Copy for LayoutCalculator<Cx>

impl<Cx: Debug> Debug for LayoutCalculator<Cx>

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

Formats the value using the given formatter.

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.