Struct CodeWriter 

pub struct CodeWriter { /* private fields */ }

An indentation-aware string builder for generated source code.

Construct one with CodeWriter::new, passing the per-target indent unit (" ", " ", or "\t"). Emit lines with line, nest with scope / block, splice pre-rendered multi-line text with block_raw, and finish with finish.

Implementations

impl CodeWriter

pub fn new(unit: impl Into<String>) -> Self

Create an empty writer whose one indent level is unit (commonly " ", " ", or "\t").

pub fn four_space() -> Self

Create an empty writer with a four-space indent unit, the most common default across the generators.

pub fn two_space() -> Self

Create an empty writer with a two-space indent unit.

pub fn tabs() -> Self

Create an empty writer with a tab indent unit.

pub fn depth(&self) -> usize

The current indentation depth (number of units prepended to a line).

pub fn with_depth(self, depth: usize) -> Self

Start the writer already nested depth levels deep. Useful when rendering a fragment that belongs inside an enclosing block whose indentation the caller tracks separately (for example a backend that still threads an explicit indent string through its render functions).

pub fn indent_str(&self) -> String

The literal indentation prefix at the current depth. Useful when calling a helper that takes an explicit indent string.

pub fn indent(&mut self) -> &mut Self

Increase the indentation depth by one level.

pub fn dedent(&mut self) -> &mut Self

Decrease the indentation depth by one level. Saturates at zero so an unbalanced dedent can never panic mid-render.

pub fn line(&mut self, s: impl AsRef<str>) -> &mut Self

Write one line at the current indentation, followed by a newline.

An empty (or whitespace-only-after-trim is not applied here; only a truly empty string) argument emits a bare newline with no trailing whitespace, so callers can use line("") interchangeably with blank.

pub fn blank(&mut self) -> &mut Self

Write a blank line (a single newline, never trailing whitespace).

pub fn raw(&mut self, s: impl AsRef<str>) -> &mut Self

Append text verbatim with no indentation and no trailing newline.

Use this for already-fully-formatted fragments (a generated-file prelude, a precomputed block) that must be spliced in unchanged.

pub fn block_raw(&mut self, s: impl AsRef<str>) -> &mut Self

Splice a multi-line fragment, re-indenting every non-empty line to the current depth while preserving the fragment’s own relative indentation. A trailing newline on the fragment is honored; blank lines stay blank (no trailing whitespace).

This is the migration workhorse: a backend can keep a large literal snippet as a raw string and let the writer place it at the right depth.

pub fn scope(&mut self, f: impl FnOnce(&mut Self)) -> &mut Self

Run f with the indentation increased by one level, then restore it.

pub fn block( &mut self, open: impl AsRef<str>, close: impl AsRef<str>, f: impl FnOnce(&mut Self), ) -> &mut Self

Emit open, run f at one deeper indent, then emit close at the original indent. The canonical way to write a braced or :-introduced block.

use weaveffi_core::codegen::writer::CodeWriter;
let mut w = CodeWriter::four_space();
w.block("fn main() {", "}", |w| {
    w.line("println!(\"hi\");");
});
assert_eq!(w.finish(), "fn main() {\n    println!(\"hi\");\n}\n");

pub fn doc(&mut self, doc: &Option<String>, style: DocCommentStyle) -> &mut Self

Emit a doc comment for doc in style at the current indentation. No-op when doc is None or trims to empty. Mirrors emit_doc, but indents from the writer’s current depth instead of an explicit prefix argument.

pub fn as_str(&self) -> &str

Borrow the accumulated text without consuming the writer.

pub fn is_empty(&self) -> bool

True when nothing has been written yet.

pub fn finish(self) -> String

Consume the writer and return the accumulated source text.

Trait Implementations

impl Clone for CodeWriter

fn clone(&self) -> CodeWriter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodeWriter

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

Formats the value using the given formatter.