Enum HirExpr

pub enum HirExpr {
    Ident {
        name: String,
        span: SourceSpan,
    },
    Number(NumberLiteral),
    String(String),
    Bool(bool),
    Array(Vec<ExprId>),
    Tuple(Vec<ExprId>),
    StructLit {
        name: String,
        fields: Vec<(String, ExprId)>,
    },
    Call {
        callee: ExprId,
        args: Vec<ExprId>,
    },
    IntrinsicCall {
        intrinsic: IntrinsicId,
        type_args: Vec<TypeExpr>,
        args: Vec<ExprId>,
    },
    Field {
        base: ExprId,
        field: String,
    },
    Index {
        base: ExprId,
        index: ExprId,
    },
    SliceRange {
        base: ExprId,
        start: Option<ExprId>,
        end: Option<ExprId>,
    },
    Prefix {
        op: PrefixOp,
        value: ExprId,
    },
    Binary {
        op: BinaryOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    Relational {
        op: RelationalOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    Block {
        body: Vec<StmtId>,
    },
    SpliceMeta {
        value: String,
    },
}

HIR expression node.

Variants

Ident

Identifier reference expression.

Fields

name: String

Identifier text as written in source.

span: SourceSpan

Source span covering the identifier token.

Number(NumberLiteral)

Numeric literal expression.

String(String)

String literal expression.

Bool(bool)

Boolean literal expression.

Array(Vec<ExprId>)

Array literal expression.

Tuple(Vec<ExprId>)

Tuple literal expression.

StructLit

Struct literal expression.

Fields

name: String

Binding name introduced by the statement.

fields: Vec<(String, ExprId)>

Field expressions keyed by field name.

Call

Function call expression.

Fields

callee: ExprId

Expression id naming the callee.

args: Vec<ExprId>

Positional argument expression ids.

IntrinsicCall

Builtin intrinsic call expression.

Fields

intrinsic: IntrinsicId

Builtin intrinsic identifier.

type_args: Vec<TypeExpr>

Optional explicit type arguments passed to the intrinsic.

args: Vec<ExprId>

Positional argument expression ids.

Field

Field projection expression.

Fields

base: ExprId

Base expression being projected from.

field: String

Field name being accessed.

Index

Collection indexing expression.

Fields

base: ExprId

Base expression being projected from.

index: ExprId

Expression id for the index value.

SliceRange

Slice-range expression over an array or slice.

Fields

base: ExprId

Base expression being projected from.

start: Option<ExprId>

Optional start bound expression id.

end: Option<ExprId>

Optional end bound expression id.

Prefix

Prefix operator expression.

Fields

op: PrefixOp

Prefix operator to apply.

value: ExprId

Expression id providing the bound value.

Binary

Binary operator expression.

Fields

op: BinaryOp

Binary operator to apply.

lhs: ExprId

Left-hand operand expression id.

rhs: ExprId

Right-hand operand expression id.

Relational

Relational comparison expression.

Fields

op: RelationalOp

Relational operator to apply.

lhs: ExprId

Left-hand operand expression id.

rhs: ExprId

Right-hand operand expression id.

Block

Nested block expression.

Fields

body: Vec<StmtId>

Statement ids executed for each iteration.

SpliceMeta

Meta splice placeholder retained in HIR.

Fields

value: String

Serialized meta value carried by the splice.

Trait Implementations

impl Clone for HirExpr

fn clone(&self) -> HirExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HirExpr

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

Formats the value using the given formatter.