@scriptc/compiler 0.2.7 → 0.2.8

package/dist/frontend/lowering/runtime-optional-bounds.d.ts

@@ -0,0 +1,19 @@
+import * as ts from "../ts7/adapter.js";
+/** Proves that an indexed store `xs[i] = v` writes inside the array, so it
+ * cannot leave holes before index `i`. A store at an index below the
+ * length overwrites an existing slot.
+ *
+ * The proof is syntactic: a guard that dominates the store shows `i` is
+ * below `xs.length`, either a condition `i < xs.length` (`xs.length > i`)
+ * of an enclosing `if` or loop, or an earlier asserted read `xs[i]!`, which
+ * throws for a missing index. Between the guard and the store nothing may
+ * change the length or either operand: no call, construction, `await`,
+ * `yield` or `delete`, and no write of `xs`, `i` or `xs.length`. A loop
+ * crossed on the way repeats its whole body between the two. */
+export declare function indexStoreInBounds(store: ts.BinaryExpression): boolean;
+/** Proves that an element read `xs[i]` (typically `xs[i]!` forwarded to a
+ * call) names an index below the length, by the same dominating guards as
+ * indexStoreInBounds. Everything the enclosing statement evaluates before
+ * the read (a callee, earlier arguments, a left operand) joins the code
+ * that must leave the operands unchanged. */
+export declare function indexReadInBounds(read: ts.ElementAccessExpression): boolean;

package/dist/frontend/lowering/runtime-optional-bounds.js

@@ -0,0 +1,354 @@
+import * as ts from "../ts7/adapter.js";
+/** Proves that an indexed store `xs[i] = v` writes inside the array, so it
+ * cannot leave holes before index `i`. A store at an index below the
+ * length overwrites an existing slot.
+ *
+ * The proof is syntactic: a guard that dominates the store shows `i` is
+ * below `xs.length`, either a condition `i < xs.length` (`xs.length > i`)
+ * of an enclosing `if` or loop, or an earlier asserted read `xs[i]!`, which
+ * throws for a missing index. Between the guard and the store nothing may
+ * change the length or either operand: no call, construction, `await`,
+ * `yield` or `delete`, and no write of `xs`, `i` or `xs.length`. A loop
+ * crossed on the way repeats its whole body between the two. */
+export function indexStoreInBounds(store) {
+    if (store.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+        return false;
+    const target = peel(store.left);
+    if (!ts.isElementAccessExpression(target))
+        return false;
+    const array = peel(target.expression);
+    const index = peel(target.argumentExpression);
+    if (!isSimpleReference(array) || !(isSimpleReference(index) || ts.isNumericLiteral(index)))
+        return false;
+    const parent = store.parent;
+    if (!parent || !ts.isExpressionStatement(parent))
+        return false;
+    return boundedBefore(parent, { array, index }, [store.right]);
+}
+/** Proves that an element read `xs[i]` (typically `xs[i]!` forwarded to a
+ * call) names an index below the length, by the same dominating guards as
+ * indexStoreInBounds. Everything the enclosing statement evaluates before
+ * the read (a callee, earlier arguments, a left operand) joins the code
+ * that must leave the operands unchanged. */
+export function indexReadInBounds(read) {
+    if (read.questionDotToken)
+        return false;
+    const array = peel(read.expression);
+    const index = peel(read.argumentExpression);
+    if (!isSimpleReference(array) || !(isSimpleReference(index) || ts.isNumericLiteral(index)))
+        return false;
+    const before = [];
+    let child = read;
+    let parent = read.parent;
+    while (parent) {
+        if (ts.isParenthesizedExpression(parent) ||
+            ts.isNonNullExpression(parent) ||
+            ts.isAsExpression(parent) ||
+            ts.isSatisfiesExpression(parent)) {
+            // A value-preserving wrapper.
+        }
+        else if (ts.isCallExpression(parent) || ts.isNewExpression(parent)) {
+            const args = parent.arguments ?? [];
+            const at = args.indexOf(child);
+            if (at < 0 || (ts.isCallExpression(parent) && parent.questionDotToken))
+                return false;
+            before.push(parent.expression, ...args.slice(0, at));
+        }
+        else if (ts.isBinaryExpression(parent)) {
+            const op = parent.operatorToken.kind;
+            if (op >= ts.SyntaxKind.FirstAssignment && op <= ts.SyntaxKind.LastAssignment) {
+                if (parent.right !== child || !ts.isIdentifier(parent.left))
+                    return false;
+            }
+            else if (parent.right === child)
+                before.push(parent.left);
+        }
+        else if (ts.isVariableDeclaration(parent) &&
+            parent.initializer === child &&
+            ts.isVariableDeclarationList(parent.parent) &&
+            parent.parent.declarations[0] === parent &&
+            ts.isVariableStatement(parent.parent.parent)) {
+            return boundedBefore(parent.parent.parent, { array, index }, before);
+        }
+        else if ((ts.isExpressionStatement(parent) || ts.isReturnStatement(parent)) &&
+            parent.expression === child) {
+            return boundedBefore(parent, { array, index }, before);
+        }
+        else
+            return false;
+        child = parent;
+        parent = parent.parent;
+    }
+    return false;
+}
+/** A guard dominating `statement` bounds the index, and nothing between the
+ * guard and the access (`between`, plus the statements and conditions
+ * crossed) can change the operands. */
+function boundedBefore(statement, operands, start) {
+    const between = [...start];
+    let child = statement;
+    let parent = statement.parent;
+    while (parent && !isFunctionBoundary(parent)) {
+        if (isStatementList(parent)) {
+            const statements = parent.statements;
+            const at = statements.indexOf(child);
+            for (let i = at - 1; i >= 0; i--) {
+                const statement = statements[i];
+                if (assertsSlot(statement, operands) && unchanged([statement, ...between], operands))
+                    return true;
+                between.push(statement);
+            }
+        }
+        else if (ts.isIfStatement(parent)) {
+            if (child === parent.thenStatement &&
+                (assertsSlot(parent.expression, operands) || boundedBy(parent.expression, operands)) &&
+                unchanged([parent.expression, ...between], operands))
+                return true;
+            between.push(parent.expression);
+        }
+        else if (ts.isWhileStatement(parent) ||
+            ts.isForStatement(parent) ||
+            ts.isDoStatement(parent) ||
+            ts.isForOfStatement(parent) ||
+            ts.isForInStatement(parent)) {
+            const condition = ts.isWhileStatement(parent) || ts.isDoStatement(parent)
+                ? parent.expression
+                : ts.isForStatement(parent)
+                    ? parent.condition
+                    : undefined;
+            // The condition runs right before each pass over the body.
+            if (!ts.isDoStatement(parent) &&
+                child === parent.statement &&
+                condition !== undefined &&
+                boundedBy(condition, operands) &&
+                unchanged([condition, ...between], operands))
+                return true;
+            between.push(parent);
+        }
+        else if (ts.isSwitchStatement(parent)) {
+            between.push(parent.expression);
+        }
+        else if (!ts.isBlock(parent) && !ts.isLabeledStatement(parent) && !ts.isCaseBlock(parent)) {
+            return false;
+        }
+        child = parent;
+        parent = parent.parent;
+    }
+    return false;
+}
+function isFunctionBoundary(node) {
+    return (ts.isFunctionLike(node) ||
+        ts.isSourceFile(node) ||
+        ts.isClassStaticBlockDeclaration(node) ||
+        ts.isTryStatement(node) ||
+        ts.isCatchClause(node));
+}
+function isStatementList(node) {
+    return ts.isBlock(node) || ts.isCaseClause(node) || ts.isDefaultClause(node);
+}
+function peel(node) {
+    let e = node;
+    while (ts.isParenthesizedExpression(e) || ts.isNonNullExpression(e))
+        e = e.expression;
+    return e;
+}
+/** An identifier, `this`, or a property chain over one. */
+function isSimpleReference(node) {
+    const e = peel(node);
+    if (ts.isIdentifier(e) || e.kind === ts.SyntaxKind.ThisKeyword)
+        return true;
+    return ts.isPropertyAccessExpression(e) && !e.questionDotToken && isSimpleReference(e.expression);
+}
+function sameReference(a, b) {
+    const left = peel(a);
+    const right = peel(b);
+    if (ts.isIdentifier(left) && ts.isIdentifier(right))
+        return left.text === right.text;
+    if (ts.isNumericLiteral(left) && ts.isNumericLiteral(right))
+        return Number(left.text) === Number(right.text);
+    if (left.kind === ts.SyntaxKind.ThisKeyword && right.kind === ts.SyntaxKind.ThisKeyword)
+        return true;
+    if (ts.isPropertyAccessExpression(left) && ts.isPropertyAccessExpression(right))
+        return left.name.text === right.name.text && sameReference(left.expression, right.expression);
+    return false;
+}
+function isLengthOf(node, array) {
+    const e = peel(node);
+    return (ts.isPropertyAccessExpression(e) &&
+        e.name.text === "length" &&
+        sameReference(e.expression, array));
+}
+/** `condition` holding proves `index < array.length`. */
+function boundedBy(condition, { array, index }) {
+    const e = peel(condition);
+    if (!ts.isBinaryExpression(e))
+        return false;
+    const op = e.operatorToken.kind;
+    if (op === ts.SyntaxKind.AmpersandAmpersandToken)
+        return boundedBy(e.left, { array, index }) || boundedBy(e.right, { array, index });
+    if (op === ts.SyntaxKind.LessThanToken)
+        return sameReference(e.left, index) && isLengthOf(e.right, array);
+    if (op === ts.SyntaxKind.GreaterThanToken)
+        return isLengthOf(e.left, array) && sameReference(e.right, index);
+    return false;
+}
+/** Evaluating `node` reads `array[index]!` on every path that completes. */
+function assertsSlot(node, operands) {
+    let found = false;
+    const visit = (n) => {
+        if (found)
+            return;
+        if (ts.isNonNullExpression(n) &&
+            ts.isElementAccessExpression(peel(n.expression)) &&
+            !peel(n.expression).questionDotToken) {
+            const read = peel(n.expression);
+            if (sameReference(read.expression, operands.array) &&
+                sameReference(read.argumentExpression, operands.index)) {
+                found = true;
+                return;
+            }
+        }
+        // Skip operands that do not run on every completing path.
+        if (ts.isBinaryExpression(n)) {
+            const op = n.operatorToken.kind;
+            visit(n.left);
+            if (op !== ts.SyntaxKind.AmpersandAmpersandToken &&
+                op !== ts.SyntaxKind.BarBarToken &&
+                op !== ts.SyntaxKind.QuestionQuestionToken &&
+                op !== ts.SyntaxKind.AmpersandAmpersandEqualsToken &&
+                op !== ts.SyntaxKind.BarBarEqualsToken &&
+                op !== ts.SyntaxKind.QuestionQuestionEqualsToken)
+                visit(n.right);
+            return;
+        }
+        if (ts.isConditionalExpression(n)) {
+            visit(n.condition);
+            return;
+        }
+        if (ts.isFunctionLike(n) ||
+            ts.isClassDeclaration(n) ||
+            ts.isClassExpression(n) ||
+            ts.isIfStatement(n) ||
+            ts.isWhileStatement(n) ||
+            ts.isDoStatement(n) ||
+            ts.isForStatement(n) ||
+            ts.isForOfStatement(n) ||
+            ts.isForInStatement(n) ||
+            ts.isSwitchStatement(n) ||
+            ts.isTryStatement(n) ||
+            ts.isLabeledStatement(n) ||
+            ts.isBlock(n)) {
+            if (ts.isIfStatement(n))
+                visit(n.expression);
+            return;
+        }
+        if ((n.flags & ts.NodeFlags.OptionalChain) !== 0)
+            return;
+        n.forEachChild(visit);
+    };
+    if (ts.isVariableStatement(node)) {
+        for (const declaration of node.declarationList.declarations)
+            if (declaration.initializer)
+                visit(declaration.initializer);
+    }
+    else if (ts.isExpressionStatement(node))
+        visit(node.expression);
+    else if (!ts.isStatement(node))
+        visit(node);
+    return found;
+}
+/** Running `nodes` cannot change the array's length or either operand. */
+function unchanged(nodes, { array, index }) {
+    const roots = [];
+    for (const operand of [array, index]) {
+        const root = rootName(operand);
+        if (root !== null)
+            roots.push(root);
+    }
+    // Another reference can alias a property chain, so any property write
+    // named `length` or like a link of either chain may change an operand.
+    const links = new Set(["length", ...linkNames(array), ...linkNames(index)]);
+    let ok = true;
+    const writes = (target) => {
+        const e = peel(target);
+        if (ts.isIdentifier(e))
+            return roots.includes(e.text);
+        if (ts.isPropertyAccessExpression(e))
+            return links.has(e.name.text);
+        if (ts.isElementAccessExpression(e)) {
+            // A computed key could name `length` or a chain link.
+            const key = peel(e.argumentExpression);
+            return !ts.isNumericLiteral(key) && !isSimpleReference(key)
+                ? true
+                : ts.isStringLiteral(key) && links.has(key.text);
+        }
+        if (ts.isArrayLiteralExpression(e) || ts.isObjectLiteralExpression(e)) {
+            let hit = false;
+            const walk = (n) => {
+                if (ts.isIdentifier(n) && roots.includes(n.text))
+                    hit = true;
+                n.forEachChild(walk);
+            };
+            walk(e);
+            return hit;
+        }
+        return false;
+    };
+    const visit = (n) => {
+        if (!ok)
+            return;
+        if (ts.isFunctionLike(n) || ts.isClassDeclaration(n) || ts.isClassExpression(n))
+            return;
+        if (ts.isCallExpression(n) ||
+            ts.isNewExpression(n) ||
+            ts.isTaggedTemplateExpression(n) ||
+            ts.isAwaitExpression(n) ||
+            ts.isYieldExpression(n) ||
+            ts.isDeleteExpression(n)) {
+            ok = false;
+            return;
+        }
+        if (ts.isBinaryExpression(n)) {
+            const op = n.operatorToken.kind;
+            if (op >= ts.SyntaxKind.FirstAssignment &&
+                op <= ts.SyntaxKind.LastAssignment &&
+                writes(n.left)) {
+                ok = false;
+                return;
+            }
+        }
+        if ((ts.isPrefixUnaryExpression(n) || ts.isPostfixUnaryExpression(n)) &&
+            (n.operator === ts.SyntaxKind.PlusPlusToken ||
+                n.operator === ts.SyntaxKind.MinusMinusToken) &&
+            writes(n.operand)) {
+            ok = false;
+            return;
+        }
+        if ((ts.isForOfStatement(n) || ts.isForInStatement(n)) &&
+            !ts.isVariableDeclarationList(n.initializer) &&
+            writes(n.initializer)) {
+            ok = false;
+            return;
+        }
+        n.forEachChild(visit);
+    };
+    for (const node of nodes)
+        visit(node);
+    return ok;
+}
+function linkNames(node) {
+    const names = [];
+    let e = peel(node);
+    while (ts.isPropertyAccessExpression(e)) {
+        names.push(e.name.text);
+        e = peel(e.expression);
+    }
+    return names;
+}
+function rootName(node) {
+    let e = peel(node);
+    while (ts.isPropertyAccessExpression(e))
+        e = peel(e.expression);
+    return ts.isIdentifier(e) ? e.text : null;
+}
+//# sourceMappingURL=runtime-optional-bounds.js.map

package/dist/frontend/lowering/runtime-optional-bounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-optional-bounds.js","sourceRoot":"","sources":["../../../src/frontend/lowering/runtime-optional-bounds.ts"],"names":[],"mappings":"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"}

package/dist/frontend/lowering/runtime-optional-bounds.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/frontend/lowering/runtime-optional-bounds.test.js

@@ -0,0 +1,66 @@
+import { afterAll, expect, test } from "vitest";
+import * as ts from "../ts7/adapter.js";
+import { closeSourceParser, parseSourceFile } from "../ts7/source-parser-node.js";
+import { indexReadInBounds, indexStoreInBounds } from "./runtime-optional-bounds.js";
+afterAll(closeSourceParser);
+/** Whether each indexed store in `body` is proven to stay inside its array. */
+function stores(body) {
+    const file = parseSourceFile("bounds.ts", body, "ts");
+    const results = [];
+    ts.walkPreorder(file, (node) => {
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isElementAccessExpression(node.left))
+            results.push(indexStoreInBounds(node));
+        return undefined;
+    });
+    return results;
+}
+test("a dominating length comparison or asserted read bounds the store", () => {
+    expect(stores(`function f(xs: number[], i: number) {
+      for (let j = 0; j < xs.length; j++) xs[j] = 0;
+      if (i < xs.length) xs[i] = 1;
+      if (xs.length > i) { xs[i] = 2; }
+      const old = xs[i]!;
+      xs[i] = old + 1;
+      xs[i] = 3;
+    }`)).toEqual([true, true, true, true, true]);
+});
+test("a swap is bounded by the reads that precede each store", () => {
+    expect(stores(`function swap(xs: number[], a: number, b: number) {
+      const t = xs[a]!;
+      xs[a] = xs[b]!;
+      xs[b] = t;
+    }`)).toEqual([true, true]);
+});
+test("code that can change the length or an operand voids the proof", () => {
+    expect(stores(`declare function shrink(): void;
+    function f(xs: number[], i: number) {
+      if (i < xs.length) { shrink(); xs[i] = 1; }
+      if (i < xs.length) { xs.length = 0; xs[i] = 2; }
+      if (i < xs.length) { i++; xs[i] = 3; }
+      if (i < xs.length) { xs = []; xs[i] = 4; }
+      if (i < xs.length) xs[i + 1] = 5;
+      if (i <= xs.length) xs[i] = 6;
+      while (i < xs.length) { xs[i] = 7; xs.pop(); }
+    }`)).toEqual([false, false, false, false, false, false, true]);
+});
+test("a guarded read forwarded to a call is bounded when nothing earlier can change it", () => {
+    const file = parseSourceFile("reads.ts", `declare function use(...values: number[]): void;
+    declare function shrink(): number;
+    function f(xs: number[], i: number) {
+      for (let j = 0; j < xs.length; j++) use(xs[j]!);
+      if (i < xs.length) use(i, xs[i]!);
+      if (i < xs.length) use(shrink(), xs[i]!);
+      use(xs[i]!);
+      if (i < xs.length) { const v = xs[i]!; use(v); }
+    }`, "ts");
+    const results = [];
+    ts.walkPreorder(file, (node) => {
+        if (ts.isElementAccessExpression(node))
+            results.push(indexReadInBounds(node));
+        return undefined;
+    });
+    expect(results).toEqual([true, true, false, false, true]);
+});
+//# sourceMappingURL=runtime-optional-bounds.test.js.map

package/dist/frontend/lowering/runtime-optional-bounds.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-optional-bounds.test.js","sourceRoot":"","sources":["../../../src/frontend/lowering/runtime-optional-bounds.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAErF,QAAQ,CAAC,iBAAiB,CAAC,CAAC;AAE5B,+EAA+E;AAC/E,SAAS,MAAM,CAAC,IAAY;IAC1B,MAAM,IAAI,GAAG,eAAe,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACtD,MAAM,OAAO,GAAc,EAAE,CAAC;IAC9B,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;QAC7B,IACE,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC;YAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;YACrD,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC;YAEvC,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC;QACzC,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,IAAI,CAAC,kEAAkE,EAAE,GAAG,EAAE;IAC5E,MAAM,CACJ,MAAM,CAAC;;;;;;;MAOL,CAAC,CACJ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAC5C,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,wDAAwD,EAAE,GAAG,EAAE;IAClE,MAAM,CACJ,MAAM,CAAC;;;;MAIL,CAAC,CACJ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAC1B,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,+DAA+D,EAAE,GAAG,EAAE;IACzE,MAAM,CACJ,MAAM,CAAC;;;;;;;;;MASL,CAAC,CACJ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAC9D,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,kFAAkF,EAAE,GAAG,EAAE;IAC5F,MAAM,IAAI,GAAG,eAAe,CAC1B,UAAU,EACV;;;;;;;;MAQE,EACF,IAAI,CACL,CAAC;IACF,MAAM,OAAO,GAAc,EAAE,CAAC;IAC9B,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;QAC7B,IAAI,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9E,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAC5D,CAAC,CAAC,CAAC"}

package/dist/frontend/lowering/runtime-optional-elements.d.ts

@@ -0,0 +1,117 @@
+import * as ts from "../ts7/adapter.js";
+/** Program queries the element-state scan needs from the optional-read
+ * analysis. Element keys name a native array's element ABI (`typeKey` of
+ * the element type); arrays only alias other arrays with the same key,
+ * because a conversion to another element type copies the elements and
+ * rejects holes and undefined while it does. */
+export interface ElementStateHost {
+    /** Element keys of every native array `node` can evaluate to: `[]` when
+     * it is not a native array (or is a dynamic value, whose own storage is
+     * separate), `null` when its element ABI is not known yet (a generic
+     * element type). */
+    arrayKeys(node: ts.Expression): readonly string[] | null;
+    /** The element type behind this key admits `undefined` itself. */
+    elementAdmitsUndefined(key: string): boolean;
+    /** The value stored by `node` can be `undefined` at runtime. */
+    mayBeUndefined(node: ts.Expression): boolean;
+    /** A callback argument can return `undefined` at runtime. */
+    callbackReturnsUndefined(node: ts.Expression): boolean;
+    /** The value may be a plain array-like object, whose missing indices
+     * read as undefined. */
+    isArrayLikeObject(node: ts.Expression): boolean;
+    /** The expression's static type is a string. */
+    isString(node: ts.Expression): boolean;
+    /** `node` names the standard global `name` (`Array`, `Object`, ...). */
+    isGlobal(node: ts.Expression, name: string): boolean;
+    /** Element keys of the rest parameter that the spread arguments of
+     * `call` fill: `[]` when the callee has none, null when it is unknown. */
+    restKeys(call: ts.CallExpression | ts.NewExpression): readonly string[] | null;
+    /** Record that iterating `node`'s binding can observe `undefined`;
+     * `known` when the iterated array's own facts (not only those shared by
+     * its element ABI) say so. Returns true when the binding's record grew. */
+    markIterationBinding(node: ts.Identifier, known: boolean): boolean;
+    /** The storage slot that alone owns the array `node` references, whose
+     * facts are tracked for that slot instead of its element ABI. */
+    ownerOf(node: ts.Expression): ts.Symbol | null;
+    /** The owning slot a newly built array is stored into. */
+    allocationOwner(node: ts.Expression): ts.Symbol | null;
+    /** Debug provenance for a new fact. */
+    note: ((fact: "undefined" | "holes", key: string, site: ts.Node | undefined) => void) | null;
+}
+/** Whole-program facts about which native array element ABIs can hold an
+ * explicit `undefined` value or a hole, refined per expression for arrays
+ * an expression creates itself. An element parameter of an array callback
+ * is present whenever its receiver can hold neither: the callback methods
+ * skip holes (except the find family), and every explicit `undefined`
+ * enters a native array through a store, a copy, or a builtin scanned
+ * here. Facts only grow, so the enclosing fixed point stays monotone. */
+export declare class ArrayElementStates {
+    private readonly host;
+    private readonly undefinedKeys;
+    private readonly holeyKeys;
+    /** A store wrote a possibly undefined value or a hole into an array
+     * whose element ABI is decided per generic instantiation. */
+    private anyUndefined;
+    private anyHoley;
+    /** Facts of arrays owned by one storage slot. */
+    private readonly undefinedOwners;
+    private readonly holeyOwners;
+    /** The node being scanned, for provenance notes. */
+    private site;
+    /** While set, arrays judged only by their element ABI count as present. */
+    private ownFactsOnly;
+    constructor(host: ElementStateHost);
+    /** Every element a callback of `method` receives from `receiver` is a
+     * present value. */
+    elementsPresent(receiver: ts.Expression, method: string): boolean;
+    /** Scans one syntax node; true when a fact was added. */
+    scan(node: ts.Node): boolean;
+    /** `[a, ...rest] = source` copies the remaining indices into a new
+     * array: holes become undefined. */
+    private scanRestPattern;
+    /** `[a, ...rest] = source` as an assignment. */
+    private scanRestAssignment;
+    /** Contents of the array `node` evaluates to; null when its element ABI
+     * is generic. Arrays the expression creates are judged by how they are
+     * built; any other array by the facts of its element ABI. */
+    private contents;
+    /** Contents of an array a call creates; undefined when the call is not a
+     * known array constructor or method. */
+    private builtContents;
+    /** The facts recorded for arrays with these element ABIs. */
+    private stored;
+    /** Reading every index of `node` (a spread, an iteration, `Array.from`)
+     * can produce `undefined`. Only native arrays can: other iterables reject
+     * an undefined value when it is stored. */
+    private mayYieldUndefined;
+    /** One stored value, or the elements a spread copies. */
+    private valueMayBeUndefined;
+    /** Records an array the expression creates, for the slot that owns it
+     * or else under its element ABI. */
+    private record;
+    /** Element ABIs of a built array, including those an enclosing type
+     * assertion gives it (`[a, , b] as T[]`). */
+    private keysAsUsed;
+    /** A store through `receiver` can add an undefined value. */
+    private addUndefinedTo;
+    /** A store through `receiver` can leave holes. */
+    private addHolesTo;
+    private addUndefined;
+    private addHoles;
+    private scanAssignment;
+    private scanCall;
+    /** Writes that bypass the array methods: `Object.assign(xs, ...)`,
+     * `Reflect.set(xs, ...)`, `Array.prototype.push.call(xs, ...)` and the
+     * like may store any value at any index of an array argument. */
+    private scanReflectiveWrite;
+    /** A for-of loop over `node`'s iterable can bind `undefined`: a hole
+     * or a stored undefined in the array it walks. When it cannot, every
+     * element the loop reads is a present value. */
+    loopMayYieldUndefined(node: ts.ForOfStatement): boolean;
+    /** The loop's array itself, as built or as owned by one slot, can hold
+     * a hole or undefined. Facts shared by every array with the same element
+     * ABI are coarser: a loop judged only by them keeps checked reads. */
+    private loopHolesKnown;
+    private loopSource;
+    private scanForOf;
+}