Enum sway_core::language::ty::TyExpressionVariant

pub enum TyExpressionVariant {
    Literal(Literal),
    FunctionApplication {
        call_path: CallPath,
        contract_call_params: HashMap<String, TyExpression>,
        arguments: Vec<(Ident, TyExpression)>,
        fn_ref: DeclRefFunction,
        selector: Option<ContractCallParams>,
        type_binding: Option<TypeBinding<()>>,
        call_path_typeid: Option<TypeId>,
    },
    LazyOperator {
        op: LazyOp,
        lhs: Box<TyExpression>,
        rhs: Box<TyExpression>,
    },
    ConstantExpression {
        span: Span,
        const_decl: Box<TyConstantDecl>,
        call_path: Option<CallPath>,
    },
    VariableExpression {
        name: Ident,
        span: Span,
        mutability: VariableMutability,
        call_path: Option<CallPath>,
    },
    Tuple {
        fields: Vec<TyExpression>,
    },
    Array {
        elem_type: TypeId,
        contents: Vec<TyExpression>,
    },
    ArrayIndex {
        prefix: Box<TyExpression>,
        index: Box<TyExpression>,
    },
    StructExpression {
        struct_ref: DeclRef<DeclId<TyStructDecl>>,
        fields: Vec<TyStructExpressionField>,
        instantiation_span: Span,
        call_path_binding: TypeBinding<CallPath>,
    },
    CodeBlock(TyCodeBlock),
    FunctionParameter,
    MatchExp {
        desugared: Box<TyExpression>,
        scrutinees: Vec<TyScrutinee>,
    },
    IfExp {
        condition: Box<TyExpression>,
        then: Box<TyExpression>,
        else: Option<Box<TyExpression>>,
    },
    AsmExpression {
        registers: Vec<TyAsmRegisterDeclaration>,
        body: Vec<AsmOp>,
        returns: Option<(AsmRegister, Span)>,
        whole_block_span: Span,
    },
    StructFieldAccess {
        prefix: Box<TyExpression>,
        field_to_access: TyStructField,
        field_instantiation_span: Span,
        resolved_type_of_parent: TypeId,
    },
    TupleElemAccess {
        prefix: Box<TyExpression>,
        elem_to_access_num: usize,
        resolved_type_of_parent: TypeId,
        elem_to_access_span: Span,
    },
    EnumInstantiation {
        enum_ref: DeclRef<DeclId<TyEnumDecl>>,
        variant_name: Ident,
        tag: usize,
        contents: Option<Box<TyExpression>>,
        variant_instantiation_span: Span,
        call_path_binding: TypeBinding<CallPath>,
        call_path_decl: TyDecl,
    },
    AbiCast {
        abi_name: CallPath,
        address: Box<TyExpression>,
        span: Span,
    },
    StorageAccess(TyStorageAccess),
    IntrinsicFunction(TyIntrinsicFunctionKind),
    AbiName(AbiName),
    EnumTag {
        exp: Box<TyExpression>,
    },
    UnsafeDowncast {
        exp: Box<TyExpression>,
        variant: TyEnumVariant,
        call_path_decl: TyDecl,
    },
    WhileLoop {
        condition: Box<TyExpression>,
        body: TyCodeBlock,
    },
    Break,
    Continue,
    Reassignment(Box<TyReassignment>),
    Return(Box<TyExpression>),
}

Variants

Literal(Literal)

FunctionApplication

Fields

call_path: CallPath

contract_call_params: HashMap<String, TyExpression>

arguments: Vec<(Ident, TyExpression)>

fn_ref: DeclRefFunction

selector: Option<ContractCallParams>

type_binding: Option<TypeBinding<()>>

optional binding information for the LSP

call_path_typeid: Option<TypeId>

In case it is a method should contain a TypeId to either an enum, struct or a type alias.

LazyOperator

Fields

op: LazyOp

lhs: Box<TyExpression>

rhs: Box<TyExpression>

ConstantExpression

Fields

span: Span

const_decl: Box<TyConstantDecl>

call_path: Option<CallPath>

VariableExpression

Fields

name: Ident

span: Span

mutability: VariableMutability

call_path: Option<CallPath>

Tuple

Fields

fields: Vec<TyExpression>

Array

Fields

elem_type: TypeId

contents: Vec<TyExpression>

ArrayIndex

Fields

prefix: Box<TyExpression>

index: Box<TyExpression>

StructExpression

Fields

struct_ref: DeclRef<DeclId<TyStructDecl>>

fields: Vec<TyStructExpressionField>

instantiation_span: Span

call_path_binding: TypeBinding<CallPath>

CodeBlock(TyCodeBlock)

FunctionParameter

MatchExp

Fields

desugared: Box<TyExpression>

scrutinees: Vec<TyScrutinee>

IfExp

Fields

condition: Box<TyExpression>

then: Box<TyExpression>

else: Option<Box<TyExpression>>

AsmExpression

Fields

registers: Vec<TyAsmRegisterDeclaration>

body: Vec<AsmOp>

returns: Option<(AsmRegister, Span)>

whole_block_span: Span

StructFieldAccess

Fields

prefix: Box<TyExpression>

field_to_access: TyStructField

field_instantiation_span: Span

resolved_type_of_parent: TypeId

TupleElemAccess

Fields

prefix: Box<TyExpression>

elem_to_access_num: usize

resolved_type_of_parent: TypeId

elem_to_access_span: Span

EnumInstantiation

Fields

enum_ref: DeclRef<DeclId<TyEnumDecl>>

variant_name: Ident

for printing

tag: usize

contents: Option<Box<TyExpression>>

variant_instantiation_span: Span

If there is an error regarding this instantiation of the enum, use these spans as it points to the call site and not the declaration. They are also used in the language server.

call_path_binding: TypeBinding<CallPath>

call_path_decl: TyDecl

The enum type, can be a type alias.

AbiCast

Fields

abi_name: CallPath

address: Box<TyExpression>

span: Span

StorageAccess(TyStorageAccess)

IntrinsicFunction(TyIntrinsicFunctionKind)

AbiName(AbiName)

a zero-sized type-system-only compile-time thing that is used for constructing ABI casts.

EnumTag

Fields

exp: Box<TyExpression>

grabs the enum tag from the particular enum and variant of the exp

UnsafeDowncast

Fields

exp: Box<TyExpression>

variant: TyEnumVariant

call_path_decl: TyDecl

Should contain a TyDecl to either an enum or a type alias.

performs an unsafe cast from the exp to the type of the given enum variant

WhileLoop

Fields

condition: Box<TyExpression>

body: TyCodeBlock

Break

Continue

Reassignment(Box<TyReassignment>)

Return(Box<TyExpression>)

Trait Implementations

impl Clone for TyExpressionVariant

fn clone(&self) -> TyExpressionVariant

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TyExpressionVariant

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

Formats the value using the given formatter.