Enum Expression 

pub enum Expression {
    Identifier(Loc<Path>),
    IntLiteral(Loc<IntLiteral>),
    BoolLiteral(Loc<bool>),
    StrLiteral(Loc<String>),
    TriLiteral(Loc<BitLiteral>),
    ArrayLiteral(Vec<Loc<Expression>>),
    ArrayShorthandLiteral(Box<Loc<Expression>>, Box<Loc<Expression>>),
    Index(Box<Loc<Expression>>, Box<Loc<Expression>>),
    RangeIndex {
        target: Box<Loc<Expression>>,
        start: Box<Loc<Expression>>,
        end: Box<Loc<Expression>>,
    },
    Parenthesized(Box<Loc<Expression>>),
    TupleLiteral(Vec<Loc<Expression>>),
    TupleIndex(Box<Loc<Expression>>, Loc<u128>),
    FieldAccess(Box<Loc<Expression>>, Loc<Identifier>),
    CreatePorts,
    Lambda {
        unit_kind: Loc<UnitKind>,
        args: Loc<Vec<Loc<Pattern>>>,
        body: Box<Loc<Block>>,
    },
    Call {
        kind: CallKind,
        callee: Loc<Path>,
        args: Loc<ArgumentList>,
        turbofish: Option<Loc<TurbofishInner>>,
    },
    MethodCall {
        target: Box<Loc<Expression>>,
        name: Loc<Identifier>,
        args: Loc<ArgumentList>,
        kind: CallKind,
        turbofish: Option<Loc<TurbofishInner>>,
    },
    If(Box<Loc<Expression>>, Box<Loc<Expression>>, Box<Loc<Expression>>),
    TypeLevelIf(Box<Loc<Expression>>, Box<Loc<Expression>>, Box<Loc<Expression>>),
    Match(Box<Loc<Expression>>, Loc<Vec<(Loc<Pattern>, Loc<Expression>)>>),
    UnaryOperator(Loc<UnaryOperator>, Box<Loc<Expression>>),
    BinaryOperator(Box<Loc<Expression>>, Loc<BinaryOperator>, Box<Loc<Expression>>),
    Block(Box<Block>),
    Unsafe(Box<Loc<Block>>),
    PipelineReference {
        stage_kw_and_reference_loc: Loc<()>,
        stage: PipelineStageReference,
        name: Loc<Identifier>,
    },
    StageValid,
    StageReady,
    StaticUnreachable(Loc<String>),
}

Variants

Identifier(Loc<Path>)

IntLiteral(Loc<IntLiteral>)

BoolLiteral(Loc<bool>)

StrLiteral(Loc<String>)

TriLiteral(Loc<BitLiteral>)

ArrayLiteral(Vec<Loc<Expression>>)

[1, 2, 3]

ArrayShorthandLiteral(Box<Loc<Expression>>, Box<Loc<Expression>>)

[<expr>; <amount>] amount is a const generic

Index(Box<Loc<Expression>>, Box<Loc<Expression>>)

RangeIndex

Fields

target: Box<Loc<Expression>>

start: Box<Loc<Expression>>

end: Box<Loc<Expression>>

Parenthesized(Box<Loc<Expression>>)

TupleLiteral(Vec<Loc<Expression>>)

TupleIndex(Box<Loc<Expression>>, Loc<u128>)

FieldAccess(Box<Loc<Expression>>, Loc<Identifier>)

CreatePorts

Lambda

Fields

unit_kind: Loc<UnitKind>

args: Loc<Vec<Loc<Pattern>>>

body: Box<Loc<Block>>

Call

Fields

kind: CallKind

callee: Loc<Path>

args: Loc<ArgumentList>

turbofish: Option<Loc<TurbofishInner>>

MethodCall

Fields

target: Box<Loc<Expression>>

name: Loc<Identifier>

args: Loc<ArgumentList>

kind: CallKind

turbofish: Option<Loc<TurbofishInner>>

If(Box<Loc<Expression>>, Box<Loc<Expression>>, Box<Loc<Expression>>)

TypeLevelIf(Box<Loc<Expression>>, Box<Loc<Expression>>, Box<Loc<Expression>>)

Match(Box<Loc<Expression>>, Loc<Vec<(Loc<Pattern>, Loc<Expression>)>>)

UnaryOperator(Loc<UnaryOperator>, Box<Loc<Expression>>)

BinaryOperator(Box<Loc<Expression>>, Loc<BinaryOperator>, Box<Loc<Expression>>)

Block(Box<Block>)

Unsafe(Box<Loc<Block>>)

PipelineReference

E.g. stage(-5).x, stage('b).y

Fields

stage_kw_and_reference_loc: Loc<()>

stage(-5).xyz
^^^^^^^^^

stage: PipelineStageReference

stage(-5).xyz
      ^^

name: Loc<Identifier>

stage(-5).xyz
          ^^^

StageValid

StageReady

StaticUnreachable(Loc<String>)

Implementations

impl Expression

pub fn int_literal_signed(val: i32) -> Self

pub fn bool_literal(val: bool) -> Self

pub fn as_int_literal(self) -> Option<IntLiteral>

pub fn assume_block(&self) -> &Block

pub fn variant_str(&self) -> &'static str

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl PartialEq for Expression

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