## MirPatch

# Struct MirPatch

Source

    pub(crate) struct MirPatch<'tcx> {
        term_patch_map: FxHashMap<BasicBlock, TerminatorKind<'tcx>>,
        nop_statements: Vec<Location>,
        new_blocks: Vec<BasicBlockData<'tcx>>,
        new_statements: Vec<(Location, StatementKind<'tcx>)>,
        new_locals: Vec<LocalDecl<'tcx>>,
        resume_block: Option<BasicBlock>,
        unreachable_cleanup_block: Option<BasicBlock>,
        unreachable_no_cleanup_block: Option<BasicBlock>,
        terminate_block: Option<(BasicBlock, UnwindTerminateReason)>,
        body_span: Span,
        next_local: usize,
        next_block: usize,
    }

Expand description

This struct lets you “patch” a MIR body, i.e. modify it. You can queue up various changes, such as the addition of new statements and basic blocks and replacement of terminators, and then apply the queued changes all at once with `apply`. This is useful for MIR transformation passes.

## Fields§

§`term_patch_map: FxHashMap<BasicBlock, TerminatorKind<'tcx>>`§`nop_statements: Vec<Location>`

Set of statements that should be replaced by `Nop`.

§`new_blocks: Vec<BasicBlockData<'tcx>>`§`new_statements: Vec<(Location, StatementKind<'tcx>)>`§`new_locals: Vec<LocalDecl<'tcx>>`§`resume_block: Option<BasicBlock>`§`unreachable_cleanup_block: Option<BasicBlock>`§`unreachable_no_cleanup_block: Option<BasicBlock>`§`terminate_block: Option<(BasicBlock, UnwindTerminateReason)>`§`body_span: Span`§`next_local: usize`

The number of locals at the start of the transformation. New locals get appended at the end.

§`next_block: usize`

The number of blocks at the start of the transformation. New blocks get appended at the end.

## Implementations§

Source§

### impl<'tcx> MirPatch<'tcx>

Source

#### pub(crate) fn new(body: &Body<'tcx>) -> Self

Creates a new, empty patch.

Source

#### pub(crate) fn resume_block(&mut self) -> BasicBlock

Source

#### pub(crate) fn unreachable_cleanup_block(&mut self) -> BasicBlock

Source

#### pub(crate) fn unreachable_no_cleanup_block(&mut self) -> BasicBlock

Source

#### pub(crate) fn terminate_block( &mut self, reason: UnwindTerminateReason, ) -> BasicBlock

Source

#### pub(crate) fn is_term_patched(&self, bb: BasicBlock) -> bool

Has a replacement of this block’s terminator been queued in this patch?

Source

#### pub(crate) fn block<'a>( &'a self, body: &'a Body<'tcx>, bb: BasicBlock, ) -> &'a BasicBlockData<'tcx>

Universal getter for block data, either it is in ‘old’ blocks or in patched ones

Source

#### pub(crate) fn terminator_loc( &self, body: &Body<'tcx>, bb: BasicBlock, ) -> Location

Source

#### pub(crate) fn new_local_with_info( &mut self, ty: Ty<'tcx>, span: Span, local_info: LocalInfo<'tcx>, ) -> Local

Queues the addition of a new temporary with additional local info.

Source

#### pub(crate) fn new_temp(&mut self, ty: Ty<'tcx>, span: Span) -> Local

Queues the addition of a new temporary.

Source

#### pub(crate) fn local_ty(&self, local: Local) -> Ty<'tcx>

Returns the type of a local that’s newly-added in the patch.

Source

#### pub(crate) fn new_block(&mut self, data: BasicBlockData<'tcx>) -> BasicBlock

Queues the addition of a new basic block.

Source

#### pub(crate) fn patch_terminator( &mut self, block: BasicBlock, new: TerminatorKind<'tcx>, )

Queues the replacement of a block’s terminator.

Source

#### pub(crate) fn nop_statement(&mut self, loc: Location)

Mark given statement to be replaced by a `Nop`.

This method only works on statements from the initial body, and cannot be used to remove statements from `add_statement` or `add_assign`.

Source

#### pub(crate) fn add_statement(&mut self, loc: Location, stmt: StatementKind<'tcx>)

Queues the insertion of a statement at a given location. The statement currently at that location, and all statements that follow, are shifted down. If multiple statements are queued for addition at the same location, the final statement order after calling `apply` will match the queue insertion order.

E.g. if we have `s0` at location `loc` and do these calls:

p.add_statement(loc, s1); p.add_statement(loc, s2); p.apply(body);

then the final order will be `s1, s2, s0`, with `s1` at `loc`.

Source

#### pub(crate) fn add_assign( &mut self, loc: Location, place: Place<'tcx>, rv: Rvalue<'tcx>, )

Like `add_statement`, but specialized for assignments.

Source

#### pub(crate) fn apply(self, body: &mut Body<'tcx>)

Applies the queued changes.

Source

#### fn source_info_for_index(data: &BasicBlockData<'_>, loc: Location) -> SourceInfo

Source

#### pub(crate) fn source_info_for_location( &self, body: &Body<'tcx>, loc: Location, ) -> SourceInfo

## Auto Trait Implementations§

§

### impl<'tcx> DynSend for MirPatch<'tcx>

§

### impl<'tcx> DynSync for MirPatch<'tcx>

§

### impl<'tcx> Freeze for MirPatch<'tcx>

§

### impl<'tcx> !RefUnwindSafe for MirPatch<'tcx>

§

### impl<'tcx> Send for MirPatch<'tcx>

§

### impl<'tcx> Sync for MirPatch<'tcx>

§

### impl<'tcx> Unpin for MirPatch<'tcx>

§

### impl<'tcx> !UnwindSafe for MirPatch<'tcx>

## Blanket Implementations§

Source§

### impl<T> Aligned for T

Source§

#### const ALIGN: Alignment

Alignment of `Self`.
Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T, R> CollectAndApply<T, R> for T

Source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

Source§

#### type Output = R

Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T> Instrument for T

Source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
Source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> IntoEither for T

Source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

### impl<P> IntoQueryParam<P> for P

Source§

#### fn into_query_param(self) -> P

Source§

### impl<T> MaybeResult<T> for T

Source§

#### type Error = !

Source§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

Source§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

Source§

### impl<T> Pointable for T

Source§

#### const ALIGN: usize

The alignment of pointer.
Source§

#### type Init = T

The type for initializers.
Source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

### impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

Source§

#### fn upcast(self, interner: I) -> U

Source§

### impl<I, T> UpcastFrom<I, T> for T

Source§

#### fn upcast_from(from: T, _tcx: I) -> T

Source§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

#### fn vzip(self) -> V

Source§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

Source§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

Source§

### impl<T> WithSubscriber for T

Source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

Source§

### impl<T> ErasedDestructor for T
where T: 'static,

## 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: 176 bytes