Struct rustc_mir_transform::shim::async_destructor_ctor::AsyncDestructorCtorShimBuilder

struct AsyncDestructorCtorShimBuilder<'tcx> {
    tcx: TyCtxt<'tcx>,
    def_id: DefId,
    self_ty: Option<Ty<'tcx>>,
    span: Span,
    source_info: SourceInfo,
    param_env: ParamEnv<'tcx>,
    stack: Vec<Operand<'tcx>>,
    last_bb: BasicBlock,
    top_cleanup_bb: Option<BasicBlock>,
    locals: IndexVec<Local, LocalDecl<'tcx>>,
    bbs: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
}

Builder for async_drop_in_place shim. Functions as a stack machine to build up an expression using combinators. Stack contains pairs of locals and types. Combinator is a not yet instantiated pair of a function and a type, is considered to be an operator which consumes operands from the stack by instantiating its function and its type with operand types and moving locals into the function call. Top pair is considered to be the last operand.

Fields

tcx: TyCtxt<'tcx>

def_id: DefId

self_ty: Option<Ty<'tcx>>

span: Span

source_info: SourceInfo

param_env: ParamEnv<'tcx>

stack: Vec<Operand<'tcx>>

last_bb: BasicBlock

top_cleanup_bb: Option<BasicBlock>

locals: IndexVec<Local, LocalDecl<'tcx>>

bbs: IndexVec<BasicBlock, BasicBlockData<'tcx>>

Implementations

impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx>

const SELF_PTR: Local = _

const INPUT_COUNT: usize = 1usize

const MAX_STACK_LEN: usize = 2usize

fn new(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Option<Ty<'tcx>>) -> Self

fn build(self) -> Body<'tcx>

fn build_enum( self, adt_def: AdtDef<'tcx>, args: GenericArgsRef<'tcx>, surface_drop: Option<SurfaceDropKind> ) -> Body<'tcx>

fn build_chain<I>( self, surface_drop: Option<SurfaceDropKind>, elem_tys: I ) -> Body<'tcx>

where I: Iterator<Item = Ty<'tcx>> + ExactSizeIterator,

fn build_zst_output(self) -> Body<'tcx>

fn build_fused_async_surface(self) -> Body<'tcx>

fn build_fused_sync_surface(self) -> Body<'tcx>

fn build_slice(self, is_array: bool, elem_ty: Ty<'tcx>) -> Body<'tcx>

fn put_zst_output(&mut self)

fn put_self(&mut self)

Puts to_drop: *mut Self on top of the stack.

fn put_array_as_slice(&mut self, elem_ty: Ty<'tcx>)

Given that Self is [ElemTy; N] puts to_drop: *mut [ElemTy] on top of the stack.

fn put_field(&mut self, field: FieldIdx, field_ty: Ty<'tcx>)

If given Self is a struct puts to_drop: *mut FieldTy on top of the stack.

fn put_variant_field( &mut self, variant_sym: Symbol, variant: VariantIdx, field: FieldIdx, field_ty: Ty<'tcx> )

If given Self is an enum puts to_drop: *mut FieldTy on top of the stack.

fn put_discr(&mut self, discr: Discr<'tcx>)

If given Self is an enum puts to_drop: *mut FieldTy on top of the stack.

fn put_temp_rvalue(&mut self, rvalue: Rvalue<'tcx>)

Puts x: RvalueType on top of the stack.

fn put_operand(&mut self, operand: Operand<'tcx>)

Puts operand on top of the stack.

fn put_noop(&mut self) -> Ty<'tcx>

Puts noop: async_drop::Noop on top of the stack

fn combine_async_surface(&mut self) -> Ty<'tcx>

fn combine_sync_surface(&mut self) -> Ty<'tcx>

fn combine_fuse(&mut self, inner_future_ty: Ty<'tcx>) -> Ty<'tcx>

fn combine_slice(&mut self, elem_ty: Ty<'tcx>) -> Ty<'tcx>

fn combine_defer(&mut self, to_drop_ty: Ty<'tcx>) -> Ty<'tcx>

fn combine_chain(&mut self, first: Ty<'tcx>, second: Ty<'tcx>) -> Ty<'tcx>

fn combine_either(&mut self, other: Ty<'tcx>, matched: Ty<'tcx>) -> Ty<'tcx>

fn return_(self) -> Body<'tcx>

fn apply_combinator( &mut self, arity: usize, function: LangItem, args: &[GenericArg<'tcx>] ) -> Ty<'tcx>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 136 bytes