@scriptc/compiler 0.2.8 → 0.2.10

package/dist/frontend/lowering/nan-coded-reads.d.ts

@@ -0,0 +1,161 @@
+import * as ts from "../ts7/adapter.js";
+import type { IrBytesElem } from "../../ir/ir.js";
+export interface NanCodedHost {
+    symbolOf(node: ts.Node): ts.Symbol | null;
+    declarationOf(symbol: ts.Symbol): ts.Node | undefined;
+    /** The element kind of a typed-array receiver, or null. */
+    bytesElemOf(receiver: ts.Expression): IrBytesElem | null;
+    /** The static IR type of the node is a plain number. */
+    isNumber(node: ts.Node): boolean;
+    isString(node: ts.Expression): boolean;
+    /** The receiver is an array or a typed array (for `.length`). */
+    hasLength(node: ts.Expression): boolean;
+    isStdlibGlobal(node: ts.Expression, name: string): boolean;
+    /** Parameter `index` of the callable is a plain `number` in its signature. */
+    paramIsNumber(fn: ts.Symbol, index: number): boolean;
+    /** The callable's signature returns a plain `number`. */
+    returnIsNumber(fn: ts.Symbol): boolean;
+    /** The method shares its dispatch slot with another class's method. */
+    methodOverridden(fn: ts.Symbol): boolean;
+}
+export declare class NanCodedReads {
+    private readonly host;
+    private readonly files;
+    /** Typed-array element reads that can lower as NaN-coded doubles. */
+    private readonly reads;
+    /** Typed-array element reads proven to name an existing element. */
+    private readonly presentReads;
+    private readonly counters;
+    private readonly fixedLengths;
+    private readonly bindings;
+    private readonly notSlots;
+    /** Every slot's value occurrences. */
+    private readonly useNodes;
+    private readonly returns;
+    /** Identifiers by text across the analyzed files. */
+    private readonly names;
+    private readonly symbolCache;
+    private readonly pneCache;
+    private readonly pneReturnCache;
+    private readonly fnEligibility;
+    private readonly callSites;
+    /** Slots that are NaN-coded after the fixed point. */
+    private readonly eligible;
+    private readonly genuineNaN;
+    private readonly numericReads;
+    private analyzed;
+    constructor(host: NanCodedHost, files: readonly ts.SourceFile[]);
+    /** The read lowers to a double holding NaN for an invalid index. */
+    isNumericRead(read: ts.ElementAccessExpression): boolean;
+    /** Both operands of this equality are NaN-coded values that may stand
+     * for undefined: undefined equals undefined, so equal NaNs compare equal. */
+    needsUndefinedEquality(expr: ts.BinaryExpression): boolean;
+    /** Bindings and returns that are NaN-coded (consistency checks). */
+    nanCodedBinding(symbol: ts.Symbol): boolean;
+    nanCodedReturn(symbol: ts.Symbol): boolean;
+    get size(): {
+        reads: number;
+        slots: number;
+        present: number;
+    };
+    analyze(): void;
+    private readonly removals;
+    private removalReason;
+    private debugReport;
+    private symbolOf;
+    /** An element read (never a write target) of a TypeScript file. */
+    private isReadCandidate;
+    /** `t[i]` names an existing element: `i` is a non-negative integer
+     * counter and a dominating guard bounds it by `t.length` (or by the
+     * length of a typed array that always has the same length).
+     *
+     * The guard proof only sees code written between the guard and the read.
+     * Code it cannot see (a getter, a conversion hook) cannot reach either
+     * operand: `t` is a fixed-length typed array no other code can reach, and
+     * only the reading function itself writes `i`. */
+    private presentRead;
+    /** A `let`/`const` binding that starts at a non-negative integer literal
+     * and only ever grows by non-negative integer literals (`i++`, `++i`,
+     * `i += 2`) or is reset to one (`i = 0`): it always holds a non-negative
+     * integer. Every write is in the declaring function (no closure writes). */
+    private nonNegativeCounter;
+    /** Two typed arrays whose lengths are equal for their whole lifetime. */
+    private sameFixedLength;
+    /** The allocation `new Uint8Array(n)` of a `const` typed array whose every
+     * reference is an element access or `.length`: nothing can reach its
+     * buffer to detach it, so its length never changes. */
+    private fixedLength;
+    /** The function whose `return` statement contains `node`. */
+    private containingFunction;
+    /** The declaration of a directly called function or method, when every
+     * reference to it is a direct call (no value use, no overrides). */
+    private eligibleFunction;
+    /** Every call of the function, or null when some reference is not a
+     * direct, non-optional call. */
+    private directCalls;
+    private bindingSlot;
+    private scanBindingSlot;
+    /** How an identifier reference touches its binding. */
+    private writeOf;
+    private inDestructuringTarget;
+    private returnSlot;
+    /** The callee of a call: a function or method symbol. */
+    private calleeSymbol;
+    /** The slot a value flows into, through transparent wrappers and
+     * conditional branches; null for a direct consumer. */
+    private sinkOf;
+    /** A slot that never holds a genuine NaN encodes undefined exactly, so
+     * any consumer can rebuild the union (see `reboxes`); a slot that may
+     * hold a genuine NaN needs NaN-insensitive consumers throughout. */
+    private slotOk;
+    /** The eligible slot whose value this occurrence reads, if any. */
+    private slotOfValue;
+    /** This read of a NaN-coded slot reaches a consumer that could observe
+     * undefined: lowering rebuilds `number | undefined` from the double (NaN
+     * is undefined, exactly, since the slot never holds a genuine NaN), and
+     * the optional-read analysis treats the occurrence as optional, so the
+     * consumer lowers exactly as it does for an ordinary read. */
+    reboxes(node: ts.Expression): boolean;
+    /** A consumer that takes the value whole, so the rebuilt union lowers
+     * there exactly like an ordinary optional read: an argument, a stored
+     * or returned value, a literal element, or string concatenation. Any
+     * other consumer (a member access, `typeof`, `??`, ...) keeps the slot
+     * on the ordinary optional lowering instead. */
+    private reboxConsumer;
+    private computeGenuineNaN;
+    /** A value allowed into a NaN-coded slot, or null. */
+    private sourceInfo;
+    /** The value flows into a NaN-coded slot: lowering converts an optional
+     * number to NaN-for-undefined on entry. */
+    convertsSource(node: ts.Expression): boolean;
+    /** The occurrence reads a NaN-coded slot. */
+    readsNanCodedSlot(node: ts.Expression): boolean;
+    /** `+`, `-` or `*` over finite literals and integer values proven present
+     * where they are read: the result is never NaN. A NaN-coded slot that
+     * never holds a genuine NaN holds integers, finite plain numbers or NaN
+     * for undefined, and a comparison guarding the read excludes NaN. */
+    private nanFreeArithmetic;
+    /** An occurrence of a never-reassigned number binding under a dominating
+     * comparison with a number that is never NaN (`x >= 0 ? x : y`): the
+     * comparison is false for undefined and for NaN, so here the binding
+     * holds a plain number that is not NaN, even when the binding itself is
+     * NaN-coded. */
+    private guardedOccurrence;
+    /** A dominating condition compares the never-reassigned binding with a
+     * number literal, which is false for undefined. */
+    private provenPresent;
+    private conditionExcludesUndefined;
+    /** How the value lowers once the analysis is final: NaN-coded (a numeric
+     * read or a read of a NaN-coded slot) or not. */
+    private loweredInfo;
+    /** A number expression that is never undefined in Node and always lowers
+     * to a plain double, whatever the optional-read analysis decides. */
+    private plainNumber;
+    private computePlainNumber;
+    /** A function whose every return value is a plain number. */
+    private plainReturn;
+    /** Whether the value's consumer cannot tell undefined from NaN. */
+    private useSafe;
+    /** The value of a logical expression is only tested for truthiness. */
+    private inConditionContext;
+}