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>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result<Self, Err>

fn from_tuple( (ty, layout): (Ty<'tcx>, Layout<'tcx>), members: &'tcx List<Ty<'tcx>>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result<Self, Err>

Constructs a Tree from a tuple.

fn from_struct( (ty, layout): (Ty<'tcx>, Layout<'tcx>), def: AdtDef<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result<Self, Err>

Constructs a Tree from a struct.

Panics

Panics if def is not a struct definition.

fn from_enum( (ty, layout): (Ty<'tcx>, Layout<'tcx>), def: AdtDef<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result<Self, Err>

Constructs a Tree from an enum.

Panics

Panics if def is not an enum definition.

fn from_variant( def: Def<'tcx>, tag: Option<ScalarInt>, (ty, layout): (Ty<'tcx>, Layout<'tcx>), total_size: Size, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result<Self, Err>

Constructs a Tree from a ‘variant-like’ layout.

A ‘variant-like’ layout includes those of structs and, of course, enum variants. Pragmatically speaking, this method supports anything with FieldsShape::Arbitrary.

Note: This routine assumes that the optional tag is the first field, and enum callers should check that tag_field is, in fact, 0.

fn from_tag(tag: ScalarInt, tcx: TyCtxt<'tcx>) -> Self

Constructs a Tree representing the value of a enum tag.

fn from_union( (ty, layout): (Ty<'tcx>, Layout<'tcx>), def: AdtDef<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result<Self, Err>

Constructs a Tree from a union.

Panics

Panics if def is not a union definition.

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 true.

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 for Tree<D, R>

where D: Def + PartialEq, R: Ref + PartialEq,

fn eq(&self, other: &Tree<D, R>) -> 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<D, R> Eq for Tree<D, R>

where D: Def + Eq, R: Ref + Eq,

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.