Skip to main content

OpSpec

Enum OpSpec 

Source
#[non_exhaustive]
pub enum OpSpec {
Show 16 variants Op(OpKind), OpWith(Op), Compound(OpKind), CompoundWith(Op), Assign, RefAssign, Identity, Borrow(BorrowKind), Deref, Await, Template(TemplateId), Extern(NameRef), Intrinsic(NameRef), CompoundExtern(NameRef), CompoundIntrinsic(NameRef), CompoundTemplate(TemplateId),
}
Expand description

What an operator token lowers to.

§Examples

use hir_lang::{Op, OpKind, Overflow};
use lower_lang::OpSpec;

let plus = OpSpec::Op(OpKind::Add);                       // language policy
let wrapping = OpSpec::OpWith(Op::new(OpKind::Add).with_overflow(Overflow::Wrap));
let plus_eq = OpSpec::Compound(OpKind::Add);              // `+=`
assert_ne!(plus, wrapping);
assert_ne!(plus, plus_eq);

Variants (Non-exhaustive)§

This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
§

Op(OpKind)

An intrinsic op with the language’s policies (LangPolicy).

§

OpWith(Op)

An intrinsic op with exactly this policy ([semantics.ops] "/" = { op = "div", zero = "trap" }).

§

Compound(OpKind)

Compound assignment (+=) with the language’s policies.

§

CompoundWith(Op)

Compound assignment with exactly this policy.

§

Assign

Plain assignment (= as an operator).

§

RefAssign

Reference assignment (=&).

§

Identity

The operand itself (unary +).

§

Borrow(BorrowKind)

&x / &mut x as a prefix operator.

§

Deref

*x as a prefix operator.

§

Await

await x (prefix) or x.await (postfix).

§

Template(TemplateId)

A template whose expression holes receive the operands, in order (&&, ||, ??, x++).

§

Extern(NameRef)

A call of a host function with the operands as arguments (Mox . string concatenation).

§

Intrinsic(NameRef)

A named backend intrinsic applied to the operands.

§

CompoundExtern(NameRef)

Compound assignment through a host function (.= as mox.concat): let_place p = target in p = f(p, value), so the place’s operands are evaluated once (HIR LetPlace).

§

CompoundIntrinsic(NameRef)

Compound assignment through a named intrinsic (**= as mox.pow), lowered like CompoundExtern.

§

CompoundTemplate(TemplateId)

Compound assignment through a template with exactly two expression holes, which receive the place alias and the value (??= through coalesce): let_place p = target in p = template(p, value).

Trait Implementations§

Source§

impl Clone for OpSpec

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Copy for OpSpec

Source§

impl Debug for OpSpec

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Eq for OpSpec

Source§

impl PartialEq for OpSpec

Source§

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

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

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

Inequality operator !=. Read more
Source§

impl StructuralPartialEq for OpSpec

Auto Trait Implementations§

Blanket Implementations§

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> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

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> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

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

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

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.