Enum UnOp

pub enum UnOp {
    Not,
    Neg,
    Cast(CastKind),
    ArrayToSlice(RefKind, Ty, ConstGeneric),
}

Unary operation

Variants

Not

Neg

This can overflow. In practice, rust introduces an assert before (in debug mode) to check that it is not equal to the minimum integer value (for the proper type).

Cast(CastKind)

Casts are rvalues in MIR, but we treat them as unops.

ArrayToSlice(RefKind, Ty, ConstGeneric)

Coercion from array (i.e., [T; N]) to slice.

Remark: We introduce this unop when translating from MIR, then transform it to a function call in a micro pass. The type and the scalar value are not necessary as we can retrieve them from the context, but storing them here is very useful. The RefKind argument states whethere we operate on a mutable or a shared borrow to an array.

Implementations

impl UnOp

pub fn is_not(&self) -> bool

pub fn is_neg(&self) -> bool

pub fn is_cast(&self) -> bool

pub fn is_array_to_slice(&self) -> bool

impl UnOp

pub fn variant_name(&self) -> &'static str

Trait Implementations

impl Clone for UnOp

fn clone(&self) -> UnOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UnOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UnOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drive for UnOp

fn drive<V: Visitor>(&self, visitor: &mut V)

impl DriveMut for UnOp

fn drive_mut<V: VisitorMut>(&mut self, visitor: &mut V)

impl<C: AstFormatter> FmtWithCtx<C> for UnOp

fn fmt_with_ctx(&self, ctx: &C) -> String

fn fmt_with_ctx_and_indent(&self, _tab: &str, _ctx: &C) -> String

fn with_ctx<'a>(&'a self, ctx: &'a C) -> impl Display + 'a

Returns a struct that implements Display. This allows the following:

impl PartialEq for UnOp

fn eq(&self, other: &UnOp) -> 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 Serialize for UnOp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for UnOp

impl StructuralPartialEq for UnOp