Enum StatementKind 

pub enum StatementKind {
    Assign(Place, Rvalue),
    SetDiscriminant(Place, VariantId),
    StorageLive(LocalId),
    StorageDead(LocalId),
    PlaceMention(Place),
    Borrowck(BorrowckStatement),
    Drop {
        place: Place,
        fn_ptr: FnPtr,
        kind: DropKind,
        on_unwind: Block,
    },
    Assert {
        assert: Assert,
        on_failure: AbortKind,
        on_unwind: Block,
    },
    InlineAsm {
        asm: String,
        targets: Vec<Block>,
        on_unwind: Block,
    },
    Call {
        call: Call,
        on_unwind: Block,
    },
    Abort(AbortKind),
    Return,
    UnwindResume,
    Break(usize),
    Continue(usize),
    Nop,
    Switch(Switch),
    Loop(Block),
    Error(String),
}

A raw statement: a statement without meta data.

Variants

Assign(Place, Rvalue)

Assigns an Rvalue to a Place. e.g. let y = x; could become y := move x which is represented as Assign(y, Rvalue::Use(Operand::Move(x))).

SetDiscriminant(Place, VariantId)

Not used today because we take MIR built.

StorageLive(LocalId)

Indicates that this local should be allocated; if it is already allocated, this frees the local and re-allocates it. The arguments do not receive a StorageLive. We ensure in the micro-pass insert_storage_statements that all other locals have a StorageLive associated with them.

StorageDead(LocalId)

Indicates that this local should be deallocated; if it is already deallocated, this is a no-op. A local may not have a StorageDead in the function’s body, in which case it is implicitly deallocated at the end of the function. The return local does not receive a StorageDead. We ensure in the micro-pass insert_storage_statements that all other locals have a StorageDead before function exits.

PlaceMention(Place)

A place is mentioned, but not accessed. The place itself must still be valid though, so this statement is not a no-op: it can trigger UB if the place’s projections are not valid (e.g. because they go out of bounds).

Borrowck(BorrowckStatement)

Statements that only affect borrow-checking.

Drop

Drop the value at the given place.

Depending on DropKind, this may be a real call to drop_glue, or a conditional call that should only happen if the place has not been moved out of. See the docs of DropKind for more details; to get precise drops use --precise-drops.

Fields

place: Place

fn_ptr: FnPtr

Reference to the drop_glue code to call on drop.

kind: DropKind

on_unwind: Block

Assert

Fields

assert: Assert

on_failure: AbortKind

on_unwind: Block

InlineAsm

An inline assembly block. For now we only preserve the template string.

Fields

asm: String

targets: Vec<Block>

on_unwind: Block

Call

Fields

call: Call

on_unwind: Block

Abort(AbortKind)

Panic also handles “unreachable”. We keep the name of the panicking function that was called.

Return

UnwindResume

Unwind out of the current function into its caller.

Break(usize)

Break to outer loops. The usize gives the index of the outer loop to break to:

• 0: break to first outer loop (the current loop)
• 1: break to second outer loop
• …

Continue(usize)

Continue to outer loops. The usize gives the index of the outer loop to continue to:

• 0: continue to first outer loop (the current loop)
• 1: continue to second outer loop
• …

Nop

No-op.

Switch(Switch)

Loop(Block)

Error(String)

Implementations

impl StatementKind

pub fn is_assign(&self) -> bool

pub fn is_set_discriminant(&self) -> bool

pub fn is_storage_live(&self) -> bool

pub fn is_storage_dead(&self) -> bool

pub fn is_place_mention(&self) -> bool

pub fn is_borrowck(&self) -> bool

pub fn is_drop(&self) -> bool

pub fn is_assert(&self) -> bool

pub fn is_inline_asm(&self) -> bool

pub fn is_call(&self) -> bool

pub fn is_abort(&self) -> bool

pub fn is_return(&self) -> bool

pub fn is_unwind_resume(&self) -> bool

pub fn is_break(&self) -> bool

pub fn is_continue(&self) -> bool

pub fn is_nop(&self) -> bool

pub fn is_switch(&self) -> bool

pub fn is_loop(&self) -> bool

pub fn is_error(&self) -> bool

impl StatementKind

pub fn to_assign(self) -> Option<(Place, Rvalue)>

pub fn to_set_discriminant(self) -> Option<(Place, VariantId)>

pub fn to_storage_live(self) -> Option<LocalId>

pub fn to_storage_dead(self) -> Option<LocalId>

pub fn to_place_mention(self) -> Option<Place>

pub fn to_borrowck(self) -> Option<BorrowckStatement>

pub fn to_drop(self) -> Option<(Place, FnPtr, DropKind, Block)>

pub fn to_assert(self) -> Option<(Assert, AbortKind, Block)>

pub fn to_inline_asm(self) -> Option<(String, Vec<Block>, Block)>

pub fn to_call(self) -> Option<(Call, Block)>

pub fn to_abort(self) -> Option<AbortKind>

pub fn to_return(self) -> Option<()>

pub fn to_unwind_resume(self) -> Option<()>

pub fn to_break(self) -> Option<usize>

pub fn to_continue(self) -> Option<usize>

pub fn to_nop(self) -> Option<()>

pub fn to_switch(self) -> Option<Switch>

pub fn to_loop(self) -> Option<Block>

pub fn to_error(self) -> Option<String>

impl StatementKind

pub fn as_assign(&self) -> Option<(&Place, &Rvalue)>

pub fn as_set_discriminant(&self) -> Option<(&Place, &VariantId)>

pub fn as_storage_live(&self) -> Option<&LocalId>

pub fn as_storage_dead(&self) -> Option<&LocalId>

pub fn as_place_mention(&self) -> Option<&Place>

pub fn as_borrowck(&self) -> Option<&BorrowckStatement>

pub fn as_drop(&self) -> Option<(&Place, &FnPtr, &DropKind, &Block)>

pub fn as_assert(&self) -> Option<(&Assert, &AbortKind, &Block)>

pub fn as_inline_asm(&self) -> Option<(&String, &Vec<Block>, &Block)>

pub fn as_call(&self) -> Option<(&Call, &Block)>

pub fn as_abort(&self) -> Option<&AbortKind>

pub fn as_return(&self) -> Option<()>

pub fn as_unwind_resume(&self) -> Option<()>

pub fn as_break(&self) -> Option<&usize>

pub fn as_continue(&self) -> Option<&usize>

pub fn as_nop(&self) -> Option<()>

pub fn as_switch(&self) -> Option<&Switch>

pub fn as_loop(&self) -> Option<&Block>

pub fn as_error(&self) -> Option<&String>

impl StatementKind

pub fn as_assign_mut(&mut self) -> Option<(&mut Place, &mut Rvalue)>

pub fn as_set_discriminant_mut( &mut self, ) -> Option<(&mut Place, &mut VariantId)>

pub fn as_storage_live_mut(&mut self) -> Option<&mut LocalId>

pub fn as_storage_dead_mut(&mut self) -> Option<&mut LocalId>

pub fn as_place_mention_mut(&mut self) -> Option<&mut Place>

pub fn as_borrowck_mut(&mut self) -> Option<&mut BorrowckStatement>

pub fn as_drop_mut( &mut self, ) -> Option<(&mut Place, &mut FnPtr, &mut DropKind, &mut Block)>

pub fn as_assert_mut( &mut self, ) -> Option<(&mut Assert, &mut AbortKind, &mut Block)>

pub fn as_inline_asm_mut( &mut self, ) -> Option<(&mut String, &mut Vec<Block>, &mut Block)>

pub fn as_call_mut(&mut self) -> Option<(&mut Call, &mut Block)>

pub fn as_abort_mut(&mut self) -> Option<&mut AbortKind>

pub fn as_return_mut(&mut self) -> Option<()>

pub fn as_unwind_resume_mut(&mut self) -> Option<()>

pub fn as_break_mut(&mut self) -> Option<&mut usize>

pub fn as_continue_mut(&mut self) -> Option<&mut usize>

pub fn as_nop_mut(&mut self) -> Option<()>

pub fn as_switch_mut(&mut self) -> Option<&mut Switch>

pub fn as_loop_mut(&mut self) -> Option<&mut Block>

pub fn as_error_mut(&mut self) -> Option<&mut String>

Trait Implementations

impl AstVisitable for StatementKind

fn drive<V: VisitAst>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_mut<V: VisitAstMut>(&mut self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_two<V: ZipAst>(&self, other: &Self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn name(&self) -> &'static str

The name of the type, used for debug logging.

fn dyn_visit<T: AstVisitable>(&self, f: impl FnMut(&T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_mut<T: AstVisitable>(&mut self, f: impl FnMut(&mut T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

impl BodyVisitable for StatementKind

fn drive_body<V: VisitBody>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_body_mut<V: VisitBodyMut>( &mut self, v: &mut V, ) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn dyn_visit_in_body<T: BodyVisitable>(&self, f: impl FnMut(&T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_in_body_mut<T: BodyVisitable>(&mut self, f: impl FnMut(&mut T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

impl Clone for StatementKind

fn clone(&self) -> StatementKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StatementKind

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

Formats the value using the given formatter.

impl<'de, __State: ?Sized> DeserializeState<'de, __State> for StatementKind

where Place: DeserializeState<'de, __State>, Rvalue: DeserializeState<'de, __State>, VariantId: DeserializeState<'de, __State>, LocalId: DeserializeState<'de, __State>, BorrowckStatement: DeserializeState<'de, __State>, FnPtr: DeserializeState<'de, __State>, DropKind: DeserializeState<'de, __State>, Block: DeserializeState<'de, __State>, Assert: DeserializeState<'de, __State>, AbortKind: DeserializeState<'de, __State>, String: DeserializeState<'de, __State>, Vec<Block>: DeserializeState<'de, __State>, Call: DeserializeState<'de, __State>, usize: DeserializeState<'de, __State>, Switch: DeserializeState<'de, __State>,

fn deserialize_state<__D>( __state: &__State, __deserializer: __D, ) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

impl<'s, V> Drive<'s, V> for StatementKind

where V: Visitor + Visit<'s, Place> + Visit<'s, Rvalue> + Visit<'s, VariantId> + Visit<'s, LocalId> + Visit<'s, BorrowckStatement> + Visit<'s, FnPtr> + Visit<'s, Block> + Visit<'s, Assert> + Visit<'s, AbortKind> + Visit<'s, String> + Visit<'s, Vec<Block>> + Visit<'s, Call> + Visit<'s, Switch>,

fn drive_inner(&'s self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveMut<'s, V> for StatementKind

where V: Visitor + VisitMut<'s, Place> + VisitMut<'s, Rvalue> + VisitMut<'s, VariantId> + VisitMut<'s, LocalId> + VisitMut<'s, BorrowckStatement> + VisitMut<'s, FnPtr> + VisitMut<'s, Block> + VisitMut<'s, Assert> + VisitMut<'s, AbortKind> + VisitMut<'s, String> + VisitMut<'s, Vec<Block>> + VisitMut<'s, Call> + VisitMut<'s, Switch>,

fn drive_inner_mut(&'s mut self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveTwo<'s, V> for StatementKind

where V: Visitor<Break: Default> + VisitTwo<'s, Place> + VisitTwo<'s, Rvalue> + VisitTwo<'s, VariantId> + VisitTwo<'s, LocalId> + VisitTwo<'s, BorrowckStatement> + VisitTwo<'s, FnPtr> + VisitTwo<'s, Block> + VisitTwo<'s, Assert> + VisitTwo<'s, AbortKind> + VisitTwo<'s, String> + VisitTwo<'s, Vec<Block>> + VisitTwo<'s, Call> + VisitTwo<'s, Switch>,

fn drive_two_inner( &'s self, other: &'s Self, visitor: &mut V, ) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self and other, if they correspond. If the values don’t match up, this returns Break(Default::default()).

impl PartialEq for StatementKind

fn eq(&self, other: &StatementKind) -> 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<__State: ?Sized> SerializeState<__State> for StatementKind

where Place: SerializeState<__State>, Rvalue: SerializeState<__State>, VariantId: SerializeState<__State>, LocalId: SerializeState<__State>, BorrowckStatement: SerializeState<__State>, FnPtr: SerializeState<__State>, DropKind: SerializeState<__State>, Block: SerializeState<__State>, Assert: SerializeState<__State>, AbortKind: SerializeState<__State>, String: SerializeState<__State>, Vec<Block>: SerializeState<__State>, Call: SerializeState<__State>, usize: SerializeState<__State>, Switch: SerializeState<__State>,

fn serialize_state<__S>( &self, __state: &__State, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl Eq for StatementKind

impl StructuralPartialEq for StatementKind