Enum TerminatorKind 

pub enum TerminatorKind {
    Goto {
        target: BlockId,
    },
    Switch {
        data: SwitchData,
        branches: IndexVec<BranchId, BlockId>,
    },
    Call {
        call: Call,
        target: BlockId,
        on_unwind: BlockId,
    },
    Drop {
        kind: DropKind,
        place: Place,
        fn_ptr: FnPtr,
        target: BlockId,
        on_unwind: BlockId,
    },
    InlineAsm {
        asm: InlineAsm,
        fallthrough: Option<BlockId>,
        labels: IndexVec<BranchId, BlockId>,
        on_unwind: BlockId,
    },
    Assert {
        assert: Assert,
        target: BlockId,
        on_unwind: BlockId,
    },
    Panic {
        name: Name,
        on_unwind: BlockId,
    },
    UnwindTerminate,
    UnwindResume,
    Return,
    UndefinedBehavior,
}

Variants

Goto

Fields

target: BlockId

Switch

Fields

data: SwitchData

branches: IndexVec<BranchId, BlockId>

Call

Fields

call: Call

target: BlockId

on_unwind: BlockId

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

kind: DropKind

place: Place

fn_ptr: FnPtr

Reference to the drop_glue code to call on drop.

target: BlockId

on_unwind: BlockId

InlineAsm

An inline assembly block.

Fields

asm: InlineAsm

fallthrough: Option<BlockId>

Next block if the control-flow continues without jumping. Absent for naked_asm! and noreturn.

labels: IndexVec<BranchId, BlockId>

Targets of AsmOperand::Label operands.

on_unwind: BlockId

Action to be taken if the inline assembly unwinds.

Assert

Assert that the given condition holds, and if not, unwind to the given block. This is used for bounds checks, overflow checks, etc.

Fields

assert: Assert

target: BlockId

on_unwind: BlockId

Panic

Call to a built-in panicking function.

Fields

name: Name

The name of the function that was called.

on_unwind: BlockId

UnwindTerminate

Unwinding must stop for ABI reasons or because cleanup code panicked again.

UnwindResume

Unwind out of the current function into its caller.

Return

UndefinedBehavior

Reaching this point is undefined behavior in the Rust abstract machine.

Implementations

impl TerminatorKind

pub fn is_goto(&self) -> bool

pub fn is_switch(&self) -> bool

pub fn is_call(&self) -> bool

pub fn is_drop(&self) -> bool

pub fn is_inline_asm(&self) -> bool

pub fn is_assert(&self) -> bool

pub fn is_panic(&self) -> bool

pub fn is_unwind_terminate(&self) -> bool

pub fn is_unwind_resume(&self) -> bool

pub fn is_return(&self) -> bool

pub fn is_undefined_behavior(&self) -> bool

impl TerminatorKind

pub fn as_goto(&self) -> Option<&BlockId>

pub fn as_switch(&self) -> Option<(&SwitchData, &IndexVec<BranchId, BlockId>)>

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

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

pub fn as_inline_asm( &self, ) -> Option<(&InlineAsm, &Option<BlockId>, &IndexVec<BranchId, BlockId>, &BlockId)>

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

pub fn as_panic(&self) -> Option<(&Name, &BlockId)>

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

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

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

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

impl TerminatorKind

pub fn as_goto_mut(&mut self) -> Option<&mut BlockId>

pub fn as_switch_mut( &mut self, ) -> Option<(&mut SwitchData, &mut IndexVec<BranchId, BlockId>)>

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

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

pub fn as_inline_asm_mut( &mut self, ) -> Option<(&mut InlineAsm, &mut Option<BlockId>, &mut IndexVec<BranchId, BlockId>, &mut BlockId)>

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

pub fn as_panic_mut(&mut self) -> Option<(&mut Name, &mut BlockId)>

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

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

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

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

impl TerminatorKind

pub fn take(&mut self) -> Self

Replace this terminator with a dummy.

Trait Implementations

impl AstVisitable for TerminatorKind

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 TerminatorKind

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 TerminatorKind

fn clone(&self) -> TerminatorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TerminatorKind

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

Formats the value using the given formatter.

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

where BlockId: DeserializeState<'de, __State>, SwitchData: DeserializeState<'de, __State>, IndexVec<BranchId, BlockId>: DeserializeState<'de, __State>, Call: DeserializeState<'de, __State>, DropKind: DeserializeState<'de, __State>, Place: DeserializeState<'de, __State>, FnPtr: DeserializeState<'de, __State>, InlineAsm: DeserializeState<'de, __State>, Option<BlockId>: DeserializeState<'de, __State>, Assert: DeserializeState<'de, __State>, Name: 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 TerminatorKind

where V: Visitor + Visit<'s, BlockId> + Visit<'s, SwitchData> + Visit<'s, IndexVec<BranchId, BlockId>> + Visit<'s, Call> + Visit<'s, DropKind> + Visit<'s, Place> + Visit<'s, FnPtr> + Visit<'s, InlineAsm> + Visit<'s, Option<BlockId>> + Visit<'s, Assert> + Visit<'s, Name>,

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 TerminatorKind

where V: Visitor + VisitMut<'s, BlockId> + VisitMut<'s, SwitchData> + VisitMut<'s, IndexVec<BranchId, BlockId>> + VisitMut<'s, Call> + VisitMut<'s, DropKind> + VisitMut<'s, Place> + VisitMut<'s, FnPtr> + VisitMut<'s, InlineAsm> + VisitMut<'s, Option<BlockId>> + VisitMut<'s, Assert> + VisitMut<'s, Name>,

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 TerminatorKind

where V: Visitor<Break: Default> + VisitTwo<'s, BlockId> + VisitTwo<'s, SwitchData> + VisitTwo<'s, IndexVec<BranchId, BlockId>> + VisitTwo<'s, Call> + VisitTwo<'s, DropKind> + VisitTwo<'s, Place> + VisitTwo<'s, FnPtr> + VisitTwo<'s, InlineAsm> + VisitTwo<'s, Option<BlockId>> + VisitTwo<'s, Assert> + VisitTwo<'s, Name>,

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 Eq for TerminatorKind

impl PartialEq for TerminatorKind

fn eq(&self, other: &TerminatorKind) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<__State: ?Sized> SerializeState<__State> for TerminatorKind

where BlockId: SerializeState<__State>, SwitchData: SerializeState<__State>, IndexVec<BranchId, BlockId>: SerializeState<__State>, Call: SerializeState<__State>, DropKind: SerializeState<__State>, Place: SerializeState<__State>, FnPtr: SerializeState<__State>, InlineAsm: SerializeState<__State>, Option<BlockId>: SerializeState<__State>, Assert: SerializeState<__State>, Name: SerializeState<__State>,

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

where __S: Serializer,

impl StructuralPartialEq for TerminatorKind