Enum sway_ast::expr::Expr

source · [−]

pub enum Expr {
Show 42 variants
    Path(PathExpr),
    Literal(Literal),
    AbiCast {
        abi_token: AbiToken,
        args: Parens<AbiCastArgs>,
    },
    Struct {
        path: PathExpr,
        fields: Braces<Punctuated<ExprStructField, CommaToken>>,
    },
    Tuple(Parens<ExprTupleDescriptor>),
    Parens(Parens<Box<Expr>>),
    Block(Braces<CodeBlockContents>),
    Array(SquareBrackets<ExprArrayDescriptor>),
    Asm(AsmBlock),
    Return {
        return_token: ReturnToken,
        expr_opt: Option<Box<Expr>>,
    },
    If(IfExpr),
    Match {
        match_token: MatchToken,
        value: Box<Expr>,
        branches: Braces<Vec<MatchBranch>>,
    },
    While {
        while_token: WhileToken,
        condition: Box<Expr>,
        block: Braces<CodeBlockContents>,
    },
    FuncApp {
        func: Box<Expr>,
        args: Parens<Punctuated<Expr, CommaToken>>,
    },
    Index {
        target: Box<Expr>,
        arg: SquareBrackets<Box<Expr>>,
    },
    MethodCall {
        target: Box<Expr>,
        dot_token: DotToken,
        name: Ident,
        contract_args_opt: Option<Braces<Punctuated<ExprStructField, CommaToken>>>,
        args: Parens<Punctuated<Expr, CommaToken>>,
    },
    FieldProjection {
        target: Box<Expr>,
        dot_token: DotToken,
        name: Ident,
    },
    TupleFieldProjection {
        target: Box<Expr>,
        dot_token: DotToken,
        field: BigUint,
        field_span: Span,
    },
    Ref {
        ref_token: RefToken,
        expr: Box<Expr>,
    },
    Deref {
        deref_token: DerefToken,
        expr: Box<Expr>,
    },
    Not {
        bang_token: BangToken,
        expr: Box<Expr>,
    },
    Mul {
        lhs: Box<Expr>,
        star_token: StarToken,
        rhs: Box<Expr>,
    },
    Div {
        lhs: Box<Expr>,
        forward_slash_token: ForwardSlashToken,
        rhs: Box<Expr>,
    },
    Modulo {
        lhs: Box<Expr>,
        percent_token: PercentToken,
        rhs: Box<Expr>,
    },
    Add {
        lhs: Box<Expr>,
        add_token: AddToken,
        rhs: Box<Expr>,
    },
    Sub {
        lhs: Box<Expr>,
        sub_token: SubToken,
        rhs: Box<Expr>,
    },
    Shl {
        lhs: Box<Expr>,
        shl_token: ShlToken,
        rhs: Box<Expr>,
    },
    Shr {
        lhs: Box<Expr>,
        shr_token: ShrToken,
        rhs: Box<Expr>,
    },
    BitAnd {
        lhs: Box<Expr>,
        ampersand_token: AmpersandToken,
        rhs: Box<Expr>,
    },
    BitXor {
        lhs: Box<Expr>,
        caret_token: CaretToken,
        rhs: Box<Expr>,
    },
    BitOr {
        lhs: Box<Expr>,
        pipe_token: PipeToken,
        rhs: Box<Expr>,
    },
    Equal {
        lhs: Box<Expr>,
        double_eq_token: DoubleEqToken,
        rhs: Box<Expr>,
    },
    NotEqual {
        lhs: Box<Expr>,
        bang_eq_token: BangEqToken,
        rhs: Box<Expr>,
    },
    LessThan {
        lhs: Box<Expr>,
        less_than_token: LessThanToken,
        rhs: Box<Expr>,
    },
    GreaterThan {
        lhs: Box<Expr>,
        greater_than_token: GreaterThanToken,
        rhs: Box<Expr>,
    },
    LessThanEq {
        lhs: Box<Expr>,
        less_than_eq_token: LessThanEqToken,
        rhs: Box<Expr>,
    },
    GreaterThanEq {
        lhs: Box<Expr>,
        greater_than_eq_token: GreaterThanEqToken,
        rhs: Box<Expr>,
    },
    LogicalAnd {
        lhs: Box<Expr>,
        double_ampersand_token: DoubleAmpersandToken,
        rhs: Box<Expr>,
    },
    LogicalOr {
        lhs: Box<Expr>,
        double_pipe_token: DoublePipeToken,
        rhs: Box<Expr>,
    },
    Reassignment {
        assignable: Assignable,
        reassignment_op: ReassignmentOp,
        expr: Box<Expr>,
    },
    Break {
        break_token: BreakToken,
    },
    Continue {
        continue_token: ContinueToken,
    },
}

Variants

`Path(PathExpr)`

`Literal(Literal)`

`AbiCast`

Fields

abi_token: AbiToken

args: Parens<AbiCastArgs>

`Struct`

Fields

path: PathExpr

fields: Braces<Punctuated<ExprStructField, CommaToken>>

`Tuple(Parens<ExprTupleDescriptor>)`

`Parens(Parens<Box<Expr>>)`

`Block(Braces<CodeBlockContents>)`

`Array(SquareBrackets<ExprArrayDescriptor>)`

`Asm(AsmBlock)`

`Return`

Fields

return_token: ReturnToken

expr_opt: Option<Box<Expr>>

`If(IfExpr)`

`Match`

Fields

match_token: MatchToken

value: Box<Expr>

branches: Braces<Vec<MatchBranch>>

`While`

Fields

while_token: WhileToken

condition: Box<Expr>

block: Braces<CodeBlockContents>

`FuncApp`

Fields

func: Box<Expr>

args: Parens<Punctuated<Expr, CommaToken>>

`Index`

Fields

target: Box<Expr>

arg: SquareBrackets<Box<Expr>>

`MethodCall`

Fields

target: Box<Expr>

dot_token: DotToken

name: Ident

contract_args_opt: Option<Braces<Punctuated<ExprStructField, CommaToken>>>

args: Parens<Punctuated<Expr, CommaToken>>

`FieldProjection`

Fields

target: Box<Expr>

dot_token: DotToken

name: Ident

`TupleFieldProjection`

Fields

target: Box<Expr>

dot_token: DotToken

field: BigUint

field_span: Span

`Ref`

Fields

ref_token: RefToken

expr: Box<Expr>

`Deref`

Fields

deref_token: DerefToken

expr: Box<Expr>

`Not`

Fields

bang_token: BangToken

expr: Box<Expr>

`Mul`

Fields

lhs: Box<Expr>

star_token: StarToken

rhs: Box<Expr>

`Div`

Fields

lhs: Box<Expr>

forward_slash_token: ForwardSlashToken

rhs: Box<Expr>

`Modulo`

Fields

lhs: Box<Expr>

percent_token: PercentToken

rhs: Box<Expr>

`Add`

Fields

lhs: Box<Expr>

add_token: AddToken

rhs: Box<Expr>

`Sub`

Fields

lhs: Box<Expr>

sub_token: SubToken

rhs: Box<Expr>

`Shl`

Fields

lhs: Box<Expr>

shl_token: ShlToken

rhs: Box<Expr>

`Shr`

Fields

lhs: Box<Expr>

shr_token: ShrToken

rhs: Box<Expr>

`BitAnd`

Fields

lhs: Box<Expr>

ampersand_token: AmpersandToken

rhs: Box<Expr>

`BitXor`

Fields

lhs: Box<Expr>

caret_token: CaretToken

rhs: Box<Expr>

`BitOr`

Fields

lhs: Box<Expr>

pipe_token: PipeToken

rhs: Box<Expr>

`Equal`

Fields

lhs: Box<Expr>

double_eq_token: DoubleEqToken

rhs: Box<Expr>

`NotEqual`

Fields

lhs: Box<Expr>

bang_eq_token: BangEqToken

rhs: Box<Expr>

`LessThan`

Fields

lhs: Box<Expr>

less_than_token: LessThanToken

rhs: Box<Expr>

`GreaterThan`

Fields

lhs: Box<Expr>

greater_than_token: GreaterThanToken

rhs: Box<Expr>

`LessThanEq`

Fields

lhs: Box<Expr>

less_than_eq_token: LessThanEqToken

rhs: Box<Expr>

`GreaterThanEq`

Fields

lhs: Box<Expr>

greater_than_eq_token: GreaterThanEqToken

rhs: Box<Expr>

`LogicalAnd`

Fields

lhs: Box<Expr>

double_ampersand_token: DoubleAmpersandToken

rhs: Box<Expr>

`LogicalOr`

Fields

lhs: Box<Expr>

double_pipe_token: DoublePipeToken

rhs: Box<Expr>

`Reassignment`

Fields

assignable: Assignable

reassignment_op: ReassignmentOp

expr: Box<Expr>

`Break`

Fields

break_token: BreakToken

`Continue`

Fields

continue_token: ContinueToken

Implementations

source

impl Expr

source

pub fn try_into_assignable(self) -> Result<Assignable, Expr>

source

pub fn is_control_flow(&self) -> bool

Trait Implementations

source

impl Clone for Expr

source

fn clone(&self) -> Expr

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl Debug for Expr

source

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

Formats the value using the given formatter. Read more

source

impl Spanned for Expr

source

fn span(&self) -> Span

Auto Trait Implementations

impl RefUnwindSafe for Expr

impl Send for Expr

impl Sync for Expr

impl Unpin for Expr

impl UnwindSafe for Expr

Blanket Implementations

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> Same<T> for T

type Output = T

Should always be Self

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.