openalgo-script 0.5.0 → 0.7.0

package/src/core/importer/lexer.ts

@@ -0,0 +1,285 @@
+/**
+ * Reading a script in the source dialect into logical lines of tokens.
+ *
+ * The source dialect is line oriented and indentation delimited, like
+ * OpenScript, and it differs in the two places a reader has to know about. A
+ * statement continues onto the next line when a bracket is still open, when
+ * the line ends on an operator that cannot end one, or when the next line is
+ * indented by an amount that is not a whole number of blocks: the dialect's
+ * blocks are four columns deep, and a continuation is told apart from a block
+ * by being indented off that grid. A tab in leading whitespace counts as one
+ * block.
+ *
+ * This reader is deliberately separate from OpenScript's lexer. The two
+ * languages share a shape and differ in almost every token rule that matters to
+ * a diagnostic: the source dialect has `:=`, `=>` and single quoted strings as
+ * ordinary tokens and no `none`, and running its text through OpenScript's
+ * lexer would report every one of those as a mistake in a file nobody wrote in
+ * OpenScript.
+ *
+ * Nothing here refuses anything. A character the dialect does not have becomes
+ * a `bad` token, and the parser decides what the statement holding it is.
+ */
+import type { SourceFile } from '../source/index.js';
+
+export type TokenKind = 'name' | 'number' | 'string' | 'color' | 'op' | 'bad';
+
+export interface Token {
+  readonly kind: TokenKind;
+  /** The characters as written. */
+  readonly text: string;
+  /** A string literal's decoded value; for every other kind, the text. */
+  readonly value: string;
+  readonly offset: number;
+  readonly length: number;
+}
+
+/** A `//` comment, with the text after the two slashes. */
+export interface Remark {
+  readonly text: string;
+  readonly offset: number;
+  readonly line: number;
+}
+
+/** One statement's worth of tokens, which may have spanned several lines. */
+export interface Logical {
+  /** Leading columns of the first line, a tab counted as one block. */
+  readonly indent: number;
+  readonly tokens: readonly Token[];
+  /** Comments written after code on any of the statement's lines. */
+  readonly remarks: readonly Remark[];
+  readonly firstLine: number;
+  readonly lastLine: number;
+}
+
+export type Item =
+  | { readonly kind: 'code'; readonly logical: Logical }
+  | { readonly kind: 'remark'; readonly remark: Remark; readonly indent: number }
+  | { readonly kind: 'blank'; readonly line: number };
+
+/** The width of one block in the dialect, which a continuation is indented off. */
+const BLOCK = 4;
+
+const TWO_CHARACTER = [':=', '==', '!=', '<=', '>=', '=>', '+=', '-=', '*=', '/=', '%='];
+const ONE_CHARACTER = '+-*/%<>=?:,.()[]';
+
+/** Tokens after which a statement cannot end, so the next indented line continues it. */
+const CONTINUES = new Set([
+  ',', '+', '-', '*', '/', '%', '==', '!=', '<', '<=', '>', '>=', '?', ':', ':=', '=',
+  '+=', '-=', '*=', '/=', '%=', 'and', 'or', 'not', '(', '[',
+]);
+
+const NAME_START = /[A-Za-z_]/;
+const NAME_PART = /[A-Za-z0-9_]/;
+const DIGIT = /[0-9]/;
+const HEX = /[0-9A-Fa-f]/;
+
+const ESCAPES: Readonly<Record<string, string>> = { n: '\n', t: '\t', r: '\r', '\\': '\\', "'": "'", '"': '"' };
+
+interface Physical {
+  readonly line: number;
+  readonly indent: number;
+  readonly tokens: Token[];
+  readonly remark: Remark | undefined;
+}
+
+/** Columns of leading whitespace, and where the text after it starts. */
+function measure(text: string): { indent: number; start: number } {
+  let indent = 0;
+  let start = 0;
+  while (start < text.length) {
+    const c = text[start];
+    if (c === ' ') indent += 1;
+    else if (c === '\t') indent += BLOCK - (indent % BLOCK);
+    else break;
+    start += 1;
+  }
+  return { indent, start };
+}
+
+function readString(text: string, at: number): { end: number; value: string; closed: boolean } {
+  const quote = text[at];
+  let value = '';
+  let i = at + 1;
+  while (i < text.length) {
+    const c = text[i] ?? '';
+    if (c === quote) return { end: i + 1, value, closed: true };
+    if (c === '\\' && i + 1 < text.length) {
+      const next = text[i + 1] ?? '';
+      value += ESCAPES[next] ?? next;
+      i += 2;
+      continue;
+    }
+    value += c;
+    i += 1;
+  }
+  return { end: text.length, value, closed: false };
+}
+
+function readNumber(text: string, at: number): number {
+  let i = at;
+  while (i < text.length && DIGIT.test(text[i] ?? '')) i += 1;
+  if (text[i] === '.' && !NAME_START.test(text[i + 1] ?? '')) {
+    i += 1;
+    while (i < text.length && DIGIT.test(text[i] ?? '')) i += 1;
+  }
+  if ((text[i] === 'e' || text[i] === 'E') && /[0-9+-]/.test(text[i + 1] ?? '')) {
+    let j = i + 1;
+    if (text[j] === '+' || text[j] === '-') j += 1;
+    if (DIGIT.test(text[j] ?? '')) {
+      i = j;
+      while (i < text.length && DIGIT.test(text[i] ?? '')) i += 1;
+    }
+  }
+  return i;
+}
+
+/** Every token on one physical line, and the comment that ends it if any. */
+function tokensOf(
+  text: string,
+  start: number,
+  lineStart: number,
+  line: number,
+): { tokens: Token[]; remark: Remark | undefined } {
+  const tokens: Token[] = [];
+  const token = (kind: TokenKind, from: number, to: number, value?: string): void => {
+    const written = text.slice(from, to);
+    tokens.push({ kind, text: written, value: value ?? written, offset: lineStart + from, length: to - from });
+  };
+  let i = start;
+  while (i < text.length) {
+    const c = text[i] ?? '';
+    if (c === ' ' || c === '\t') {
+      i += 1;
+      continue;
+    }
+    if (c === '/' && text[i + 1] === '/') {
+      return { tokens, remark: { text: text.slice(i + 2).trimEnd(), offset: lineStart + i, line } };
+    }
+    if (NAME_START.test(c)) {
+      let j = i + 1;
+      while (j < text.length && NAME_PART.test(text[j] ?? '')) j += 1;
+      token('name', i, j);
+      i = j;
+      continue;
+    }
+    if (DIGIT.test(c) || (c === '.' && DIGIT.test(text[i + 1] ?? ''))) {
+      const j = readNumber(text, i);
+      token('number', i, j);
+      i = j;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const read = readString(text, i);
+      token(read.closed ? 'string' : 'bad', i, read.end, read.value);
+      i = read.end;
+      continue;
+    }
+    if (c === '#') {
+      let j = i + 1;
+      while (j < text.length && HEX.test(text[j] ?? '')) j += 1;
+      token(j - i === 7 || j - i === 9 ? 'color' : 'bad', i, j);
+      i = j;
+      continue;
+    }
+    const pair = text.slice(i, i + 2);
+    if (TWO_CHARACTER.includes(pair)) {
+      token('op', i, i + 2);
+      i += 2;
+      continue;
+    }
+    token(ONE_CHARACTER.includes(c) ? 'op' : 'bad', i, i + 1);
+    i += 1;
+  }
+  return { tokens, remark: undefined };
+}
+
+/** How far a line's brackets leave the statement open. */
+function depthAfter(depth: number, tokens: readonly Token[]): number {
+  let open = depth;
+  for (const one of tokens) {
+    if (one.kind !== 'op') continue;
+    if (one.text === '(' || one.text === '[') open += 1;
+    else if (one.text === ')' || one.text === ']') open = Math.max(0, open - 1);
+  }
+  return open;
+}
+
+interface Building {
+  indent: number;
+  tokens: Token[];
+  remarks: Remark[];
+  firstLine: number;
+  lastLine: number;
+  depth: number;
+}
+
+function continues(current: Building, next: Physical): boolean {
+  if (current.depth > 0) return true;
+  if (next.indent <= current.indent) return false;
+  if (next.indent % BLOCK !== 0) return true;
+  const last = current.tokens[current.tokens.length - 1];
+  return last !== undefined && CONTINUES.has(last.text);
+}
+
+/**
+ * The whole file as items: statements, comment lines and blank lines, in order.
+ *
+ * A comment line or a blank line inside an open statement belongs to that
+ * statement and ends nothing, the same rule OpenScript gives them.
+ */
+export function readItems(file: SourceFile): readonly Item[] {
+  const items: Item[] = [];
+  let current: Building | undefined;
+  const held: Item[] = [];
+
+  const close = (): void => {
+    if (current === undefined) return;
+    const { indent, tokens, remarks, firstLine, lastLine } = current;
+    items.push({ kind: 'code', logical: { indent, tokens, remarks, firstLine, lastLine } });
+    current = undefined;
+  };
+
+  for (let line = 1; line <= file.lineCount; line += 1) {
+    const text = file.lineText(line);
+    const { indent, start } = measure(text);
+    const read = tokensOf(text, start, file.lineStart(line), line);
+    const physical: Physical = { line, indent, tokens: read.tokens, remark: read.remark };
+
+    if (physical.tokens.length === 0) {
+      if (current !== undefined && current.depth > 0) {
+        if (physical.remark !== undefined) current.remarks.push(physical.remark);
+        continue;
+      }
+      held.push(
+        physical.remark === undefined
+          ? { kind: 'blank', line }
+          : { kind: 'remark', remark: physical.remark, indent },
+      );
+      continue;
+    }
+
+    if (current !== undefined && continues(current, physical)) {
+      current.tokens.push(...physical.tokens);
+      if (physical.remark !== undefined) current.remarks.push(physical.remark);
+      current.lastLine = line;
+      current.depth = depthAfter(current.depth, physical.tokens);
+      continue;
+    }
+
+    close();
+    items.push(...held);
+    held.length = 0;
+    current = {
+      indent,
+      tokens: [...physical.tokens],
+      remarks: physical.remark === undefined ? [] : [physical.remark],
+      firstLine: line,
+      lastLine: line,
+      depth: depthAfter(0, physical.tokens),
+    };
+  }
+  close();
+  items.push(...held);
+  return items;
+}

package/src/core/importer/names.ts

@@ -0,0 +1,104 @@
+/**
+ * Scopes, and the name each source name is written as.
+ *
+ * Two rules of the source dialect differ from OpenScript's, and both are about
+ * meaning rather than spelling. A declaration inside a block or a function
+ * always makes a new name there, hiding any outer name it shares a spelling
+ * with, where OpenScript updates the outer name instead and refuses to hide one
+ * (`language.md` 12.2 and 12.3). And the source dialect's built-ins live behind
+ * namespaces, so `rsi` or `step` is an ordinary name there and a library name or
+ * a reserved word here.
+ *
+ * So a declaration that would hide a visible name is renamed with a number, and
+ * a name OpenScript reserves or defines is renamed with `Value` after it. Every
+ * new spelling is checked against every name the source uses anywhere and every
+ * name OpenScript has, so a rename can never land on another name. Nothing
+ * else is renamed: a name that collides with neither keeps its spelling, and
+ * two sibling blocks may both declare it, as both languages allow.
+ */
+import { NAMESPACES, isLibraryName } from '../check/index.js';
+import { canonicalNumber } from '../emit/index.js';
+import { RESERVED_WORDS } from '../tokens/index.js';
+
+export type BindingKind = 'variable' | 'function' | 'parameter' | 'loop';
+
+export interface Binding {
+  readonly output: string;
+  readonly kind: BindingKind;
+  readonly topLevel: boolean;
+  /** Bound to a declaration handle, which only `fill` may take. */
+  handle: 'plot' | 'level' | undefined;
+  /** Never absent on any bar: bound to an input or a literal and never reassigned. */
+  present: boolean;
+  /** A whole-number constant in the source dialect's sense, which version 5 divides without a fraction. */
+  whole: boolean;
+  /** A function's parameters, source spelling to output spelling, for its named arguments. */
+  labels: ReadonlyMap<string, string> | undefined;
+}
+
+/** Words OpenScript gives a meaning of its own outside the library. */
+const DECLARATION_WORDS = ['study', 'strategy', 'limits', 'version'];
+
+export class Scope {
+  readonly names = new Map<string, Binding>();
+  readonly parent: Scope | undefined;
+
+  constructor(parent: Scope | undefined) {
+    this.parent = parent;
+  }
+
+  find(name: string): Binding | undefined {
+    return this.names.get(name) ?? this.parent?.find(name);
+  }
+
+  get isGlobal(): boolean {
+    return this.parent === undefined;
+  }
+}
+
+export class Namer {
+  readonly #taken: Set<string>;
+
+  /** `used` is every identifier the source writes, anywhere. */
+  constructor(used: Iterable<string>) {
+    this.#taken = new Set(used);
+  }
+
+  /** Whether OpenScript already means something by this name. */
+  static reserved(name: string): boolean {
+    return (
+      (RESERVED_WORDS as readonly string[]).includes(name) ||
+      isLibraryName(name) ||
+      NAMESPACES.includes(name) ||
+      DECLARATION_WORDS.includes(name)
+    );
+  }
+
+  /** A spelling no source name and no OpenScript name has, starting from `base`. */
+  fresh(base: string): string {
+    let candidate = base;
+    for (let n = 2; this.#taken.has(candidate) || Namer.reserved(candidate); n += 1) {
+      candidate = `${base}${canonicalNumber(n)}`;
+    }
+    this.#taken.add(candidate);
+    return candidate;
+  }
+
+  /**
+   * The spelling of a source name declared in `scope`.
+   *
+   * `hides` says whether an enclosing scope can already see the name, which is
+   * the case the source dialect reads as a new name and OpenScript would read
+   * as an update of the old one.
+   */
+  declare(name: string, hides: boolean): string {
+    if (Namer.reserved(name)) return this.fresh(`${name}Value`);
+    if (hides) return this.fresh(name);
+    return name;
+  }
+}
+
+/** A binding with the defaults a plain declaration has. */
+export function binding(output: string, kind: BindingKind, topLevel: boolean): Binding {
+  return { output, kind, topLevel, handle: undefined, present: false, whole: false, labels: undefined };
+}

package/src/core/importer/orders.ts

@@ -0,0 +1,307 @@
+/**
+ * The declaration, and the calls that trade.
+ *
+ * **The declaration** is written from the source's options where OpenScript
+ * has the same option (`language.md` 13.2 and 13.3), and every default the two
+ * languages disagree about is written out rather than left to the default: the
+ * source dialect starts a strategy with a million in capital where OpenScript
+ * starts with a hundred thousand, so a strategy that names no capital is given
+ * the source's. An option with no equivalent is left out of the declaration,
+ * because the file needs it, with OS9006 where it changes what is computed or
+ * traded and OS9009 where it changes only what is shown.
+ *
+ * **An entry** in the source dialect closes an opposite position before it
+ * opens its own, and is ignored while a position on its side is already held at
+ * the default pyramiding. It is written as exactly that: a `close()` behind a
+ * guard on the opposite side, then the entry behind a guard on its own side.
+ * **An exit** that names its entry is guarded by that entry's side, so that the
+ * levels of a long exit and a short exit do not replace each other on every
+ * bar, and a profit or loss given in ticks is converted to a price distance by
+ * the instrument's tick size. Every order call raises OS9010 once, because the
+ * two order models are close and are not the same.
+ */
+import { diagnosticFor } from '../diagnostics/index.js';
+import { bind } from './calls.js';
+import type { Bound } 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 { PREC, numberText, translate, wrap } from './values.js';
+
+/** The capital a source strategy starts with when it names none. */
+const SOURCE_CAPITAL = '1000000';
+
+const DECLARATION_POSITIONAL = ['title', 'shorttitle', 'overlay', 'format', 'precision'];
+
+const DISPLAY = new Set([
+  'max_bars_back', 'explicit_plot_zorder', 'max_lines_count', 'max_labels_count', 'max_boxes_count',
+  'max_polylines_count', 'dynamic_requests', 'behind_chart', 'risk_free_rate', 'calc_bars_count',
+]);
+
+/** Options that change what is computed or traded, with the literal that changes nothing. */
+const INERT: Readonly<Record<string, string>> = {
+  timeframe: '""',
+  timeframe_gaps: 'true',
+  calc_on_order_fills: 'false',
+  calc_on_every_tick: 'false',
+  use_bar_magnifier: 'false',
+  fill_orders_on_standard_ohlc: 'false',
+  backtest_fill_limits_assumption: '0',
+  close_entries_rule: '"FIFO"',
+  margin_long: 'margin',
+  margin_short: 'margin',
+};
+
+const QTY_TYPES: Readonly<Record<string, string>> = { fixed: 'units', cash: 'cash', percent_of_equity: 'equityPercent' };
+const COMMISSIONS: Readonly<Record<string, string>> = { percent: 'percent', cash_per_order: 'perTrade', cash_per_contract: 'perUnit' };
+
+function literalOf(expr: Expr | undefined): string | undefined {
+  if (expr === undefined) return undefined;
+  if (expr.kind === 'number') return numberText(expr.text);
+  if (expr.kind === 'bool') return String(expr.value);
+  if (expr.kind === 'string') return quoted(expr.value);
+  if (expr.kind === 'unary' && expr.op === '-' && expr.operand.kind === 'number') return `-${numberText(expr.operand.text)}`;
+  return undefined;
+}
+
+function constantOf(expr: Expr | undefined, prefix: string): string | undefined {
+  const path = expr === undefined ? undefined : pathOf(expr);
+  return path?.startsWith(prefix) ? path.slice(prefix.length) : undefined;
+}
+
+/** The declaration line, with every option it can carry. */
+export function declarationLine(ctx: Context, call: CallExpr, path: string): string {
+  const strategy = path === 'strategy';
+  const bound = bind(call, DECLARATION_POSITIONAL);
+  const cannot = (arg: Arg, name: string): void =>
+    ctx.note(diagnosticFor('OS9006', ctx.span(arg.at), { argument: name, call: path }));
+  const shownOnly = (arg: Arg, name: string): void =>
+    ctx.note(diagnosticFor('OS9009', ctx.span(arg.at), { argument: name, call: path }));
+
+  for (const one of bound.stray) cannot(one.arg, one.name);
+  const titleArg = bound.byName.get('title');
+  let title = titleArg?.value.kind === 'string' ? titleArg.value.value : undefined;
+  if (title === undefined) {
+    if (titleArg !== undefined) cannot(titleArg, 'title');
+    title = 'Imported script';
+  }
+  const options: string[] = [quoted(title)];
+  const put = (name: string, value: string): void => {
+    options.push(`${name} = ${value}`);
+  };
+
+  const commission = { type: undefined as string | undefined, given: false };
+  for (const [name, arg] of bound.byName) {
+    const literal = literalOf(arg.value);
+    switch (name) {
+      case 'title':
+        continue;
+      case 'shorttitle':
+        if (arg.value.kind === 'string') put('short', literal ?? '""');
+        else shownOnly(arg, name);
+        continue;
+      case 'overlay':
+        if (arg.value.kind === 'bool') put('overlay', literal ?? 'false');
+        else shownOnly(arg, name);
+        continue;
+      case 'precision':
+        if (arg.value.kind === 'number') put('precision', literal ?? '4');
+        else shownOnly(arg, name);
+        continue;
+      case 'format':
+      case 'scale': {
+        const word = constantOf(arg.value, `${name}.`);
+        const known = name === 'format' ? ['price', 'percent', 'volume'] : ['right', 'left', 'none'];
+        if (word !== undefined && known.includes(word)) put(name, quoted(word));
+        else shownOnly(arg, name);
+        continue;
+      }
+    }
+    if (DISPLAY.has(name)) {
+      shownOnly(arg, name);
+      continue;
+    }
+    const inert = INERT[name];
+    if (inert !== undefined) {
+      if (literal !== inert) cannot(arg, name);
+      continue;
+    }
+    if (!strategy) {
+      cannot(arg, name);
+      continue;
+    }
+    const numeric = arg.value.kind === 'number' ? literal : undefined;
+    switch (name) {
+      case 'initial_capital':
+        if (numeric !== undefined) put('capital', numeric);
+        else cannot(arg, name);
+        break;
+      case 'default_qty_value':
+        if (numeric !== undefined) put('qty', numeric);
+        else cannot(arg, name);
+        break;
+      case 'default_qty_type': {
+        const type = QTY_TYPES[constantOf(arg.value, 'strategy.') ?? ''];
+        ctx.qtyInUnits = type === 'units';
+        if (type !== undefined) put('qtyType', quoted(type));
+        else cannot(arg, name);
+        break;
+      }
+      case 'pyramiding':
+        if (numeric !== undefined && Number(numeric) <= 1) break;
+        if (numeric !== undefined) {
+          ctx.pyramiding = Number(numeric);
+          put('pyramiding', numeric);
+        }
+        cannot(arg, name);
+        break;
+      case 'currency': {
+        const code = constantOf(arg.value, 'currency.');
+        if (code === undefined) shownOnly(arg, name);
+        else if (code !== 'NONE') put('currency', quoted(code));
+        break;
+      }
+      case 'slippage':
+        if (numeric !== undefined) put('slippage', numeric);
+        else cannot(arg, name);
+        break;
+      case 'commission_type':
+        commission.type = COMMISSIONS[constantOf(arg.value, 'strategy.commission.') ?? ''];
+        if (commission.type === undefined) cannot(arg, name);
+        break;
+      case 'commission_value':
+        if (numeric !== undefined) {
+          put('commission', numeric);
+          commission.given = true;
+        } else cannot(arg, name);
+        break;
+      case 'process_orders_on_close':
+        if (literal === 'true') put('fillOn', '"close"');
+        else if (literal !== 'false') cannot(arg, name);
+        break;
+      default:
+        cannot(arg, name);
+    }
+  }
+  if (strategy) {
+    if (!bound.byName.has('initial_capital')) put('capital', SOURCE_CAPITAL);
+    if (commission.given) put('commissionType', quoted(commission.type ?? 'percent'));
+  }
+  return `${strategy ? 'strategy' : 'study'}(${options.join(', ')})`;
+}
+
+/** OS9010, once per order call. */
+function orderNote(ctx: Context, call: CallExpr, path: string): void {
+  ctx.note(diagnosticFor('OS9010', ctx.span(call.callee.at), { call: path }), `OS9010 ${path}`);
+}
+
+/**
+ * Refuses the first argument that changes the order with no equivalent, and
+ * reports every one that changes only its label. Returns whether to go on.
+ */
+function sortArguments(ctx: Context, path: string, bound: Bound, carried: readonly string[], refused: readonly string[]): boolean {
+  const first = bound.stray[0];
+  if (first !== undefined) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(first.arg.at), { argument: first.name, call: path }));
+    return false;
+  }
+  for (const [name, arg] of bound.byName) {
+    if (carried.includes(name)) continue;
+    if (refused.includes(name) || !(name.startsWith('comment') || name.startsWith('alert') || name === 'disable_alert')) {
+      ctx.refuse(diagnosticFor('OS9006', ctx.span(arg.at), { argument: name, call: path }));
+      return false;
+    }
+    ctx.note(diagnosticFor('OS9009', ctx.span(arg.at), { argument: name, call: path }));
+  }
+  return true;
+}
+
+function required(ctx: Context, call: CallExpr, path: string, bound: Bound, name: string): string | undefined {
+  const arg = bound.byName.get(name);
+  if (arg !== undefined) return translate(ctx, arg.value).text;
+  ctx.refuse(diagnosticFor('OS9006', ctx.span(call.at), { argument: name, call: path }));
+  return undefined;
+}
+
+export function entryLines(ctx: Context, call: CallExpr, path: string, depth: number): OutLine[] {
+  const bound = bind(call, ['id', 'direction', 'qty', 'limit', 'stop']);
+  if (!sortArguments(ctx, path, bound, ['id', 'direction', 'qty'], ['limit', 'stop', 'oca_name', 'oca_type'])) return [];
+  const tag = required(ctx, call, path, bound, 'id');
+  const direction = constantOf(bound.byName.get('direction')?.value, 'strategy.');
+  if (tag === undefined) return [];
+  if (direction !== 'long' && direction !== 'short') {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(bound.byName.get('direction')?.at ?? call.at), { argument: 'direction', call: path }));
+    return [];
+  }
+  const qty = bound.byName.get('qty');
+  if (qty !== undefined && !ctx.qtyInUnits) {
+    ctx.refuse(diagnosticFor('OS9006', ctx.span(qty.at), { argument: 'qty', call: path }));
+    return [];
+  }
+  orderNote(ctx, call, path);
+  const args = qty === undefined ? `tag = ${tag}` : `qty = ${translate(ctx, qty.value).text}, tag = ${tag}`;
+  const long = direction === 'long';
+  const lines: OutLine[] = [
+    { depth, text: `if pos.size ${long ? '<' : '>'} 0` },
+    { depth: depth + 1, text: 'close()' },
+  ];
+  if (ctx.pyramiding <= 1) {
+    lines.push({ depth, text: `if pos.size ${long ? '<=' : '>='} 0` }, { depth: depth + 1, text: `${long ? 'buy' : 'sell'}(${args})` });
+  } else {
+    lines.push({ depth, text: `${long ? 'buy' : 'sell'}(${args})` });
+  }
+  return lines;
+}
+
+export function closeLines(ctx: Context, call: CallExpr, path: string, depth: number): OutLine[] {
+  const all = path === 'strategy.close_all';
+  const bound = bind(call, all ? [] : ['id']);
+  if (!sortArguments(ctx, path, bound, ['id'], ['qty', 'qty_percent', 'immediately'])) return [];
+  if (all) {
+    orderNote(ctx, call, path);
+    return [{ depth, text: 'close()' }];
+  }
+  const tag = required(ctx, call, path, bound, 'id');
+  if (tag === undefined) return [];
+  orderNote(ctx, call, path);
+  return [{ depth, text: `close(tag = ${tag})` }];
+}
+
+export function exitLines(ctx: Context, call: CallExpr, path: string, depth: number): OutLine[] {
+  const bound = bind(call, ['id', 'from_entry', 'qty', 'qty_percent', 'profit', 'limit', 'loss', 'stop']);
+  const carried = ['id', 'from_entry', 'profit', 'limit', 'loss', 'stop'];
+  const refused = ['qty', 'qty_percent', 'trail_price', 'trail_points', 'trail_offset', 'oca_name'];
+  if (!sortArguments(ctx, path, bound, carried, refused)) return [];
+  for (const [distance, price] of [['profit', 'limit'], ['loss', 'stop']] as const) {
+    const both = bound.byName.get(distance);
+    if (both !== undefined && bound.byName.has(price)) {
+      ctx.refuse(diagnosticFor('OS9006', ctx.span(both.at), { argument: distance, call: path }));
+      return [];
+    }
+  }
+  const tag = required(ctx, call, path, bound, 'id');
+  if (tag === undefined) return [];
+  let guard: string | undefined;
+  const from = bound.byName.get('from_entry');
+  if (from !== undefined) {
+    const side = from.value.kind === 'string' ? ctx.facts.entries.get(from.value.value) : undefined;
+    if (side === undefined) {
+      ctx.refuse(diagnosticFor('OS9006', ctx.span(from.at), { argument: 'from_entry', call: path }));
+      return [];
+    }
+    guard = side === 'long' ? 'if pos.size >= 0' : 'if pos.size <= 0';
+  }
+  const parts = [`tag = ${tag}`];
+  for (const name of ['stop', 'limit']) {
+    const arg = bound.byName.get(name);
+    if (arg !== undefined) parts.push(`${name} = ${translate(ctx, arg.value).text}`);
+  }
+  for (const name of ['profit', 'loss']) {
+    const arg = bound.byName.get(name);
+    if (arg !== undefined) parts.push(`${name} = ${wrap(translate(ctx, arg.value), PREC.multiplicative)} * chart.tickSize`);
+  }
+  orderNote(ctx, call, path);
+  const line = `exit(${parts.join(', ')})`;
+  return guard === undefined ? [{ depth, text: line }] : [{ depth, text: guard }, { depth: depth + 1, text: line }];
+}