Enum ExprKind

pub enum ExprKind {
    Literal(P<LiteralNode>),
    BinOp(P<BinaryOperationNode>),
    UnaryOp(P<UnaryOperationNode>),
    FunctionCall(P<FunctionCallNode>),
    Array(ArrayKind),
    New(P<NewNode>),
    NewArray(P<NewArrayNode>),
    MemberAccess(P<MemberAccessNode>),
    Identifier(P<IdentifierNode>),
    ArrayAccess(P<ArrayAccessNode>),
    Phi(P<PhiNode>),
    Range(P<RangeNode>),
}

Represents an expression node in the AST.

Variants

Literal(P<LiteralNode>)

Represents a literal node in the AST.

BinOp(P<BinaryOperationNode>)

Represents a binary operation node in the AST.

UnaryOp(P<UnaryOperationNode>)

Represents a unary operation node in the AST.

FunctionCall(P<FunctionCallNode>)

Represents a function call node in the AST.

Array(ArrayKind)

Represents an array node in the AST.

New(P<NewNode>)

Represents a new node in the AST.

NewArray(P<NewArrayNode>)

Represents a new array node in the AST.

MemberAccess(P<MemberAccessNode>)

Represents a member access node in the AST.

Identifier(P<IdentifierNode>)

Represents an identifier node in the AST.

ArrayAccess(P<ArrayAccessNode>)

Represents an array access node in the AST.

Phi(P<PhiNode>)

Represents a phi node in the AST.

Range(P<RangeNode>)

Represents a range node in the AST.

Trait Implementations

impl AstVisitable for ExprKind

fn accept<V: AstVisitor>(&self, visitor: &mut V) -> V::Output

Accepts a visitor for the AST node.

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ArrayAccessNode> for ExprKind

fn from(id: ArrayAccessNode) -> Self

Converts to this type from the input type.

impl From<ArrayKind> for ExprKind

fn from(id: ArrayKind) -> Self

Converts to this type from the input type.

impl From<ArrayNode> for ExprKind

fn from(id: ArrayNode) -> Self

Converts to this type from the input type.

impl From<BinaryOperationNode> for ExprKind

fn from(id: BinaryOperationNode) -> Self

Converts to this type from the input type.

impl From<ExprKind> for AstKind

fn from(id: ExprKind) -> Self

Converts to this type from the input type.

impl From<FunctionCallNode> for ExprKind

fn from(id: FunctionCallNode) -> Self

Converts to this type from the input type.

impl From<IdentifierNode> for ExprKind

fn from(id: IdentifierNode) -> Self

Converts to this type from the input type.

impl From<LiteralNode> for ExprKind

fn from(id: LiteralNode) -> Self

Converts to this type from the input type.

impl From<MemberAccessNode> for ExprKind

fn from(id: MemberAccessNode) -> Self

Converts to this type from the input type.

impl From<NewArrayNode> for ExprKind

fn from(id: NewArrayNode) -> Self

Converts to this type from the input type.

impl From<NewNode> for ExprKind

fn from(id: NewNode) -> Self

Converts to this type from the input type.

impl From<P<ArrayAccessNode>> for ExprKind

fn from(id: P<ArrayAccessNode>) -> Self

Converts to this type from the input type.

impl From<P<ArrayNode>> for ExprKind

fn from(id: P<ArrayNode>) -> Self

Converts to this type from the input type.

impl From<P<BinaryOperationNode>> for ExprKind

fn from(id: P<BinaryOperationNode>) -> Self

Converts to this type from the input type.

impl From<P<FunctionCallNode>> for ExprKind

fn from(id: P<FunctionCallNode>) -> Self

Converts to this type from the input type.

impl From<P<IdentifierNode>> for ExprKind

fn from(id: P<IdentifierNode>) -> Self

Converts to this type from the input type.

impl From<P<MemberAccessNode>> for ExprKind

fn from(id: P<MemberAccessNode>) -> Self

Converts to this type from the input type.

impl From<P<NewArrayNode>> for ExprKind

fn from(id: P<NewArrayNode>) -> Self

Converts to this type from the input type.

impl From<P<NewNode>> for ExprKind

fn from(id: P<NewNode>) -> Self

Converts to this type from the input type.

impl From<P<PhiArrayNode>> for ExprKind

fn from(id: P<PhiArrayNode>) -> Self

Converts to this type from the input type.

impl From<P<PhiNode>> for ExprKind

fn from(id: P<PhiNode>) -> Self

Converts to this type from the input type.

impl From<P<RangeNode>> for ExprKind

fn from(id: P<RangeNode>) -> Self

Converts to this type from the input type.

impl From<P<UnaryOperationNode>> for ExprKind

fn from(id: P<UnaryOperationNode>) -> Self

Converts to this type from the input type.

impl From<PhiArrayNode> for ExprKind

fn from(id: PhiArrayNode) -> Self

Converts to this type from the input type.

impl From<PhiNode> for ExprKind

fn from(id: PhiNode) -> Self

Converts to this type from the input type.

impl From<RangeNode> for ExprKind

fn from(id: RangeNode) -> Self

Converts to this type from the input type.

impl From<UnaryOperationNode> for ExprKind

fn from(id: UnaryOperationNode) -> Self

Converts to this type from the input type.

impl PartialEq for ExprKind

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

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 ExprKind