Enum AstNodeKind 

pub enum AstNodeKind {
    Int(i64),
    Float(f64),
    Bool(bool),
    Null,
    Str {
        segments: Vec<StrSegment>,
    },
    IndentedStr {
        segments: Vec<StrSegment>,
    },
    Path(String),
    Ident(String),
    Select {
        target: NodeId,
        path: Vec<String>,
        fallback: Option<NodeId>,
    },
    HasAttr {
        target: NodeId,
        path: Vec<String>,
    },
    List(Vec<NodeId>),
    AttrSet {
        recursive: bool,
        entries: Vec<AttrEntry>,
        inherits: Vec<InheritClause>,
    },
    LetIn {
        bindings: Vec<AttrEntry>,
        inherits: Vec<InheritClause>,
        body: NodeId,
    },
    With {
        env: NodeId,
        body: NodeId,
    },
    Assert {
        condition: NodeId,
        body: NodeId,
    },
    Lambda {
        param: LambdaParam,
        body: NodeId,
    },
    Apply {
        function: NodeId,
        argument: NodeId,
    },
    IfThenElse {
        condition: NodeId,
        then_branch: NodeId,
        else_branch: NodeId,
    },
    BinOp {
        op: BinaryOp,
        left: NodeId,
        right: NodeId,
    },
    UnaryOp {
        op: UnaryOp,
        operand: NodeId,
    },
    Unknown {
        kind: String,
        source_text: String,
    },
}

Discriminator for every node variant. Stable IDs by name; append new variants at the bottom of the enum, never reorder (rkyv archive compatibility).

Variants

Int(i64)

Float(f64)

Bool(bool)

Null

Str

Quoted string (possibly with interpolation, modeled as a concatenation of segments).

Fields

segments: Vec<StrSegment>

IndentedStr

''…'' indented string.

Fields

segments: Vec<StrSegment>

Path(String)

Ident(String)

Select

expr.attr.path (with optional or fallback).

Fields

target: NodeId

path: Vec<String>

fallback: Option<NodeId>

HasAttr

expr ? attr.path — attribute-presence test.

Fields

target: NodeId

path: Vec<String>

List(Vec<NodeId>)

AttrSet

Fields

recursive: bool

entries: Vec<AttrEntry>

inherits: Vec<InheritClause>

LetIn

Fields

bindings: Vec<AttrEntry>

inherits: Vec<InheritClause>

body: NodeId

With

Fields

env: NodeId

body: NodeId

Assert

Fields

condition: NodeId

body: NodeId

Lambda

Fields

param: LambdaParam

body: NodeId

Apply

Fields

function: NodeId

argument: NodeId

IfThenElse

Fields

condition: NodeId

then_branch: NodeId

else_branch: NodeId

BinOp

Fields

op: BinaryOp

left: NodeId

right: NodeId

UnaryOp

Fields

op: UnaryOp

operand: NodeId

Unknown

Construct we don’t model yet. source_text is the verbatim span from the rnix CST so the underlying meaning is recoverable.

Fields

kind: String

source_text: String

Trait Implementations

impl Archive for AstNodeKind

where i64: Archive, f64: Archive, bool: Archive, Vec<StrSegment>: Archive, String: Archive, NodeId: Archive, Vec<String>: Archive, Option<NodeId>: Archive, Vec<NodeId>: Archive, Vec<AttrEntry>: Archive, Vec<InheritClause>: Archive, LambdaParam: Archive, BinaryOp: Archive, UnaryOp: Archive,

type Archived = ArchivedAstNodeKind

The archived representation of this type.

type Resolver = AstNodeKindResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for AstNodeKind

fn clone(&self) -> AstNodeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AstNodeKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AstNodeKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<AstNodeKind, __D> for Archived<AstNodeKind>

where i64: Archive, <i64 as Archive>::Archived: Deserialize<i64, __D>, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, Vec<StrSegment>: Archive, <Vec<StrSegment> as Archive>::Archived: Deserialize<Vec<StrSegment>, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, NodeId: Archive, <NodeId as Archive>::Archived: Deserialize<NodeId, __D>, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>, Option<NodeId>: Archive, <Option<NodeId> as Archive>::Archived: Deserialize<Option<NodeId>, __D>, Vec<NodeId>: Archive, <Vec<NodeId> as Archive>::Archived: Deserialize<Vec<NodeId>, __D>, Vec<AttrEntry>: Archive, <Vec<AttrEntry> as Archive>::Archived: Deserialize<Vec<AttrEntry>, __D>, Vec<InheritClause>: Archive, <Vec<InheritClause> as Archive>::Archived: Deserialize<Vec<InheritClause>, __D>, LambdaParam: Archive, <LambdaParam as Archive>::Archived: Deserialize<LambdaParam, __D>, BinaryOp: Archive, <BinaryOp as Archive>::Archived: Deserialize<BinaryOp, __D>, UnaryOp: Archive, <UnaryOp as Archive>::Archived: Deserialize<UnaryOp, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<AstNodeKind, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq for AstNodeKind

fn eq(&self, other: &AstNodeKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for AstNodeKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for AstNodeKind

where i64: Serialize<__S>, f64: Serialize<__S>, bool: Serialize<__S>, Vec<StrSegment>: Serialize<__S>, String: Serialize<__S>, NodeId: Serialize<__S>, Vec<String>: Serialize<__S>, Option<NodeId>: Serialize<__S>, Vec<NodeId>: Serialize<__S>, Vec<AttrEntry>: Serialize<__S>, Vec<InheritClause>: Serialize<__S>, LambdaParam: Serialize<__S>, BinaryOp: Serialize<__S>, UnaryOp: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for AstNodeKind