Enum rustc_transmute::layout::tree::Tree

pub(crate) enum Tree<D, R>where
    D: Def,
    R: Ref,{
    Seq(Vec<Self>),
    Alt(Vec<Self>),
    Def(D),
    Ref(R),
    Byte(Byte),
}

A tree-based representation of a type layout.

Invariants:

1. All paths through the layout have the same length (in bytes).

Nice-to-haves:

1. An Alt is never directly nested beneath another Alt.
2. A Seq is never directly nested beneath another Seq.
3. Seqs and Alts with a single member do not exist.

Variants

Seq(Vec<Self>)

A sequence of successive layouts.

Alt(Vec<Self>)

A choice between alternative layouts.

Def(D)

A definition node.

Ref(R)

A reference node.

Byte(Byte)

A byte node.

Implementations

impl<'tcx> Tree<Def<'tcx>, Ref<'tcx>>

pub fn from_ty(ty: Ty<'tcx>, tcx: TyCtxt<'tcx>) -> Result<Self, Err>

fn from_repr_c_variant(
    ty: Ty<'tcx>,
    adt_def: AdtDef<'tcx>,
    substs_ref: SubstsRef<'tcx>,
    layout_summary: &LayoutSummary,
    discr: Option<Discr<'tcx>>,
    variant_def: &'tcx VariantDef,
    tcx: TyCtxt<'tcx>
) -> Result<Self, Err>

pub fn from_discr(discr: Discr<'tcx>, tcx: TyCtxt<'tcx>, size: usize) -> Self

impl<D, R> Tree<D, R>where
    D: Def,
    R: Ref,

pub(crate) fn def(def: D) -> Self

A Tree consisting only of a definition node.

pub(crate) fn uninhabited() -> Self

A Tree representing an uninhabited type.

pub(crate) fn unit() -> Self

A Tree representing a zero-sized type.

pub(crate) fn uninit() -> Self

A Tree containing a single, uninitialized byte.

pub(crate) fn bool() -> Self

A Tree representing the layout of bool.

pub(crate) fn u8() -> Self

A Tree whose layout matches that of a u8.

pub(crate) fn from_bits(bits: u8) -> Self

A Tree whose layout accepts exactly the given bit pattern.

pub(crate) fn number(width_in_bytes: usize) -> Self

A Tree whose layout is a number of the given width.

pub(crate) fn padding(width_in_bytes: usize) -> Self

A Tree whose layout is entirely padding of the given width.

pub(crate) fn prune<F>(self, f: &F) -> Tree<!, R>where
    F: Fn(D) -> bool,

Remove all Def nodes, and all branches of the layout for which f produces false.

pub(crate) fn is_inhabited(&self) -> bool

Produces true if Tree is an inhabited type; otherwise false.

impl<D, R> Tree<D, R>where
    D: Def,
    R: Ref,

pub(crate) fn then(self, other: Self) -> Self

Produces a new Tree where other is sequenced after self.

pub(crate) fn or(self, other: Self) -> Self

Produces a new Tree accepting either self or other as alternative layouts.

Trait Implementations

impl<D, R> Clone for Tree<D, R>where
    D: Def + Clone,
    R: Ref + Clone,

fn clone(&self) -> Tree<D, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D, R> Debug for Tree<D, R>where
    D: Def + Debug,
    R: Ref + Debug,

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

Formats the value using the given formatter.

impl<D, R> Hash for Tree<D, R>where
    D: Def + Hash,
    R: Ref + Hash,

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<D, R> PartialEq<Tree<D, R>> for Tree<D, R>where
    D: Def + PartialEq,
    R: Ref + PartialEq,

fn eq(&self, other: &Tree<D, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<D, R> Eq for Tree<D, R>where
    D: Def + Eq,
    R: Ref + Eq,

impl<D, R> StructuralEq for Tree<D, R>where
    D: Def,
    R: Ref,

impl<D, R> StructuralPartialEq for Tree<D, R>where
    D: Def,
    R: Ref,

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.