Enum CodeNode 

#[non_exhaustive]
pub enum CodeNode {
    Literal(String),
    TypeRef(TypeName),
    NameRef(String),
    StringLit(String),
    VerbatimStr(String),
    InlineLiteral(String),
    Nested(CodeBlock),
    Comment(String),
    Attribute(String),
    SoftBreak,
    Indent,
    Dedent,
    StatementBegin,
    StatementEnd,
    Newline,
    BlockOpen(String),
    BlockClose(String),
    BranchClose(String),
    Sequence(Vec<CodeNode>),
}

A single node in the code generation tree.

Each variant is self-contained: a type reference is CodeNode::TypeRef(TypeName), not a separate format tag plus a positional argument.

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.

Literal(String)

Literal text (no interpolation).

TypeRef(TypeName)

A type reference with import tracking (was %T + Arg::TypeName).

NameRef(String)

A name identifier (was %N + Arg::Name).

StringLit(String)

A string literal value, rendered with language-specific quoting (was %S + Arg::StringLit).

VerbatimStr(String)

A verbatim string literal, rendered with minimal escaping that preserves interpolation sigils (was %V + Arg::VerbatimStr).

InlineLiteral(String)

An inline literal string (was %L + Arg::Literal).

Nested(CodeBlock)

A nested code block (was %L + Arg::Code).

Comment(String)

A comment line. Rendered as {prefix} {text}{suffix} using the language’s comment syntax.

Attribute(String)

An attribute / annotation line. Rendered with the language’s annotation prefix and suffix (Rust: #[text], Java/Python: @text, C++: [[text]]).

SoftBreak

Soft line break point (%W). In direct mode emits a space; in pretty mode becomes BoxDoc::softline().

Indent

Increase indent level (%>).

Dedent

Decrease indent level (%<).

StatementBegin

Statement begin marker (%[). Triggers ensure_indent().

StatementEnd

Statement end marker (%]). Emits ; if the language uses semicolons.

Newline

Hard newline.

BlockOpen(String)

Block open delimiter. Carries the control-flow condition text (e.g., "if x > 0", "for i in range(10)"). At render time the renderer calls lang.block_open_for(condition) — if it returns Some(s), emit s; otherwise fall back to lang.block_syntax().block_open. Empty string means no condition (e.g., a bare { } block).

BlockClose(String)

Terminal block close delimiter. Carries the condition from the matching begin_control_flow call. At render time the renderer calls lang.block_close_for(condition) — if it returns Some(s), emit s; otherwise fall back to lang.block_syntax().block_close. Emits: the closer only (no semicolon, no newline — those come from StatementEnd and Newline nodes that follow).

BranchClose(String)

Non-terminal block close before a branch keyword (else, elif, catch). Like BlockClose but emits closer + space (not newline) so the branch keyword continues on the same line (e.g., } else {). Suppressed when block_syntax().close_on_transition is false (Lua, Bash — where else/elif sit between opener and closer).

Sequence(Vec<CodeNode>)

A sequence of nodes (for grouping, e.g. a statement or control flow block).

Trait Implementations

impl Clone for CodeNode

fn clone(&self) -> CodeNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodeNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CodeNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CodeNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.