Enum sway_core::language::parsed::ExpressionKind

pub enum ExpressionKind {
    Error(Box<[Span]>, ErrorEmitted),
    Literal(Literal),
    AmbiguousPathExpression(Box<AmbiguousPathExpression>),
    FunctionApplication(Box<FunctionApplicationExpression>),
    LazyOperator(LazyOperatorExpression),
    AmbiguousVariableExpression(Ident),
    Variable(Ident),
    Tuple(Vec<Expression>),
    TupleIndex(TupleIndexExpression),
    Array(ArrayExpression),
    Struct(Box<StructExpression>),
    CodeBlock(CodeBlock),
    If(IfExpression),
    Match(MatchExpression),
    Asm(Box<AsmExpression>),
    MethodApplication(Box<MethodApplicationExpression>),
    Subfield(SubfieldExpression),
    DelineatedPath(Box<DelineatedPathExpression>),
    AbiCast(Box<AbiCastExpression>),
    ArrayIndex(ArrayIndexExpression),
    StorageAccess(StorageAccessExpression),
    IntrinsicFunction(IntrinsicFunctionExpression),
    WhileLoop(WhileLoopExpression),
    ForLoop(ForLoopExpression),
    Break,
    Continue,
    Reassignment(ReassignmentExpression),
    ImplicitReturn(Box<Expression>),
    Return(Box<Expression>),
    Ref(Box<Expression>),
    Deref(Box<Expression>),
}

Variants

Error(Box<[Span]>, ErrorEmitted)

A malformed expression.

Used for parser recovery when we cannot form a more specific node. The list of Spans are for consumption by the LSP and are, when joined, the same as that stored in expr.span.

Literal(Literal)

AmbiguousPathExpression(Box<AmbiguousPathExpression>)

An ambiguous path where we don’t know until type checking whether this is a free function call, an enum variant or a UFCS (Rust term) style associated function call.

FunctionApplication(Box<FunctionApplicationExpression>)

LazyOperator(LazyOperatorExpression)

AmbiguousVariableExpression(Ident)

And ambiguous single ident which could either be a variable or an enum variant

Variable(Ident)

Tuple(Vec<Expression>)

TupleIndex(TupleIndexExpression)

Array(ArrayExpression)

Struct(Box<StructExpression>)

CodeBlock(CodeBlock)

If(IfExpression)

Match(MatchExpression)

Asm(Box<AsmExpression>)

MethodApplication(Box<MethodApplicationExpression>)

Subfield(SubfieldExpression)

A subfield expression is anything of the form:

<ident>.<ident>

DelineatedPath(Box<DelineatedPathExpression>)

A delineated path is anything of the form:

<ident>::<ident>

Where there are n >= 2 idents. These could be either enum variant constructions, or they could be references to some sort of module in the module tree. For example, a reference to a module:

std::ops::add

And, an enum declaration:

enum MyEnum {
  Variant1,
  Variant2
}

MyEnum::Variant1

AbiCast(Box<AbiCastExpression>)

A cast of a hash to an ABI for calling a contract.

ArrayIndex(ArrayIndexExpression)

StorageAccess(StorageAccessExpression)

IntrinsicFunction(IntrinsicFunctionExpression)

WhileLoop(WhileLoopExpression)

A control flow element which loops continually until some boolean expression evaluates as false.

ForLoop(ForLoopExpression)

A control flow element which loops between values of an iterator.

Break

Continue

Reassignment(ReassignmentExpression)

ImplicitReturn(Box<Expression>)

An implicit return expression is different from a [Expression::Return] because it is not a control flow item. Therefore it is a different variant.

An implicit return expression is an Expression at the end of a code block which has no semicolon, denoting that it is the Expression to be returned from that block.

Return(Box<Expression>)

Ref(Box<Expression>)

Deref(Box<Expression>)

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.