tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/shared-results.d.ts

@@ -0,0 +1,696 @@
+import { type Node, type SourceFile } from './ast.js';
+import type { Checker } from './checker.js';
+import { Type, Signature } from './checker-types.js';
+import { type Symbol } from './symbol.js';
+import { LinkTable } from './link-tables.js';
+declare const enum RecordKind {
+    /** A type the checker creates when it starts: its position in `initialTypes`. */
+    Initial = 0,
+    /** A regular literal type: its flags, then its value as a double or its text. */
+    Literal = 1,
+    /** The fresh type of the literal type `refs[0]`. */
+    FreshLiteral = 2,
+    /** The literal type of the enum member `symbol`. */
+    EnumLiteral = 3,
+    /** The unique symbol type of `symbol`. */
+    UniqueSymbol = 4,
+    /** The declared type of `symbol` (class, interface, enum, type parameter). */
+    Declared = 5,
+    /** The this-type of the declared class or interface type of `symbol`. */
+    ThisType = 6,
+    /** The type of the value `symbol` (the anonymous type of a function, class, enum or module). */
+    SymbolType = 7,
+    /** The type of the type node `node` (a type literal, function or constructor type, mapped or conditional type). */
+    NodeType = 8,
+    /** A reference to the generic type `refs[0]` with the type arguments `refs[1..]`. */
+    Reference = 9,
+    /** The tuple target: readonly, then the element flags and label nodes. */
+    TupleTarget = 10,
+    /**
+     * The instantiation of the anonymous, mapped or deferred reference type `refs[0]` with the outer type arguments
+     * after it, then the return types its signatures had resolved (built after it); the node declares it.
+     */
+    Instantiation = 11,
+    /** A union of `refs` with the origin record, or -1. */
+    Union = 12,
+    /** An intersection of `refs`. */
+    Intersection = 13,
+    /** `keyof refs[0]` with the index flags. */
+    Index = 14,
+    /** `refs[0][refs[1]]` with the access flags. */
+    IndexedAccess = 15,
+    /** The instantiation of the conditional type of `node` with outer type arguments `refs`, for constraints when the tag is 1. */
+    Conditional = 16,
+    /** A template literal type of its texts and `refs`. */
+    Template = 17,
+    /** The string mapping `symbol` of `refs[0]`. */
+    StringMapping = 18,
+    /** A substitution type of `refs[0]` constrained by `refs[1]`. */
+    Substitution = 19,
+    /** `NoInfer<refs[0]>`. */
+    NoInfer = 20,
+    /**
+     * The member for the constituent `refs[last]` of the distribution of the conditional type of `node` instantiated
+     * with outer type arguments `refs[0..last)`, for constraints when the tag is 1.
+     */
+    DistributedConditional = 21,
+    /**
+     * An anonymous object type of the object literal `symbol` with members resolved when it was created (an object
+     * literal type, or its regular, widened or spread form): its object flags, then the record of its members.
+     */
+    AnonymousObject = 22,
+    /** The members of the `AnonymousObject` record whose index is written first: the properties `refs` and index infos. */
+    CompleteObject = 23,
+    /**
+     * A property symbol a checker created: its symbol flags, check flags and name, its declarations, its type
+     * `refs[0]`, name type `refs[1]` (or -1), the symbol it was made from `refs[2]` (a property record, or -1 for the
+     * symbol of the program written with it) and its parent (its alias).
+     */
+    Property = 24
+}
+/**
+ * Writes records into a checker's store: int32 words at a cursor, strings into its string log, and each record's
+ * offset in its record table. The cursor is the writer's alone until it publishes a result.
+ */
+export declare class StoreWriter {
+    readonly numbers: Int32Array;
+    readonly strings: Uint16Array;
+    readonly table: Int32Array;
+    readonly fileIndex: Map<SourceFile, number>;
+    /** The cursor in the number log, and in the string log. */
+    at: number;
+    unitAt: number;
+    /** Set when a record or a field didn't fit the store's configured capacity. */
+    full: boolean;
+    constructor(numbers: Int32Array, strings: Uint16Array, table: Int32Array, fileIndex: Map<SourceFile, number>);
+    /** Returns to the cursors `at` and `unitAt`. */
+    reset(at: number, unitAt: number): void;
+    /** Starts record `index` at the cursor: its header, and its offset in the record table. */
+    beginRecord(index: number, header: number): void;
+    word(value: number): void;
+    /** A double as the two int32 halves of its bits. */
+    double(value: number): void;
+    /** A string as its offset and length in the string log. */
+    text(value: string): void;
+    /** A node as its file, range and id, or -1 for none. The file must be one `fileIndex` has. */
+    node(node: Node | undefined): void;
+}
+/** The types every checker creates when it starts, in the same order; marker types are left out. */
+export declare function initialTypes(c: Checker): Type[];
+/** The reason an export stops at its budget (`Exporter.limit`), which `post` returns: the result is not posted. */
+export declare const budgetFailure = "export budget";
+/** A checker's `Exporter.mergedOrigins`, kept while its merged symbols stay the same. */
+export declare class MergedOrigins {
+    origins: Map<Symbol, number>;
+    size: number;
+}
+/** Writes a result as records; `failure` names the first part that has no record kind. */
+export declare class Exporter {
+    readonly c: Checker;
+    readonly writer: StoreWriter;
+    /**
+     * The index of the first record of the export in progress. A checker's exporter keeps the records of the types it
+     * exported before (`ThreadSharing.post`): its store has them already, and a result's records are only the new ones.
+     */
+    base: number;
+    /** The number of records the export in progress wrote. */
+    count: number;
+    /** The record of each type, by type id, and of each property symbol, by symbol id. */
+    readonly indexes: Map<number, number>;
+    readonly properties: Map<number, number>;
+    /** The types and properties the export in progress gave indexes, which a failed export forgets again. */
+    readonly addedTypes: number[];
+    readonly addedProperties: number[];
+    /**
+     * The most records the export in progress may add (`ThreadSharing.post` prices it with `kappa`); past it the export
+     * fails and the result is not posted.
+     */
+    limit: number;
+    readonly initial: Map<number, number>;
+    failure: string | undefined;
+    /** The ids above which nodes and symbols are the checker thread's own (lazily parsed JSDoc), or Infinity. */
+    nodeLimit: number;
+    symbolLimit: number;
+    /** The ids of the symbols each merged symbol merged (`getMergedSymbol`), built on first use. */
+    mergedOrigins: Map<Symbol, number> | undefined;
+    /** Where the checker keeps `mergedOrigins` between exports. */
+    originsCache: MergedOrigins | undefined;
+    /** How the record in progress names its symbol and its alias, and the node it carries. */
+    private naming;
+    private namingMerged;
+    private namingNode;
+    private aliasNaming;
+    private aliasMerged;
+    private aliasNode;
+    private aliasRefs;
+    private node;
+    constructor(c: Checker, initial: Map<number, number>, writer: StoreWriter);
+    fail(reason: string): number;
+    /** Whether `node` is one every checker shares, and can name; fails if not. */
+    sharedNode(node: Node | undefined): boolean;
+    /**
+     * The index of the next record of the store, or -1 if the result is over its export budget; the store's table must
+     * have room for it.
+     */
+    nextIndex(): number;
+    /** Records the type `t` at `index`. */
+    private memo;
+    /**
+     * Sets how the record in progress names `symbol`: a symbol of the program by the node it is the symbol of, or a
+     * symbol the checker merged by the id of a symbol it merged. Fails for a symbol of the thread.
+     */
+    nameSymbol(symbol: Symbol | undefined, alias: boolean): boolean;
+    /** The ids of the symbols each merged symbol merged, from the checker's `mergedSymbols`. */
+    private buildOrigins;
+    /**
+     * Names the alias of the record in progress, after its type arguments are exported, and returns the header bits that
+     * name it; -1 if it can't be named.
+     */
+    private aliasBits;
+    /**
+     * Starts the record at `index`: its header, its refs, its alias, its symbol and its node, all decided by `bits` and
+     * the fields set just before. A kind's own fields follow.
+     */
+    begin(kind: RecordKind, index: number, refs: readonly number[], bits: number): void;
+    /** The record of `t` of `kind`, with `refs` and no fields of its own; its index. */
+    private plain;
+    /** The record of the initial type `t`, which is `num`th in `initialTypes`. */
+    private initialType;
+    /** The record of the type `t` of `kind` named by `symbol`, with `refs`; its index. */
+    private symbolType;
+    /** The record of the type `t` of the type node `node`; its index. */
+    private nodeType;
+    types(list: readonly Type[]): number[];
+    type(t: Type): number;
+    private literal;
+    /** The record of the constituents of a union's or intersection's origin, which is not a type: it has no alias. */
+    private originRecord;
+    private union;
+    private intersection;
+    private object;
+    /** An object literal type, or one made from one, with its properties and index infos. */
+    private anonymousObject;
+    /** A property symbol of an object literal type: a checker's own, made from one of the program or from another. */
+    private property;
+    private tupleTarget;
+    /** An instantiated anonymous or mapped type, or a deferred type reference: its target and outer type arguments. */
+    private instantiation;
+    /**
+     * Adds to `refs` the return types the checker resolved for the signatures of the instantiation `t`, exported after
+     * it. The consumer then creates them right after `t` and before the types that contain it, as this checker did:
+     * inference stops at references whose type ids grow along its stack (`isDeeplyNestedType`), so a consumer that
+     * created them later, when it resolved them, could stop an inference this checker made.
+     */
+    private resolvedReturnTypes;
+    /**
+     * The record of `t`, or -1 if it can't be exported; that leaves the export in progress as it was. An export that
+     * failed before stays failed.
+     */
+    optionalType(t: Type): number;
+    /**
+     * The record of the conditional type `t`: the conditional type of a type node, or the instantiation of one with
+     * outer type arguments; -1 if it can't be exported.
+     */
+    private conditional;
+}
+/** Translates the records of another checker's store into this checker's types, reading them where they are. */
+export declare class Translator {
+    readonly c: Checker;
+    readonly store: StoreReader;
+    readonly initial: Type[];
+    /** Set when a record has no counterpart here; the translation is then abandoned. */
+    failed: boolean;
+    constructor(c: Checker, store: StoreReader);
+    /**
+     * The symbol of `node`, named by `how`: the symbol of the node itself, or its export symbol. The record names
+     * symbols of the program this way, and a consumer that hasn't the symbol fails the translation.
+     */
+    private namedSymbol;
+    /** Abandons the record being read: the translation fails, and a later one starts afresh. */
+    private abandon;
+    /** A property symbol made as the producer made it; undefined if its record can't be read here. */
+    property(index: number): Symbol | undefined;
+    /** Sets the members of the `AnonymousObject` record a `CompleteObject` record completes; false if it can't read it. */
+    complete(index: number): boolean;
+    /**
+     * Resolves the declared type of the type alias whose declaration contains the type node `node`, as resolving its
+     * nodes through the alias does: that records the alias's type parameters, which its variances are measured with.
+     * Sets `failed` if the alias's declared type is being resolved here.
+     */
+    aliasOfNode(node: Node): void;
+    /** The type record `index`; undefined if it or a record it needs can't be translated here. */
+    record(index: number): Type | undefined;
+}
+/** Whether the type of `symbol` is shared: a variable or property declared in the program, other than parameters. */
+export declare function isSharedValueSymbol(symbol: Symbol): boolean;
+/** Whether the return type of `sig` is shared: the signature of a declaration, as `getSignatureFromDeclaration` makes it. */
+export declare function isSharedReturnSignature(c: Checker, sig: Signature): boolean;
+/**
+ * What a checker thread needs to share results with the others; posted in its `workerData` (a plain object: class
+ * instances arrive without their class).
+ */
+export interface ThreadSharingData {
+    readonly index: number;
+    readonly count: number;
+    /**
+     * Whether this run's posts are cost-bounded (`RunConfig.bounded`): it posts only results another checker demanded
+     * and its takes build a bounded number of records. A run with it off keeps Phase 1's rule.
+     */
+    readonly bounded: boolean;
+    /**
+     * For each file, by file index: -2 if no checker checks it, -1 if checkers check it in statement ranges, 0 until a
+     * checker takes it, and 1 + k once checker k took it.
+     */
+    readonly takers: SharedArrayBuffer;
+    /**
+     * For each file, by file index, the checkers (one bit each) that took a result for a declaration in it before any
+     * checker took the file: they never check it, and hand its positions on (`handoff`).
+     */
+    readonly forbidden: SharedArrayBuffer;
+    /**
+     * For each file, by file index, the checkers (one bit each, the same shape as `forbidden`) that looked for a result
+     * for one of its declarations and found none. A checker posts a result only for a declaration whose file one of
+     * them reads (`ThreadSharing.demanded`).
+     */
+    readonly wanted: SharedArrayBuffer;
+    /**
+     * Positions of the order a checker handed on: a lock, their number, the number of checkers that may still hand
+     * positions on, then the positions.
+     */
+    readonly handoff: SharedArrayBuffer;
+    readonly typeTable: SharedArrayBuffer;
+    readonly returnTable: SharedArrayBuffer;
+    /** The ids above which nodes and symbols are a thread's own. */
+    readonly nodeIds: number;
+    readonly symbolIds: number;
+    /**
+     * Each checker's store of the records of the results it shares, by checker index: their numbers, and the code units
+     * of their strings. `used` has two counters per checker, `usedStride` int32s apart, how much of each it wrote; a
+     * checker keeps its cursors in its own writer and writes them there only for the summary. (Results go through
+     * shared memory: a message a worker receives synchronously makes the native build store the number fields of
+     * classes as doubles.)
+     */
+    readonly numberLogs: SharedArrayBuffer[];
+    readonly stringLogs: SharedArrayBuffer[];
+    readonly used: SharedArrayBuffer;
+    /** For each checker, where each record of its store is in its number log: a word per record. */
+    readonly recordTables: SharedArrayBuffer[];
+    /**
+     * One int32, read by every checker before it posts or translates a result: 0 runs, 1 stops posting, 2
+     * stops posting and translating. The main thread sets it (`startParallelCheck`'s window) when the
+     * results are not worth what they cost; every switch keeps the diagnostics the same, because a
+     * checker that does not take a posted result computes it itself.
+     */
+    readonly control: SharedArrayBuffer;
+    /**
+     * One row of `shareStatColumns` doubles per checker, for the counters the main thread reads while
+     * checking runs (`ThreadSharing.writeStats`).
+     */
+    readonly stats: SharedArrayBuffer;
+}
+/**
+ * The columns of a checker's row of `ThreadSharingData.stats`: the milliseconds of its outermost
+ * computations by kind (0 owned, 1 computed here for a file another checker took, 2 translated, 3
+ * other), of exporting, translating and unpacking results, the results it posted and translated, and
+ * the milliseconds it saved by translating a result instead of computing it.
+ */
+export declare const shareStatColumns = 10;
+export declare const shareStatKinds = 4;
+export declare const shareStatExport = 4;
+export declare const shareStatTranslation = 5;
+export declare const shareStatUnpack = 6;
+export declare const shareStatPosted = 7;
+export declare const shareStatTranslated = 8;
+export declare const shareStatSaved = 9;
+/**
+ * The size of each checker's logs: numbers (int32s) and string code units (2 bytes each), 8 MB and 2 MB. Only the
+ * pages a checker writes take memory.
+ */
+export declare const numberLogSize: number;
+export declare const stringLogSize: number;
+/** The number of records each checker's store can hold. */
+export declare const recordTableSize: number;
+/** The int32s each checker gets in `ThreadSharingData.used`, a cache line each, for two counters. */
+export declare const usedStride = 16;
+/** The number of entries of each result table: a power of two. */
+export declare const resultTableSize: number;
+/**
+ * The most checker threads that share results: a result's state (`postedState`) holds the checker and an offset in
+ * its number log, below `numberLogSize` (2^21), in one int32, so the count times 2^21 stays below 2^31 - 2.
+ */
+export declare const maxSharingCheckers = 1023;
+/** The state of the result checker `producer` of `count` posted at `offset` of its number log. */
+export declare function postedState(count: number, producer: number, offset: number): number;
+/** The checker that posted the result of `state`, of `count` checkers. */
+export declare function postedProducer(count: number, state: number): number;
+/** The offset in its producer's number log of the result of `state`, of `count` checkers. */
+export declare function postedOffset(count: number, state: number): number;
+/** The int32 words of each file's forbidden bits (`ThreadSharingData.forbidden`): a bit for each of `count` checkers. */
+export declare function forbiddenWords(count: number): number;
+/** Whether checker `index` of `count` took results for declarations of file `file` before any checker took it. */
+export declare function isForbidden(forbidden: Int32Array, count: number, file: number, index: number): boolean;
+/** Whether checker `index` of `count` looked for a result for a declaration of file `file` and found none (`wanted`). */
+export declare function isWanted(wanted: Int32Array, count: number, file: number, index: number): boolean;
+/**
+ * An open-addressing table in a SharedArrayBuffer, from a key (a symbol or node id) to a result's state: 0 until a
+ * checker posts it, then `postedState`.
+ */
+export declare class ResultTable {
+    readonly words: Int32Array;
+    constructor(buffer: SharedArrayBuffer);
+    /** The slot of `key`, inserted if absent; -1 if the table is full. */
+    slot(key: number): number;
+    state(slot: number): number;
+    /** The slot of `key`, or -1 if it has none. */
+    find(key: number): number;
+    /** Sets the state of `slot` to a posted result's unless one is there already. */
+    publish(slot: number, state: number): void;
+}
+/**
+ * The rule that decides whether a checker posts a result it computed, and how much a consumer may build to take one.
+ * The conditions that keep a take exact (the result's diagnostics, `forbidsLast`, the resolution stack) are checked
+ * by the callers, as are the stop switch and the demand bits.
+ */
+export interface PostingRule {
+    /**
+     * Whether a checker that just computed the result keyed `key` of a declaration in file `fileIndex` may post it, in
+     * `ms`, with `diagnosticFiles` the files its diagnostics are in. The caller checks first that the computation met
+     * no resolution cycle, that the stop switch is off, that (when the run is cost-bounded) another checker demanded the
+     * file (`demanded`) and that no result for the key is posted.
+     */
+    posts(sharing: ThreadSharing, key: number, ms: number, diagnosticFiles: readonly number[], fileIndex: number): boolean;
+    /**
+     * The most records a consumer may build to take a posted result whose producer computed it in `ms` milliseconds: 0
+     * admits only takes that build nothing, because every record they need is in the consumer's caches already.
+     */
+    buildBudget(ms: number): number;
+}
+/**
+ * The rule of the design's Phase 2: a result is posted when it took at least the floor (`ThreadSharing.minMs`), and a
+ * consumer builds at most `lambda*T/c` records to take one, where `T` is the producer's time for it.
+ */
+export declare class CostBoundedRule implements PostingRule {
+    readonly bounded: boolean;
+    /** `bounded` false is Phase 1's rule: the same floor, and a take that may build any number of records. */
+    constructor(bounded: boolean);
+    posts(sharing: ThreadSharing, _key: number, ms: number, _diagnosticFiles: readonly number[], _fileIndex: number): boolean;
+    buildBudget(ms: number): number;
+}
+/** Sets the sharing data of this checker thread; its first checker shares with the other threads. */
+export declare function setThreadSharingData(data: ThreadSharingData | undefined): void;
+/** Gives `c` the thread's sharing state, if the thread shares and no checker of it has it yet. */
+export declare function startThreadSharing(c: Checker): void;
+/** A checker's state of sharing with the other checker threads. */
+/** A set of ids (symbol or node ids), a bit each. */
+export declare class IdBits {
+    private bits;
+    has(id: number): boolean;
+    add(id: number): void;
+}
+/**
+ * The files of the diagnostics of results, by key (a symbol or declaration id), with a bit per key: most results have
+ * none, and the bit answers that without a lookup. A file is its index in the program (`Checker.fileIndex`), and -1
+ * a diagnostic without a file.
+ */
+export declare class FilesByKey {
+    private readonly files;
+    private readonly keys;
+    get(key: number): readonly number[] | undefined;
+    set(key: number, files: readonly number[]): void;
+}
+export declare class ThreadSharing {
+    readonly c: Checker;
+    readonly data: ThreadSharingData;
+    readonly types: ResultTable;
+    readonly returns: ResultTable;
+    /** TSC_TS_SHARE_MIN_MS: the shortest computation this checker posts. */
+    readonly minMs: number;
+    /**
+     * Whether this run is cost-bounded, which the run's configuration chose (`RunConfig.bounded`, off by default and
+     * learned from the project's records). Without it the run keeps Phase 1's behavior: no demand bits, no export or
+     * take budget, the 2-8 ms floor.
+     */
+    readonly bounded: boolean;
+    /**
+     * The rule that decides which of this checker's results are posted, and how much a take may build. A small-result
+     * tier stacks on it by constructing its own rule here. Built per checker, not once at module evaluation, for the
+     * reason the cost model's functions give (`shareKappa`).
+     */
+    readonly rule: PostingRule;
+    readonly initialIndexes: Map<number, number>;
+    readonly initial: Type[];
+    readonly numberLogs: Int32Array[];
+    readonly recordTables: Int32Array[];
+    readonly stringLogs: Uint16Array[];
+    readonly used: Int32Array;
+    readonly takers: Int32Array;
+    readonly forbidden: Int32Array;
+    /** The checkers that missed on a key in each file (`ThreadSharingData.wanted`). */
+    readonly wanted: Int32Array;
+    /** The files this checker noted a miss on, so that each is marked in `wanted` once. */
+    private readonly wantedFiles;
+    /** The stop switch of every checker (`ThreadSharingData.control`). */
+    readonly control: Int32Array;
+    /** This checker's row of the counters the main thread reads (`ThreadSharingData.stats`). */
+    readonly stats: Float64Array;
+    readonly row: number;
+    /** The number of results this checker posted. */
+    posted: number;
+    translated: number;
+    /**
+     * Set while this checker exports a result into its store. A computation nested in the export walk can reach
+     * another shared result: posting it would write its records in the middle of the record being exported, and an
+     * export that failed would rewind over the posted result's words.
+     */
+    exporting: boolean;
+    /** Shared results a nested computation left to the checkers that compute them. */
+    nested: number;
+    /** Outermost shared-kind computations: nesting depth, the kind of the current one, and the time by kind. */
+    depth: number;
+    kind: number;
+    readonly kindMs: number[];
+    /** Kinds: 0 owned, 1 computed here for a file another checker took, 2 translated, 3 other. */
+    addOutermost(ms: number): void;
+    /**
+     * Copies this checker's counters into its row of `stats`, the memory the main thread reads them from
+     * while checking runs. Called where a counter changes, a few times per result at most.
+     */
+    writeStats(): void;
+    /** Adds to the milliseconds this checker saved by translating results instead of computing them. */
+    addSaved(ms: number): void;
+    /** Whether the main thread stopped translating posted results (control 2): this checker computes them. */
+    stoppedTranslating(): boolean;
+    notShareable: number;
+    notShareableMs: number;
+    /** Whether the outermost computations are timed by kind (TSC_TS_SHARE_SUMMARY). */
+    readonly timing: boolean;
+    /** TSC_TS_SHARE_VERIFY: translations checked, and those equal only as text. */
+    verified: number;
+    verifiedIdentity: number;
+    belowMin: number;
+    belowMinMs: number;
+    /** Results whose export passed the budget `kappa*T`, and translations that stopped at `lambda*T/c`. */
+    overBudget: number;
+    overBudgetMs: number;
+    stoppedTranslations: number;
+    /** Results not posted because no checker that may take one missed on a key in the declaration's file. */
+    notDemanded: number;
+    exportFailed: number;
+    exportFailedMs: number;
+    readonly exportFailures: Map<string, number>;
+    /** TSC_TS_SHARE_VERIFY=2: records whose translation created types before an earlier record's. */
+    orderViolations: number;
+    storeFailed: number;
+    /** Of `storeFailed`, the results that didn't fit in this checker's logs. */
+    logFull: number;
+    computedPrivately: number;
+    /** Results this checker computed and kept because the main thread stopped sharing (control 1 or 2). */
+    stopped: number;
+    /** How often a posted result couldn't be taken here; and results for declarations of the checker's own files. */
+    sawDoneUnusable: number;
+    owned: number;
+    /** The program's nodes results named, by id. */
+    readonly nodesById: Map<number, Node>;
+    readonly origins: MergedOrigins;
+    translationMs: number;
+    exportMs: number;
+    /** The symbol and signature whose next `getTypeOfSymbol` or `getReturnTypeOfSignature` computes here. */
+    computing: Symbol | undefined;
+    computingSignature: Signature | undefined;
+    /** The value type of `symbol`, or else the return type of `sig`, computed here. */
+    computeHere(symbol: Symbol | undefined, sig: Signature | undefined): Type;
+    /**
+     * The files of the diagnostics each value type (by symbol id) and return type (by declaration id) reported, with
+     * those of the results it used, cached and translated ones too; only for results with diagnostics. A checker that
+     * takes a result checks none of these files, since it would have reported the diagnostics in them.
+     */
+    readonly typeFiles: FilesByKey;
+    readonly returnFiles: FilesByKey;
+    /** The files of the computations in progress, innermost last. */
+    readonly fileStack: (Set<number> | undefined)[];
+    /** Adds `files` to those of the computation in progress. */
+    noteFiles(files: readonly number[] | undefined): void;
+    /** The last `computeShared`: whether its result can be shared, and how long it took. */
+    lastShareable: boolean;
+    lastMs: number;
+    /** `tracked`, recording whether the result can be shared, which it can't when the computation met a resolution cycle. */
+    computeShared(files: FilesByKey, key: number, symbol: Symbol | undefined, sig: Signature | undefined): Type;
+    /** Runs `compute`, keeping in `files` under `key` the files of its diagnostics and of the results it used. */
+    tracked(files: FilesByKey, key: number, symbol: Symbol | undefined, sig: Signature | undefined): Type;
+    /**
+     * The index of the program file named `fileName`, or -1: a diagnostic in a file this checker hasn't is one every
+     * checker would report, like a diagnostic without a file.
+     */
+    fileIndexOfName(fileName: string): number;
+    /** The index of each file by name, built on first use. */
+    private filesByIndex;
+    constructor(c: Checker, data: ThreadSharingData);
+    summary(): string;
+    /**
+     * Whether this checker checks `file`, or may: a result computed for a declaration in it is never taken here. That is
+     * a file it took, and one checked in statement ranges; a file no checker took yet it never checks once it took a
+     * result for it (`forbid`).
+     */
+    owns(file: SourceFile): boolean;
+    /** Whether this checker checks file `index`, or may; -1 names a diagnostic without a file, which it has. */
+    ownsIndex(index: number): boolean;
+    /**
+     * Notes that this checker looked for a result for a declaration in `file` and found none: a checker posts results
+     * for that file only then (`demanded`). One `Atomics.or` per file and checker.
+     */
+    want(file: SourceFile): void;
+    /**
+     * Whether a checker other than this one and the file's taker missed on a key in file `index`: someone other than
+     * the checkers that already compute its declarations would take a result for one of them.
+     */
+    demanded(index: number): boolean;
+    /** After taking a result for a declaration in `file`: if no checker took the file yet, this one never will. */
+    forbid(file: SourceFile): void;
+    forbidIndex(index: number): void;
+    /**
+     * Whether taking a result would leave file `index` to no checker: no checker took it, and every other checker
+     * took results for its declarations already. The main thread would check it, alone.
+     */
+    forbidsLast(index: number): boolean;
+    /** The result checker `k` posted at `offset` in its number log: the record of its type, and the files it named. */
+    result(k: number, offset: number): StoredResult;
+    /** The exporter of this checker's store: it exports each type once. */
+    storeExporter: Exporter | undefined;
+    /**
+     * Exports `t` into this checker's store and logs a result with it as the root; returns its state for the result
+     * tables, -1 if it doesn't fit in the logs or a node or symbol in it can't be named across threads, or why it can't
+     * be exported.
+     */
+    post(t: Type, diagnosticFiles: readonly number[], computeMs: number): number | string;
+    /** The records this checker stored. */
+    storedRecords: number;
+    /** The readers of the other checkers' stores. */
+    readonly readers: (StoreReader | undefined)[];
+    /** The translation of `posted` into this checker, or undefined if it can't be taken here. */
+    translatePosted(producer: number, posted: StoredResult, files: FilesByKey, key: number, declarationFile: SourceFile): Type | undefined;
+}
+/** A result in a checker's store: the record of its type, and the files of its diagnostics. */
+export declare class StoredResult {
+    readonly root: number;
+    readonly files: number[];
+    /** How long computing the result took its producer, in milliseconds. */
+    readonly computeMs: number;
+    constructor(root: number, files: number[], computeMs?: number);
+}
+/** Shares the value type of `symbol` with the other checker threads, computing it with `compute` where needed. */
+export declare function threadTypeOfSymbol(c: Checker, symbol: Symbol): Type;
+/** Notes that the computation in progress used the cached return type of `sig` (see `ThreadSharing.typeFiles`). */
+export declare function noteReturnTypeUse(c: Checker, sig: Signature): void;
+export declare function threadReturnType(c: Checker, sig: Signature): Type;
+/** The nodes of the program records name, by id, found by descending from their file through the nodes that contain them. */
+export declare class NodeFinder {
+    readonly files: readonly SourceFile[];
+    readonly nodesById: Map<number, Node>;
+    private visitor;
+    constructor(files: readonly SourceFile[], nodesById: Map<number, Node>);
+    /** The node of file `fileIndex` with the range `pos`-`end` and id `id`; undefined if the program hasn't it. */
+    find(fileIndex: number, pos: number, end: number, id: number): Node | undefined;
+}
+/**
+ * Reads the records of a checker's store where it wrote them. `begin` starts a record at its offset in the number log
+ * and finds its parts without decoding its kind's fields: its refs, its alias, its symbol, its node, then the fields
+ * at `fields`.
+ */
+export declare class RecordReader {
+    readonly numbers: Int32Array;
+    readonly strings: Uint16Array;
+    readonly table: Int32Array;
+    readonly finder: NodeFinder;
+    /** The record in progress: its header and kind, and where its refs are. */
+    header: number;
+    kind: number;
+    refAt: number;
+    refCount: number;
+    /** Where its alias refs are, if it has an alias; -1 if none. */
+    aliasRefAt: number;
+    aliasRefCount: number;
+    /** How its alias is named: `SymbolNaming` and a merged symbol id, or a node at `aliasNodeStart`. */
+    aliasNaming: number;
+    aliasMergedId: number;
+    aliasNodeStart: number;
+    /** How its symbol is named: the kind of naming, a merged symbol id, or a node at `symbolNodeStart`. */
+    symbolNaming: number;
+    symbolMergedId: number;
+    symbolNodeStart: number;
+    /** Where its node is, if it has one; -1 if none. */
+    nodeStart: number;
+    /** The offset of its kind's own fields. */
+    fields: number;
+    /** The records a record names, filled by `scan`. */
+    readonly deps: number[];
+    constructor(numbers: Int32Array, strings: Uint16Array, table: Int32Array, files: readonly SourceFile[], nodesById: Map<number, Node>);
+    /** Starts the record at `index`; false if the store hasn't it. */
+    begin(index: number): boolean;
+    /** Finds the record's alias refs, its symbol and its node, and the fields that follow them. */
+    private locate;
+    /** The words a node at `p` takes: its file index, range and id, or one word for no node. */
+    nodeWords(p: number): number;
+    /** The node at `p`; undefined if it is none or the program hasn't it. */
+    readNode(p: number): Node | undefined;
+    /** The record's own node; undefined if it has none or the program hasn't it. */
+    node(): Node | undefined;
+    doubleAt(p: number): number;
+    textAt(p: number): string;
+    /**
+     * Collects in `deps` the indexes of the records the record in progress needs: its refs, its alias refs, and the
+     * types of its own fields that are records (a union's origin, an object literal's completion, a completed object's
+     * members' types). A record is written before the records it needs.
+     */
+    scan(): void;
+}
+/**
+ * A consumer's translations of another checker's store: each record is read where it is, and translated once, when a
+ * result first needs it, in the order of the store, which is the order the producer exported them in.
+ */
+declare class StoreReader {
+    readonly sharing: ThreadSharing;
+    readonly producer: number;
+    readonly translator: Translator;
+    readonly reader: RecordReader;
+    /** Whether the last `translate` stopped at its budget, having built nothing. */
+    stopped: boolean;
+    /** By record: the type it translated to, the symbol a property record makes, and whether a completion is done. */
+    readonly types: LinkTable<Type>;
+    readonly symbols: LinkTable<Symbol>;
+    readonly completed: LinkTable<boolean>;
+    constructor(sharing: ThreadSharing, producer: number);
+    /**
+     * Whether record `index` is translated: a property record made its symbol, an object literal got its members, a
+     * shell whose members come later only counts with them. A translation that fails after it built a shell leaves
+     * the empty type behind, and a later translation of the shell alone would take it for the object.
+     */
+    private isBuilt;
+    /** Whether the record in progress names only merged symbols this program has. */
+    private present;
+    /**
+     * The translation of record `root` and the records it needs; undefined if one can't be translated here, or if the
+     * records it would build pass `budget`.
+     */
+    translate(root: number, budget?: number): Type | undefined;
+}
+export {};