formatter 0.0.2-preview.1
A code formatter for Zena
formatter#
A code formatter for Zena source code, built on a Wadler/Prettier-style document intermediate representation (Doc).
Usage#
Formatting Zena Source#
import { format } from 'formatter';
let formatted = format('export function add(a:i32,b:i32):i32{return a+b;}');
Building Custom Documents#
You can also construct and print Doc trees directly using formatter/doc and formatter/doc-printer:
import { group, concat, text, line } from 'formatter/doc';
import { printDocToString, PrintOptions } from 'formatter/doc-printer';
let doc = group(concat([text('a,'), line, text('b')]));
let rendered = printDocToString(doc, new PrintOptions(80));
Libraries#
formatter/formatter/printer— Zena AST printer (format,printModuleToDoc)formatter/doc— document IR builders (Doc,text,concat,group,indent,line,softline,hardline,ifBreak,join,fill,lineSuffix)formatter/doc-printer— line-breaking document renderer (printDocToString,PrintOptions)
License#
MIT
20.2 KiB
Raw
// Doc Printer — Prettier's line-breaking algorithm
// Ported from Prettier's src/document/printer/printer.js
//
// Converts a Doc IR into a formatted string, handling line breaking,
// indentation, and group flattening.
import { StringBuilder, growable } from 'zena:core';
import {
Doc,
DocKind,
TextDoc,
ArrayDoc,
GroupDoc,
IndentDoc,
DedentDoc,
AlignDoc,
IfBreakDoc,
FillDoc,
LineSuffixDoc,
IndentIfBreakDoc,
LabelDoc
} from './doc.zena';
// ============================================================================
// Mode: flat (try one line) or break (broken across lines)
// ============================================================================
export enum Mode {
Flat,
Break,
}
// ============================================================================
// Indent representation
// ============================================================================
// Indentation is tracked as a simple level count.
// Each level = 2 spaces (matching Zena's style).
let INDENT_WIDTH: i32 = 2;
// ============================================================================
// Print Options
// ============================================================================
export class PrintOptions {
printWidth: i32;
tabWidth: i32;
useTabs: boolean;
new(printWidth: i32) : printWidth = printWidth, tabWidth = 2, useTabs = false;
}
// ============================================================================
// Command on the print stack
// ============================================================================
class PrintCommand {
indent: i32;
mode: Mode;
doc: Doc;
new(indent: i32, mode: Mode, doc: Doc)
: indent = indent, mode = mode, doc = doc;
}
// ============================================================================
// Group break tracking (for ifBreak with groupId)
// ============================================================================
// Track which group IDs have broken.
// Simple approach: fixed-size array indexed by group ID.
let MAX_GROUPS: i32 = 1024;
class GroupBreakMap {
#broken: GrowableArray<boolean>;
new()
: #broken = new Array<boolean>()
{
var i = 0;
while (i < MAX_GROUPS) {
this.#broken.push(false);
i += 1;
}
}
set(id: i32, broken: boolean): void {
if (id > 0 && id < MAX_GROUPS) {
this.#broken[id] = broken;
}
}
get(id: i32): boolean {
if (id > 0 && id < MAX_GROUPS) {
return this.#broken[id];
}
return false;
}
}
// ============================================================================
// propagateBreaks — pre-pass to propagate hardlines/breakParent upward
// ============================================================================
// Stack entry for the propagateBreaks traversal. When isExit is true,
// this is a "group exit" marker: after all children of a group have been
// processed, we pop the group stack and propagate its break status upward.
class PropagateEntry {
doc: Doc;
isExit: boolean;
new(doc: Doc, isExit: boolean) : doc = doc, isExit = isExit;
}
function propagateBreaks(doc: Doc) {
let stack = new Array<PropagateEntry>();
let groupStack = new Array<GroupDoc>();
stack.push(new PropagateEntry(doc, false));
while (stack.length > 0) {
let entry = stack.pop();
let d = entry.doc;
if (entry.isExit) {
// Exiting a group: pop from groupStack, propagate if broken
let g = groupStack.pop();
if (g.shouldBreak && groupStack.length > 0) {
groupStack[groupStack.length - 1].shouldBreak = true;
}
} else if (d.kind == DocKind.BreakParent
|| d.kind == DocKind.Hardline
|| d.kind == DocKind.LiteralLine) {
// These all force the enclosing group to break
if (groupStack.length > 0) {
groupStack[groupStack.length - 1].shouldBreak = true;
}
} else if (d.kind == DocKind.Group) {
let g = d as GroupDoc;
groupStack.push(g);
// Push exit marker (processed after all children)
stack.push(new PropagateEntry(d, true));
// Push contents (processed before exit marker — LIFO)
stack.push(new PropagateEntry(g.contents, false));
// If already broken, propagate to parent
if (g.shouldBreak && groupStack.length > 1) {
groupStack[groupStack.length - 2].shouldBreak = true;
}
} else {
// Push children for traversal
if (d.kind == DocKind.Array) {
let ad = d as ArrayDoc;
var i = ad.parts.length - 1;
while (i >= 0) {
stack.push(new PropagateEntry(ad.parts[i], false));
i = i - 1;
}
} else if (d.kind == DocKind.Indent) {
stack.push(new PropagateEntry((d as IndentDoc).contents, false));
} else if (d.kind == DocKind.Dedent) {
stack.push(new PropagateEntry((d as DedentDoc).contents, false));
} else if (d.kind == DocKind.Align) {
stack.push(new PropagateEntry((d as AlignDoc).contents, false));
} else if (d.kind == DocKind.IfBreak) {
let ib = d as IfBreakDoc;
stack.push(new PropagateEntry(ib.flatContents, false));
stack.push(new PropagateEntry(ib.breakContents, false));
} else if (d.kind == DocKind.Fill) {
let fd = d as FillDoc;
var i = fd.parts.length - 1;
while (i >= 0) {
stack.push(new PropagateEntry(fd.parts[i], false));
i = i - 1;
}
} else if (d.kind == DocKind.LineSuffix) {
stack.push(new PropagateEntry((d as LineSuffixDoc).contents, false));
} else if (d.kind == DocKind.IndentIfBreak) {
stack.push(new PropagateEntry((d as IndentIfBreakDoc).contents, false));
} else if (d.kind == DocKind.Label) {
stack.push(new PropagateEntry((d as LabelDoc).contents, false));
}
// Leaf nodes (Text, Line, Softline, etc.): no children
}
}
}
// ============================================================================
// fits — check if doc fits within remaining width without breaking
//
// Ported from Prettier's fits() function. Key improvement over the naive
// version: when the local command stack is exhausted, continues scanning
// into restCmds (the main print stack) so that a group that fits in
// isolation but is followed by content that overflows will correctly break.
// Also tracks lineSuffix state: if a lineSuffix has been seen and we hit
// a lineSuffixBoundary, the line doesn't fit (suffix content may overflow).
// ============================================================================
function fits(
cmds: GrowableArray<PrintCommand>,
restCmds: GrowableArray<PrintCommand>,
groupBreaks: GroupBreakMap,
hasLineSuffix: boolean,
width: i32
): boolean {
var remaining = width;
var restIdx = restCmds.length;
var hasSuffix = hasLineSuffix;
while (remaining >= 0) {
if (cmds.length == 0) {
if (restIdx == 0) { return true; }
restIdx = restIdx - 1;
cmds.push(restCmds[restIdx]);
continue;
}
let cmd = cmds.pop();
let doc = cmd.doc;
if (doc.kind == DocKind.Text) {
let td = doc as TextDoc;
remaining = remaining - td.value.length;
} else if (doc.kind == DocKind.Array) {
let ad = doc as ArrayDoc;
var j = ad.parts.length - 1;
while (j >= 0) {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, ad.parts[j]));
j = j - 1;
}
} else if (doc.kind == DocKind.Group) {
let gd = doc as GroupDoc;
if (gd.shouldBreak) {
// Pre-broken group: use Break mode so it hits line breaks early
cmds.push(new PrintCommand(cmd.indent, Mode.Break, gd.contents));
} else {
cmds.push(new PrintCommand(cmd.indent, Mode.Flat, gd.contents));
}
} else if (doc.kind == DocKind.Indent) {
cmds.push(new PrintCommand(cmd.indent + 1, cmd.mode, (doc as IndentDoc).contents));
} else if (doc.kind == DocKind.Dedent) {
var newIndent = cmd.indent - 1;
if (newIndent < 0) { newIndent = 0; }
cmds.push(new PrintCommand(newIndent, cmd.mode, (doc as DedentDoc).contents));
} else if (doc.kind == DocKind.Align) {
cmds.push(new PrintCommand(cmd.indent + 1, cmd.mode, (doc as AlignDoc).contents));
} else if (doc.kind == DocKind.IfBreak) {
let ib = doc as IfBreakDoc;
if (ib.groupId > 0) {
if (groupBreaks.get(ib.groupId)) {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, ib.breakContents));
} else {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, ib.flatContents));
}
} else if (cmd.mode == Mode.Break) {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, ib.breakContents));
} else {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, ib.flatContents));
}
} else if (doc.kind == DocKind.Fill) {
let fd = doc as FillDoc;
var j = fd.parts.length - 1;
while (j >= 0) {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, fd.parts[j]));
j = j - 1;
}
} else if (doc.kind == DocKind.Line) {
if (cmd.mode == Mode.Flat) {
remaining = remaining - 1; // space
} else {
return true; // line break = fits
}
} else if (doc.kind == DocKind.Softline) {
if (cmd.mode == Mode.Flat) {
// nothing
} else {
return true;
}
} else if (doc.kind == DocKind.Hardline) {
return true;
} else if (doc.kind == DocKind.LiteralLine) {
return true;
} else if (doc.kind == DocKind.LineSuffix) {
hasSuffix = true;
} else if (doc.kind == DocKind.LineSuffixBoundary) {
if (hasSuffix) { return false; }
} else if (doc.kind == DocKind.IndentIfBreak) {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, (doc as IndentIfBreakDoc).contents));
} else if (doc.kind == DocKind.Label) {
cmds.push(new PrintCommand(cmd.indent, cmd.mode, (doc as LabelDoc).contents));
}
// BreakParent, Trim: no width effect in fits check
}
return false;
}
// ============================================================================
// printDocToString — the main algorithm
// ============================================================================
/**
* Writes `pending` spaces of deferred indentation and returns the new pending
* count, which is zero.
*
* Indentation is written when the line turns out to have content on it rather
* than when the newline before it is emitted. A line that holds nothing —
* the blank line between two class members, say — then ends at its newline
* instead of carrying the indentation of the member that follows. Deferring
* only ever withholds spaces the printer was about to add; it never removes
* bytes a `text` contributed, so trailing spaces written inside a template
* literal survive.
*/
function flushIndent(out: StringBuilder, pending: i32): i32 {
var remaining = pending;
while (remaining > 0) {
out.append(' ');
remaining -= 1;
}
return 0;
}
export function printDocToString(doc: Doc, options: PrintOptions): String {
propagateBreaks(doc);
let out = new StringBuilder();
let cmds = new Array<PrintCommand>();
let groupBreaks = new GroupBreakMap();
var lineSuffixes = new Array<PrintCommand>();
cmds.push(new PrintCommand(0, Mode.Break, doc));
var pos = 0; // current column position
// Indentation owed to the current line, written once it has content.
var pendingIndent = 0;
while (cmds.length > 0) {
let cmd = cmds.pop();
let indentLevel = cmd.indent;
let mode = cmd.mode;
let d = cmd.doc;
if (d.kind == DocKind.Text) {
let td = d as TextDoc;
pendingIndent = flushIndent(out, pendingIndent);
out.append(td.value);
pos = pos + td.value.length;
} else if (d.kind == DocKind.Array) {
let ad = d as ArrayDoc;
// Push parts in reverse order (stack = LIFO)
var i = ad.parts.length - 1;
while (i >= 0) {
cmds.push(new PrintCommand(indentLevel, mode, ad.parts[i]));
i = i - 1;
}
} else if (d.kind == DocKind.Group) {
let gd = d as GroupDoc;
if (gd.shouldBreak) {
// Pre-broken group
if (gd.id > 0) { groupBreaks.set(gd.id, true); }
cmds.push(new PrintCommand(indentLevel, Mode.Break, gd.contents));
} else {
// Try flat: build a temporary stack and check fits
let fitsCmds = growable<PrintCommand>([
new PrintCommand(indentLevel, Mode.Flat, gd.contents),
]);
let hasSuffix = lineSuffixes.length > 0;
if (fits(fitsCmds, cmds, groupBreaks, hasSuffix, options.printWidth - pos)) {
// Fits on one line
if (gd.id > 0) { groupBreaks.set(gd.id, false); }
cmds.push(new PrintCommand(indentLevel, Mode.Flat, gd.contents));
} else {
// Must break
if (gd.id > 0) { groupBreaks.set(gd.id, true); }
cmds.push(new PrintCommand(indentLevel, Mode.Break, gd.contents));
}
}
} else if (d.kind == DocKind.Indent) {
let id = d as IndentDoc;
cmds.push(new PrintCommand(indentLevel + 1, mode, id.contents));
} else if (d.kind == DocKind.Dedent) {
let dd = d as DedentDoc;
var newIndent = indentLevel - 1;
if (newIndent < 0) { newIndent = 0; }
cmds.push(new PrintCommand(newIndent, mode, dd.contents));
} else if (d.kind == DocKind.Align) {
let ad = d as AlignDoc;
// Align adds spaces, not indent levels — approximate with indent
cmds.push(new PrintCommand(indentLevel + 1, mode, ad.contents));
} else if (d.kind == DocKind.IfBreak) {
let ib = d as IfBreakDoc;
let broken = if (ib.groupId > 0) {
groupBreaks.get(ib.groupId)
} else {
mode == Mode.Break
};
if (broken) {
cmds.push(new PrintCommand(indentLevel, mode, ib.breakContents));
} else {
cmds.push(new PrintCommand(indentLevel, mode, ib.flatContents));
}
} else if (d.kind == DocKind.Fill) {
let fd = d as FillDoc;
let parts = fd.parts;
if (parts.length == 0) {
// Empty fill — nothing to do
} else if (parts.length == 1) {
// Single content item
cmds.push(new PrintCommand(indentLevel, Mode.Flat, parts[0]));
} else {
let content = parts[0];
let whitespace = parts[1];
// Build remaining parts (parts[2..])
let remaining = new Array<Doc>();
var j = 2;
while (j < parts.length) {
remaining.push(parts[j]);
j = j + 1;
}
if (remaining.length == 0) {
// Last content+whitespace pair — print both flat
cmds.push(new PrintCommand(indentLevel, Mode.Flat, whitespace));
cmds.push(new PrintCommand(indentLevel, Mode.Flat, content));
} else {
// Greedy: check if content fits flat
let contentFitsCmds = growable<PrintCommand>([
new PrintCommand(indentLevel, Mode.Flat, content),
]);
let emptyRest = new Array<PrintCommand>();
let contentFits = fits(contentFitsCmds, emptyRest, groupBreaks, false, options.printWidth - pos);
let remainingFill = new FillDoc(remaining);
if (contentFits) {
// Check if content + whitespace(flat) + nextContent also fits
let bothCmds = new Array<PrintCommand>();
// Push in reverse for stack (LIFO): content processed first
bothCmds.push(new PrintCommand(indentLevel, Mode.Flat, remaining[0]));
bothCmds.push(new PrintCommand(indentLevel, Mode.Flat, whitespace));
bothCmds.push(new PrintCommand(indentLevel, Mode.Flat, content));
let bothFit = fits(bothCmds, emptyRest, groupBreaks, false, options.printWidth - pos);
if (bothFit) {
// Everything fits: content flat, whitespace flat, continue
cmds.push(new PrintCommand(indentLevel, mode, remainingFill));
cmds.push(new PrintCommand(indentLevel, Mode.Flat, whitespace));
cmds.push(new PrintCommand(indentLevel, Mode.Flat, content));
} else {
// Content fits but next won't: break whitespace
cmds.push(new PrintCommand(indentLevel, mode, remainingFill));
cmds.push(new PrintCommand(indentLevel, Mode.Break, whitespace));
cmds.push(new PrintCommand(indentLevel, Mode.Flat, content));
}
} else {
// Content doesn't fit: break both
cmds.push(new PrintCommand(indentLevel, mode, remainingFill));
cmds.push(new PrintCommand(indentLevel, Mode.Break, whitespace));
cmds.push(new PrintCommand(indentLevel, Mode.Break, content));
}
}
}
} else if (d.kind == DocKind.Line) {
if (mode == Mode.Flat) {
pendingIndent = flushIndent(out, pendingIndent);
out.append(' ');
pos = pos + 1;
} else {
// Flush line suffixes before newline
if (lineSuffixes.length > 0) {
// Push line first (bottom of stack, processed second)
cmds.push(new PrintCommand(indentLevel, mode, d));
// Push suffixes on top (processed first)
var i = 0;
while (i < lineSuffixes.length) {
cmds.push(lineSuffixes[i]);
i += 1;
}
lineSuffixes = new Array<PrintCommand>();
} else {
out.append('\n');
pendingIndent = indentLevel * INDENT_WIDTH;
pos = pendingIndent;
}
}
} else if (d.kind == DocKind.Softline) {
if (mode == Mode.Flat) {
// nothing
} else {
// Same as line in break mode
if (lineSuffixes.length > 0) {
// Push softline first (bottom of stack, processed second)
cmds.push(new PrintCommand(indentLevel, mode, d));
// Push suffixes on top (processed first)
var i = 0;
while (i < lineSuffixes.length) {
cmds.push(lineSuffixes[i]);
i += 1;
}
lineSuffixes = new Array<PrintCommand>();
} else {
out.append('\n');
pendingIndent = indentLevel * INDENT_WIDTH;
pos = pendingIndent;
}
}
} else if (d.kind == DocKind.Hardline) {
// Flush line suffixes before the newline
if (lineSuffixes.length > 0) {
// Push hardline first (bottom of stack, processed second)
cmds.push(new PrintCommand(indentLevel, mode, d));
// Push suffixes on top (processed first, before the hardline)
var i = 0;
while (i < lineSuffixes.length) {
cmds.push(lineSuffixes[i]);
i += 1;
}
lineSuffixes = new Array<PrintCommand>();
} else {
out.append('\n');
pendingIndent = indentLevel * INDENT_WIDTH;
pos = pendingIndent;
}
} else if (d.kind == DocKind.LiteralLine) {
out.append('\n');
pendingIndent = 0;
pos = 0;
// No indentation for literal lines
} else if (d.kind == DocKind.LineSuffix) {
let ls = d as LineSuffixDoc;
lineSuffixes.push(new PrintCommand(indentLevel, mode, ls.contents));
} else if (d.kind == DocKind.LineSuffixBoundary) {
// Force-flush line suffixes
if (lineSuffixes.length > 0) {
var i = 0;
while (i < lineSuffixes.length) {
cmds.push(lineSuffixes[i]);
i += 1;
}
lineSuffixes = new Array<PrintCommand>();
}
} else if (d.kind == DocKind.BreakParent) {
// breakParent is handled during propagateBreaks pre-pass.
// For now, it's a no-op in the printer.
} else if (d.kind == DocKind.Trim) {
// Remove trailing whitespace — not yet implemented
// Would need to scan backwards in the StringBuilder
} else if (d.kind == DocKind.IndentIfBreak) {
let iib = d as IndentIfBreakDoc;
let broken = groupBreaks.get(iib.groupId);
if (broken) {
cmds.push(new PrintCommand(indentLevel + 1, mode, iib.contents));
} else {
cmds.push(new PrintCommand(indentLevel, mode, iib.contents));
}
} else if (d.kind == DocKind.Label) {
let ld = d as LabelDoc;
// Labels are transparent — just print contents
cmds.push(new PrintCommand(indentLevel, mode, ld.contents));
}
}
// Flush remaining line suffixes
for (let cmd in lineSuffixes) {
let d = cmd.doc;
if (d.kind == DocKind.Text) {
let td = d as TextDoc;
pendingIndent = flushIndent(out, pendingIndent);
out.append(td.value);
}
}
return out.toString();
}
- compiler compiler.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
| Version | Published | Dependencies | Approved by |
|---|---|---|---|
| 0.0.2-preview.1 | 2026-11-19 |
|
|