Enum ExpressionNode 

pub enum ExpressionNode {
    Identifier {
        name: String,
        span: Range<usize>,
    },
    Literal(LiteralNode),
    MethodCall {
        receiver: Option<Box<ExpressionNode>>,
        method: String,
        args: Vec<ExpressionNode>,
        span: Range<usize>,
    },
    BinaryOp {
        left: Box<ExpressionNode>,
        operator: String,
        right: Box<ExpressionNode>,
        span: Range<usize>,
    },
    UnaryOp {
        operator: String,
        operand: Box<ExpressionNode>,
        span: Range<usize>,
    },
    Array {
        elements: Vec<ExpressionNode>,
        span: Range<usize>,
    },
    Hash {
        pairs: Vec<(ExpressionNode, ExpressionNode)>,
        span: Range<usize>,
    },
}

Ruby expression node

Variants

Identifier

Identifier

Fields

name: String

Identifier name

span: Range<usize>

Source code span

Literal(LiteralNode)

Literal

MethodCall

Method call

Fields

receiver: Option<Box<ExpressionNode>>

Receiver

method: String

Method name

args: Vec<ExpressionNode>

Argument list

span: Range<usize>

Source code span

BinaryOp

Binary operation

Fields

left: Box<ExpressionNode>

Left operand

operator: String

Operator

right: Box<ExpressionNode>

Right operand

span: Range<usize>

Source code span

UnaryOp

Unary operation

Fields

operator: String

Operator

operand: Box<ExpressionNode>

Operand

span: Range<usize>

Source code span

Array

Array

Fields

elements: Vec<ExpressionNode>

Array element list

span: Range<usize>

Source code span

Hash

Hash

Fields

pairs: Vec<(ExpressionNode, ExpressionNode)>

The key-value pairs in the hash.

span: Range<usize>

The source span of the hash.

Trait Implementations

impl Clone for ExpressionNode

fn clone(&self) -> ExpressionNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExpressionNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExpressionNode

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExpressionNode