@geastack/compiler 1.0.15

package/dist/semantics/normalize/identities.js

@@ -0,0 +1,426 @@
+import ts from 'typescript';
+import { declarationId, functionId, nodeId } from '../../identity/ids.js';
+import { isAmbientDeclaration } from '../ambient.js';
+import { emptySpecializationCensus, genericSubjectOf } from './specialization.js';
+import { createPathSubstitution } from './structural-generics.js';
+export const rootSpecialization = [];
+/**
+ * The identity suffix for a path: the ordinals alone.
+ *
+ * The owner is deliberately left out. A node's own identity already pins where
+ * it is, so which generics enclose it is not in question -- only which copy is,
+ * and that is what the ordinals say. Putting the owner in as well would make the
+ * suffix longer without making any two copies more distinguishable.
+ */
+export const specializationKey = (path) => path.map((step) => step.ordinal).join('.');
+/**
+ * Ordinals for every node of a file, in one deterministic order.
+ *
+ * Two passes, and the second one is not an afterthought: `ts.forEachChild` does
+ * not descend into a node's attached JSDoc, and in a JavaScript source **JSDoc
+ * is the type syntax**. `/** @type {{start:number,count:number}} *\/` parses to a
+ * real `TypeLiteral` -- the declaration of an anonymous object type, exactly
+ * what `const x: { start: number }` declares in TypeScript -- and the checker
+ * hands that node back as a declaration like any other. Reached only through
+ * `node.jsDoc`, it never entered the map, so `declarationIdOf` threw and every
+ * producer that touched the type reported a failure instead of a type. That was
+ * 3291 of the three.js app's 6492 diagnostics: three.js is compiled from source, so its
+ * JSDoc is load-bearing.
+ *
+ * The JSDoc pass runs *after* the whole child walk rather than inline with it,
+ * so every ordinal a program already had keeps the value it had: JSDoc
+ * identities are appended past the end, and nothing that did not need this
+ * moves. Determinism is unaffected -- the second pass repeats the first pass's
+ * order and visits each node's tags in source order.
+ */
+const walkOrdinals = (file) => {
+    const ordinals = new Map();
+    let next = 0;
+    const assign = (node) => {
+        if (ordinals.has(node))
+            return;
+        ordinals.set(node, next);
+        next += 1;
+    };
+    const visit = (node) => {
+        assign(node);
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    // The attached comments themselves, which `forEachChild` skips and no public
+    // accessor reports in full: `ts.getJSDocTags` was tried first and drops whole
+    // blocks -- a host carrying three comments, one of them a `@callback`, hands
+    // back only the tags of the other two, so every `JSDocSignature` in
+    // `three/src/loaders/Loader.js` stayed unreachable. `node.jsDoc` is the
+    // parser's own list and is complete; it is `@internal` in the shipped
+    // declarations, so the field is named here in a structural type rather than
+    // reached through `any`. `forEachChild` DOES descend once inside a JSDoc node,
+    // so one walk from each comment reaches every tag, type expression and
+    // literal under it.
+    const visitJsDoc = (node) => {
+        for (const comment of node.jsDoc ?? [])
+            visit(comment);
+        ts.forEachChild(node, visitJsDoc);
+    };
+    visitJsDoc(file);
+    return ordinals;
+};
+export const createIdentityTable = (program, checker, specializations = emptySpecializationCensus) => {
+    // Sorting by the program's own file names gives a deterministic index without
+    // that name ever reaching an identity: only the index does.
+    //
+    // Ambient declaration files are indexed too. They are not compiled, but every
+    // program references declarations that live in them -- `Array`, `Promise`,
+    // `Record` -- and a declaration the compiler can reach must have an identity
+    // wherever it was declared. Excluding them makes `declarationIdOf` throw the
+    // first time any real program mentions a library type.
+    const files = program
+        .getSourceFiles()
+        .slice()
+        .sort((left, right) => (left.fileName < right.fileName ? -1 : left.fileName > right.fileName ? 1 : 0));
+    const fileIndex = new Map();
+    files.forEach((file, index) => fileIndex.set(file, `f${index}`));
+    const ordinalsByFile = new Map();
+    const ordinalOf = (node) => {
+        const file = node.getSourceFile();
+        const identity = fileIndex.get(file);
+        if (identity === undefined)
+            throw new Error('node belongs to a source file outside the compiled program');
+        let ordinals = ordinalsByFile.get(file);
+        if (!ordinals) {
+            ordinals = walkOrdinals(file);
+            ordinalsByFile.set(file, ordinals);
+        }
+        const ordinal = ordinals.get(node);
+        if (ordinal === undefined)
+            throw new Error('node was not reached by the deterministic walk of its source file');
+        return { file: identity, ordinal };
+    };
+    const fileIdentityOf = (file) => {
+        const identity = fileIndex.get(file);
+        if (identity === undefined)
+            throw new Error('source file is outside the compiled program');
+        return identity;
+    };
+    const sourceFileNames = new Map(files.map((file) => [fileIdentityOf(file), file.fileName]));
+    const nodeIdOf = (node, path = rootSpecialization) => {
+        const { file, ordinal } = ordinalOf(node);
+        const id = nodeId(file, ts.SyntaxKind[node.kind], ordinal, specializationKey(path));
+        return id;
+    };
+    const declarationIdOf = (declaration, path = rootSpecialization) => {
+        const { file, ordinal } = ordinalOf(declaration);
+        const id = declarationId(file, ordinal, specializationKey(path));
+        return id;
+    };
+    const functionIdOf = (declaration, path = rootSpecialization) => functionId(declarationIdOf(declaration, path));
+    /**
+     * The symbol a reference denotes once import aliases are followed.
+     *
+     * `import { f } from './m'` and a direct reference to `f` are the same
+     * binding, and treating them as two would let one operation acquire two
+     * identities. Checked JavaScript's `const f = require('./m')` is ALSO an
+     * alias to the checker -- that is how it types `f.x` from the target's
+     * `module.exports` -- but at run time it is a local cell the loader's
+     * result is stored into, and its declaration is the variable, not the
+     * target module's `module.exports = ...` assignment. Following it named a
+     * declaration the program never introduces (`native-boundary:external-
+     * binding` on fastify's `const AjvCompiler = require(...)`). An alias whose
+     * own declaration is a variable or a binding element is that cell.
+     */
+    const aliasTargetOf = (symbol) => {
+        if ((symbol.flags & ts.SymbolFlags.Alias) === 0)
+            return symbol;
+        if ((symbol.declarations ?? []).some((declaration) => ts.isVariableDeclaration(declaration) || ts.isBindingElement(declaration)))
+            return symbol;
+        return checker.getAliasedSymbol(symbol);
+    };
+    const declarationOfSymbol = (symbol) => {
+        const resolved = aliasTargetOf(symbol);
+        // A merged ambient global -- `interface Error {}` for the type plus
+        // `declare var Error: ErrorConstructor` for the value -- is one symbol with
+        // two declarations, and this returns the first. For a *value* reference
+        // that is the wrong one whenever the interface sorts earlier: the name then
+        // anchors on a type-space declaration that has no constructor, which is why
+        // `new Error(...)` finds no callable.
+        //
+        // Preferring `valueDeclaration` here is NOT the fix, and it was measured:
+        // both the unconditional form and one narrowed to the interface-first merge
+        // sent a whole family of corpus programs into unbounded recursion.
+        // The reason is that this one function answers two questions. The same
+        // declaration is the nominal ANCHOR the structural walk interns a shape
+        // under, and moving `Error`'s anchor onto its `var` makes that anchor's type
+        // `ErrorConstructor`, whose `prototype: Error` closes the cycle the anchor
+        // existed to break.
+        //
+        // So the value declaration belongs to the caller that is resolving a value,
+        // not to this shared resolution. Splitting the two is the fix, and it is not
+        // a one-line one.
+        const declarations = resolved.getDeclarations();
+        return declarations && declarations.length > 0 ? (declarations[0] ?? null) : null;
+    };
+    /**
+     * The value half of the question `declarationOfSymbol` answers.
+     *
+     * The body of an overloaded function creates its one runtime binding;
+     * otherwise `valueDeclaration` is TypeScript's answer to which declaration
+     * holds the value. The fallback matters: a symbol with no
+     * value declaration at all -- a pure type -- keeps the anchor's answer, which
+     * is what every caller that is *not* resolving a value already relies on.
+     */
+    const valueDeclarationOfSymbol = (symbol) => {
+        const resolved = aliasTargetOf(symbol);
+        // Overload signatures introduce no function object. TypeScript's value
+        // declaration can be the first signature, but every read must name the
+        // implementation binding that FunctionDeclarationInstantiation creates.
+        const implementation = resolved
+            .getDeclarations()
+            ?.find((declaration) => ts.isFunctionDeclaration(declaration) && declaration.body !== undefined);
+        if (implementation)
+            return implementation;
+        return resolved.valueDeclaration ?? declarationOfSymbol(resolved);
+    };
+    /**
+     * `genericSubjectOf` with the checker bound in, and memoized.
+     *
+     * Memoized because `prefixFor` asks it once per step per node -- the hottest
+     * path in the whole table -- and the identifier case costs a symbol
+     * resolution. The answer is a pure function of the node, so caching it is
+     * caching a fact rather than a decision.
+     */
+    const subjects = new Map();
+    const targetOfName = (name) => {
+        const symbol = checker.getSymbolAtLocation(name);
+        return symbol ? valueDeclarationOfSymbol(symbol) : null;
+    };
+    const subjectOf = (declaration) => {
+        const known = subjects.get(declaration);
+        if (known !== undefined)
+            return known;
+        const subject = genericSubjectOf(declaration, targetOfName);
+        subjects.set(declaration, subject);
+        return subject;
+    };
+    /**
+     * Which copy a use site reaches, when the thing it names is a generic this
+     * program instantiates.
+     *
+     * The site recorded by the specialization census is the call or the type
+     * reference itself, so a name in callee position asks about its parent. A
+     * name that reaches no instantiation answers `null` and falls back to the
+     * lexical rule, which is what every non-generic reference wants.
+     *
+     * `substitute` is what the copy doing the naming binds a type parameter to. A
+     * site inside a generic is routinely written with that generic's own
+     * parameter -- `extends Component<Root>` -- and its arguments are concrete
+     * only once they have been substituted for this copy. Without it such a site
+     * reads as "no instantiation" and the name falls back to the unspecialized
+     * declaration, which is a class the census never published.
+     */
+    const useSitePath = (declaration, at, substitute) => {
+        // The node the census keys copies on, which for `const f = <T>...` is the
+        // arrow rather than the declaration naming it -- see `genericSubjectOf`.
+        // Both the comparison and the path entry use it, so a name resolves to the
+        // very entry `census.ts` pushed when it forked.
+        const subject = subjectOf(declaration);
+        for (const node of [at, at?.parent]) {
+            const site = node ? specializations.specializationAt(node, substitute) : null;
+            if (site && site.declaration === subject)
+                return [{ owner: subject, ordinal: site.ordinal }];
+        }
+        // No site, and a `const f = <T>...` with exactly ONE copy: that copy is the
+        // only thing the name can mean. The root identity is not an alternative --
+        // `census.ts` records this declaration per copy and never at the root, so
+        // falling back to it names a declaration the program does not introduce,
+        // which the emitter then refuses by name at the read.
+        //
+        // This is `instantiation.ts`'s own rule one level up: a hole filled the
+        // same way everywhere has one answer, and taking it is exact rather than
+        // an approximation. Two or more copies has no single answer -- `const jsxs
+        // = jsx` genuinely denotes a template, which C++ has no value for -- and
+        // falls through to be refused rather than answered with a guess.
+        //
+        // ⛔ NARROW ON PURPOSE -- but the line is AMBIENT, not the spelling.
+        //
+        // The first cut of this rule was `if (subject === declaration) return
+        // null`, which admitted only the `const f = <T>...` spelling, where the
+        // subject is the arrow and the declaration the variable naming it.
+        // Applied to every generic instead, it re-keyed names that were resolving
+        // to the root correctly and had every right to: measured over the corpus,
+        // `image-demo` lost its certificate to a `return-conversion:
+        // native-handle(GeaEmbeddedImage) -> native-record-ref` that did not
+        // exist before, `e-reader` stopped emitting on a `SetConstructor` handle
+        // that "carries no [[Construct]] convention", and `dialer` stopped
+        // compiling.
+        //
+        // Every one of those is a declaration a HOST owns: `Set`, `Map`,
+        // `GeaEmbeddedImage`. A host's protocol is keyed on the root, because the
+        // host implements the thing once and this program never forks it, so
+        // answering a copy for one breaks the binding rather than fixing one.
+        // That is the real line, and `semantics/ambient.ts` already draws it --
+        // "declared, never defined" is exactly "the root is the only id there
+        // is".
+        //
+        // A generic this program DEFINES is the other side: `census.ts` records
+        // it per copy and never at the root, so a name that falls back to the
+        // root names a declaration the program does not introduce, which the
+        // emitter then refuses by name at the read. hono reaches this with
+        // `new HonoRequest(...)` (introduced as `decl|f77|148@0`, read as
+        // `decl|f77|148`) and with a plain generic function declaration called
+        // from one of its own copies.
+        if (isAmbientDeclaration(declaration))
+            return null;
+        const copies = specializations.specializationsOf(subject);
+        const only = copies.length === 1 ? copies[0] : undefined;
+        if (only)
+            return [{ owner: subject, ordinal: only.ordinal }];
+        return null;
+    };
+    const symbolDeclarationId = (symbol, at) => {
+        const declaration = declarationOfSymbol(symbol);
+        if (!declaration)
+            return null;
+        return declarationIdOf(declaration, useSitePath(declaration, at) ?? rootSpecialization);
+    };
+    const symbolValueDeclarationId = (symbol, at) => {
+        const declaration = valueDeclarationOfSymbol(symbol);
+        if (!declaration)
+            return null;
+        return declarationIdOf(declaration, useSitePath(declaration, at) ?? rootSpecialization);
+    };
+    /**
+     * How much of a copy's path applies to one node.
+     *
+     * A node is inside a generic when that generic is one of its ancestors. The
+     * path lists the copies enclosing the *candidate*, outermost first, so the
+     * answer for any other node is the longest prefix of that list whose owners
+     * are all ancestors of it -- full path for a node in the copy's own body,
+     * empty for one declared outside every enclosing generic, and a proper prefix
+     * for one in an outer generic but not an inner.
+     */
+    const contains = (ancestor, node) => {
+        for (let current = node; current; current = current.parent)
+            if (current === ancestor)
+                return true;
+        return false;
+    };
+    /**
+     * Whether one copy's step applies to this node.
+     *
+     * Ancestry is the usual answer: a node inside a generic's body belongs to
+     * whichever copy of it is being walked. `const f = <T>(x: T) => x` is the one
+     * shape where the relation runs the other way -- the copy is keyed on the
+     * arrow, which is the declaration's CHILD, so ancestry says no for the
+     * declaration that names it while `census.ts` has already recorded that
+     * declaration under the copy's path. Two answers for one node, and the read
+     * then names an identity the program never introduces.
+     */
+    /**
+     * Whether `node` sits in a variable declaration whose subject is this step's
+     * owner.
+     *
+     * `census.ts` walks a forked declaration's WHOLE subtree under the copy's
+     * path -- the name, the type annotation, and for `const jsxs = jsx` the
+     * initializer that names the subject. Agreeing only about the declaration
+     * node itself leaves every node under it minted at the root while the census
+     * recorded it in the copy, which is a dangling citation for any of them that
+     * produces a cited result: the alias's own initializer read is exactly that,
+     * and it withheld the declaration that cites it.
+     *
+     * The first enclosing variable declaration is the answer, not the first
+     * MATCHING one. A node inside a nested declaration belongs to that one; if it
+     * also belongs to this copy it is reached by ancestry below, which is the
+     * ordinary rule.
+     */
+    const inDeclarationOf = (owner, node) => {
+        for (let current = node; current !== undefined; current = current.parent) {
+            if (ts.isVariableDeclaration(current))
+                return subjectOf(current) === owner;
+            if (ts.isSourceFile(current))
+                return false;
+        }
+        return false;
+    };
+    const stepApplies = (owner, node) => inDeclarationOf(owner, node) || contains(owner, node);
+    const prefixFor = (node, path) => {
+        let length = 0;
+        while (length < path.length) {
+            const step = path[length];
+            if (!step || !stepApplies(step.owner, node))
+                break;
+            length += 1;
+        }
+        return length === path.length ? path : path.slice(0, length);
+    };
+    const copyKeyOf = (path) => path.map((step) => `${nodeIdOf(step.owner)}#${step.ordinal}`).join('/');
+    const views = new Map();
+    const forSpecialization = (path) => {
+        const key = copyKeyOf(path);
+        const cached = views.get(key);
+        if (cached)
+            return cached;
+        // What this copy binds each type parameter to, which is what turns a site
+        // written with an enclosing generic's own parameter (`extends
+        // Component<Root>`) into the concrete arguments that name one copy. Built
+        // once per view, for the same reason the view itself exists.
+        const substituteInPath = createPathSubstitution(declarationOfSymbol, specializations, path);
+        // An INLINE generic callable -- `memoizeOne(<T extends JSDocType>(kind) =>
+        // ...)` -- is its own copy's subject, and the census records its
+        // allocation under that copy (`census.ts` forks at the arrow) while the
+        // call holding it asks from the enclosing path. The site the census keyed
+        // on the arrow itself (`specialization.ts`'s `fromValueUse`) names the
+        // copy, exactly as `useSitePath` resolves a NAME to one; without it the
+        // caller cited an allocation minted under a path it never spelled.
+        const pathOf = (node) => {
+            const prefix = prefixFor(node, path);
+            if (!(ts.isArrowFunction(node) || ts.isFunctionExpression(node)))
+                return prefix;
+            if (prefix.some((step) => step.owner === node))
+                return prefix;
+            const site = specializations.specializationAt(node, substituteInPath);
+            return site && site.declaration === node ? [...prefix, { owner: node, ordinal: site.ordinal }] : prefix;
+        };
+        const view = {
+            forSpecialization,
+            copyKeyOf,
+            prefixFor,
+            fileIdentityOf,
+            sourceFileNames,
+            nodeIdOf: (node, override) => nodeIdOf(node, override ?? pathOf(node)),
+            declarationIdOf: (declaration, override) => declarationIdOf(declaration, override ?? pathOf(declaration)),
+            functionIdOf: (declaration, override) => functionIdOf(declaration, override ?? pathOf(declaration)),
+            declarationOfSymbol,
+            valueDeclarationOfSymbol,
+            genericSubjectOf: subjectOf,
+            symbolDeclarationId: (symbol, at) => {
+                const declaration = declarationOfSymbol(symbol);
+                if (!declaration)
+                    return null;
+                return declarationIdOf(declaration, useSitePath(declaration, at, substituteInPath) ?? prefixFor(declaration, path));
+            },
+            symbolValueDeclarationId: (symbol, at) => {
+                const declaration = valueDeclarationOfSymbol(symbol);
+                if (!declaration)
+                    return null;
+                return declarationIdOf(declaration, useSitePath(declaration, at, substituteInPath) ?? prefixFor(declaration, path));
+            }
+        };
+        views.set(key, view);
+        return view;
+    };
+    return {
+        forSpecialization,
+        copyKeyOf,
+        prefixFor,
+        fileIdentityOf,
+        sourceFileNames,
+        nodeIdOf,
+        declarationIdOf,
+        functionIdOf,
+        declarationOfSymbol,
+        valueDeclarationOfSymbol,
+        genericSubjectOf: subjectOf,
+        symbolDeclarationId,
+        symbolValueDeclarationId
+    };
+};

package/dist/semantics/normalize/implicit-arguments-tuple.d.ts

@@ -0,0 +1,97 @@
+import ts from 'typescript';
+import { type ImplicitArgumentsSlot } from './implicit-arguments.js';
+/**
+ * What the magic `arguments` frame of one source function holds, owned by the
+ * parameter census and read by every consumer of that frame: the structural
+ * mapper's phantom rest slot (`structural-parts.ts`), numeric reads of the
+ * object (`implicitArgumentsReadTypeAt`), and the positional expansion of a
+ * forwarded `...arguments` (`producers/spread-arguments.ts`).
+ *
+ * Two frames, chosen by how the body reads the object:
+ *
+ * - `tuple`: every read names a FIXED position -- a literal index, or a final
+ *   `...arguments` spread into a callee convention with no rest formal, which
+ *   reads positions `0..n-1` exactly. Each position is then its own fact,
+ *   joined over the closed callers that fill it. This is the shape three's
+ *   WebGL forwarding shims need: `texImage3D()` is called with numbers in its
+ *   leading positions and `ArrayBufferView | null` in its last, and one element
+ *   type over all ten positions could only be a union no caller wrote.
+ *   Positions from `required` on are ones some closed caller omits, so they
+ *   are optional: a read there is `T | undefined`, and the rest slot leaves
+ *   the field absent rather than inventing a value.
+ * - `array`: the body reads a position only known at run time
+ *   (`arguments[i]`, `arguments.length`), reads its own element back through
+ *   a recursive call, or declares parameters in front of the phantom slot.
+ *   The frame is then a runtime-sized Array of one element type joined over
+ *   every supplied position -- the frame this fact published before positions
+ *   existed.
+ */
+export type ImplicitArgumentsTuple = {
+    readonly frame: 'tuple';
+    readonly elements: readonly ts.Type[];
+    readonly required: number;
+} | {
+    readonly frame: 'array';
+    readonly element: ts.Type;
+};
+/** The one convention fact the fixed-spread admission reads off a callee. */
+export interface ArgumentsSpreadConvention {
+    /** The callee's rest formal, or `null` when it declares none. */
+    readonly restFrom: number | null;
+}
+/**
+ * Whether `args[index]` is a final magic-`arguments` spread into a callee
+ * with a static convention and no rest formal.
+ *
+ * Such a spread fills the callee's formals POSITIONALLY: the frame's values
+ * land at `0..n-1` exactly as a written argument list would, and a formal no
+ * value reaches binds `undefined` the way an omitted argument does. It must be
+ * the LAST argument, or a later written argument would land at a position only
+ * the frame's runtime length knows; the callee must declare no rest formal, or
+ * the split between named formals and the packed tail would be that same
+ * runtime fact. `convention === null` is a callee with no static convention at
+ * all, which states nothing to fill positionally.
+ *
+ * Shared by the census (which admits the spread as a read-only use of the
+ * frame) and the producer (which mints one read per position): the two
+ * deciding separately is how an admitted use would meet a refused expansion.
+ */
+export declare const isFixedArgumentsSpreadAt: (checker: ts.TypeChecker, args: readonly ts.Expression[], index: number, convention: ArgumentsSpreadConvention | null) => boolean;
+export interface ImplicitArgumentsEvidence {
+    readonly checker: ts.TypeChecker;
+    readonly owner: ts.SignatureDeclaration;
+    readonly slot: ImplicitArgumentsSlot;
+    /** Every reference to the owner's own `arguments` frame. */
+    readonly uses: readonly ts.Identifier[];
+    /** The owner's closed call sites; the census has already proved the set closed. */
+    readonly calls: readonly (ts.CallExpression | ts.NewExpression)[];
+    /** The arguments a call site passes, after the census's explicit-`this` rewrite. */
+    readonly argumentsOf: (call: ts.CallExpression | ts.NewExpression) => readonly ts.Expression[];
+    /** Whether the shared write inventory names this node as a write target. */
+    readonly isWritten: (node: ts.Expression) => boolean;
+    readonly isRecursiveCall: (call: ts.CallExpression | ts.NewExpression) => boolean;
+    /** The settled type an argument holds, or `null` when it states nothing usable. */
+    readonly argumentTypeOf: (argument: ts.Expression) => ts.Type | null;
+    /** The owner's own declared parameter types that state a usable upper bound. */
+    readonly statedElements: readonly ts.Type[];
+}
+export type ImplicitArgumentsInference = {
+    readonly tuple: ImplicitArgumentsTuple;
+} | {
+    readonly refused: string;
+    readonly evidence?: ts.Node;
+};
+/**
+ * The frame fact for one owner, from its uses and its closed callers.
+ *
+ * Never inferred from only the callers that happened to type: one caller
+ * whose argument states nothing refuses the whole frame, because the frame is
+ * what EVERY caller fills.
+ */
+export declare const inferImplicitArgumentsTuple: (evidence: ImplicitArgumentsEvidence) => ImplicitArgumentsInference;
+/** One element read's type out of a settled frame: `index === null` is a position only known at run time. */
+export declare const implicitArgumentsElementTypeOf: (checker: ts.TypeChecker, tuple: ImplicitArgumentsTuple, index: number | null) => ts.Type | null;
+/** Every numeric read consumes the owning frame's fact, including reads published to sibling censuses. */
+export declare const implicitArgumentsReadTypeAt: (checker: ts.TypeChecker, node: ts.Node, tupleAt: (owner: ts.Node) => ImplicitArgumentsTuple | null) => ts.Type | null;
+/** Two settled frame facts state the same frame: the fixpoint's identity test for this query. */
+export declare const sameImplicitArgumentsTuple: (left: ImplicitArgumentsTuple, right: ImplicitArgumentsTuple) => boolean;