Enum BinOp

pub enum BinOp {
    Add,
    AddUnchecked,
    AddWithOverflow,
    Sub,
    SubUnchecked,
    SubWithOverflow,
    Mul,
    MulUnchecked,
    MulWithOverflow,
    Div,
    Rem,
    BitXor,
    BitAnd,
    BitOr,
    Shl,
    ShlUnchecked,
    Shr,
    ShrUnchecked,
    Eq,
    Lt,
    Le,
    Ne,
    Ge,
    Gt,
    Cmp,
    Offset,
}

Variants

Add

The + operator (addition)

AddUnchecked

Like Add, but with UB on overflow. (Integers only.)

AddWithOverflow

Like Add, but returns (T, bool) of both the wrapped result and a bool indicating whether it overflowed.

Sub

The - operator (subtraction)

SubUnchecked

Like Sub, but with UB on overflow. (Integers only.)

SubWithOverflow

Like Sub, but returns (T, bool) of both the wrapped result and a bool indicating whether it overflowed.

Mul

The * operator (multiplication)

MulUnchecked

Like Mul, but with UB on overflow. (Integers only.)

MulWithOverflow

Like Mul, but returns (T, bool) of both the wrapped result and a bool indicating whether it overflowed.

Div

The / operator (division)

For integer types, division by zero is UB, as is MIN / -1 for signed. The compiler should have inserted checks prior to this.

Floating-point division by zero is safe, and does not need guards.

Rem

The % operator (modulus)

For integer types, using zero as the modulus (second operand) is UB, as is MIN % -1 for signed. The compiler should have inserted checks prior to this.

Floating-point remainder by zero is safe, and does not need guards.

BitXor

The ^ operator (bitwise xor)

BitAnd

The & operator (bitwise and)

BitOr

The | operator (bitwise or)

Shl

The << operator (shift left)

The offset is given by RHS.rem_euclid(LHS::BITS). In other words, it is (uniquely) determined as follows:

• it is “equal modulo LHS::BITS” to the RHS
• it is in the range 0..LHS::BITS

ShlUnchecked

Like Shl, but is UB if the RHS >= LHS::BITS or RHS < 0

Shr

The >> operator (shift right)

The offset is given by RHS.rem_euclid(LHS::BITS). In other words, it is (uniquely) determined as follows:

• it is “equal modulo LHS::BITS” to the RHS
• it is in the range 0..LHS::BITS

This is an arithmetic shift if the LHS is signed and a logical shift if the LHS is unsigned.

ShrUnchecked

Like Shl, but is UB if the RHS >= LHS::BITS or RHS < 0

Eq

The == operator (equality)

Lt

The < operator (less than)

Le

The <= operator (less than or equal to)

Ne

The != operator (not equal to)

Ge

The >= operator (greater than or equal to)

Gt

The > operator (greater than)

Cmp

The <=> operator (three-way comparison, like Ord::cmp)

This is supported only on the integer types and char, always returning rustc_hir::LangItem::OrderingEnum (aka std::cmp::Ordering).

Rvalue::BinaryOp(BinOp::Cmp, A, B) returns

• Ordering::Less (-1_i8, as a Scalar) if A < B
• Ordering::Equal (0_i8, as a Scalar) if A == B
• Ordering::Greater (+1_i8, as a Scalar) if A > B

Offset

The ptr.offset operator

Implementations

impl<'tcx> BinOp

pub fn ty( &self, tcx: TyCtxt<'tcx>, lhs_ty: Ty<'tcx>, rhs_ty: Ty<'tcx>, ) -> Ty<'tcx>

impl BinOp

pub(crate) fn to_hir_binop(self) -> BinOpKind

pub fn overflowing_to_wrapping(self) -> Option<BinOp>

If this is a FooWithOverflow, return Some(Foo).

pub fn is_overflowing(self) -> bool

Returns whether this is a FooWithOverflow

pub fn wrapping_to_overflowing(self) -> Option<BinOp>

If this is a Foo, return Some(FooWithOverflow).

Trait Implementations

impl Clone for BinOp

fn clone(&self) -> BinOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BinOp

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

Formats the value using the given formatter.

impl<__D: TyDecoder> Decodable<__D> for BinOp

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

impl<__E: TyEncoder> Encodable<__E> for BinOp

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

impl Hash for BinOp

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 BinOp

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

impl PartialEq for BinOp

fn eq(&self, other: &BinOp) -> 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<'tcx> TypeFoldable<TyCtxt<'tcx>> for BinOp

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &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>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

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 BinOp

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V, ) -> __V::Result

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

impl Copy for BinOp

impl Eq for BinOp

impl StructuralPartialEq for BinOp

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: 1 byte

Size for each variant:

• Add: 0 bytes
• AddUnchecked: 0 bytes
• AddWithOverflow: 0 bytes
• Sub: 0 bytes
• SubUnchecked: 0 bytes
• SubWithOverflow: 0 bytes
• Mul: 0 bytes
• MulUnchecked: 0 bytes
• MulWithOverflow: 0 bytes
• Div: 0 bytes
• Rem: 0 bytes
• BitXor: 0 bytes
• BitAnd: 0 bytes
• BitOr: 0 bytes
• Shl: 0 bytes
• ShlUnchecked: 0 bytes
• Shr: 0 bytes
• ShrUnchecked: 0 bytes
• Eq: 0 bytes
• Lt: 0 bytes
• Le: 0 bytes
• Ne: 0 bytes
• Ge: 0 bytes
• Gt: 0 bytes
• Cmp: 0 bytes
• Offset: 0 bytes