Enum BinaryOperator 

pub enum BinaryOperator<'db> {
    Dot(TerminalDot<'db>),
    Not(TerminalNot<'db>),
    Mul(TerminalMul<'db>),
    MulEq(TerminalMulEq<'db>),
    Div(TerminalDiv<'db>),
    DivEq(TerminalDivEq<'db>),
    Mod(TerminalMod<'db>),
    ModEq(TerminalModEq<'db>),
    Plus(TerminalPlus<'db>),
    PlusEq(TerminalPlusEq<'db>),
    Minus(TerminalMinus<'db>),
    MinusEq(TerminalMinusEq<'db>),
    EqEq(TerminalEqEq<'db>),
    Neq(TerminalNeq<'db>),
    Eq(TerminalEq<'db>),
    And(TerminalAnd<'db>),
    AndAnd(TerminalAndAnd<'db>),
    Or(TerminalOr<'db>),
    OrOr(TerminalOrOr<'db>),
    Xor(TerminalXor<'db>),
    LE(TerminalLE<'db>),
    GE(TerminalGE<'db>),
    LT(TerminalLT<'db>),
    GT(TerminalGT<'db>),
    DotDot(TerminalDotDot<'db>),
    DotDotEq(TerminalDotDotEq<'db>),
}

Variants

Dot(TerminalDot<'db>)

Not(TerminalNot<'db>)

Mul(TerminalMul<'db>)

MulEq(TerminalMulEq<'db>)

Div(TerminalDiv<'db>)

DivEq(TerminalDivEq<'db>)

Mod(TerminalMod<'db>)

ModEq(TerminalModEq<'db>)

Plus(TerminalPlus<'db>)

PlusEq(TerminalPlusEq<'db>)

Minus(TerminalMinus<'db>)

MinusEq(TerminalMinusEq<'db>)

EqEq(TerminalEqEq<'db>)

Neq(TerminalNeq<'db>)

Eq(TerminalEq<'db>)

And(TerminalAnd<'db>)

AndAnd(TerminalAndAnd<'db>)

Or(TerminalOr<'db>)

OrOr(TerminalOrOr<'db>)

Xor(TerminalXor<'db>)

LE(TerminalLE<'db>)

GE(TerminalGE<'db>)

LT(TerminalLT<'db>)

GT(TerminalGT<'db>)

DotDot(TerminalDotDot<'db>)

DotDotEq(TerminalDotDotEq<'db>)

Implementations

impl<'db> BinaryOperator<'db>

pub fn is_variant(kind: SyntaxKind) -> bool

Checks if a kind of a variant of BinaryOperator.

Trait Implementations

impl<'db> Clone for BinaryOperator<'db>

fn clone(&self) -> BinaryOperator<'db>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db> Debug for BinaryOperator<'db>

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

Formats the value using the given formatter.

impl<'db> Hash for BinaryOperator<'db>

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<'db> PartialEq for BinaryOperator<'db>

fn eq(&self, other: &BinaryOperator<'db>) -> 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<'db> TypedSyntaxNode<'db> for BinaryOperator<'db>

const OPTIONAL_KIND: Option<SyntaxKind> = None

The relevant SyntaxKind. None for enums.

type StablePtr = BinaryOperatorPtr<'db>

type Green = BinaryOperatorGreen<'db>

fn missing(db: &'db dyn Database) -> Self::Green

fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self

fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self>

fn as_syntax_node(&self) -> SyntaxNode<'db>

fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr

impl<'db> Update for BinaryOperator<'db>

unsafe fn maybe_update(old_pointer_: *mut Self, new_value_: Self) -> bool

Returns

impl<'db> Eq for BinaryOperator<'db>

impl<'db> StructuralPartialEq for BinaryOperator<'db>