Struct rustc_middle::mir::SwitchTargets

pub struct SwitchTargets {
    pub(super) values: SmallVec<[u128; 1]>,
    pub(super) targets: SmallVec<[BasicBlock; 2]>,
}

Fields

values: SmallVec<[u128; 1]>

Possible values. The locations to branch to in each case are found in the corresponding indices from the targets vector.

targets: SmallVec<[BasicBlock; 2]>

Possible branch sites. The last element of this vector is used for the otherwise branch, so targets.len() == values.len() + 1 should hold.

Implementations

impl SwitchTargets

pub fn new( targets: impl Iterator<Item = (u128, BasicBlock)>, otherwise: BasicBlock ) -> Self

Creates switch targets from an iterator of values and target blocks.

The iterator may be empty, in which case the SwitchInt instruction is equivalent to goto otherwise;.

pub fn static_if(value: u128, then: BasicBlock, else_: BasicBlock) -> Self

Builds a switch targets definition that jumps to then if the tested value equals value, and to else_ if not.

pub fn otherwise(&self) -> BasicBlock

Returns the fallback target that is jumped to when none of the values match the operand.

pub fn iter(&self) -> SwitchTargetsIter<'_>

Returns an iterator over the switch targets.

The iterator will yield tuples containing the value and corresponding target to jump to, not including the otherwise fallback target.

Note that this may yield 0 elements. Only the otherwise branch is mandatory.

pub fn all_targets(&self) -> &[BasicBlock]

Returns a slice with all possible jump targets (including the fallback target).

pub fn all_targets_mut(&mut self) -> &mut [BasicBlock]

pub fn target_for_value(&self, value: u128) -> BasicBlock

Finds the BasicBlock to which this SwitchInt will branch given the specific value. This cannot fail, as it’ll return the otherwise branch if there’s not a specific match for the value.

Trait Implementations

impl Clone for SwitchTargets

fn clone(&self) -> SwitchTargets

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SwitchTargets

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for SwitchTargets

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for SwitchTargets

fn encode(&self, __encoder: &mut __E)

impl Hash for SwitchTargets

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<'__ctx> HashStable<StableHashingContext<'__ctx>> for SwitchTargets

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )

impl PartialEq<SwitchTargets> for SwitchTargets

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for SwitchTargets

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, _: &mut F ) -> Result<Self, F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, _: &mut F) -> Self

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for SwitchTargets

fn visit_with<F: TypeVisitor<TyCtxt<'tcx>>>( &self, _: &mut F ) -> ControlFlow<F::BreakTy>

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl StructuralPartialEq for SwitchTargets

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: 64 bytes