openalgo-script 0.5.0 → 0.7.0

package/src/core/importer/outputs.ts

@@ -0,0 +1,245 @@
+/**
+ * Inputs, and what lands on the chart.
+ *
+ * Every argument of a drawing call is about the picture, so an argument with no
+ * OpenScript spelling is left out with OS9009 and the call is kept. An input is
+ * kept as well when one of its arguments cannot be carried, because the rest of
+ * the script reads the value it declares, and that argument is reported with
+ * OS9006 instead.
+ *
+ * OpenScript keys a column, a level, a marker and an input by its title and
+ * refuses two of one kind with one title (OS3017), where the source dialect
+ * accepts both. A repeated title is therefore numbered, which changes a label
+ * and nothing a script computes.
+ */
+import { diagnosticFor } from '../diagnostics/index.js';
+import { bind, onlyKnown } from './calls.js';
+import type { Context, OutLine } from './context.js';
+import { quoted } from './context.js';
+import { pathOf } from './syntax.js';
+import type { Arg, CallExpr, Expr } from './syntax.js';
+import { NOTHING, atom, translate } from './values.js';
+import type { Out } from './values.js';
+
+const INPUT_ARGUMENTS = ['defval', 'title', 'minval', 'maxval', 'step', 'tooltip', 'inline', 'group', 'confirm', 'options', 'display'];
+const PRESENTATION_ONLY = new Set(['inline', 'confirm', 'display']);
+
+function literalString(expr: Expr | undefined): string | undefined {
+  return expr?.kind === 'string' ? expr.value : undefined;
+}
+
+/** OS9009 for an argument that changes only the picture. */
+function leftOut(ctx: Context, arg: Arg, name: string, call: string): void {
+  ctx.note(diagnosticFor('OS9009', ctx.span(arg.at), { argument: name, call }));
+}
+
+/**
+ * `input.int(14, "Length", minval = 1)` and its siblings, as one `input()`.
+ *
+ * `assigned` is whether the input is the whole value of a declaration, where
+ * OpenScript takes the name as the title and a title may be left out.
+ */
+export function translateInput(ctx: Context, call: CallExpr, path: string, assigned: boolean): Out {
+  const bound = bind(call, ['defval', 'title']);
+  if (!onlyKnown(ctx, path, bound, INPUT_ARGUMENTS)) return NOTHING;
+  const defval = bound.byName.get('defval');
+  if (defval === undefined) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(call.at), { argument: 'defval', call: path }));
+    return NOTHING;
+  }
+  const parts = [translate(ctx, defval.value).text];
+  const titleArg = bound.byName.get('title');
+  const written = literalString(titleArg?.value);
+  if (titleArg !== undefined && written === undefined) leftOut(ctx, titleArg, 'title', path);
+  if (written !== undefined && written !== '') parts.push(quoted(ctx.title('input', written)));
+  else if (!assigned) parts.push(quoted(ctx.title('input', 'Input')));
+
+  const numeric = path === 'input.int' || path === 'input.float' || (path === 'input' && defval.value.kind === 'number');
+  for (const [source, target] of [['minval', 'min'], ['maxval', 'max'], ['step', 'step']] as const) {
+    const arg = bound.byName.get(source);
+    if (arg !== undefined) parts.push(`${target} = ${translate(ctx, arg.value).text}`);
+  }
+  const options = bound.byName.get('options');
+  if (options !== undefined) {
+    if (numeric) ctx.note(diagnosticFor('OS9006', ctx.span(options.at), { argument: 'options', call: path }));
+    else parts.push(`options = ${listText(ctx, options.value)}`);
+  }
+  for (const name of ['group', 'tooltip']) {
+    const arg = bound.byName.get(name);
+    if (arg !== undefined) parts.push(`${name} = ${translate(ctx, arg.value).text}`);
+  }
+  for (const [name, arg] of bound.byName) if (PRESENTATION_ONLY.has(name)) leftOut(ctx, arg, name, path);
+  return atom(`input(${parts.join(', ')})`);
+}
+
+function listText(ctx: Context, expr: Expr): string {
+  if (expr.kind !== 'list') return translate(ctx, expr).text;
+  return `[${expr.items.map((item) => translate(ctx, item).text).join(', ')}]`;
+}
+
+/** A member constant's last word, when the argument is `namespace.word`. */
+function constantOf(expr: Expr | undefined, namespace: string): string | undefined {
+  const path = expr === undefined ? undefined : pathOf(expr);
+  return path?.startsWith(`${namespace}.`) ? path.slice(namespace.length + 1) : undefined;
+}
+
+const PLOT_STYLES: Readonly<Record<string, string | null>> = {
+  style_line: null,
+  style_linebr: null,
+  style_stepline: 'step',
+  style_steplinebr: 'step',
+  style_histogram: 'histogram',
+  style_columns: 'column',
+  style_area: 'area',
+  style_areabr: 'area',
+};
+
+const FORMATS = new Set(['price', 'percent', 'volume']);
+
+/** The title a declared output is given: the source's literal, or a name made from what it draws. */
+function outputTitle(ctx: Context, kind: string, arg: Arg | undefined, drawn: Expr | undefined, fallback: string, call: string): string {
+  const written = literalString(arg?.value);
+  if (arg !== undefined && written === undefined) leftOut(ctx, arg, 'title', call);
+  const base = written !== undefined && written !== '' ? written : drawn?.kind === 'name' ? drawn.name : fallback;
+  return ctx.title(kind, base);
+}
+
+const PLOT_ARGUMENTS = ['series', 'title', 'color', 'linewidth', 'style', 'trackprice', 'histbase', 'offset', 'join', 'editable', 'show_last', 'display'];
+
+export function plotCall(ctx: Context, call: CallExpr, path: string): Out {
+  const bound = bind(call, PLOT_ARGUMENTS);
+  const series = bound.byName.get('series');
+  if (series === undefined || bound.stray.length > 0) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(call.at), { argument: 'series', call: path }));
+    return NOTHING;
+  }
+  const parts = [translate(ctx, series.value).text];
+  parts.push(quoted(outputTitle(ctx, 'plot', bound.byName.get('title'), series.value, 'Plot', path)));
+  for (const [name, arg] of bound.byName) {
+    if (name === 'series' || name === 'title') continue;
+    if (name === 'color') parts.splice(2, 0, translate(ctx, arg.value).text);
+    else if (name === 'linewidth') parts.push(`width = ${translate(ctx, arg.value).text}`);
+    else if (name === 'offset' || name === 'precision') parts.push(`${name} = ${translate(ctx, arg.value).text}`);
+    else if (name === 'style' && PLOT_STYLES[constantOf(arg.value, 'plot') ?? ''] !== undefined) {
+      const style = PLOT_STYLES[constantOf(arg.value, 'plot') ?? ''];
+      if (style !== null && style !== undefined) parts.push(`style = ${quoted(style)}`);
+    } else if (name === 'format' && FORMATS.has(constantOf(arg.value, 'format') ?? '')) {
+      parts.push(`format = ${quoted(constantOf(arg.value, 'format') ?? '')}`);
+    } else leftOut(ctx, arg, name, path);
+  }
+  return atom(`plot(${parts.join(', ')})`);
+}
+
+const LINE_STYLES: Readonly<Record<string, string>> = { style_solid: 'solid', style_dotted: 'dotted', style_dashed: 'dashed' };
+
+export function levelCall(ctx: Context, call: CallExpr, path: string): Out {
+  const bound = bind(call, ['price', 'title', 'color', 'linestyle', 'linewidth', 'editable', 'display']);
+  const price = bound.byName.get('price');
+  if (price === undefined || bound.stray.length > 0) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(call.at), { argument: 'price', call: path }));
+    return NOTHING;
+  }
+  const parts = [translate(ctx, price.value).text];
+  const titleArg = bound.byName.get('title');
+  const written = literalString(titleArg?.value);
+  if (titleArg !== undefined && written === undefined) leftOut(ctx, titleArg, 'title', path);
+  if (written !== undefined && written !== '') parts.push(quoted(ctx.title('level', written)));
+  for (const [name, arg] of bound.byName) {
+    if (name === 'price' || name === 'title') continue;
+    const style = LINE_STYLES[constantOf(arg.value, 'hline') ?? ''];
+    if (name === 'color') parts.push(`color = ${translate(ctx, arg.value).text}`);
+    else if (name === 'linewidth') parts.push(`width = ${translate(ctx, arg.value).text}`);
+    else if (name === 'linestyle' && style !== undefined) parts.push(`style = ${quoted(style)}`);
+    else leftOut(ctx, arg, name, path);
+  }
+  return atom(`level(${parts.join(', ')})`);
+}
+
+/** `fill` between two named plots; a level or an expression in either place is refused. */
+export function fillLine(ctx: Context, call: CallExpr, path: string, depth: number): OutLine[] {
+  const bound = bind(call, ['plot1', 'plot2', 'color']);
+  const ends = [bound.byName.get('plot1') ?? bound.byName.get('hline1'), bound.byName.get('plot2') ?? bound.byName.get('hline2')];
+  const names: string[] = [];
+  for (const end of ends) {
+    const binding = end?.value.kind === 'name' ? ctx.lookup(end.value.name, end.value.at) : undefined;
+    if (end === undefined || binding === undefined || binding.handle === undefined) {
+      ctx.refuse(diagnosticFor('OS9002', ctx.span(call.at), { construct: 'a fill between values that are not plots' }));
+      return [];
+    }
+    if (binding.handle === 'level') {
+      ctx.refuse(diagnosticFor('OS9002', ctx.span(call.at), { construct: 'a fill that ends at a horizontal line' }));
+      return [];
+    }
+    names.push(binding.output);
+  }
+  const parts = [...names];
+  for (const [name, arg] of bound.byName) {
+    if (['plot1', 'plot2', 'hline1', 'hline2'].includes(name)) continue;
+    if (name === 'color') parts.push(`color = ${translate(ctx, arg.value).text}`);
+    else leftOut(ctx, arg, name, path);
+  }
+  for (const one of bound.stray) leftOut(ctx, one.arg, one.name, path);
+  return [{ depth, text: `fill(${parts.join(', ')})` }];
+}
+
+/** `bgcolor` and `barcolor`, which paint one bar and take a colour. */
+export function paintLine(ctx: Context, call: CallExpr, path: string, target: string, depth: number): OutLine[] {
+  const bound = bind(call, ['color']);
+  const colour = bound.byName.get('color');
+  if (colour === undefined) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(call.at), { argument: 'color', call: path }));
+    return [];
+  }
+  for (const [name, arg] of bound.byName) if (name !== 'color') leftOut(ctx, arg, name, path);
+  for (const one of bound.stray) leftOut(ctx, one.arg, one.name, path);
+  return [{ depth, text: `${target}(${translate(ctx, colour.value).text})` }];
+}
+
+const SHAPES: Readonly<Record<string, string>> = {
+  triangleup: 'triangleUp',
+  triangledown: 'triangleDown',
+  arrowup: 'arrowUp',
+  arrowdown: 'arrowDown',
+  circle: 'circle',
+  square: 'square',
+  diamond: 'diamond',
+  cross: 'cross',
+  flag: 'flag',
+  labelup: 'label',
+  labeldown: 'label',
+};
+
+const LOCATIONS: Readonly<Record<string, string>> = { abovebar: 'above', belowbar: 'below' };
+
+/** `plotshape(cond, ...)`, which draws on the bars its series holds: a marker behind an if. */
+export function shapeLines(ctx: Context, call: CallExpr, path: string, depth: number): OutLine[] {
+  const bound = bind(call, ['series', 'title', 'style', 'location', 'color']);
+  const series = bound.byName.get('series');
+  if (series === undefined) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(call.at), { argument: 'series', call: path }));
+    return [];
+  }
+  const condition = translate(ctx, series.value).text;
+  const textArg = bound.byName.get('text');
+  const text = literalString(textArg?.value);
+  const shown = text !== undefined && text !== '';
+  const titleArg = bound.byName.get('title');
+  if (textArg !== undefined && !shown) leftOut(ctx, textArg, 'text', path);
+  if (titleArg !== undefined && shown) leftOut(ctx, titleArg, 'title', path);
+  const title = outputTitle(ctx, 'signal', shown ? textArg : titleArg, undefined, 'Shape', path);
+  const parts = [quoted(title)];
+  for (const [name, arg] of bound.byName) {
+    if (name === 'series' || name === 'title' || name === 'text') continue;
+    const shape = SHAPES[constantOf(arg.value, 'shape') ?? ''];
+    const location = LOCATIONS[constantOf(arg.value, 'location') ?? ''];
+    if (name === 'color') parts.push(`color = ${translate(ctx, arg.value).text}`);
+    else if (name === 'style' && shape !== undefined) parts.push(`shape = ${quoted(shape)}`);
+    else if (name === 'location' && location !== undefined) parts.push(`at = ${quoted(location)}`);
+    else leftOut(ctx, arg, name, path);
+  }
+  for (const one of bound.stray) leftOut(ctx, one.arg, one.name, path);
+  return [
+    { depth, text: `if ${condition}` },
+    { depth: depth + 1, text: `signal(${parts.join(', ')})` },
+  ];
+}

package/src/core/importer/parser.ts

@@ -0,0 +1,436 @@
+/**
+ * Statements and blocks in the source dialect.
+ *
+ * A block is the run of lines indented past its header, as in OpenScript. A
+ * statement the reader cannot take apart is not a parse error that stops the
+ * file: it becomes one `refused` statement covering its own lines and its
+ * block, so the translator can keep it as a comment and go on to the next.
+ */
+import { Cursor, Unreadable, UNREAD, badConstruct, expression, placeOf } from './expressions.js';
+import type { Item, Logical, Remark, Token } from './lexer.js';
+import { joined } from './syntax.js';
+import type { Arm, Body, Branch, Entry, Expr, Named, Param, Place, Stmt } from './syntax.js';
+
+const KEYWORD_FORMS: Readonly<Record<string, string>> = {
+  import: 'an import',
+  export: 'an export',
+  method: 'a method declaration',
+  type: 'a type declaration',
+  enum: 'an enum declaration',
+  else: 'an else with no if before it',
+};
+
+const QUALIFIERS = new Set(['const', 'simple', 'series']);
+const TYPES = new Set([
+  'int', 'float', 'bool', 'color', 'string', 'line', 'label', 'box', 'table', 'linefill',
+  'polyline', 'array', 'matrix', 'map',
+]);
+const ASSIGNMENTS = new Set([':=', '+=', '-=', '*=', '/=', '%=']);
+
+interface Parsed {
+  readonly stmt: Stmt;
+  readonly next: number;
+}
+
+function placeOfLogical(logical: Logical): Place {
+  const first = logical.tokens[0];
+  const last = logical.tokens[logical.tokens.length - 1];
+  if (first === undefined || last === undefined) return { offset: 0, length: 0 };
+  return joined(placeOf(first), placeOf(last));
+}
+
+/** The last input line a body reaches, or the fallback when it holds no code. */
+function lastLineOf(body: Body, fallback: number): number {
+  let last = fallback;
+  for (const entry of body) {
+    if (entry.kind === 'stmt') last = Math.max(last, entry.stmt.lines.last);
+  }
+  return last;
+}
+
+function nextCode(items: readonly Item[], from: number): Logical | undefined {
+  for (let i = from; i < items.length; i += 1) {
+    const item = items[i];
+    if (item !== undefined && item.kind === 'code') return item.logical;
+  }
+  return undefined;
+}
+
+function entryOf(item: Item): Entry | undefined {
+  if (item.kind === 'remark') return { kind: 'remark', remark: item.remark };
+  if (item.kind === 'blank') return { kind: 'blank', line: item.line };
+  return undefined;
+}
+
+/** The statements indented past a header at `headerIndent`, starting at item `from`. */
+function blockAfter(items: readonly Item[], from: number, headerIndent: number): { body: Entry[]; next: number } {
+  const body: Entry[] = [];
+  let i = from;
+  while (i < items.length) {
+    const item = items[i];
+    if (item === undefined) break;
+    if (item.kind !== 'code') {
+      const code = nextCode(items, i);
+      if (code === undefined || code.indent <= headerIndent) break;
+      const entry = entryOf(item);
+      if (entry !== undefined) body.push(entry);
+      i += 1;
+      continue;
+    }
+    if (item.logical.indent <= headerIndent) break;
+    const parsed = statementAt(items, i, item.logical);
+    body.push({ kind: 'stmt', stmt: parsed.stmt });
+    i = parsed.next;
+  }
+  return { body, next: i };
+}
+
+/** The whole file as one top level body. */
+export function readScript(items: readonly Item[]): Body {
+  return blockAfter(items, 0, -1).body;
+}
+
+/** Names a statement the reader refused would have declared, read off its first tokens. */
+function declaredBy(tokens: readonly Token[]): Named[] {
+  let i = 0;
+  const at = (k: number): Token | undefined => tokens[k];
+  if (at(i)?.text === 'var' || at(i)?.text === 'varip') i += 1;
+  while (at(i) !== undefined && (QUALIFIERS.has(at(i)?.text ?? '') || TYPES.has(at(i)?.text ?? ''))) i += 1;
+  const head = at(i);
+  if (head === undefined) return [];
+  if (head.kind === 'name' && at(i + 1)?.text === '=') return [{ name: head.text, at: placeOf(head) }];
+  if (head.text === '[') {
+    const names: Named[] = [];
+    for (let k = i + 1; k < tokens.length; k += 1) {
+      const token = tokens[k];
+      if (token === undefined || token.text === ']') break;
+      if (token.kind === 'name') names.push({ name: token.text, at: placeOf(token) });
+    }
+    return names;
+  }
+  if (head.kind === 'name' && at(i + 1)?.text === '(') {
+    if (tokens.some((token) => token.text === '=>')) return [{ name: head.text, at: placeOf(head) }];
+  }
+  return [];
+}
+
+/** A statement kept whole, with the block below it swallowed so its lines stay together. */
+function refusedAt(items: readonly Item[], index: number, logical: Logical, at: Place, construct: string): Parsed {
+  const { body, next } = blockAfter(items, index + 1, logical.indent);
+  const lines = { first: logical.firstLine, last: lastLineOf(body, logical.lastLine) };
+  const stmt: Stmt = { kind: 'refused', construct, declares: declaredBy(logical.tokens), at, lines, remarks: logical.remarks };
+  return { stmt, next };
+}
+
+/** The statement starting at item `index`, whose logical line is `logical`. */
+function statementAt(items: readonly Item[], index: number, logical: Logical): Parsed {
+  try {
+    return statementOf(items, index, logical);
+  } catch (error) {
+    if (!(error instanceof Unreadable)) throw error;
+    return refusedAt(items, index, logical, error.at, error.construct);
+  }
+}
+
+function common(logical: Logical, last: number = logical.lastLine): {
+  at: Place;
+  lines: { first: number; last: number };
+  remarks: readonly Remark[];
+} {
+  return { at: placeOfLogical(logical), lines: { first: logical.firstLine, last }, remarks: logical.remarks };
+}
+
+function wholeLine(c: Cursor): void {
+  if (!c.done()) c.fail();
+}
+
+function statementOf(items: readonly Item[], index: number, logical: Logical): Parsed {
+  const c = new Cursor(logical.tokens);
+  const first = c.peek();
+  if (first === undefined) throw new Unreadable(placeOfLogical(logical), UNREAD);
+  if (first.kind === 'bad') throw new Unreadable(placeOf(first), badConstruct(first));
+  const word = first.kind === 'name' ? first.text : '';
+  const keyword = KEYWORD_FORMS[word];
+  if (keyword !== undefined) throw new Unreadable(placeOf(first), keyword);
+
+  switch (word) {
+    case 'if':
+      return ifAt(items, index, logical, c);
+    case 'for':
+      return forAt(items, index, logical, c);
+    case 'while': {
+      c.take();
+      const condition = expression(c);
+      wholeLine(c);
+      const { body, next } = blockAfter(items, index + 1, logical.indent);
+      return { stmt: { kind: 'while', condition, body, ...common(logical, lastLineOf(body, logical.lastLine)) }, next };
+    }
+    case 'switch':
+      return switchAt(items, index, logical, c);
+    case 'break':
+    case 'continue':
+      c.take();
+      wholeLine(c);
+      return { stmt: { kind: word, ...common(logical) }, next: index + 1 };
+  }
+  return simpleAt(items, index, logical, c);
+}
+
+function ifAt(items: readonly Item[], index: number, logical: Logical, c: Cursor): Parsed {
+  c.take();
+  const branches: Branch[] = [];
+  let condition = expression(c);
+  wholeLine(c);
+  let { body, next } = blockAfter(items, index + 1, logical.indent);
+  let otherwise: Entry[] | undefined;
+  let last = lastLineOf(body, logical.lastLine);
+  for (;;) {
+    branches.push({ condition, body });
+    // Comment and blank lines before an else belong to the branch they follow.
+    let ahead = next;
+    const between: Entry[] = [];
+    for (let item = items[ahead]; item !== undefined && item.kind !== 'code'; item = items[++ahead]) {
+      const entry = entryOf(item);
+      if (entry !== undefined) between.push(entry);
+    }
+    const following = items[ahead];
+    if (following === undefined || following.kind !== 'code') break;
+    const line = following.logical;
+    if (line.indent !== logical.indent || line.tokens[0]?.text !== 'else') break;
+    body.push(...between);
+    next = ahead;
+    const tail = new Cursor(line.tokens);
+    tail.take();
+    if (tail.done()) {
+      const block = blockAfter(items, next + 1, logical.indent);
+      otherwise = block.body;
+      last = lastLineOf(block.body, line.lastLine);
+      next = block.next;
+      break;
+    }
+    tail.expect('if');
+    condition = expression(tail);
+    wholeLine(tail);
+    const block = blockAfter(items, next + 1, logical.indent);
+    body = block.body;
+    last = lastLineOf(block.body, line.lastLine);
+    next = block.next;
+  }
+  return { stmt: { kind: 'if', branches, otherwise, ...common(logical, last) }, next };
+}
+
+function forAt(items: readonly Item[], index: number, logical: Logical, c: Cursor): Parsed {
+  const head = c.take();
+  const variable = c.take();
+  if (variable.kind !== 'name' || c.sees('in')) {
+    throw new Unreadable(joined(placeOf(head), placeOf(variable)), 'a for loop over a collection');
+  }
+  c.expect('=');
+  const from = expression(c);
+  c.expect('to');
+  const to = expression(c);
+  let by: Expr | undefined;
+  if (c.sees('by')) {
+    c.take();
+    by = expression(c);
+  }
+  wholeLine(c);
+  const { body, next } = blockAfter(items, index + 1, logical.indent);
+  const named = { name: variable.text, at: placeOf(variable) };
+  const stmt: Stmt = { kind: 'for', variable: named, from, to, by, body, ...common(logical, lastLineOf(body, logical.lastLine)) };
+  return { stmt, next };
+}
+
+function switchAt(items: readonly Item[], index: number, logical: Logical, c: Cursor): Parsed {
+  c.take();
+  const subject = c.done() ? undefined : expression(c);
+  wholeLine(c);
+  const arms: { match: Expr | undefined; body: Entry[] }[] = [];
+  // Comment and blank lines between arms stay with the arm before them, and
+  // any before the first arm go at the start of its body.
+  const pending: Entry[] = [];
+  let i = index + 1;
+  let last = logical.lastLine;
+  while (i < items.length) {
+    const item = items[i];
+    if (item === undefined) break;
+    if (item.kind !== 'code') {
+      const code = nextCode(items, i);
+      if (code === undefined || code.indent <= logical.indent) break;
+      const entry = entryOf(item);
+      if (entry !== undefined) (arms[arms.length - 1]?.body ?? pending).push(entry);
+      i += 1;
+      continue;
+    }
+    const line = item.logical;
+    if (line.indent <= logical.indent) break;
+    const arm = new Cursor(line.tokens);
+    const match = arm.sees('=>') ? undefined : expression(arm);
+    arm.expect('=>');
+    if (arm.done()) {
+      const block = blockAfter(items, i + 1, line.indent);
+      arms.push({ match, body: [...pending.splice(0), ...block.body] });
+      last = lastLineOf(block.body, line.lastLine);
+      i = block.next;
+      continue;
+    }
+    const rest: Logical = { ...line, tokens: line.tokens.slice(arm.index) };
+    const inner = simpleAt(items, i, rest, new Cursor(rest.tokens));
+    arms.push({ match, body: [...pending.splice(0), { kind: 'stmt', stmt: inner.stmt }] });
+    last = line.lastLine;
+    i += 1;
+  }
+  const read: Arm[] = arms;
+  return { stmt: { kind: 'switch', subject, arms: read, ...common(logical, last) }, next: i };
+}
+
+/** Skips `var`, qualifiers and a type; returns the mode and whether a type was written. */
+function declarationHead(c: Cursor): { mode: 'plain' | 'var' | 'varip'; typed: boolean } {
+  let mode: 'plain' | 'var' | 'varip' = 'plain';
+  if (c.sees('var') || c.sees('varip')) mode = c.take().text === 'var' ? 'var' : 'varip';
+  let typed = false;
+  while (c.peek()?.kind === 'name' && QUALIFIERS.has(c.peek()?.text ?? '')) c.take();
+  const type = c.peek();
+  if (type !== undefined && type.kind === 'name' && TYPES.has(type.text)) {
+    const after = c.peek(1);
+    const generic = after?.text === '<';
+    if (generic || (after?.kind === 'name' && after.text !== 'and' && after.text !== 'or')) {
+      c.take();
+      typed = true;
+      if (generic) {
+        while (!c.done() && !c.sees('>')) c.take();
+        c.expect('>');
+      }
+    }
+  }
+  return { mode, typed };
+}
+
+function simpleAt(items: readonly Item[], index: number, logical: Logical, c: Cursor): Parsed {
+  const next = index + 1;
+  const { mode, typed } = declarationHead(c);
+  const head = c.peek();
+  if (head === undefined) c.fail();
+
+  if (head.text === '[' && mode === 'plain' && !typed) return tupleAt(index, logical, c);
+
+  if (head.kind === 'name' && c.sees('(', 1) && mode === 'plain' && !typed) {
+    const fn = functionAt(items, index, logical, c);
+    if (fn !== undefined) return fn;
+  }
+
+  if (head.kind === 'name' && c.sees('=', 1)) {
+    c.take();
+    c.take();
+    const valueStart = c.peek();
+    if (valueStart !== undefined && (valueStart.text === 'if' || valueStart.text === 'switch')) {
+      return valueFormAt(items, index, logical, valueStart);
+    }
+    const value = expression(c);
+    wholeLine(c);
+    const name = { name: head.text, at: placeOf(head) };
+    return { stmt: { kind: 'declare', mode, name, value, ...common(logical) }, next };
+  }
+
+  if (mode !== 'plain' || typed) c.fail();
+
+  if (head.kind === 'name' && c.peek(1)?.kind === 'op' && ASSIGNMENTS.has(c.peek(1)?.text ?? '')) {
+    c.take();
+    const op = c.take().text;
+    const value = expression(c);
+    wholeLine(c);
+    const name = { name: head.text, at: placeOf(head) };
+    return { stmt: { kind: 'assign', op, name, value, ...common(logical) }, next };
+  }
+
+  const expr = expression(c);
+  wholeLine(c);
+  return { stmt: { kind: 'evaluate', expr, ...common(logical) }, next };
+}
+
+/** `x = if ...` and `x = switch ...`, kept whole with every branch they own. */
+function valueFormAt(items: readonly Item[], index: number, logical: Logical, word: Token): Parsed {
+  const rest: Logical = { ...logical, tokens: logical.tokens.slice(logical.tokens.indexOf(word)) };
+  const inner = word.text === 'if' ? ifAt(items, index, rest, new Cursor(rest.tokens)) : switchAt(items, index, rest, new Cursor(rest.tokens));
+  const construct = word.text === 'if' ? 'an if used as a value' : 'a switch used as a value';
+  const stmt: Stmt = {
+    kind: 'refused',
+    construct,
+    declares: declaredBy(logical.tokens),
+    at: placeOf(word),
+    lines: { first: logical.firstLine, last: inner.stmt.lines.last },
+    remarks: logical.remarks,
+  };
+  return { stmt, next: inner.next };
+}
+
+function tupleAt(index: number, logical: Logical, c: Cursor): Parsed {
+  const open = c.take();
+  const names: Named[] = [];
+  while (!c.sees(']')) {
+    const token = c.take();
+    if (token.kind !== 'name') throw new Unreadable(placeOf(token), UNREAD);
+    names.push({ name: token.text, at: placeOf(token) });
+    if (!c.sees(',')) break;
+    c.take();
+  }
+  const close = c.expect(']');
+  if (!c.sees('=')) throw new Unreadable(joined(placeOf(open), placeOf(close)), 'a tuple reassignment');
+  c.take();
+  const value = expression(c);
+  wholeLine(c);
+  return { stmt: { kind: 'tuple', names, value, ...common(logical) }, next: index + 1 };
+}
+
+/** A function declaration, or undefined when the line is a call rather than one. */
+function functionAt(items: readonly Item[], index: number, logical: Logical, c: Cursor): Parsed | undefined {
+  const tokens = logical.tokens;
+  let depth = 0;
+  let close = -1;
+  for (let k = c.index + 1; k < tokens.length; k += 1) {
+    const text = tokens[k]?.text;
+    if (text === '(') depth += 1;
+    else if (text === ')') {
+      depth -= 1;
+      if (depth === 0) {
+        close = k;
+        break;
+      }
+    }
+  }
+  if (close < 0 || tokens[close + 1]?.text !== '=>') return undefined;
+
+  const nameToken = c.take();
+  c.expect('(');
+  const params: Param[] = [];
+  while (!c.sees(')')) {
+    declarationHead(c);
+    const token = c.take();
+    if (token.kind !== 'name') throw new Unreadable(placeOf(token), UNREAD);
+    let fallback: Expr | undefined;
+    if (c.sees('=')) {
+      c.take();
+      fallback = expression(c);
+    }
+    params.push({ name: token.text, at: placeOf(token), fallback });
+    if (!c.sees(',')) break;
+    c.take();
+  }
+  c.expect(')');
+  c.expect('=>');
+  const name = { name: nameToken.text, at: placeOf(nameToken) };
+  if (!c.done()) {
+    const body = expression(c);
+    wholeLine(c);
+    return { stmt: { kind: 'function', name, params, body, ...common(logical) }, next: index + 1 };
+  }
+  const block = blockAfter(items, index + 1, logical.indent);
+  const stmt: Stmt = {
+    kind: 'function',
+    name,
+    params,
+    body: block.body,
+    ...common(logical, lastLineOf(block.body, logical.lastLine)),
+  };
+  return { stmt, next: block.next };
+}