@geastack/compiler 1.0.15

package/dist/semantics/normalize/flow/parameter-values.d.ts

@@ -0,0 +1,27 @@
+import ts from 'typescript';
+import { type ValueFlowIndex } from './model.js';
+/**
+ * # Parameter values over closed callers
+ *
+ * Every expression a parameter can be bound to, or `null` when some caller
+ * cannot be enumerated. A parameter is a cell whose writes are the arguments
+ * of its calls, so the question is only whether every call is known:
+ *
+ * - A constructor's calls are the constructions of its class family, which
+ *   `ownedClassReceiverInventoryOf` enumerates completely or refuses, plus
+ *   every `super(...)` of a subclass whose base constructor it is. A
+ *   subclass with no constructor of its own forwards its arguments unchanged.
+ * - Any other callable needs callable reach's closed call-site proof beside
+ *   the calls the checker names directly. A `.call`/`.apply` site shifts
+ *   argument positions and refuses, as does an `arguments` mention in a
+ *   non-class function: in sloppy mode that object aliases the parameters.
+ *
+ * A missing argument binds `undefined`, which holds nothing, so it adds no
+ * value. A default initializer adds one whenever any call exists. Stores to the
+ * parameter inside its body are plain writes and add their values too.
+ */
+type Call = ts.CallExpression | ts.NewExpression;
+/** Every call that runs this constructor: family constructions it is the nearest constructor of, and subclass `super(...)` calls. */
+export declare const constructorCallsOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, constructor: ts.ConstructorDeclaration) => Call[] | null;
+export declare const parameterValuesOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, parameter: ts.ParameterDeclaration) => readonly ts.Expression[] | null;
+export {};

package/dist/semantics/normalize/flow/parameter-values.js

@@ -0,0 +1,251 @@
+import ts from 'typescript';
+import { outermostErasureOf } from '../producers/erasure.js';
+import { isClassSpelledSourceClass } from './model.js';
+import { indexCallableReach } from './callable-reach.js';
+import { ownedClassReceiverInventoryOf } from './owned-class-receivers.js';
+import { isModuleExportedDeclaration, isTypePositionReference, runtimeParametersOf } from './targets.js';
+import { enterHypothesisGuard, exitHypothesisGuard, hypothesisGuardIsOpen, noteHypothesis } from './proof-hypotheses.js';
+const reaches = new WeakMap();
+const answers = new WeakMap();
+/** Body writes that bind the whole parameter to a stated value; the argument edges are enumerated from the calls instead. */
+const BODY_WRITES = new Set([
+    'identifier-assignment',
+    'logical-assignment',
+    'declaration-initializer',
+    'default-parameter'
+]);
+const ARGUMENT_WRITES = new Set(['call-argument', 'super-argument']);
+const isThisParameter = (parameter) => ts.isIdentifier(parameter.name) && parameter.name.text === 'this';
+const baseClassOf = (checker, owner) => {
+    // A constructor function has no `extends`, and the prototype-chain spelling
+    // that stands in for one is refused at admission (`familyRootsOf`), so a
+    // root that reaches here provably has no base rather than merely no
+    // heritage clause.
+    if (!isClassSpelledSourceClass(owner))
+        return null;
+    const extended = owner.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0];
+    if (!extended)
+        return null;
+    const declaration = checker.getTypeAtLocation(extended.expression).getSymbol()?.valueDeclaration;
+    return declaration && (ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration)) ? declaration : null;
+};
+/**
+ * The `constructor(...)` member `owner` declares, or null.
+ *
+ * Null for a constructor function is the right answer, not a refusal: its
+ * parameters are an ordinary function's, bound by the `call-argument` edges
+ * the flow index already records at `new F( ... )`. This census exists for the
+ * case those edges cannot see -- a constructor reached through a SUBCLASS
+ * construction or a `super(...)` -- and neither is reachable for a root with
+ * no base.
+ */
+const ownConstructorOf = (owner) => (isClassSpelledSourceClass(owner)
+    ? owner.members.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined)
+    : undefined) ?? null;
+/** The constructor `new owner(...)` runs, or `null` when no source constructor is on the chain. */
+const constructorRunBy = (checker, owner) => {
+    const seen = new Set();
+    for (let current = owner; current && !seen.has(current); current = baseClassOf(checker, current)) {
+        seen.add(current);
+        const own = ownConstructorOf(current);
+        if (own)
+            return own;
+    }
+    return null;
+};
+/** `super(...)` calls in a constructor; an arrow function shares its `super`, a nested function or class does not. */
+const superCallsIn = (constructor) => {
+    const calls = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)
+            calls.push(node);
+        if (ts.isFunctionLike(node) && !ts.isArrowFunction(node))
+            return;
+        if (ts.isClassLike(node))
+            return;
+        ts.forEachChild(node, visit);
+    };
+    if (constructor.body)
+        ts.forEachChild(constructor.body, visit);
+    return calls;
+};
+/**
+ * A class body is UNCONDITIONALLY strict code (ECMA-262 `ClassTail`), with or
+ * without a `'use strict'` directive.
+ *
+ * That settles the only question the `arguments` refusal below exists to ask.
+ * A MAPPED `arguments` -- the one whose elements alias the parameter bindings,
+ * so that `arguments[ 0 ] = x` rewrites the first parameter -- is created only
+ * for a NON-strict function with a simple parameter list
+ * (`FunctionDeclarationInstantiation`). Inside a class element the object is
+ * always the unmapped kind: writing the parameter cannot change the frame and
+ * writing the frame cannot change the parameter, so enumerating the call
+ * arguments still enumerates every value the parameter can hold.
+ *
+ * three's `Object3D.add( object )` walks its own `arguments` to add several
+ * children at once, and that alone refused `object`'s value set -- which is
+ * the cell behind the `array-element` carriers, the largest single group in
+ * the three.js app's nested population.
+ *
+ * ⚠ Narrow on purpose. A plain function in an ES module, or under an explicit
+ * `'use strict'`, is also always unmapped and could join this -- but proving
+ * "this file is a module" is a different question, and a class element is the
+ * slice that is unambiguous from syntax alone.
+ */
+const isAlwaysStrictClassElement = (callable) => ts.isClassElement(callable) && (ts.isClassDeclaration(callable.parent) || ts.isClassExpression(callable.parent));
+const mentionsArguments = (callable) => {
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isIdentifier(node) && node.text === 'arguments')
+            found = true;
+        if (ts.isFunctionLike(node) && !ts.isArrowFunction(node))
+            return;
+        ts.forEachChild(node, visit);
+    };
+    if ('body' in callable && callable.body)
+        ts.forEachChild(callable.body, visit);
+    return found;
+};
+/** Every call that runs this constructor: family constructions it is the nearest constructor of, and subclass `super(...)` calls. */
+export const constructorCallsOf = (checker, flow, constructor) => {
+    const owner = constructor.parent;
+    const inventory = ownedClassReceiverInventoryOf(checker, flow, new Set([owner]));
+    if (!inventory)
+        return null;
+    const calls = [];
+    for (const { call, familyProjection } of inventory.constructionFacts) {
+        if (familyProjection.some((constructed) => constructorRunBy(checker, constructed) === constructor))
+            calls.push(call);
+    }
+    for (const member of inventory.classes) {
+        const own = member === owner ? null : ownConstructorOf(member);
+        const base = own && baseClassOf(checker, member);
+        if (own && base && constructorRunBy(checker, base) === constructor)
+            calls.push(...superCallsIn(own));
+    }
+    return calls;
+};
+/**
+ * The calls of a callable bound once to an unexported name that only direct
+ * calls mention (three's `uploadTexture`). Callable reach leaves exactly
+ * these to its consumer. Any other mention -- an alias, an export, a
+ * publication -- is callable reach's to prove.
+ */
+const directCallsOf = (checker, flow, callable) => {
+    const position = outermostErasureOf(callable);
+    const binding = ts.isFunctionDeclaration(callable)
+        ? callable
+        : ts.isVariableDeclaration(position.parent) && position.parent.initializer === position && ts.isIdentifier(position.parent.name)
+            ? position.parent
+            : null;
+    if (!binding?.name || isModuleExportedDeclaration(checker, binding, checker.getSymbolAtLocation(binding.name) ?? null))
+        return null;
+    const rebound = flow
+        .writesToDeclaration(binding)
+        .some((write) => write.slot === 'whole' && write.edge !== 'return' && write.edge !== 'declaration-initializer');
+    if (rebound)
+        return null;
+    const calls = [];
+    for (const reference of flow.referencesToDeclaration(binding)) {
+        if (reference === binding.name || isTypePositionReference(reference))
+            continue;
+        const callee = outermostErasureOf(reference);
+        const call = callee.parent;
+        if (!(ts.isCallExpression(call) || ts.isNewExpression(call)) || call.expression !== callee)
+            return null;
+        calls.push(call);
+    }
+    return calls;
+};
+const callableCallsOf = (checker, flow, callable) => {
+    if (mentionsArguments(callable) && !isAlwaysStrictClassElement(callable))
+        return null;
+    const direct = directCallsOf(checker, flow, callable);
+    const calls = new Set(direct ?? []);
+    if (!direct) {
+        let reach = reaches.get(flow);
+        if (!reach)
+            reaches.set(flow, (reach = indexCallableReach(checker, flow)));
+        const enumerated = reach.enumeratedCallSitesOf(callable);
+        if (!enumerated)
+            return null;
+        for (const call of enumerated)
+            calls.add(call);
+        for (const site of flow.calls) {
+            if (site.checkerDeclaration !== callable && site.inferredDeclaration !== callable && !site.targets.includes(callable))
+                continue;
+            if (site.explicitThis)
+                return null;
+            calls.add(site.call);
+        }
+    }
+    for (const call of calls) {
+        const callee = call.expression;
+        if (ts.isPropertyAccessExpression(callee) && (callee.name.text === 'call' || callee.name.text === 'apply'))
+            return null;
+    }
+    return [...calls];
+};
+const computeParameterValues = (checker, flow, parameter) => {
+    if (!ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || isThisParameter(parameter))
+        return null;
+    const callable = parameter.parent;
+    if (!ts.isFunctionLike(callable) || callable.getSourceFile().isDeclarationFile)
+        return null;
+    // An ambient or overload signature is not the code the call runs.
+    if (!('body' in callable) || !callable.body)
+        return null;
+    const index = runtimeParametersOf(callable).indexOf(parameter);
+    const calls = ts.isConstructorDeclaration(callable)
+        ? constructorCallsOf(checker, flow, callable)
+        : callableCallsOf(checker, flow, callable);
+    if (!calls)
+        return null;
+    const values = [];
+    for (const call of calls) {
+        const args = call.arguments ?? [];
+        // A spread before or at this position may fill it with anything.
+        if (args.slice(0, index + 1).some(ts.isSpreadElement))
+            return null;
+        if (args[index])
+            values.push(args[index]);
+    }
+    if (calls.length > 0 && parameter.initializer)
+        values.push(parameter.initializer);
+    for (const write of flow.writesToDeclaration(parameter)) {
+        if (write.slot !== 'whole' || ARGUMENT_WRITES.has(write.edge))
+            continue;
+        if (!BODY_WRITES.has(write.edge) || write.value === null)
+            return null;
+        if (write.value !== parameter.initializer)
+            values.push(write.value);
+    }
+    return values;
+};
+export const parameterValuesOf = (checker, flow, parameter) => {
+    let held = answers.get(flow);
+    if (!held)
+        answers.set(flow, (held = new Map()));
+    if (held.has(parameter)) {
+        // The recursive `null` below is a HYPOTHESIS, not a result, and a caller
+        // that keeps a refusal must know it leaned on one: the settled answer is
+        // written over it moments later, so an answer computed inside the window
+        // is only valid while this same parameter is still being proven.
+        if (hypothesisGuardIsOpen(parameter))
+            noteHypothesis(parameter);
+        return held.get(parameter);
+    }
+    // A recursive query for the same parameter is refused while it is proven.
+    held.set(parameter, null);
+    enterHypothesisGuard(parameter);
+    try {
+        const values = computeParameterValues(checker, flow, parameter);
+        held.set(parameter, values);
+        return values;
+    }
+    finally {
+        exitHypothesisGuard(parameter, true);
+    }
+};

package/dist/semantics/normalize/flow/proof-hypotheses.d.ts

@@ -0,0 +1,66 @@
+/** Record that the computation now running leaned on `key` being assumed. */
+export declare const noteHypothesis: (key: object) => void;
+export declare const hypothesisNotes: () => number;
+/** Begin collecting what a computation leans on; the returned set is its trail. */
+export declare const pushHypothesisTrail: () => Set<object>;
+export declare const popHypothesisTrail: () => void;
+export declare const hypothesisSettledAsTruth: (key: object) => boolean;
+export declare const enterHypothesisGuard: (key: object) => void;
+/**
+ * An answer a memo holds whose applicability still names hypotheses.
+ *
+ * `assumed` is deliberately mutable: a hypothesis is not permanent. The guard
+ * that issued it eventually produces the REAL answer to the same question, and
+ * when that answer is what the guard handed out, the hypothesis has become a
+ * fact -- so the answers that leaned on it stop depending on it and are
+ * reusable everywhere.
+ */
+export interface GuardedAnswer {
+    readonly assumed: Set<object>;
+}
+/**
+ * A key nothing ever parks and no guard ever opens. An answer carrying it can
+ * never apply again -- which is exactly what should happen to one that leaned
+ * on a hypothesis the real answer went on to contradict.
+ */
+export declare const REFUTED_HYPOTHESIS: object;
+/**
+ * Hold `answer` for every open guard it leaned on, so closing that guard can
+ * settle it. Without this a guard-leaning answer was simply discarded, and
+ * measurement says that is nearly all of them: in 200,000 three.js proof
+ * entries the member-closure memo computed 156,070 answers and KEPT 119 --
+ * 155,951 were thrown away for naming an open guard. Every later ask of those
+ * same questions then had to prove them again, which is where millions of
+ * proof entries over 64 distinct questions come from.
+ */
+export declare const registerGuardedAnswer: (answer: GuardedAnswer, discard?: () => void) => void;
+/**
+ * `confirmed` says whether the answers that leaned on this hypothesis are
+ * still sound once the real answer is known.
+ *
+ * Which way that falls depends on the KIND of hypothesis, and the two kinds
+ * are opposites. A RE-ENTRY guard is pessimistic: it hands its re-entries
+ * "unknown" -- a refusal, a null, an empty set -- so an answer computed under
+ * it is conservative. If the real answer turns out to be KNOWN, that does not
+ * make the conservative answer wrong; it only makes it weaker than it needed
+ * to be, and a weaker sound answer is still sound. Such a guard confirms
+ * either way. An OPTIMISTIC park is the reverse: it hands out "closed/true",
+ * so an answer leaning on it is only as good as that claim and must be struck
+ * when the claim fails.
+ *
+ * Getting this backwards is expensive and silent. Every guard enrolled here
+ * is pessimistic, and every site reported "cannot tell": of 787,705 answers
+ * registered in one three.js run, 0 were ever confirmed and 668,256 were struck
+ * AND spliced out of their buckets. The memo then held almost nothing, which
+ * is why the buckets never reached their cap (`droppedByLimit=0`) while the
+ * same questions kept missing and re-proving.
+ */
+/** TEMPORARY INSTRUMENT -- not for landing. Counts how the discharge actually settles. */
+export declare const hypothesisStats: {
+    registered: number;
+    confirmed: number;
+    struck: number;
+    discarded: number;
+};
+export declare const exitHypothesisGuard: (key: object, confirmed?: boolean, settled?: boolean) => void;
+export declare const hypothesisGuardIsOpen: (key: object) => boolean;

package/dist/semantics/normalize/flow/proof-hypotheses.js

@@ -0,0 +1,162 @@
+/**
+ * The hypotheses a whole-program proof is answering UNDER, and the trail each
+ * computation leaves of the ones it leaned on.
+ *
+ * Two different things park a question in this compiler and both are
+ * hypotheses in exactly the same sense:
+ *
+ * - an OPTIMISTIC park -- `activeMembers`, `activeFamilies`, an open record or
+ *   value proof -- answers "closed" on the strength of a proof still running,
+ *   so a POSITIVE answer that leaned on it is reusable only where the same
+ *   park is in force. `callable-reach.ts` has always recorded these.
+ * - a RE-ENTRY guard -- an invocation fact, a record method call, a slot read
+ *   or a member-implementation walk already on the stack -- answers "unknown"
+ *   for the same reason, so a REFUSAL that leaned on it is reusable only where
+ *   that same question is still open. These were recorded nowhere, which is
+ *   why no memo in the proof could keep a refusal: a refusal might have been
+ *   false, and nothing said which ones could have been.
+ *
+ * Both are trails of object keys and one stack carries them, so a memo asks
+ * one question of an answer -- "is every key it leaned on still in force" --
+ * whichever kind of hypothesis produced it.
+ *
+ * MODULE level, not per proof: a nested question re-enters through a fresh
+ * `indexCallableReach`, and only a shared stack sees across those frames.
+ */
+const trails = [];
+let notes = 0;
+/** Record that the computation now running leaned on `key` being assumed. */
+export const noteHypothesis = (key) => {
+    notes++;
+    trails[trails.length - 1]?.add(key);
+};
+export const hypothesisNotes = () => notes;
+/** Begin collecting what a computation leans on; the returned set is its trail. */
+export const pushHypothesisTrail = () => {
+    const trail = new Set();
+    trails.push(trail);
+    return trail;
+};
+export const popHypothesisTrail = () => {
+    trails.pop();
+};
+/**
+ * Re-entry guards open right now, counted because the same question can be
+ * re-entered through two nesting proofs and the outer one must keep it open
+ * after the inner one returns.
+ *
+ * Counted rather than a plain set for a second reason: the guard SETS
+ * themselves are proof-local (`activeInvocationFacts` is a fresh `Set` per
+ * `indexCallableReach`), so "is this question still being answered" is a
+ * question about the STACK, not about one proof's bookkeeping.
+ */
+const openGuards = new Map();
+/**
+ * Keys whose guard closed having handed every re-entry exactly the answer the
+ * question turned out to have.
+ *
+ * This is a STRICTLY STRONGER claim than `confirmed` below, and the two must
+ * not be conflated. `confirmed` says a conservative answer stays SOUND now that
+ * the real answer is known, which is true of every pessimistic guard by
+ * construction. That is enough to keep an answer the memo already holds. It is
+ * NOT enough to promote a REFUSAL from "true while this question was open" to
+ * "true": a refusal computed under a guard that went on to answer something
+ * knowable is weaker than the question deserves, and replaying it refuses
+ * where a fresh walk would have succeeded -- a program that compiled stops
+ * compiling. Certification needs completeness, not only soundness.
+ *
+ * `settled` is the completeness half: the guard handed out a refusal, and the
+ * refusal was the truth. An answer that leaned on it lost nothing by leaning.
+ *
+ * A guard that reopens on the same key is answering the question again and may
+ * answer it differently, so entering clears any settlement from last time; a
+ * key is only ever noted while its guard is open, so no trail can carry a
+ * settlement that belongs to a previous episode.
+ */
+const settledAsTruth = new WeakSet();
+export const hypothesisSettledAsTruth = (key) => settledAsTruth.has(key);
+export const enterHypothesisGuard = (key) => {
+    settledAsTruth.delete(key);
+    openGuards.set(key, (openGuards.get(key) ?? 0) + 1);
+};
+/**
+ * A key nothing ever parks and no guard ever opens. An answer carrying it can
+ * never apply again -- which is exactly what should happen to one that leaned
+ * on a hypothesis the real answer went on to contradict.
+ */
+export const REFUTED_HYPOTHESIS = Object.freeze({ hypothesis: 'refuted' });
+const guardDependents = new Map();
+/**
+ * Hold `answer` for every open guard it leaned on, so closing that guard can
+ * settle it. Without this a guard-leaning answer was simply discarded, and
+ * measurement says that is nearly all of them: in 200,000 three.js proof
+ * entries the member-closure memo computed 156,070 answers and KEPT 119 --
+ * 155,951 were thrown away for naming an open guard. Every later ask of those
+ * same questions then had to prove them again, which is where millions of
+ * proof entries over 64 distinct questions come from.
+ */
+export const registerGuardedAnswer = (answer, discard) => {
+    for (const key of answer.assumed) {
+        if (!openGuards.has(key))
+            continue;
+        let dependents = guardDependents.get(key);
+        if (!dependents)
+            guardDependents.set(key, (dependents = []));
+        dependents.push({ answer, discard });
+        hypothesisStats.registered++;
+    }
+};
+/**
+ * `confirmed` says whether the answers that leaned on this hypothesis are
+ * still sound once the real answer is known.
+ *
+ * Which way that falls depends on the KIND of hypothesis, and the two kinds
+ * are opposites. A RE-ENTRY guard is pessimistic: it hands its re-entries
+ * "unknown" -- a refusal, a null, an empty set -- so an answer computed under
+ * it is conservative. If the real answer turns out to be KNOWN, that does not
+ * make the conservative answer wrong; it only makes it weaker than it needed
+ * to be, and a weaker sound answer is still sound. Such a guard confirms
+ * either way. An OPTIMISTIC park is the reverse: it hands out "closed/true",
+ * so an answer leaning on it is only as good as that claim and must be struck
+ * when the claim fails.
+ *
+ * Getting this backwards is expensive and silent. Every guard enrolled here
+ * is pessimistic, and every site reported "cannot tell": of 787,705 answers
+ * registered in one three.js run, 0 were ever confirmed and 668,256 were struck
+ * AND spliced out of their buckets. The memo then held almost nothing, which
+ * is why the buckets never reached their cap (`droppedByLimit=0`) while the
+ * same questions kept missing and re-proving.
+ */
+/** TEMPORARY INSTRUMENT -- not for landing. Counts how the discharge actually settles. */
+export const hypothesisStats = { registered: 0, confirmed: 0, struck: 0, discarded: 0 };
+export const exitHypothesisGuard = (key, confirmed, settled) => {
+    const remaining = (openGuards.get(key) ?? 0) - 1;
+    if (remaining > 0) {
+        openGuards.set(key, remaining);
+        return;
+    }
+    openGuards.delete(key);
+    if (settled === true)
+        settledAsTruth.add(key);
+    const dependents = guardDependents.get(key);
+    if (dependents === undefined)
+        return;
+    guardDependents.delete(key);
+    for (const { answer, discard } of dependents) {
+        answer.assumed.delete(key);
+        if (confirmed === true) {
+            hypothesisStats.confirmed++;
+            continue;
+        }
+        hypothesisStats.struck++;
+        if (discard !== undefined)
+            hypothesisStats.discarded++;
+        // The answer rested on something the real answer contradicted. Striking it
+        // is not enough: a memo bucket is BOUNDED, and a dead answer sitting in it
+        // keeps a live one out. The three.js app filled every bucket to the cap within the
+        // first 200,000 proof entries and then refused 148,185 further answers.
+        answer.assumed.add(REFUTED_HYPOTHESIS);
+        discard?.();
+    }
+};
+export const hypothesisGuardIsOpen = (key) => openGuards.has(key);

package/dist/semantics/normalize/flow/record-alias-closure.d.ts

@@ -0,0 +1,27 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+/** The static key an object-literal entry is published under, or null when it has none. */
+export declare const objectLiteralEntryKeyOf: (name: ts.PropertyName) => string | null;
+export declare const recordAllocationAliasesClosed: (checker: ts.TypeChecker, flow: ValueFlowIndex, root: ts.ObjectLiteralExpression) => boolean;
+/**
+ * Whether `this`, in a function this literal was written holding, can only
+ * ever be one of the literal's own allocations.
+ *
+ * A function written in place in a literal is reachable only through the
+ * literal's slot. If no alias of the literal hands that slot's function out as
+ * a value, and every alias reaches only uses this proof enumerates, then every
+ * call of the function is `alias.key( ... )`, and its receiver is the literal.
+ * Three's `ColorManagement` is such a record: `convert` reads `this.enabled`,
+ * and the checker names the literal's `enabled: true` for it -- a name a second
+ * literal with a getter under that key would satisfy just as well, which is why
+ * the checker's answer alone is not evidence.
+ *
+ * The walk is the slot proof's, with three differences. A store into a data
+ * slot is admitted: it keeps the slot data and hands the record to no one. A
+ * call of a slot whose function reads `this` follows that function's every
+ * `this` as one more alias, where the slot proof refused it. And an exported
+ * cell is followed into every importer (`inProgramImportReferencesOf`). A read
+ * of a `this`-reading function as a value still refuses: that is the function
+ * leaving the record.
+ */
+export declare const recordLiteralReceiverClosed: (checker: ts.TypeChecker, flow: ValueFlowIndex, root: ts.ObjectLiteralExpression) => boolean;