Enum NodeKind 

#[non_exhaustive]
pub enum NodeKind {
    Module {
        path: Option<ModulePath>,
        annotations: Vec<Annotation>,
        imports: Vec<AIRNode>,
        items: Vec<AIRNode>,
    },
    ImportDecl {
        path: ModulePath,
        items: ImportItems,
    },
    FnDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        is_async: bool,
        name: Ident,
        generic_params: Vec<GenericParam>,
        params: Vec<AIRNode>,
        return_type: Option<Box<AIRNode>>,
        effect_clause: Vec<TypePath>,
        where_clause: Vec<TypeConstraint>,
        body: Box<AIRNode>,
    },
    RecordDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        name: Ident,
        generic_params: Vec<GenericParam>,
        fields: Vec<RecordDeclField>,
    },
    EnumDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        name: Ident,
        generic_params: Vec<GenericParam>,
        variants: Vec<AIRNode>,
    },
    EnumVariant {
        name: Ident,
        payload: EnumVariantPayload,
    },
    ClassDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        name: Ident,
        generic_params: Vec<GenericParam>,
        base: Option<TypePath>,
        traits: Vec<TypePath>,
        fields: Vec<RecordDeclField>,
        methods: Vec<AIRNode>,
    },
    TraitDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        is_platform: bool,
        name: Ident,
        generic_params: Vec<GenericParam>,
        associated_types: Vec<AssociatedType>,
        methods: Vec<AIRNode>,
    },
    ImplBlock {
        annotations: Vec<Annotation>,
        generic_params: Vec<GenericParam>,
        trait_path: Option<TypePath>,
        target: Box<AIRNode>,
        where_clause: Vec<TypeConstraint>,
        methods: Vec<AIRNode>,
    },
    EffectDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        name: Ident,
        generic_params: Vec<GenericParam>,
        components: Vec<TypePath>,
        operations: Vec<AIRNode>,
    },
    TypeAlias {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        name: Ident,
        generic_params: Vec<GenericParam>,
        ty: Box<AIRNode>,
        where_clause: Vec<TypeConstraint>,
    },
    ConstDecl {
        annotations: Vec<Annotation>,
        visibility: Visibility,
        name: Ident,
        ty: Box<AIRNode>,
        value: Box<AIRNode>,
    },
    ModuleHandle {
        effect: TypePath,
        handler: Box<AIRNode>,
    },
    PropertyTest {
        name: String,
        bindings: Vec<PropertyBinding>,
        body: Box<AIRNode>,
    },
    Param {
        pattern: Box<AIRNode>,
        ty: Option<Box<AIRNode>>,
        default: Option<Box<AIRNode>>,
    },
    TypeNamed {
        path: TypePath,
        args: Vec<AIRNode>,
    },
    TypeTuple {
        elems: Vec<AIRNode>,
    },
    TypeFunction {
        params: Vec<AIRNode>,
        ret: Box<AIRNode>,
        effects: Vec<TypePath>,
    },
    TypeOptional {
        inner: Box<AIRNode>,
    },
    TypeSelf,
    Literal {
        lit: Literal,
    },
    Identifier {
        name: Ident,
    },
    BinaryOp {
        op: BinOp,
        left: Box<AIRNode>,
        right: Box<AIRNode>,
    },
    UnaryOp {
        op: UnaryOp,
        operand: Box<AIRNode>,
    },
    Assign {
        op: AssignOp,
        target: Box<AIRNode>,
        value: Box<AIRNode>,
    },
    Call {
        callee: Box<AIRNode>,
        args: Vec<AirArg>,
        type_args: Vec<AIRNode>,
    },
    MethodCall {
        receiver: Box<AIRNode>,
        method: Ident,
        type_args: Vec<AIRNode>,
        args: Vec<AirArg>,
    },
    FieldAccess {
        object: Box<AIRNode>,
        field: Ident,
    },
    Index {
        object: Box<AIRNode>,
        index: Box<AIRNode>,
    },
    Propagate {
        expr: Box<AIRNode>,
    },
    Lambda {
        params: Vec<AIRNode>,
        body: Box<AIRNode>,
    },
    Pipe {
        left: Box<AIRNode>,
        right: Box<AIRNode>,
    },
    Compose {
        left: Box<AIRNode>,
        right: Box<AIRNode>,
    },
    Await {
        expr: Box<AIRNode>,
    },
    Range {
        lo: Box<AIRNode>,
        hi: Box<AIRNode>,
        inclusive: bool,
    },
    RecordConstruct {
        path: TypePath,
        fields: Vec<AirRecordField>,
        spread: Option<Box<AIRNode>>,
    },
    ListLiteral {
        elems: Vec<AIRNode>,
    },
    MapLiteral {
        entries: Vec<AirMapEntry>,
    },
    SetLiteral {
        elems: Vec<AIRNode>,
    },
    TupleLiteral {
        elems: Vec<AIRNode>,
    },
    Interpolation {
        parts: Vec<AirInterpolationPart>,
    },
    Placeholder,
    Unreachable,
    ResultConstruct {
        variant: ResultVariant,
        value: Option<Box<AIRNode>>,
    },
    If {
        let_pattern: Option<Box<AIRNode>>,
        condition: Box<AIRNode>,
        then_block: Box<AIRNode>,
        else_block: Option<Box<AIRNode>>,
    },
    Guard {
        let_pattern: Option<Box<AIRNode>>,
        condition: Box<AIRNode>,
        else_block: Box<AIRNode>,
    },
    Match {
        scrutinee: Box<AIRNode>,
        arms: Vec<AIRNode>,
    },
    MatchArm {
        pattern: Box<AIRNode>,
        guard: Option<Box<AIRNode>>,
        body: Box<AIRNode>,
    },
    For {
        pattern: Box<AIRNode>,
        iterable: Box<AIRNode>,
        body: Box<AIRNode>,
    },
    While {
        condition: Box<AIRNode>,
        body: Box<AIRNode>,
    },
    Loop {
        body: Box<AIRNode>,
    },
    Block {
        stmts: Vec<AIRNode>,
        tail: Option<Box<AIRNode>>,
    },
    Return {
        value: Option<Box<AIRNode>>,
    },
    Break {
        value: Option<Box<AIRNode>>,
    },
    Continue,
    LetBinding {
        is_mut: bool,
        pattern: Box<AIRNode>,
        ty: Option<Box<AIRNode>>,
        value: Box<AIRNode>,
    },
    Move {
        expr: Box<AIRNode>,
    },
    Borrow {
        expr: Box<AIRNode>,
    },
    MutableBorrow {
        expr: Box<AIRNode>,
    },
    EffectOp {
        effect: TypePath,
        operation: Ident,
        args: Vec<AirArg>,
    },
    HandlingBlock {
        handlers: Vec<AirHandlerPair>,
        body: Box<AIRNode>,
    },
    EffectRef {
        path: TypePath,
    },
    WildcardPat,
    BindPat {
        name: Ident,
        is_mut: bool,
    },
    LiteralPat {
        lit: Literal,
    },
    ConstructorPat {
        path: TypePath,
        fields: Vec<AIRNode>,
    },
    RecordPat {
        path: TypePath,
        fields: Vec<AirRecordPatternField>,
        rest: bool,
    },
    TuplePat {
        elems: Vec<AIRNode>,
    },
    ListPat {
        elems: Vec<AIRNode>,
        rest: Option<Box<AIRNode>>,
    },
    OrPat {
        alternatives: Vec<AIRNode>,
    },
    GuardPat {
        pattern: Box<AIRNode>,
        guard: Box<AIRNode>,
    },
    RangePat {
        lo: Box<AIRNode>,
        hi: Box<AIRNode>,
        inclusive: bool,
    },
    RestPat,
    Error,
}

Discriminant and typed children of an AIRNode.

Children are structured per variant (not a flat Vec<AIRNode>), mirroring the AST but lowered into the unified AIR representation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Module

The root node of a compiled Bock source file.

Fields

path: Option<ModulePath>

annotations: Vec<Annotation>

Module-level annotations (@context, @requires, etc.).

imports: Vec<AIRNode>

Import declarations (NodeKind::ImportDecl).

items: Vec<AIRNode>

Top-level items.

ImportDecl

An import declaration: import Foo.Bar.{ A, B }.

Fields

path: ModulePath

items: ImportItems

FnDecl

A function declaration.

Fields

annotations: Vec<Annotation>

visibility: Visibility

is_async: bool

name: Ident

generic_params: Vec<GenericParam>

params: Vec<AIRNode>

Parameter nodes (NodeKind::Param).

return_type: Option<Box<AIRNode>>

Optional return-type node (a type-expression variant).

effect_clause: Vec<TypePath>

Effect names listed in the with clause.

where_clause: Vec<TypeConstraint>

body: Box<AIRNode>

Body block node (NodeKind::Block).

RecordDecl

A record (value-type) declaration.

Fields

annotations: Vec<Annotation>

visibility: Visibility

name: Ident

generic_params: Vec<GenericParam>

fields: Vec<RecordDeclField>

EnumDecl

An enum (algebraic data type) declaration.

Fields

annotations: Vec<Annotation>

visibility: Visibility

name: Ident

generic_params: Vec<GenericParam>

variants: Vec<AIRNode>

Variant nodes (unit, struct, or tuple — see AST EnumVariant).

EnumVariant

An enum variant — unit, struct-like, or tuple-like.

Fields

name: Ident

payload: EnumVariantPayload

None = unit; Some = struct fields or positional types.

ClassDecl

A class declaration.

Fields

annotations: Vec<Annotation>

visibility: Visibility

name: Ident

generic_params: Vec<GenericParam>

base: Option<TypePath>

traits: Vec<TypePath>

fields: Vec<RecordDeclField>

methods: Vec<AIRNode>

Method nodes (NodeKind::FnDecl).

TraitDecl

A trait (or platform-trait) declaration.

Fields

annotations: Vec<Annotation>

visibility: Visibility

is_platform: bool

name: Ident

generic_params: Vec<GenericParam>

associated_types: Vec<AssociatedType>

methods: Vec<AIRNode>

Method nodes (NodeKind::FnDecl).

ImplBlock

An impl Trait for Type or impl Type block.

Fields

annotations: Vec<Annotation>

generic_params: Vec<GenericParam>

trait_path: Option<TypePath>

target: Box<AIRNode>

The type being implemented (a type-expression node).

where_clause: Vec<TypeConstraint>

methods: Vec<AIRNode>

Method nodes (NodeKind::FnDecl).

EffectDecl

An algebraic effect declaration.

Fields

annotations: Vec<Annotation>

visibility: Visibility

name: Ident

generic_params: Vec<GenericParam>

components: Vec<TypePath>

Component effects for composite effects: effect IO = Log + Clock.

operations: Vec<AIRNode>

Operation nodes (NodeKind::FnDecl).

TypeAlias

A type alias: type Name[T] = ....

Fields

annotations: Vec<Annotation>

visibility: Visibility

name: Ident

generic_params: Vec<GenericParam>

ty: Box<AIRNode>

The aliased type-expression node.

where_clause: Vec<TypeConstraint>

ConstDecl

A constant declaration: const NAME: Type = value.

Fields

annotations: Vec<Annotation>

visibility: Visibility

name: Ident

ty: Box<AIRNode>

Type annotation node (type-expression variant).

value: Box<AIRNode>

Initialiser expression node.

ModuleHandle

A module-level handle Effect with handler declaration.

Fields

effect: TypePath

handler: Box<AIRNode>

Handler expression node.

PropertyTest

A property("name") { forall(...) { ... } } property-based test.

Fields

name: String

bindings: Vec<PropertyBinding>

body: Box<AIRNode>

Body block node (NodeKind::Block).

Param

A single function/lambda parameter.

Fields

pattern: Box<AIRNode>

Pattern node (a pattern variant).

ty: Option<Box<AIRNode>>

Optional type annotation node (type-expression variant).

default: Option<Box<AIRNode>>

Optional default-value expression node.

TypeNamed

A named type, possibly with generic arguments: List[Int].

Fields

path: TypePath

args: Vec<AIRNode>

Generic argument nodes (type-expression variants).

TypeTuple

A tuple type: (Int, String).

Fields

elems: Vec<AIRNode>

Element type nodes (type-expression variants).

TypeFunction

A function type: Fn(Int) -> String with Log.

Fields

params: Vec<AIRNode>

Parameter type nodes (type-expression variants).

ret: Box<AIRNode>

Return type node (type-expression variant).

effects: Vec<TypePath>

Effects listed in the with clause.

TypeOptional

An optional type: Int?.

Fields

inner: Box<AIRNode>

Inner type node (type-expression variant).

TypeSelf

The Self type in a trait/impl context.

Literal

A literal value.

Fields

lit: Literal

Identifier

An identifier reference.

Fields

name: Ident

BinaryOp

A binary operation: a + b.

Fields

op: BinOp

left: Box<AIRNode>

right: Box<AIRNode>

UnaryOp

A unary operation: -x, !flag.

Fields

op: UnaryOp

operand: Box<AIRNode>

Assign

An assignment expression: x = 5, x += 1.

Fields

op: AssignOp

target: Box<AIRNode>

value: Box<AIRNode>

Call

A function call: f(a, b).

Fields

callee: Box<AIRNode>

args: Vec<AirArg>

type_args: Vec<AIRNode>

MethodCall

A method call: obj.method(a, b).

Fields

receiver: Box<AIRNode>

method: Ident

type_args: Vec<AIRNode>

args: Vec<AirArg>

FieldAccess

Field access: obj.field.

Fields

object: Box<AIRNode>

field: Ident

Index

Index access: arr[i].

Fields

object: Box<AIRNode>

index: Box<AIRNode>

Propagate

Error propagation: expr? — maps to spec’s Propagate.

Fields

expr: Box<AIRNode>

Lambda

A lambda: (x) => x * 2.

Fields

params: Vec<AIRNode>

Parameter nodes (NodeKind::Param).

body: Box<AIRNode>

Body expression node.

Pipe

Pipe operator: data |> parse.

Fields

left: Box<AIRNode>

right: Box<AIRNode>

Compose

Function composition: parse >> validate.

Fields

left: Box<AIRNode>

right: Box<AIRNode>

Await

An await expression.

Fields

expr: Box<AIRNode>

Range

A range: 1..10 (exclusive) or 1..=10 (inclusive).

Fields

lo: Box<AIRNode>

hi: Box<AIRNode>

inclusive: bool

RecordConstruct

Record construction: User { id: 1, name, ..defaults }.

Fields

path: TypePath

fields: Vec<AirRecordField>

spread: Option<Box<AIRNode>>

ListLiteral

List literal: [1, 2, 3].

Fields

elems: Vec<AIRNode>

MapLiteral

Map literal: {"key": value}.

Fields

entries: Vec<AirMapEntry>

SetLiteral

Set literal: #{"a", "b"}.

Fields

elems: Vec<AIRNode>

TupleLiteral

Tuple literal: ("hello", 42).

Fields

elems: Vec<AIRNode>

Interpolation

String interpolation: "Hello, ${name}!".

Fields

parts: Vec<AirInterpolationPart>

Placeholder

A placeholder _ used in pipe expressions.

Unreachable

unreachable — a diverging expression.

ResultConstruct

Explicit Ok(v) or Err(e) result construction.

Fields

variant: ResultVariant

value: Option<Box<AIRNode>>

If

An if / if-let expression.

Fields

let_pattern: Option<Box<AIRNode>>

For if let pat = expr, holds the pattern node.

condition: Box<AIRNode>

then_block: Box<AIRNode>

Then-branch block node (NodeKind::Block).

else_block: Option<Box<AIRNode>>

Optional else branch (block or nested if node).

Guard

A guard condition else { ... } statement.

When let_pattern is Some, this is guard (let pat = expr) else { ... }.

Fields

let_pattern: Option<Box<AIRNode>>

For guard (let pat = expr), the pattern node.

condition: Box<AIRNode>

else_block: Box<AIRNode>

Match

A match expression.

Fields

scrutinee: Box<AIRNode>

arms: Vec<AIRNode>

Match arm nodes (NodeKind::MatchArm).

MatchArm

One arm of a match expression.

Fields

pattern: Box<AIRNode>

Pattern node (a pattern variant).

guard: Option<Box<AIRNode>>

Optional guard expression.

body: Box<AIRNode>

Body expression node.

For

A for loop.

Fields

pattern: Box<AIRNode>

Loop variable pattern node (a pattern variant).

iterable: Box<AIRNode>

body: Box<AIRNode>

While

A while loop.

Fields

condition: Box<AIRNode>

body: Box<AIRNode>

Loop

An infinite loop.

Fields

body: Box<AIRNode>

Block

A block of statements with an optional tail expression.

Fields

stmts: Vec<AIRNode>

tail: Option<Box<AIRNode>>

Return

A return expression.

Fields

value: Option<Box<AIRNode>>

Break

A break expression, optionally with a value.

Fields

value: Option<Box<AIRNode>>

Continue

A continue expression.

LetBinding

A let [mut] pattern [: Type] = value binding.

Fields

is_mut: bool

pattern: Box<AIRNode>

ty: Option<Box<AIRNode>>

value: Box<AIRNode>

Move

An explicit move of ownership: move expr.

Fields

expr: Box<AIRNode>

Borrow

An immutable borrow: &expr.

Fields

expr: Box<AIRNode>

MutableBorrow

A mutable borrow: &mut expr.

Fields

expr: Box<AIRNode>

EffectOp

An algebraic-effect operation invocation.

Fields

effect: TypePath

operation: Ident

args: Vec<AirArg>

HandlingBlock

A handling (Effect with handler, ...) { body } block.

Fields

handlers: Vec<AirHandlerPair>

body: Box<AIRNode>

EffectRef

A reference to an effect type (used in type positions and signatures).

Fields

path: TypePath

WildcardPat

_ — wildcard pattern, matches anything.

BindPat

name or mut name — bind pattern.

Fields

name: Ident

is_mut: bool

LiteralPat

A literal pattern: 42, "hello", true.

Fields

lit: Literal

ConstructorPat

An enum constructor pattern: Some(x), Ok(v).

Fields

path: TypePath

fields: Vec<AIRNode>

Positional field pattern nodes.

RecordPat

A record pattern: User { name, age }.

Fields

path: TypePath

fields: Vec<AirRecordPatternField>

rest: bool

true when the pattern contains a .. rest marker.

TuplePat

A tuple pattern: (a, b, c).

Fields

elems: Vec<AIRNode>

ListPat

A list pattern: [head, ..tail].

Fields

elems: Vec<AIRNode>

rest: Option<Box<AIRNode>>

OrPat

An or-pattern: A | B.

Fields

alternatives: Vec<AIRNode>

GuardPat

A guard pattern (in pattern-matching guard position).

Fields

pattern: Box<AIRNode>

guard: Box<AIRNode>

RangePat

A range pattern: 1..10 or 1..=10.

Fields

lo: Box<AIRNode>

hi: Box<AIRNode>

inclusive: bool

RestPat

A rest pattern .. (inside list/tuple patterns).

Error

An error-recovery node wrapping tokens that could not be lowered.

Trait Implementations

impl Clone for NodeKind

fn clone(&self) -> NodeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeKind

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

Formats the value using the given formatter.

impl PartialEq for NodeKind

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