openalgo-script 0.5.0 → 0.6.0

package/src/core/importer/presence.ts

@@ -0,0 +1,164 @@
+/**
+ * Three questions about a source expression that decide where the two
+ * languages part, answered from the source tree before anything is written.
+ *
+ * **Can it be absent?** The source dialect answers a comparison with an absent
+ * side `false`, where OpenScript answers `none` (`language.md` 6.4). Most
+ * places treat the two alike, because a condition that is absent takes the
+ * false branch; the places that do not are `not`, an equality with a boolean
+ * literal and a condition handed to a counting built-in, and there the
+ * translation writes `orElse(x, false)`, which is the source dialect's answer
+ * exactly. The analysis is conservative: anything it cannot show is present is
+ * treated as possibly absent, which costs an `orElse` that changes nothing.
+ *
+ * **Does it hold state?** A call that keeps state at its call site, or a user
+ * function that may, is one whose value depends on which bars it ran on
+ * (`language.md` 11.4). That is where the order and laziness of evaluation
+ * stop being invisible.
+ *
+ * **Is it a whole-number constant?** Version 5 of the source dialect divides
+ * two of those without a fraction.
+ */
+import type { Context } from './context.js';
+import { pathOf } from './syntax.js';
+import type { Expr } from './syntax.js';
+import { CALLS, COLOURS } from './table.js';
+
+/** Built-in series that hold a value on every bar, from bar 0. Volume can be absent. */
+const PRESENT_SERIES = new Set(['open', 'high', 'low', 'close', 'hl2', 'hlc3', 'ohlc4', 'hlcc4', 'time', 'bar_index']);
+
+/** Calls that return a present value whenever their arguments are present. */
+const PRESENT_WHEN_ARGUMENTS_ARE = new Set([
+  'math.abs', 'math.max', 'math.min', 'math.floor', 'math.ceil', 'math.sign', 'int', 'float',
+]);
+
+function namePresent(ctx: Context, name: string): boolean {
+  const binding = ctx.scope.find(name);
+  if (binding !== undefined) return binding.present;
+  return PRESENT_SERIES.has(name);
+}
+
+function callPresent(ctx: Context, expr: Extract<Expr, { kind: 'call' }>): boolean {
+  const path = pathOf(expr.callee);
+  if (path === undefined || ctx.scope.find(path.split('.')[0] ?? '') !== undefined) return false;
+  if (path === 'na') return true;
+  if (path === 'nz') return expr.args.length < 2 || neverAbsent(ctx, expr.args[1]?.value);
+  if (path.startsWith('input')) return true;
+  if (path === 'color.new' || path === 'color.rgb') return true;
+  if (PRESENT_WHEN_ARGUMENTS_ARE.has(path)) return expr.args.every((arg) => neverAbsent(ctx, arg.value));
+  return false;
+}
+
+/** Whether an expression holds a value on every bar, as far as the tree can show. */
+export function neverAbsent(ctx: Context, expr: Expr | undefined): boolean {
+  if (expr === undefined) return false;
+  switch (expr.kind) {
+    case 'number':
+    case 'string':
+    case 'bool':
+    case 'color':
+      return true;
+    case 'name':
+      return namePresent(ctx, expr.name);
+    case 'member': {
+      const path = pathOf(expr) ?? '';
+      if (path.startsWith('barstate.') || path === 'math.pi' || path === 'math.e') return true;
+      if (path === 'strategy.position_size') return true;
+      return path.startsWith('color.') && COLOURS.has(expr.property);
+    }
+    case 'unary':
+      return neverAbsent(ctx, expr.operand);
+    case 'binary':
+      if (expr.op === '/' || expr.op === '%') return false;
+      return neverAbsent(ctx, expr.left) && neverAbsent(ctx, expr.right);
+    case 'ternary':
+      return neverAbsent(ctx, expr.then) && neverAbsent(ctx, expr.otherwise);
+    case 'group':
+      return neverAbsent(ctx, expr.inner);
+    case 'call':
+      return callPresent(ctx, expr);
+    case 'index':
+    case 'list':
+      return false;
+  }
+}
+
+/** Whether evaluating an expression runs a call that keeps state at its call site. */
+export function holdsState(ctx: Context, expr: Expr): boolean {
+  switch (expr.kind) {
+    case 'call': {
+      const path = pathOf(expr.callee);
+      if (path !== undefined) {
+        const binding = ctx.scope.find(path);
+        if (binding !== undefined && binding.kind === 'function') return true;
+        if (CALLS.get(path)?.stateful === true) return true;
+      }
+      return holdsState(ctx, expr.callee) || expr.args.some((arg) => holdsState(ctx, arg.value));
+    }
+    case 'member':
+      return holdsState(ctx, expr.object);
+    case 'index':
+      return holdsState(ctx, expr.target) || holdsState(ctx, expr.index);
+    case 'unary':
+      return holdsState(ctx, expr.operand);
+    case 'binary':
+      return holdsState(ctx, expr.left) || holdsState(ctx, expr.right);
+    case 'ternary':
+      return holdsState(ctx, expr.condition) || holdsState(ctx, expr.then) || holdsState(ctx, expr.otherwise);
+    case 'group':
+      return holdsState(ctx, expr.inner);
+    case 'list':
+      return expr.items.some((item) => holdsState(ctx, item));
+    default:
+      return false;
+  }
+}
+
+/** A whole-number literal, as the source writes one: no point and no exponent. */
+function wholeLiteral(text: string): boolean {
+  return /^[0-9]+$/.test(text);
+}
+
+/** Whether an expression is a whole-number constant in version 5's sense. */
+export function wholeConstant(ctx: Context, expr: Expr): boolean {
+  switch (expr.kind) {
+    case 'number':
+      return wholeLiteral(expr.text);
+    case 'name':
+      return ctx.scope.find(expr.name)?.whole === true;
+    case 'unary':
+      return expr.op !== 'not' && wholeConstant(ctx, expr.operand);
+    case 'group':
+      return wholeConstant(ctx, expr.inner);
+    case 'binary':
+      return ['+', '-', '*', '/', '%'].includes(expr.op) && wholeConstant(ctx, expr.left) && wholeConstant(ctx, expr.right);
+    default:
+      return false;
+  }
+}
+
+/** Whether a name is read anywhere inside an expression. */
+export function mentions(expr: Expr, name: string): boolean {
+  switch (expr.kind) {
+    case 'name':
+      return expr.name === name;
+    case 'member':
+      return mentions(expr.object, name);
+    case 'call':
+      return mentions(expr.callee, name) || expr.args.some((arg) => mentions(arg.value, name));
+    case 'index':
+      return mentions(expr.target, name) || mentions(expr.index, name);
+    case 'unary':
+      return mentions(expr.operand, name);
+    case 'binary':
+      return mentions(expr.left, name) || mentions(expr.right, name);
+    case 'ternary':
+      return mentions(expr.condition, name) || mentions(expr.then, name) || mentions(expr.otherwise, name);
+    case 'group':
+      return mentions(expr.inner, name);
+    case 'list':
+      return expr.items.some((item) => mentions(item, name));
+    default:
+      return false;
+  }
+}

package/src/core/importer/settle.ts

@@ -0,0 +1,141 @@
+/**
+ * Settling a translation: what is kept, what it reads, and whether it compiles.
+ *
+ * The importer promises that what it hands back compiles, and the promise is
+ * kept by compiling it rather than by trusting the translators. Three passes
+ * repeat until nothing changes:
+ *
+ * 1. **The cascade.** A statement that reads a top level name declared by a
+ *    statement that was not kept is not kept either (OS9005), in source order,
+ *    so one refusal is reported once at its cause and once at each statement
+ *    that follows from it.
+ * 2. **The rendering.** Kept statements are written out; the rest are written
+ *    as their source lines behind a comment marker, so the original is there to
+ *    translate from and nothing in them is compiled.
+ * 3. **The compile.** Every error the compiler raises is laid at the statement
+ *    whose line it is on, which is then not kept (OS9012), and the loop runs
+ *    again. It ends when the output compiles, or when an error lies somewhere no
+ *    statement owns, which only the declaration can be.
+ *
+ * Warnings the compiler raises are left for the reader's own compile to show:
+ * they are about the output as OpenScript and say so in its own words.
+ */
+import { check } from '../check/index.js';
+import { DiagnosticBag, diagnosticFor } from '../diagnostics/index.js';
+import type { Diagnostic } from '../diagnostics/index.js';
+import { emit } from '../emit/index.js';
+import { lex } from '../lex/index.js';
+import { parseTokens } from '../parse/index.js';
+import { sourceFile } from '../source/index.js';
+import type { SourceFile } from '../source/index.js';
+import { isKept, reasonOf } from './context.js';
+import type { Context, Node } from './context.js';
+import type { Remark } from './lexer.js';
+
+/** One line of the output that is not a statement. */
+export type Loose =
+  | { readonly kind: 'remark'; readonly remark: Remark; readonly depth: number }
+  | { readonly kind: 'blank' }
+  | { readonly kind: 'text'; readonly text: string };
+
+export type Piece = Loose | { readonly kind: 'node'; readonly node: Node };
+
+const INDENT = '    ';
+
+function cascade(ctx: Context, nodes: readonly Node[]): void {
+  const lost = new Map<string, number>();
+  for (const node of nodes) {
+    node.lost = undefined;
+    if (node.refusal === undefined && node.failed === undefined) {
+      const hit = node.reads.find((read) => lost.has(read.name));
+      if (hit !== undefined) {
+        node.lost = diagnosticFor('OS9005', ctx.span(hit.at), { name: hit.name, line: lost.get(hit.name) ?? 0 });
+      }
+    }
+    if (!isKept(node)) for (const one of node.declares) lost.set(one.name, node.lines.first);
+  }
+}
+
+/** The output text, and for each of its lines the statement that wrote it. */
+function render(file: SourceFile, pieces: readonly Piece[]): { text: string; owners: (Node | undefined)[] } {
+  const lines: string[] = [];
+  const owners: (Node | undefined)[] = [];
+  const push = (text: string, owner: Node | undefined): void => {
+    if (text === '' && (lines.length === 0 || lines[lines.length - 1] === '')) return;
+    lines.push(text);
+    owners.push(owner);
+  };
+  for (const piece of pieces) {
+    if (piece.kind === 'blank') push('', undefined);
+    else if (piece.kind === 'text') push(piece.text, undefined);
+    else if (piece.kind === 'remark') push(`${INDENT.repeat(piece.depth)}//${piece.remark.text}`, undefined);
+    else if (isKept(piece.node)) {
+      for (const line of piece.node.output) {
+        push(line.text === '' ? '' : `${INDENT.repeat(line.depth)}${line.text}`, piece.node);
+      }
+    } else {
+      const code = reasonOf(piece.node)?.code ?? '';
+      for (let line = piece.node.lines.first; line <= piece.node.lines.last; line += 1) {
+        push(`// not translated (${code}): ${file.lineText(line)}`.trimEnd(), piece.node);
+      }
+    }
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+    owners.pop();
+  }
+  return { text: `${lines.join('\n')}\n`, owners };
+}
+
+/** The errors OpenScript's own compiler raises on a text. */
+function compileErrors(text: string): readonly Diagnostic[] {
+  const file = sourceFile('translation.oscript', text);
+  const bag = new DiagnosticBag();
+  const tokens = lex(file, bag);
+  const script = parseTokens(file, tokens, bag);
+  const checked = check(file, script, bag);
+  if (!bag.hasErrors) emit(file, checked, bag, {});
+  return bag.errors;
+}
+
+/** Repeats the three passes until the output compiles or nothing more can be done. */
+export function settle(ctx: Context, nodes: readonly Node[], pieces: readonly Piece[]): string {
+  for (let pass = 0; ; pass += 1) {
+    cascade(ctx, nodes);
+    const { text, owners } = render(ctx.facts.file, pieces);
+    const errors = compileErrors(text);
+    let changed = false;
+    for (const error of errors) {
+      const owner = owners[error.span.line - 1];
+      if (owner === undefined || !isKept(owner)) continue;
+      if (owner.declaration) {
+        owner.notes.push({ diagnostic: diagnosticFor('OS9012', ctx.span(owner.stmt.at), { code: error.code }), once: 'declaration' });
+        continue;
+      }
+      owner.failed = diagnosticFor('OS9012', ctx.span(owner.stmt.at), { code: error.code });
+      changed = true;
+    }
+    if (!changed || pass > nodes.length) return text;
+  }
+}
+
+/** Every finding, in the order a reader walks the source. */
+export function findingsOf(nodes: readonly Node[]): readonly Diagnostic[] {
+  const bag = new DiagnosticBag();
+  const once = new Set<string>();
+  for (const node of nodes) {
+    const reason = reasonOf(node);
+    if (reason !== undefined) {
+      bag.add(reason);
+      continue;
+    }
+    for (const note of node.notes) {
+      if (note.once !== undefined) {
+        if (once.has(note.once)) continue;
+        once.add(note.once);
+      }
+      bag.add(note.diagnostic);
+    }
+  }
+  return bag.ordered();
+}

package/src/core/importer/statements.ts

@@ -0,0 +1,331 @@
+/**
+ * Statements, written out as OpenScript lines.
+ *
+ * Each statement is translated inside a frame that collects the lines it needs
+ * evaluated before it: version 5's always evaluated right operand of `and` and
+ * `or`, moved to a line of its own (see `values.ts`). A frame allows that only
+ * where the moved line runs exactly as often as the statement did, so it is
+ * allowed for a plain statement and for the first condition of an `if`, and
+ * refused for an `else if`, a `while` and a `switch` arm, whose conditions the
+ * source evaluates only on some passes.
+ */
+import { diagnosticFor } from '../diagnostics/index.js';
+import { canonicalNumber } from '../emit/index.js';
+import { generic } from './calls.js';
+import type { Context, OutLine } from './context.js';
+import { binding } from './names.js';
+import { fillLine, paintLine, plotCall, levelCall, shapeLines, translateInput } from './outputs.js';
+import { closeLines, entryLines, exitLines } from './orders.js';
+import { holdsState, mentions, neverAbsent, wholeConstant } from './presence.js';
+import { pathOf } from './syntax.js';
+import type { Body, CallExpr, Expr, Stmt } from './syntax.js';
+import { CALLS } from './table.js';
+import { translate, wrap, PREC } from './values.js';
+import type { Out } from './values.js';
+
+/** Runs `work` in a frame of its own, and puts the lines it moved before its own. */
+function framed(ctx: Context, depth: number, mayHoist: boolean, work: () => OutLine[]): OutLine[] {
+  const held = { hoisted: ctx.hoisted, mayHoist: ctx.mayHoist, depth: ctx.depth };
+  ctx.hoisted = [];
+  ctx.mayHoist = mayHoist;
+  ctx.depth = depth;
+  try {
+    const lines = work();
+    return [...ctx.hoisted, ...lines];
+  } finally {
+    ctx.hoisted = held.hoisted;
+    ctx.mayHoist = held.mayHoist;
+    ctx.depth = held.depth;
+  }
+}
+
+/** A condition read where nothing may be moved out of it. */
+function fixedCondition(ctx: Context, expr: Expr): string {
+  const may = ctx.mayHoist;
+  ctx.mayHoist = false;
+  try {
+    return translate(ctx, expr).text;
+  } finally {
+    ctx.mayHoist = may;
+  }
+}
+
+function translateBody(ctx: Context, body: Body, depth: number): OutLine[] {
+  const lines: OutLine[] = [];
+  for (const entry of body) {
+    if (entry.kind === 'remark') lines.push({ depth, text: `//${entry.remark.text}` });
+    else if (entry.kind === 'blank') lines.push({ depth, text: '' });
+    else lines.push(...translateStatement(ctx, entry.stmt, depth));
+  }
+  return lines;
+}
+
+function block(ctx: Context, body: Body, depth: number): OutLine[] {
+  return ctx.within(() => translateBody(ctx, body, depth));
+}
+
+/** Where the value is a call, its path, unless the script declares the name. */
+function builtInPath(ctx: Context, expr: Expr): string | undefined {
+  if (expr.kind !== 'call') return undefined;
+  const path = pathOf(expr.callee);
+  if (path === undefined || ctx.scope.find(path.split('.')[0] ?? '') !== undefined) return undefined;
+  return path;
+}
+
+function declare(ctx: Context, stmt: Extract<Stmt, { kind: 'declare' }>, depth: number): OutLine[] {
+  const name = stmt.name.name;
+  const output = ctx.namer.declare(name, ctx.hides(name));
+  const bound = binding(output, 'variable', ctx.scope.isGlobal);
+  // The source may read the name's own history in its first value, as OpenScript may.
+  if (mentions(stmt.value, name)) ctx.scope.names.set(name, bound);
+
+  const path = builtInPath(ctx, stmt.value);
+  const special = path === undefined ? undefined : CALLS.get(path)?.special;
+  let value: Out;
+  if (special === 'input' && path !== undefined) value = translateInput(ctx, stmt.value as CallExpr, path, true);
+  else if (special === 'plot' && path !== undefined) value = plotCall(ctx, stmt.value as CallExpr, path);
+  else if (special === 'hline' && path !== undefined) value = levelCall(ctx, stmt.value as CallExpr, path);
+  else value = translate(ctx, stmt.value);
+
+  bound.handle = special === 'plot' ? 'plot' : special === 'hline' ? 'level' : undefined;
+  const reassigned = ctx.facts.reassigned.get(name);
+  bound.present = neverAbsent(ctx, stmt.value);
+  bound.whole = reassigned === undefined && stmt.mode === 'plain' && ctx.scope.isGlobal && wholeConstant(ctx, stmt.value);
+  ctx.scope.names.set(name, bound);
+  // Present only if every later value is, each read as if the name itself were.
+  if (bound.present && reassigned !== undefined) {
+    bound.present = reassigned.every((one) => one.op !== '/=' && one.op !== '%=' && neverAbsent(ctx, one.value));
+  }
+  const prefix = stmt.mode === 'var' ? 'var ' : stmt.mode === 'varip' ? 'live var ' : '';
+  return [{ depth, text: `${prefix}${output} = ${value.text}` }];
+}
+
+/** How each tuple built-in's elements line up with OpenScript's array. */
+const ELEMENTS: Readonly<Record<string, readonly number[]>> = {
+  'ta.macd': [0, 1, 2],
+  'ta.bb': [0, 1, 2],
+  'ta.supertrend': [0, 1],
+  'ta.dmi': [1, 2, 0],
+};
+
+function tuple(ctx: Context, stmt: Extract<Stmt, { kind: 'tuple' }>, depth: number): OutLine[] {
+  const bindAll = (): void => {
+    for (const one of stmt.names) {
+      const out = ctx.namer.declare(one.name, ctx.hides(one.name));
+      ctx.scope.names.set(one.name, binding(out, 'variable', ctx.scope.isGlobal));
+    }
+  };
+  const path = builtInPath(ctx, stmt.value);
+  const row = path === undefined ? undefined : CALLS.get(path);
+  const order = path === undefined ? undefined : ELEMENTS[path];
+  if (path === undefined || row === undefined || order === undefined || order.length !== stmt.names.length) {
+    if (path !== undefined && row === undefined && stmt.value.kind === 'call') {
+      ctx.refuse(diagnosticFor('OS9003', ctx.span(stmt.value.callee.at), { name: path }));
+    } else ctx.refuse(diagnosticFor('OS9002', ctx.span(stmt.at), { construct: 'a tuple assignment' }));
+    bindAll();
+    return [];
+  }
+  const value = generic(ctx, stmt.value as CallExpr, row, path);
+  const holder = ctx.namer.fresh(`${row.target}Result`);
+  const lines: OutLine[] = [{ depth, text: `${holder} = ${value.text}` }];
+  stmt.names.forEach((one, i) => {
+    const out = ctx.namer.declare(one.name, ctx.hides(one.name));
+    ctx.scope.names.set(one.name, binding(out, 'variable', ctx.scope.isGlobal));
+    if (one.name !== '_') lines.push({ depth, text: `${out} = ${holder}[${canonicalNumber(order[i] ?? 0)}]` });
+  });
+  return lines;
+}
+
+function assign(ctx: Context, stmt: Extract<Stmt, { kind: 'assign' }>, depth: number): OutLine[] {
+  const target = ctx.lookup(stmt.name.name, stmt.name.at);
+  if (target === undefined) {
+    ctx.refuse(diagnosticFor('OS9003', ctx.span(stmt.name.at), { name: stmt.name.name }));
+    return [];
+  }
+  if (target.kind !== 'variable') {
+    ctx.refuse(diagnosticFor('OS9002', ctx.span(stmt.name.at), { construct: 'an assignment to a loop variable or a parameter' }));
+    return [];
+  }
+  const value = translate(ctx, stmt.value);
+  return [{ depth, text: `${target.output} ${stmt.op === ':=' ? '=' : stmt.op} ${value.text}` }];
+}
+
+function evaluate(ctx: Context, stmt: Extract<Stmt, { kind: 'evaluate' }>, depth: number): OutLine[] {
+  const path = builtInPath(ctx, stmt.expr);
+  const call = stmt.expr as CallExpr;
+  switch (path === undefined ? undefined : CALLS.get(path)?.special) {
+    case 'declaration':
+      ctx.refuse(diagnosticFor('OS9004', ctx.span(call.callee.at), { found: 'makes a second one here' }));
+      return [];
+    case 'fill':
+      return fillLine(ctx, call, path ?? '', depth);
+    case 'paint':
+      return paintLine(ctx, call, path ?? '', path === 'bgcolor' ? 'background' : 'barColor', depth);
+    case 'shape':
+      return shapeLines(ctx, call, path ?? '', depth);
+    case 'entry':
+      return entryLines(ctx, call, path ?? '', depth);
+    case 'close':
+    case 'closeAll':
+      return closeLines(ctx, call, path ?? '', depth);
+    case 'exit':
+      return exitLines(ctx, call, path ?? '', depth);
+  }
+  return [{ depth, text: translate(ctx, stmt.expr).text }];
+}
+
+function ifLines(ctx: Context, stmt: Extract<Stmt, { kind: 'if' }>, depth: number): OutLine[] {
+  const lines: OutLine[] = [];
+  stmt.branches.forEach((branch, i) => {
+    const condition = i === 0 ? translate(ctx, branch.condition).text : fixedCondition(ctx, branch.condition);
+    lines.push({ depth, text: `${i === 0 ? 'if' : 'else if'} ${condition}` }, ...block(ctx, branch.body, depth + 1));
+  });
+  if (stmt.otherwise !== undefined) lines.push({ depth, text: 'else' }, ...block(ctx, stmt.otherwise, depth + 1));
+  return lines;
+}
+
+/** A literal number, signed or not, as its value. */
+function literalValue(expr: Expr): number | undefined {
+  if (expr.kind === 'number') return Number(expr.text);
+  if (expr.kind === 'unary' && expr.op === '-' && expr.operand.kind === 'number') return -Number(expr.operand.text);
+  if (expr.kind === 'group') return literalValue(expr.inner);
+  return undefined;
+}
+
+/** Names a loop body assigns, which a bound that is read again on each pass would see change. */
+function assigned(body: Body, into: Set<string>): Set<string> {
+  for (const entry of body) {
+    if (entry.kind !== 'stmt') continue;
+    const stmt = entry.stmt;
+    if (stmt.kind === 'assign' || stmt.kind === 'declare') into.add(stmt.name.name);
+    if (stmt.kind === 'if') {
+      for (const branch of stmt.branches) assigned(branch.body, into);
+      if (stmt.otherwise !== undefined) assigned(stmt.otherwise, into);
+    }
+    if (stmt.kind === 'for' || stmt.kind === 'while') assigned(stmt.body, into);
+    if (stmt.kind === 'switch') for (const arm of stmt.arms) assigned(arm.body, into);
+  }
+  return into;
+}
+
+function forLines(ctx: Context, stmt: Extract<Stmt, { kind: 'for' }>, depth: number): OutLine[] {
+  const changes = assigned(stmt.body, new Set());
+  const bounds = [stmt.from, stmt.to, ...(stmt.by === undefined ? [] : [stmt.by])];
+  if (bounds.some((bound) => holdsState(ctx, bound) || [...changes].some((name) => mentions(bound, name)))) {
+    ctx.refuse(diagnosticFor('OS9002', ctx.span(stmt.at), { construct: 'a for loop whose bounds change as it runs' }));
+    return [];
+  }
+  const from = translate(ctx, stmt.from);
+  const to = translate(ctx, stmt.to);
+  const start = literalValue(stmt.from);
+  const end = literalValue(stmt.to);
+  const step = stmt.by === undefined ? undefined : literalValue(stmt.by);
+  let stepText = '';
+  if (stmt.by !== undefined) {
+    if (start === undefined || end === undefined || step === undefined || step <= 0 || start > end) {
+      ctx.refuse(diagnosticFor('OS9002', ctx.span(stmt.at), { construct: 'a for loop with a step whose direction the importer cannot settle' }));
+      return [];
+    }
+    stepText = ` step ${translate(ctx, stmt.by).text}`;
+  } else if (start !== undefined && end !== undefined) {
+    if (start > end) stepText = ' step -1';
+  } else {
+    stepText = ` step (${wrap(to, PREC.comparison + 1)} >= ${wrap(from, PREC.comparison + 1)} ? 1 : -1)`;
+  }
+  return ctx.within(() => {
+    const name = stmt.variable.name;
+    const output = ctx.namer.declare(name, ctx.hides(name));
+    ctx.scope.names.set(name, binding(output, 'loop', false));
+    const header = { depth, text: `for ${output} = ${from.text} to ${to.text}${stepText}` };
+    return [header, ...translateBody(ctx, stmt.body, depth + 1)];
+  });
+}
+
+function switchLines(ctx: Context, stmt: Extract<Stmt, { kind: 'switch' }>, depth: number): OutLine[] {
+  const subject = stmt.subject === undefined ? '' : ` ${fixedCondition(ctx, stmt.subject)}`;
+  const lines: OutLine[] = [{ depth, text: `switch${subject}` }];
+  for (const arm of stmt.arms) {
+    const head = arm.match === undefined ? 'default' : `case ${fixedCondition(ctx, arm.match)}`;
+    lines.push({ depth: depth + 1, text: head }, ...block(ctx, arm.body, depth + 2));
+  }
+  return lines;
+}
+
+function functionLines(ctx: Context, stmt: Extract<Stmt, { kind: 'function' }>, depth: number): OutLine[] {
+  const output = ctx.namer.declare(stmt.name.name, ctx.hides(stmt.name.name));
+  const fn = binding(output, 'function', ctx.scope.isGlobal);
+  ctx.scope.names.set(stmt.name.name, fn);
+  return ctx.within(() => {
+    const labels = new Map<string, string>();
+    const params = stmt.params.map((param) => {
+      const fallback = param.fallback === undefined ? '' : ` = ${translate(ctx, param.fallback).text}`;
+      const out = ctx.namer.declare(param.name, ctx.hides(param.name));
+      ctx.scope.names.set(param.name, binding(out, 'parameter', false));
+      labels.set(param.name, out);
+      return `${out}${fallback}`;
+    });
+    fn.labels = labels;
+    const header = `fn ${output}(${params.join(', ')}) =>`;
+    if (!Array.isArray(stmt.body)) {
+      const body = stmt.body as Expr;
+      const lines = framed(ctx, depth + 1, true, () => [{ depth: depth + 1, text: translate(ctx, body).text }]);
+      if (lines.length === 1) return [{ depth, text: `${header} ${lines[0]?.text ?? ''}` }];
+      return [{ depth, text: header }, ...lines];
+    }
+    const body = stmt.body as Body;
+    const lines = translateBody(ctx, body, depth + 1);
+    const last = [...body].reverse().find((entry) => entry.kind === 'stmt');
+    const tail = last?.kind === 'stmt' ? last.stmt : undefined;
+    if (tail !== undefined && ['if', 'for', 'while', 'switch'].includes(tail.kind)) {
+      ctx.refuse(diagnosticFor('OS9002', ctx.span(tail.at), { construct: 'a function whose last line is a block' }));
+      return [];
+    }
+    if (tail !== undefined && (tail.kind === 'declare' || tail.kind === 'assign')) {
+      lines.push({ depth: depth + 1, text: ctx.scope.find(tail.name.name)?.output ?? tail.name.name });
+    }
+    return [{ depth, text: header }, ...lines];
+  });
+}
+
+/** A statement's own lines, before anything it moved out of itself is put in front. */
+function ownLines(ctx: Context, stmt: Stmt, depth: number): OutLine[] {
+  switch (stmt.kind) {
+    case 'declare':
+      return declare(ctx, stmt, depth);
+    case 'tuple':
+      return tuple(ctx, stmt, depth);
+    case 'assign':
+      return assign(ctx, stmt, depth);
+    case 'evaluate':
+      return evaluate(ctx, stmt, depth);
+    case 'if':
+      return ifLines(ctx, stmt, depth);
+    case 'for':
+      return forLines(ctx, stmt, depth);
+    case 'while':
+      return [{ depth, text: `while ${fixedCondition(ctx, stmt.condition)}` }, ...block(ctx, stmt.body, depth + 1)];
+    case 'switch':
+      return switchLines(ctx, stmt, depth);
+    case 'break':
+    case 'continue':
+      return [{ depth, text: stmt.kind }];
+    case 'function':
+      return functionLines(ctx, stmt, depth);
+    case 'refused':
+      ctx.refuse(diagnosticFor('OS9002', ctx.span(stmt.at), { construct: stmt.construct }));
+      return [];
+  }
+}
+
+/** Where the source wrote a comment after the statement, it goes after its first line. */
+function remarked(stmt: Stmt, lines: OutLine[]): OutLine[] {
+  const first = lines[0];
+  if (first === undefined || stmt.remarks.length === 0) return lines;
+  const trailing = stmt.remarks.map((one) => `//${one.text}`).join(' ');
+  return [{ depth: first.depth, text: `${first.text}  ${trailing}` }, ...lines.slice(1)];
+}
+
+export function translateStatement(ctx: Context, stmt: Stmt, depth: number): OutLine[] {
+  const hoists = stmt.kind !== 'while' && stmt.kind !== 'switch' && stmt.kind !== 'function' && stmt.kind !== 'refused';
+  return framed(ctx, depth, hoists, () => remarked(stmt, ownLines(ctx, stmt, depth)));
+}