openalgo-script 0.1.0-alpha.1 → 0.4.0

package/dist/core/check/declaration.js

@@ -0,0 +1,181 @@
+import { withoutGrouping } from '../ast/index.js';
+import { bindArguments } from './arguments.js';
+import { validateArguments } from './calls.js';
+import { literalNumber } from './literals.js';
+import { TOP_LEVEL } from './checker.js';
+import { checkExpression } from './expressions.js';
+import { entry, wholeRange } from './library.js';
+import { CATALOGUE_LANGUAGE_VERSION } from '../catalogue/index.js';
+const STUDY_OPTIONS = 'title: string, short?: string, overlay?: bool, precision?: number, format?: string, ' +
+    'range?: array<number>, scale?: string, group?: string, onUnconfirmed?: bool';
+const STRATEGY_OPTIONS = 'capital?: number, currency?: string, qty?: number, qtyType?: string, product?: string, ' +
+    'fillOn?: string, slippage?: number, commission?: number, commissionType?: string, ' +
+    'pyramiding?: number, closeOnSessionEnd?: bool';
+const SHARED = {
+    values: {
+        format: ['price', 'percent', 'volume'],
+        scale: ['right', 'left', 'none'],
+        qtyType: ['units', 'lots', 'cash', 'equityPercent'],
+        product: ['intraday', 'overnight'],
+        fillOn: ['nextOpen', 'close'],
+        commissionType: ['perTrade', 'perUnit', 'percent'],
+    },
+    whole: { precision: wholeRange(0, 10), pyramiding: wholeRange(1) },
+};
+/** Every option value is read once, before the first bar, so all are constant. */
+function constantNames(signature) {
+    return signature
+        .split(',')
+        .map((part) => part.split(':')[0]?.trim().replace('?', '') ?? '')
+        .filter((name) => name.length > 0);
+}
+const STUDY = entry(`study(${STUDY_OPTIONS}) -> nothing`, {
+    ...SHARED,
+    constant: constantNames(STUDY_OPTIONS),
+});
+const STRATEGY = entry(`strategy(${STUDY_OPTIONS}, ${STRATEGY_OPTIONS}) -> nothing`, {
+    ...SHARED,
+    constant: [...constantNames(STUDY_OPTIONS), ...constantNames(STRATEGY_OPTIONS)],
+});
+/** The options of `limits()`, `language.md` 10.7. */
+const LIMITS = entry('limits(loops?: number, history?: number) -> nothing');
+/**
+ * Finds the file's declaration and reads the two options every later rule needs.
+ *
+ * This runs before anything else is checked, because OS7001 has to know whether
+ * the file is a strategy and OS8002 has to know whether it runs on a bar that
+ * is still moving, and both questions are asked of lines above the declaration
+ * as readily as of lines below it.
+ */
+export function readHeader(checker, script) {
+    const declarations = script.items.filter((item) => item.kind === 'scriptDeclaration');
+    const first = declarations[0];
+    if (first === undefined) {
+        checker.report('OS2007', script.span, {});
+    }
+    else {
+        checker.declaration = {
+            node: first,
+            form: first.form,
+            title: stringOption(first, 'title', 0) ?? '',
+            options: optionsOf(first),
+            overlay: booleanOption(first, 'overlay') === true,
+            onUnconfirmed: booleanOption(first, 'onUnconfirmed') === true,
+        };
+    }
+    for (const extra of declarations.slice(1)) {
+        checker.report('OS2008', extra.span, {
+            kind: first?.form ?? extra.form,
+            line: first?.span.line ?? extra.span.line,
+        });
+    }
+    if (!script.items.some((item) => item.kind === 'versionLine')) {
+        checker.report('OS8003', script.span, { version: CATALOGUE_LANGUAGE_VERSION });
+    }
+}
+/** The declaration's own arguments, checked where the declaration is written. */
+export function checkDeclaration(checker, node) {
+    for (const argument of node.args)
+        checkExpression(checker, argument.value, TOP_LEVEL);
+    const shape = node.form === 'strategy' ? STRATEGY : STUDY;
+    const parameters = shape.parameters.map((one) => ({
+        name: one.name,
+        optional: one.optional,
+    }));
+    const filled = bindArguments(checker, node.span, node.args, node.form, parameters);
+    validateArguments(checker, shape, filled, new Map());
+    checkRangeOption(checker, shape, filled);
+}
+/**
+ * `range = [min, max]`, which is two numbers with the first below the second.
+ *
+ * OS3016 rather than OS3011, because the shape is right and the contents are
+ * not, and a reader given "array<number> was expected" would look at the wrong
+ * thing.
+ */
+function checkRangeOption(checker, shape, filled) {
+    const index = shape.parameters.findIndex((one) => one.name === 'range');
+    const argument = index < 0 ? undefined : filled[index];
+    if (argument === undefined)
+        return;
+    const literal = withoutGrouping(argument.value);
+    if (literal.kind !== 'arrayLiteral')
+        return;
+    const low = literal.elements[0] === undefined ? undefined : literalNumber(literal.elements[0]);
+    const high = literal.elements[1] === undefined ? undefined : literalNumber(literal.elements[1]);
+    const wrong = literal.elements.length !== 2 ||
+        low === undefined ||
+        high === undefined ||
+        low >= high;
+    if (!wrong)
+        return;
+    checker.report('OS3016', literal.span, {
+        low: literal.elements[0] === undefined ? '' : checker.textOf(literal.elements[0].span),
+        high: literal.elements[1] === undefined ? '' : checker.textOf(literal.elements[1].span),
+    });
+}
+/**
+ * `limits()`, which appears at most once and immediately after the declaration.
+ *
+ * Its values are literal numbers rather than compile-time constants, because
+ * the host is asked whether it will run them before the program is loaded and
+ * an `input()` is not resolved that early.
+ */
+export function checkLimits(checker, node, script, seen) {
+    for (const argument of node.args)
+        checkExpression(checker, argument.value, TOP_LEVEL);
+    const parameters = LIMITS.parameters.map((one) => ({
+        name: one.name,
+        optional: one.optional,
+    }));
+    const filled = bindArguments(checker, node.span, node.args, 'limits', parameters);
+    validateArguments(checker, LIMITS, filled, new Map());
+    if (seen || !immediatelyAfterDeclaration(script, node)) {
+        checker.report('OS3014', node.span, { line: node.span.line });
+    }
+    for (let i = 0; i < LIMITS.parameters.length; i += 1) {
+        const parameter = LIMITS.parameters[i];
+        const argument = filled[i];
+        if (parameter === undefined || argument === undefined)
+            continue;
+        if (literalNumber(argument.value) === undefined) {
+            checker.report('OS3015', argument.span, { option: parameter.name });
+        }
+    }
+}
+function immediatelyAfterDeclaration(script, node) {
+    const index = script.items.indexOf(node);
+    const before = index <= 0 ? undefined : script.items[index - 1];
+    return before?.kind === 'scriptDeclaration';
+}
+function optionsOf(node) {
+    const options = new Map();
+    let positional = 0;
+    for (const argument of node.args) {
+        if (argument.label === undefined) {
+            if (positional === 0)
+                options.set('title', argument.value);
+            positional += 1;
+            continue;
+        }
+        options.set(argument.label.text, argument.value);
+    }
+    return options;
+}
+function stringOption(node, name, position) {
+    const labelled = node.args.find((one) => one.label?.text === name);
+    const positional = node.args.filter((one) => one.label === undefined)[position];
+    const chosen = labelled ?? positional;
+    if (chosen === undefined)
+        return undefined;
+    const inner = withoutGrouping(chosen.value);
+    return inner.kind === 'stringLiteral' ? inner.value : undefined;
+}
+function booleanOption(node, name) {
+    const labelled = node.args.find((one) => one.label?.text === name);
+    if (labelled === undefined)
+        return undefined;
+    const inner = withoutGrouping(labelled.value);
+    return inner.kind === 'booleanLiteral' ? inner.value : undefined;
+}
+//# sourceMappingURL=declaration.js.map

package/dist/core/check/declaration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.js","sourceRoot":"","sources":["../../../src/core/check/declaration.ts"],"names":[],"mappings":"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"}

package/dist/core/check/expressions.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Typing an expression, and working out the first bar it can produce a value
+ * for.
+ *
+ * Every expression the pass reaches gets an answer recorded against it, and an
+ * expression something was already reported about gets `unknown`, which
+ * satisfies everything above it. That is what keeps one mistake to one
+ * diagnostic: a trader with three mistakes sees three, and a trader with one
+ * does not see the operator above it complaining as well.
+ *
+ * `language.md` sections 6 and 9 are the rules; the absence rules in particular
+ * are not implemented anywhere else, and each one is cited where it is used.
+ */
+import type { Expression } from '../ast/index.js';
+import type { Checker, Placement } from './checker.js';
+import type { Type } from './types.js';
+/**
+ * An expression, and the answer to whether it may stand where it was written.
+ *
+ * A declaration handle is the one type that is not a value (`language.md` 5.4),
+ * so the type the pass works out is checked against the closed list of places
+ * one may be written before it is handed to the rule above. Refusing here
+ * rather than at each consumer is what makes the refusal hold for a position
+ * nobody enumerated; `handles.ts` says why that matters.
+ */
+export declare function checkExpression(checker: Checker, expression: Expression, placement: Placement): Type;
+/**
+ * A condition, `language.md` 6.6: `bool` or absent, and nothing else.
+ *
+ * There is no truthiness in this language. A zero is not false and an empty
+ * string is not false, because every silent coercion rule anywhere is a source
+ * of bugs that survive review, and a script that places orders is the last
+ * place to want one.
+ */
+export declare function checkCondition(checker: Checker, condition: Expression, placement: Placement): void;
+//# sourceMappingURL=expressions.d.ts.map

package/dist/core/check/expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../../src/core/check/expressions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAU,UAAU,EAAuC,MAAM,iBAAiB,CAAC;AAK/F,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAMvD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAyBvC;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,SAAS,GACnB,IAAI,CAIN;AAsDD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,UAAU,EACrB,SAAS,EAAE,SAAS,GACnB,IAAI,CAQN"}

package/dist/core/check/expressions.js

@@ -0,0 +1,398 @@
+import { withoutGrouping } from '../ast/index.js';
+import { resolveCall } from './call-sites.js';
+import { warmupOfElement } from './call-warmup.js';
+import { inputHeldBy } from './checked.js';
+import { reportStrategyOnly } from './checker.js';
+import { allowHandle, handleAllowed, refuseHandle } from './handles.js';
+import { literalNumber } from './literals.js';
+import { isNamespace, libraryEntries, membersOf } from './surface.js';
+import { closestName } from './suggest.js';
+import { BOOL, COLOR, NONE, NUMBER, STRING, UNKNOWN, arrayOf, canBeArrayElement, compatible, elementOf, isSeries, join, sameType, seriesOf, typeText, } from './types.js';
+import { BAR_ZERO, NEVER, allOf, delayed, earlier, later, weaken } from './warmup.js';
+const ARITHMETIC = new Set(['+', '-', '*', '/', '%']);
+const COMPARISON = new Set(['<', '<=', '>', '>=']);
+const EQUALITY = new Set(['==', '!=']);
+/**
+ * An expression, and the answer to whether it may stand where it was written.
+ *
+ * A declaration handle is the one type that is not a value (`language.md` 5.4),
+ * so the type the pass works out is checked against the closed list of places
+ * one may be written before it is handed to the rule above. Refusing here
+ * rather than at each consumer is what makes the refusal hold for a position
+ * nobody enumerated; `handles.ts` says why that matters.
+ */
+export function checkExpression(checker, expression, placement) {
+    const type = checkNode(checker, expression, placement);
+    if (type.kind !== 'handle' || handleAllowed(checker, expression))
+        return type;
+    return refuseHandle(checker, expression, type);
+}
+function checkNode(checker, expression, placement) {
+    switch (expression.kind) {
+        case 'numberLiteral':
+            return checker.record(expression, NUMBER, BAR_ZERO);
+        case 'stringLiteral':
+            return checker.record(expression, STRING, BAR_ZERO);
+        case 'booleanLiteral':
+            return checker.record(expression, BOOL, BAR_ZERO);
+        case 'colorLiteral':
+            return checker.record(expression, COLOR, BAR_ZERO);
+        case 'noneLiteral':
+            return checker.record(expression, NONE, NEVER);
+        case 'missingExpression':
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        case 'grouping': {
+            const inner = checkExpression(checker, expression.expression, placement);
+            return checker.record(expression, inner, checker.warmupOf(expression.expression));
+        }
+        case 'arrayLiteral':
+            return checkArrayLiteral(checker, expression, placement);
+        case 'nameReference':
+            return checkNameReference(checker, expression);
+        case 'member':
+            return checkMember(checker, expression);
+        case 'unary':
+            return checkUnary(checker, expression, placement);
+        case 'binary':
+            return checkBinary(checker, expression, placement);
+        case 'ternary': {
+            checkCondition(checker, expression.condition, placement);
+            const whenTrue = checkExpression(checker, expression.whenTrue, placement);
+            const whenFalse = checkExpression(checker, expression.whenFalse, placement);
+            // Both arms are one type, or one of them is `none` (language.md 9.5).
+            if (!compatible(whenTrue, whenFalse)) {
+                checker.report('OS2012', expression.span, {
+                    leftType: typeText(whenTrue),
+                    rightType: typeText(whenFalse),
+                });
+                return checker.record(expression, UNKNOWN, BAR_ZERO);
+            }
+            const warmup = weaken(earlier(checker.warmupOf(expression.whenTrue), checker.warmupOf(expression.whenFalse)));
+            return checker.record(expression, join(whenTrue, whenFalse), warmup);
+        }
+        case 'call':
+            return resolveCall(checker, expression, placement);
+        case 'index':
+            return checkIndex(checker, expression, placement);
+    }
+}
+/**
+ * A condition, `language.md` 6.6: `bool` or absent, and nothing else.
+ *
+ * There is no truthiness in this language. A zero is not false and an empty
+ * string is not false, because every silent coercion rule anywhere is a source
+ * of bugs that survive review, and a script that places orders is the last
+ * place to want one.
+ */
+export function checkCondition(checker, condition, placement) {
+    const type = checkExpression(checker, condition, placement);
+    if (type.kind === 'unknown' || type.kind === 'none')
+        return;
+    if (elementOf(type).kind === 'bool')
+        return;
+    checker.report('OS2011', condition.span, {
+        type: typeText(type),
+        name: checker.textOf(condition.span),
+    });
+}
+function checkArrayLiteral(checker, expression, placement) {
+    // A handle may be named here so that the answer is OS2019, which says an
+    // array cannot hold one and where to put the declaration instead
+    // (`language.md` 5.4 and 14.1).
+    const types = expression.elements.map((element) => {
+        allowHandle(checker, element);
+        return elementOf(checkExpression(checker, element, placement));
+    });
+    const warmup = allOf(expression.elements.map((element) => checker.warmupOf(element)));
+    // An empty literal takes its element type from an annotation or from the
+    // first insertion (language.md 14.1); until then it is unknown, and OS2015
+    // is reported at the end of the check if nothing ever fixed it.
+    if (types.length === 0)
+        return checker.record(expression, arrayOf(UNKNOWN), BAR_ZERO);
+    const first = types.find((one) => one.kind !== 'none' && one.kind !== 'unknown') ?? UNKNOWN;
+    for (let i = 0; i < types.length; i += 1) {
+        const other = types[i];
+        if (other === undefined || other.kind === 'none' || other.kind === 'unknown')
+            continue;
+        if (sameType(first, other))
+            continue;
+        const element = expression.elements[i];
+        checker.report('OS2013', element?.span ?? expression.span, {
+            firstType: typeText(first),
+            otherType: typeText(other),
+            index: i,
+        });
+        // Unknown rather than an array of unknown, so the name this literal is
+        // assigned to does not also collect OS2015 for a type nobody can supply.
+        return checker.record(expression, UNKNOWN, warmup);
+    }
+    if (!canBeArrayElement(first)) {
+        checker.report('OS2019', expression.span, { type: typeText(first) });
+        return checker.record(expression, UNKNOWN, warmup);
+    }
+    return checker.record(expression, arrayOf(first), warmup);
+}
+function checkNameReference(checker, expression) {
+    const binding = checker.lookup(expression.name);
+    if (binding !== undefined) {
+        if (binding.kind === 'function') {
+            checker.report('OS2014', expression.span, { name: expression.name });
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        }
+        // A request expression is compiled over another instrument's bars, so a
+        // name computed on this chart's has no counterpart there (stdlib.md 15.4).
+        // An input is a compile-time constant and is allowed; a `var` initialised
+        // from one is not, because a later assignment may change it.
+        if (checker.requestDepth > 0 &&
+            inputHeldBy(binding) === undefined &&
+            binding.kind !== 'parameter') {
+            checker.report('OS6003', expression.span, { name: expression.name });
+        }
+        binding.isRead = true;
+        checker.references.set(expression, binding);
+        return checker.record(expression, binding.type, binding.warmup);
+    }
+    const entries = libraryEntries(expression.name);
+    const value = entries.find((one) => !one.callable);
+    if (value === undefined) {
+        if (entries.length > 0) {
+            // A library function named bare: `ema` on its own is not a value.
+            checker.report('OS2014', expression.span, { name: expression.name });
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        }
+        checker.report('OS2001', expression.span, {
+            name: expression.name,
+            suggestion: checker.suggestionFor(expression.name),
+        });
+        return checker.record(expression, UNKNOWN, BAR_ZERO);
+    }
+    if (value.planned) {
+        checker.report('OS2020', expression.span, { name: expression.name });
+    }
+    reportStrategyOnly(checker, expression.name, expression.span, value.strategyOnly);
+    const warmup = value.warmup.kind === 'data' ? weaken(BAR_ZERO) : BAR_ZERO;
+    return checker.record(expression, value.returns, warmup);
+}
+function checkMember(checker, expression) {
+    const object = withoutGrouping(expression.object);
+    const written = object.kind === 'nameReference' ? object.name : checker.textOf(object.span);
+    const member = expression.member.text;
+    const full = `${written}.${member}`;
+    if (object.kind !== 'nameReference' || !isNamespace(written)) {
+        checker.report('OS2009', expression.member.span, {
+            namespace: written,
+            member,
+            suggestion: closestName(member, membersOf(written)),
+        });
+        return checker.record(expression, UNKNOWN, BAR_ZERO);
+    }
+    const entries = libraryEntries(full);
+    const value = entries.find((one) => !one.callable);
+    if (value === undefined) {
+        if (entries.length > 0) {
+            checker.report('OS2014', expression.span, { name: full });
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        }
+        checker.report('OS2009', expression.member.span, {
+            namespace: written,
+            member,
+            suggestion: closestName(member, membersOf(written)),
+        });
+        return checker.record(expression, UNKNOWN, BAR_ZERO);
+    }
+    if (value.planned) {
+        checker.report('OS2020', expression.span, { name: full });
+    }
+    reportStrategyOnly(checker, full, expression.span, value.strategyOnly);
+    const warmup = value.warmup.kind === 'data' ? weaken(BAR_ZERO) : BAR_ZERO;
+    return checker.record(expression, value.returns, warmup);
+}
+function checkUnary(checker, expression, placement) {
+    const operand = checkExpression(checker, expression.operand, placement);
+    const warmup = checker.warmupOf(expression.operand);
+    const element = elementOf(operand);
+    const wrap = (type) => (isSeries(operand) ? seriesOf(type) : type);
+    if (expression.operator === 'not') {
+        if (element.kind !== 'bool' && element.kind !== 'none' && element.kind !== 'unknown') {
+            checker.report('OS2011', expression.span, {
+                type: typeText(operand),
+                name: checker.textOf(expression.operand.span),
+            });
+            return checker.record(expression, UNKNOWN, warmup);
+        }
+        // `not none` is none (language.md 6.6), so absence carries through.
+        return checker.record(expression, wrap(BOOL), warmup);
+    }
+    if (element.kind !== 'number' && element.kind !== 'none' && element.kind !== 'unknown') {
+        checker.report('OS2003', expression.span, {
+            leftType: typeText(NUMBER),
+            rightType: typeText(operand),
+        });
+        return checker.record(expression, UNKNOWN, warmup);
+    }
+    return checker.record(expression, wrap(NUMBER), warmup);
+}
+function checkBinary(checker, expression, placement) {
+    const left = checkExpression(checker, expression.left, placement);
+    const right = checkExpression(checker, expression.right, placement);
+    const leftWarmup = checker.warmupOf(expression.left);
+    const rightWarmup = checker.warmupOf(expression.right);
+    const series = isSeries(left) || isSeries(right);
+    const wrap = (type) => (series ? seriesOf(type) : type);
+    const a = elementOf(left);
+    const b = elementOf(right);
+    const soft = (type) => type.kind === 'none' || type.kind === 'unknown';
+    if (ARITHMETIC.has(expression.operator)) {
+        // `+` also concatenates two strings and does nothing else (language.md 9.2).
+        const strings = expression.operator === '+' && (a.kind === 'string' || b.kind === 'string');
+        const wanted = strings ? STRING : NUMBER;
+        const fits = (type) => soft(type) || type.kind === wanted.kind;
+        if (!fits(a) || !fits(b)) {
+            checker.report('OS2003', expression.span, {
+                leftType: typeText(left),
+                rightType: typeText(right),
+            });
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        }
+        // Absence propagates through arithmetic (language.md 6.2), so the result
+        // waits for both sides.
+        return checker.record(expression, wrap(wanted), later(leftWarmup, rightWarmup));
+    }
+    if (COMPARISON.has(expression.operator)) {
+        const ordered = (type) => soft(type) || type.kind === 'number' || type.kind === 'string';
+        if (!ordered(a) || !ordered(b) || (!soft(a) && !soft(b) && a.kind !== b.kind)) {
+            checker.report('OS2003', expression.span, {
+                leftType: typeText(left),
+                rightType: typeText(right),
+            });
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        }
+        if (isNoneLiteral(expression.left) || isNoneLiteral(expression.right)) {
+            checker.report('OS8012', expression.span, { op: expression.operator });
+        }
+        // Absence propagates through ordering as well (language.md 6.4).
+        return checker.record(expression, wrap(BOOL), later(leftWarmup, rightWarmup));
+    }
+    if (EQUALITY.has(expression.operator)) {
+        if (!compatible(left, right)) {
+            checker.report('OS2003', expression.span, {
+                leftType: typeText(left),
+                rightType: typeText(right),
+            });
+            return checker.record(expression, UNKNOWN, BAR_ZERO);
+        }
+        // Equality is total under absence (language.md 6.5): it answers on bar 0.
+        return checker.record(expression, wrap(BOOL), BAR_ZERO);
+    }
+    const boolean = (type) => soft(type) || type.kind === 'bool';
+    if (!boolean(a)) {
+        checker.report('OS2011', expression.left.span, {
+            type: typeText(left),
+            name: checker.textOf(expression.left.span),
+        });
+        return checker.record(expression, UNKNOWN, BAR_ZERO);
+    }
+    if (!boolean(b)) {
+        checker.report('OS2011', expression.right.span, {
+            type: typeText(right),
+            name: checker.textOf(expression.right.span),
+        });
+        return checker.record(expression, UNKNOWN, BAR_ZERO);
+    }
+    // `and` and `or` are three-valued and short-circuit (language.md 6.6 and
+    // 9.4): one decisive operand settles the answer, so the earlier of the two
+    // is a floor on when there is one, and it is only a floor.
+    return checker.record(expression, wrap(BOOL), weaken(earlier(leftWarmup, rightWarmup)));
+}
+function isNoneLiteral(expression) {
+    return withoutGrouping(expression).kind === 'noneLiteral';
+}
+/**
+ * `a[i]`: history when `a` is a series, element access when it is an array.
+ *
+ * `language.md` 9.6 settles which at compile time from the type of `a`, so
+ * there is no run-time dispatch. What has history at all is 5.2's list of four,
+ * and `hasHistory` below is that list; anything else is OS2004, whose fix is to
+ * give the value a name at the top level of the file.
+ *
+ * Neither kind of thing in 5.4 has history, and a name holding one of them sits
+ * at the top level, which is why the two are refused by name here rather than
+ * left to `hasHistory`: a handle has no per-bar value to retain, and an object
+ * is one reference that the script mutates rather than a value per bar.
+ */
+function checkIndex(checker, expression, placement) {
+    // A handle is allowed to be named here so that this reads it and says the
+    // thing a reader needs, which is that it has no history; refusing it as a
+    // value first would answer a question nobody asked.
+    allowHandle(checker, expression.target);
+    const target = checkExpression(checker, expression.target, placement);
+    checkExpression(checker, expression.index, placement);
+    const targetWarmup = checker.warmupOf(expression.target);
+    if (target.kind === 'unknown')
+        return checker.record(expression, UNKNOWN, targetWarmup);
+    if (elementOf(target).kind === 'array') {
+        const array = elementOf(target);
+        const element = array.kind === 'array' ? array.element : UNKNOWN;
+        const warmup = elementWarmup(checker, expression) ?? targetWarmup;
+        return checker.record(expression, element, warmup);
+    }
+    const held = elementOf(target).kind;
+    if (held === 'handle' || held === 'object' || !hasHistory(checker, expression.target, target)) {
+        checker.report('OS2004', expression.span, {
+            expr: checker.textOf(expression.target.span),
+        });
+        return checker.record(expression, UNKNOWN, targetWarmup);
+    }
+    markHistoryRead(checker, expression.target);
+    const back = literalNumber(expression.index);
+    // `x[n]` past the start of the dataset is absent, not an error (7.4), so the
+    // value it reads is available n bars after the value itself is.
+    const warmup = back === undefined ? weaken(targetWarmup) : delayed(targetWarmup, back);
+    return checker.record(expression, elementOf(target), warmup);
+}
+/**
+ * The warmup of one output of a multi-output call, where this reads one.
+ *
+ * `stdlib.md` 2.3 gives each element its own warmup, and the array's is the
+ * earliest of them, so `m[1]` read through the array's would claim a value for
+ * bars where the signal line is still absent and a read built on it would ask a
+ * host for too little history. Nothing here when the index is not a written
+ * number or the call states one warmup for every element: the array's is then
+ * the element's, and the caller uses it.
+ */
+function elementWarmup(checker, expression) {
+    const index = literalNumber(expression.index);
+    if (index === undefined || !Number.isInteger(index) || index < 0)
+        return undefined;
+    const inner = withoutGrouping(expression.target);
+    const call = inner.kind === 'call'
+        ? checker.callSites.get(inner)
+        : inner.kind === 'nameReference'
+            ? checker.multiOutputOf(inner.name)
+            : undefined;
+    return call === undefined ? undefined : warmupOfElement(checker, call, index);
+}
+/** The four cases of language.md 5.2, and nothing else. */
+function hasHistory(checker, target, type) {
+    const inner = withoutGrouping(target);
+    if (inner.kind === 'call' || inner.kind === 'member')
+        return isSeries(type);
+    if (inner.kind !== 'nameReference')
+        return false;
+    const binding = checker.lookup(inner.name);
+    if (binding === undefined)
+        return isSeries(type);
+    if (binding.kind === 'file')
+        return true;
+    return binding.kind === 'parameter' && isSeries(binding.type);
+}
+/** Records that a name's past is read, which is what allocates it a register. */
+function markHistoryRead(checker, target) {
+    const inner = withoutGrouping(target);
+    if (inner.kind !== 'nameReference')
+        return;
+    const binding = checker.lookup(inner.name);
+    if (binding !== undefined)
+        binding.readsHistory = true;
+}
+//# sourceMappingURL=expressions.js.map