@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.3

package/dist/src/session.js

@@ -227,12 +227,12 @@ function projectsOf(snapshot, built, written) {
 /**
  * Runs `visit` over every project the compiler configurations name, inside one never updated
  * snapshot of one client, and answers in their order. A configuration `programs` describes is
- * built as that program, or opened from the configuration it writes, instead of as a project.
- * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
- * under `"record"`. `last` runs after the last visit while the client still answers; the
- * snapshot is disposed and the client released after it, whether the visit completed or threw.
+ * built as that program, or opened from the configuration it writes. One the snapshot holds
+ * nothing for ends the run under `"refuse"` and is named in the result under `"record"`.
+ * `first` runs over every opened project before the first visit and `last` after the last,
+ * both while the client answers; the snapshot and the client are then released.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined) {
+export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined, first = () => undefined) {
     try {
         const built = [];
         const params = [];
@@ -253,7 +253,7 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
         try {
             const opened = projectsOf(snapshot, built, written);
             const log = new UnansweredLog();
-            const projects = [];
+            const views = [];
             const missing = [];
             for (const configFile of configFiles) {
                 const project = opened.get(configFile);
@@ -264,8 +264,13 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
                     missing.push(configFile);
                     continue;
                 }
-                projects.push(visit(viewOf(project, configFile, engine, log)));
+                views.push(viewOf(project, configFile, engine, log));
             }
+            first(views.map((view) => ({
+                configFile: view.configFile,
+                fileNames: () => view.ownSourceFiles().map((file) => file.fileName),
+            })));
+            const projects = views.map((view) => visit(view));
             last();
             return {
                 projects,

package/dist/src/suppress-file.js

@@ -27,6 +27,12 @@ const BASELINE_SHAPE = {
     documentWant: "an object carrying the baseline array, and an optional description",
     recordWant: "a row naming code, symbol, path and reason, each a string",
 };
+/**
+ * The reference scheme of this analyzer's language. A record of the other scheme is
+ * form-checked and then left to the analyzer of its language: it binds nothing here, counts
+ * in neither total and is reported under no code.
+ */
+const OWN_SCHEME = "ts://";
 /** The closed key list of one entry or row. */
 const RECORD_KEYS = new Set(["code", "symbol", "path", "reason"]);
 const CODE_WANT = "DS followed by four digits";
@@ -80,6 +86,9 @@ function readRecord(value, site, byReference, shape) {
     if (path !== undefined && path !== "" && !isEntryPath(path)) {
         return refuse(JSON.stringify(path), PATH_WANT);
     }
+    if (!symbol.startsWith(OWN_SCHEME)) {
+        return { records: [], refusals: [] };
+    }
     const written = {
         code,
         symbol,
@@ -196,12 +205,55 @@ export function rowReason(provenance) {
     return `recorded by ${provenance.analyzer} ${provenance.version}`;
 }
 /**
- * A baseline holding one row per finding, in the order given, which is the report's. Every
- * row carries the provenance as its reason. A finding missing a value a row needs, and an
- * identity missing its name or version, are refused rather than written, because the
- * grammar requires a reason on every row.
+ * The rows of the other language's scheme that the baseline document `text` holds, in
+ * document order and as written, which a write keeps. A document that is not a baseline,
+ * or a row in a shape no record takes, is refused rather than dropped.
+ */
+export function otherSchemeRows(text) {
+    const refuse = (detail) => {
+        throw new Error(`${BASELINE_FILE} cannot be rewritten keeping the other language's rows: ${detail}`);
+    };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        return refuse(error instanceof Error ? error.message : String(error));
+    }
+    const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+    if (!Array.isArray(held)) {
+        return refuse(BASELINE_SHAPE.documentWant);
+    }
+    return held.flatMap((value) => {
+        try {
+            readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
+        }
+        catch (error) {
+            return refuse(error instanceof Error ? error.message : String(error));
+        }
+        // readRecord has checked every member is a string and the code and symbol are present.
+        const { code, symbol, path, reason } = value;
+        if (code === undefined || symbol === undefined || symbol.startsWith(OWN_SCHEME)) {
+            return [];
+        }
+        return [
+            {
+                code,
+                symbol,
+                ...(path === undefined ? {} : { path }),
+                ...(reason === undefined ? {} : { reason }),
+            },
+        ];
+    });
+}
+/**
+ * A baseline holding one row per finding, in the order given, which is the report's, after
+ * the other language's rows `kept`, so two analyzers writing one document in either order
+ * write the same bytes. Every recorded row carries the provenance as its reason. A finding
+ * missing a value a row needs, and an identity missing its name or version, are refused
+ * rather than written, because the grammar requires a reason on every row.
  */
-export function writeBaseline(findings, provenance) {
+export function writeBaseline(findings, provenance, kept = []) {
     if (provenance.analyzer === "" || provenance.version === "") {
         throw new Error(`a baseline row would carry no reason: the analyzer identity names ${JSON.stringify(provenance.analyzer)} at version ${JSON.stringify(provenance.version)}`);
     }
@@ -212,5 +264,5 @@ export function writeBaseline(findings, provenance) {
         }
         return { code: found.code, symbol: found.symbol, path: found.path, reason };
     });
-    return jsonChunks({ description: BASELINE_DESCRIPTION, baseline }, 2);
+    return jsonChunks({ description: BASELINE_DESCRIPTION, baseline: [...kept, ...baseline] }, 2);
 }

package/dist/src/suppress-inline.js

@@ -1,7 +1,7 @@
 /**
  * The inline directive: `deadset:ignore`, the first token of a `//` line comment, naming
  * one or more codes and a reason, and binding to every declaration that begins on the line
- * below it.
+ * below it, or on its own line where it trails a token there.
  */
 import { SyntaxKind } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
@@ -170,6 +170,14 @@ function declarationLines(file, held, symbols) {
     file.forEachChild(visit);
     return below;
 }
+/**
+ * Whether the comment at `offset` follows a token on its own line, so it binds the
+ * declarations that begin on that line rather than on the next.
+ */
+function trails(file, offset) {
+    const { line } = file.getLineAndCharacterOfPosition(offset);
+    return tokenStart(file.text, file.getPositionOfLineAndCharacter(line, 0)) < offset;
+}
 /**
  * Every comment in the namespace one project's own files hold, each with the declarations
  * it binds, read while the project's view is open.
@@ -187,19 +195,20 @@ export function inlineDirectives(project, held, targetRoot) {
         const below = declarationLines(file, held, symbols);
         for (const comment of comments) {
             const site = renderPosition(file, targetRoot, comment.offset);
+            const target = trails(file, comment.offset) ? site.line : site.line + 1;
             found.push({
                 site,
                 text: comment.text,
                 directive: classifyComment(comment.text),
-                bound: [...(below.get(site.line + 1) ?? [])],
+                bound: [...(below.get(target) ?? [])],
             });
         }
     }
     return found;
 }
 /**
- * The inline directives of a run's projects, each bound to the declarations that begin on
- * the line below it, one directive binding the union of what each project holding its file
+ * The inline directives of a run's projects, each bound to the declarations the placement
+ * rule gives it, one directive binding the union of what each project holding its file
  * declares there. A directive that lacks only its reason is one {@link Refusal} per code;
  * any other malformed comment in the namespace ends the read with a
  * {@link SuppressionError} naming the first one written.

package/dist/src/suppress.js

@@ -2,8 +2,9 @@
  * The suppression grammar's records, and the ledger that decides what each one did. A
  * record is one code bound to one site with its reason, from an inline directive, an
  * ignore entry or a baseline row. A bound record marks its declaration live before the
- * sweep, and is in effect when it withholds the finding its code would have produced
- * there, dormant when the configuration withholds that finding anyway, and stale otherwise.
+ * sweep, unless its code reports a part or a dependency row, and is in effect when it
+ * withholds a finding its code would have produced there, dormant when the configuration
+ * withholds every such finding anyway, and stale otherwise.
  */
 import { ConfigError } from "./config.js";
 import { positionKey } from "./position.js";
@@ -68,28 +69,48 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
+/**
+ * The subject kinds that are a dependency row, each with the code that reports one. An
+ * ignore entry or a baseline row naming the row's reference and file withholds its finding
+ * and marks nothing, and an inline directive never binds one.
+ */
+const DEPENDENCY_SUBJECTS = new Map([
+    ["dependency", ["DS1601"]],
+    ["module-directive", ["DS1605"]],
+]);
 /**
  * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. A record binds to a declaration, so nothing
- * withholds a finding about one.
+ * each with the codes that report one. Apart from a dependency row, nothing withholds a
+ * finding about one.
  */
 const ROW_SUBJECTS = new Map([
     ["file", ["DS1501", "DS1502"]],
-    ["dependency", ["DS1601"]],
-    ["module-directive", ["DS1605"]],
+    ...DEPENDENCY_SUBJECTS,
     ["root", ["DS1704"]],
     ["configured-declaration", ["DS1706"]],
     ["suppression", ["DS1701", "DS1702", "DS1703"]],
     ["edge", ["DS1705"]],
 ]);
-/** Whether a finding's subject is a row of a document, which no record can withhold. */
+/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
     return ROW_SUBJECTS.has(kind);
 }
-/** Whether a code reports a row of a document, so no record naming it can match. */
+/** Whether a code reports a row of a document. */
 export function isRowCode(code) {
     return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
 }
+/** Whether a finding's subject is a dependency row. */
+export function isDependencySubject(kind) {
+    return DEPENDENCY_SUBJECTS.has(kind);
+}
+/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
+export function isDependencyCode(code) {
+    return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+}
+/** Whether a code reports a row of a document that no record of any mechanism can name. */
+export function isUnsuppressibleCode(code) {
+    return isRowCode(code) && !isDependencyCode(code);
+}
 /**
  * The subject kinds that are a part of a declaration rather than a declaration: a part
  * has no reference of its own, so a finding about one names the declaration that holds
@@ -124,10 +145,19 @@ function claimKey(finding) {
  * Whether one record names one finding. A record reaches a finding in two ways: it bound
  * the declaration at the finding's position, or it names the finding's reference and the
  * file the finding is reported in, each exactly. The second is how an entry copied from a
- * finding about a part of a declaration reaches the part.
+ * finding about a part of a declaration reaches the part, and the only way any record
+ * reaches a dependency row.
  */
 export function pairs(record, finding) {
-    if (record.code !== finding.code || ROW_SUBJECTS.has(finding.symbol.kind)) {
+    if (record.code !== finding.code) {
+        return false;
+    }
+    if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
+        return (record.mechanism !== "inline" &&
+            record.symbol === finding.symbol.ref &&
+            record.path === finding.position.path);
+    }
+    if (ROW_SUBJECTS.has(finding.symbol.kind)) {
         return false;
     }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {
@@ -137,31 +167,31 @@ export function pairs(record, finding) {
 }
 /**
  * Decides every record against `would`, the findings the run would produce were no record
- * there: swept with no mark, where a kind about liveness reports the marked declaration,
- * and as swept, where a kind whose subject the sweep holds live reports it. The first
- * record in reading order claims a finding, so a second naming it is stale. A record whose
- * code the dials withhold from its declaration, or whose claimed finding they withhold, is
- * dormant.
+ * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
+ * in reading order claims a finding, so a second naming it is stale; a part-kind record
+ * claims every finding of its code about a part of its declaration. A record is dormant
+ * when the dials withhold every finding it claims, read from those findings alone, or when
+ * it claims none and its code's severity is `allow`.
  */
 export function ledgerOf(records, would, dials) {
     const taken = new Set();
     const verdicts = [];
     for (const record of records) {
-        if (record.bound !== "" && dials.withholdsCode(record.code, record.bound)) {
-            verdicts.push("dormant");
+        const open = (finding) => !taken.has(claimKey(finding)) && pairs(record, finding);
+        const first = would.find(open);
+        const claimed = first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
+        if (claimed.length === 0) {
+            verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
             continue;
         }
-        const claimed = would.find((finding) => !taken.has(claimKey(finding)) && pairs(record, finding));
-        if (claimed === undefined) {
-            verdicts.push("stale");
-            continue;
+        for (const finding of claimed) {
+            taken.add(claimKey(finding));
         }
-        taken.add(claimKey(claimed));
-        verdicts.push(dials.withholds(claimed) ? "dormant" : "in-effect");
+        verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
     }
     return {
         verdicts,
-        withheld: (finding) => taken.has(claimKey(finding)) && !ROW_SUBJECTS.has(finding.symbol.kind),
+        withheld: (finding) => taken.has(claimKey(finding)),
     };
 }
 /** The suppression counts of one run's records and the ledger over them. */

package/dist/src/unimplemented-callees.js

@@ -0,0 +1,312 @@
+/**
+ * The members read where code the target cannot see receives a value of a target type. An
+ * object literal argument of a call or a `new` whose callee has no implementation in the
+ * target has every member of the parameter type it is checked against read, nested
+ * literals included. An `as` expression over an object no file of the project declares, and
+ * a `new` through an unimplemented construct signature, hand the target a value the
+ * outside code holds, so every member of the type it is given is read.
+ */
+import { isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isSatisfiesExpression, isTypeReferenceNode, isVariableDeclaration, } from "@typescript/native/unstable/ast";
+import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+/** The value an `as` expression asserts a type of, through every `as` and parenthesis around it. */
+function castOperand(node) {
+    let at = node;
+    while (isAsExpression(at) || isParenthesizedExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/** Whether a declaration node carries a body of statements or an expression. */
+function hasBody(node) {
+    return node.body !== undefined;
+}
+function isFunctionLike(node) {
+    return (node !== undefined &&
+        (isArrowFunction(node) ||
+            isFunctionExpression(node) ||
+            isFunctionDeclaration(node) ||
+            isClassExpression(node)));
+}
+/** The name a declaration is declared under, where it has one an identifier spells. */
+function nameOf(node) {
+    const name = node.name;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/**
+ * Whether an overload signature has its implementation beside it: a declaration of the same
+ * name and kind, in the same statement list or class body, that carries a body.
+ */
+function overloadImplemented(node) {
+    if (!isFunctionDeclaration(node) && !isMethodDeclaration(node)) {
+        return false;
+    }
+    const name = nameOf(node);
+    let implemented = false;
+    node.parent.forEachChild((sibling) => {
+        implemented ||= sibling.kind === node.kind && nameOf(sibling) === name && hasBody(sibling);
+    });
+    return implemented;
+}
+/** Every object literal one argument holds, the argument itself included, through nested property values. */
+function literalsOf(argument) {
+    if (!isObjectLiteralExpression(argument)) {
+        return [];
+    }
+    return [
+        argument,
+        ...argument.properties.flatMap((property) => isPropertyAssignment(property) ? literalsOf(property.initializer) : []),
+    ];
+}
+/**
+ * The reads the object-literal arguments of one project's own files make of the members of
+ * the types they are checked against, where the callee has no implementation in the target.
+ */
+export function unimplementedCalleeReads(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const own = project.ownPaths();
+    const passing = [];
+    const implementing = [];
+    const asserted = [];
+    const constructed = [];
+    const handing = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            if ((isCallExpression(node) || isNewExpression(node)) &&
+                (node.arguments ?? []).some((argument) => isObjectLiteralExpression(argument))) {
+                passing.push({ file, from: holder, call: node });
+            }
+            if (isNewExpression(node)) {
+                constructed.push({ file, from: holder, call: node });
+            }
+            if ((isCallExpression(node) || isNewExpression(node)) &&
+                (node.arguments ?? []).some((argument) => isFunctionLike(argument) || isIdentifier(argument))) {
+                handing.push(node);
+            }
+            if (isAsExpression(node) && !isAsExpression(node.parent)) {
+                asserted.push({ file, from: holder, node, operand: castOperand(node) });
+            }
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                for (const clause of node.heritageClauses ?? []) {
+                    if (isHeritageClause(clause)) {
+                        implementing.push(...clause.types.map((one) => isTypeReferenceNode(one) ? one.typeName : one.expression));
+                    }
+                }
+            }
+            // An object literal typed as an interface implements that interface's methods.
+            if (isVariableDeclaration(node) &&
+                node.type !== undefined &&
+                isTypeReferenceNode(node.type) &&
+                node.initializer !== undefined &&
+                isObjectLiteralExpression(node.initializer)) {
+                implementing.push(node.type.typeName);
+            }
+            if ((isSatisfiesExpression(node) || isAsExpression(node)) &&
+                isObjectLiteralExpression(node.expression) &&
+                isTypeReferenceNode(node.type)) {
+                implementing.push(node.type.typeName);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId);
+        });
+    }
+    if (passing.length === 0 && asserted.length === 0 && constructed.length === 0) {
+        return [];
+    }
+    const resolved = (symbol) => {
+        if (symbol === UNANSWERED || symbol === undefined) {
+            return undefined;
+        }
+        if ((symbol.flags & SymbolFlags.Alias) === 0) {
+            return symbol;
+        }
+        const target = queries.aliased(symbol);
+        return target === UNANSWERED ? undefined : target;
+    };
+    const declarationsOf = (symbol) => (symbol?.declarations ?? []).flatMap((handle) => {
+        const node = project.declarationAt(handle)?.node;
+        return node === undefined ? [] : [node];
+    });
+    const implemented = new Set(queries.symbolsAt(implementing).flatMap((symbol) => declarationsOf(resolved(symbol))));
+    /** Whether a declaration is a function or a class of the target, or a variable or property it initializes. */
+    const ownFunction = (node) => own.has(node.getSourceFile().fileName) &&
+        (isFunctionLike(node) ||
+            ((isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)) &&
+                isFunctionLike(node.initializer)));
+    /**
+     * Whether a function or a class of the target reaches one parameter of a function of the
+     * target, passed for it by a call that names the function. A call through another name
+     * is not followed, so its callee keeps no implementation and its literal reads more.
+     */
+    const reachedParameters = new Map();
+    const parameterReached = (parameter) => {
+        const known = reachedParameters.get(parameter);
+        if (known !== undefined) {
+            return known;
+        }
+        const fn = parameter.parent;
+        const fnName = nameOf(fn) ?? (isVariableDeclaration(fn.parent) ? nameOf(fn.parent) : undefined);
+        const at = fn.parameters?.indexOf(parameter) ?? -1;
+        const passed = handing.flatMap((call) => {
+            const callee = call.expression;
+            const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+            if (fnName === undefined || !isIdentifier(name) || name.text !== fnName) {
+                return [];
+            }
+            const signature = queries.resolvedSignature(call);
+            const handle = signature === UNANSWERED || signature === undefined ? undefined : signature.declaration;
+            const argument = handle === undefined || project.declarationAt(handle)?.node !== fn
+                ? undefined
+                : (call.arguments ?? [])[at];
+            return argument === undefined || at < 0 ? [] : [argument];
+        });
+        const named = passed.filter((argument) => isIdentifier(argument));
+        const reached = passed.some((argument) => isFunctionLike(argument)) ||
+            queries
+                .symbolsAt(named)
+                .some((symbol) => declarationsOf(resolved(symbol)).some((node) => ownFunction(node)));
+        reachedParameters.set(parameter, reached);
+        return reached;
+    };
+    /** Whether some function, class or object literal of the target stands for a signature. */
+    const standsFor = (passed) => {
+        const signature = queries.resolvedSignature(passed.call);
+        const handle = signature === UNANSWERED || signature === undefined ? undefined : signature.declaration;
+        const declaration = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+        if (declaration === undefined) {
+            return true;
+        }
+        if (hasBody(declaration) || overloadImplemented(declaration)) {
+            return own.has(handle?.path ?? "");
+        }
+        const holder = declaration.parent;
+        if (holder !== undefined && implemented.has(holder)) {
+            return true;
+        }
+        const callee = passed.call.expression;
+        const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+        const [named] = queries.symbolsAt([name]);
+        return declarationsOf(resolved(named)).some((node) => isParameterDeclaration(node)
+            ? own.has(node.getSourceFile().fileName) && parameterReached(node)
+            : ownFunction(node) && !isFunctionLike(node));
+    };
+    const literals = [];
+    for (const passed of passing) {
+        if (standsFor(passed)) {
+            continue;
+        }
+        for (const argument of passed.call.arguments ?? []) {
+            literals.push(...literalsOf(argument).map((literal) => ({ passed, literal })));
+        }
+    }
+    const contexts = queries.contextualTypes(literals.map((one) => one.literal));
+    const found = [];
+    literals.forEach(({ passed, literal }, at) => {
+        const context = contexts[at];
+        if (context === UNANSWERED || context === undefined) {
+            return;
+        }
+        const parts = queries.constituents(context);
+        const position = renderPosition(passed.file, root, literal.getStart());
+        for (const part of parts === UNANSWERED ? [context] : parts) {
+            const properties = queries.propertiesOf(part);
+            for (const property of properties === UNANSWERED ? [] : properties) {
+                for (const to of chains.declarationsOf(property)) {
+                    found.push({
+                        from: passed.from,
+                        to,
+                        position,
+                        use: "read",
+                        resolution: "contextual",
+                        test: testFiles.has(position.path),
+                    });
+                }
+            }
+        }
+    });
+    found.push(...handedOver());
+    return found;
+    /** Whether a type is an object no file of the project declares, a platform object's among them. */
+    function outsideValue(type) {
+        if (!type.isObjectType()) {
+            return false;
+        }
+        const symbol = queries.symbolOfType(type);
+        const declared = symbol === UNANSWERED ? undefined : symbol;
+        return declared?.declarations.every((handle) => !own.has(handle.path)) === true;
+    }
+    /** Whether a type is an object type a file of the project declares. */
+    function ownObject(type) {
+        const known = type === UNANSWERED ? undefined : type;
+        if (!known?.isObjectType()) {
+            return false;
+        }
+        const symbol = queries.symbolOfType(known);
+        const declared = symbol === UNANSWERED ? undefined : symbol;
+        return declared?.declarations.some((handle) => own.has(handle.path)) === true;
+    }
+    /** The reads of every member of each target type an outside value is handed over as. */
+    function handedOver() {
+        const operandTypes = queries.typesAt(asserted.map((one) => one.operand));
+        const fromCasts = asserted.filter((_one, at) => {
+            const type = operandTypes[at];
+            return type !== UNANSWERED && type !== undefined && outsideValue(type);
+        });
+        const newTypes = queries.typesAt(constructed.map((one) => one.call));
+        // A construct signature whose declared result is one of its type parameters names no
+        // type the target declares, so only a result the signature itself names is handed over.
+        const fromConstructors = constructed
+            .filter((one, at) => {
+            if (!ownObject(newTypes[at]) || standsFor(one)) {
+                return false;
+            }
+            const signature = queries.resolvedSignature(one.call);
+            const result = signature === UNANSWERED || signature === undefined
+                ? undefined
+                : queries.returnTypeOf(signature);
+            return result !== UNANSWERED && result !== undefined && !result.isTypeParameter();
+        })
+            .map((one) => ({ file: one.file, from: one.from, node: one.call }));
+        const handed = [...fromCasts, ...fromConstructors];
+        const types = queries.typesAt(handed.map((one) => one.node));
+        const reads = [];
+        handed.forEach((one, at) => {
+            const type = types[at];
+            if (type === UNANSWERED || type === undefined) {
+                return;
+            }
+            const position = renderPosition(one.file, root, one.node.getStart());
+            const parts = queries.constituents(type);
+            for (const part of parts === UNANSWERED ? [type] : parts) {
+                if (!ownObject(part)) {
+                    continue;
+                }
+                const properties = queries.propertiesOf(part);
+                for (const property of properties === UNANSWERED ? [] : properties) {
+                    for (const to of chains.declarationsOf(property)) {
+                        reads.push({
+                            from: one.from,
+                            to,
+                            position,
+                            use: "read",
+                            resolution: "contextual",
+                            test: testFiles.has(position.path),
+                        });
+                    }
+                }
+            }
+        });
+        return reads;
+    }
+}

package/dist/src/value-reach.js

@@ -1,11 +1,10 @@
 /**
  * The classes of the target a value of one type carries, and the members of the other
- * object types the target writes that it carries, as a serializer walking the value
- * reaches them: through union and intersection constituents, array and tuple elements,
- * and the data members and index signatures of the target's classes and of the
- * interfaces and object types the target writes. The walk stops at `any`, `unknown`, a
- * type parameter, a function and an interface or class of another program, so an
- * instance held only there is missed.
+ * object types the target writes that it carries, as a serializer walking the value reaches
+ * them: through constituents, array and tuple elements, the data members and index
+ * signatures of the types the target writes, and the values `stored` gives for a type where
+ * it erases them. The walk stops at `any`, `unknown`, a type parameter, a function and an
+ * interface or class of another program, so an instance held only there is missed.
  */
 import { ObjectFlags, SymbolFlags, } from "@typescript/native/unstable/sync";
 import { classNames, typesAt } from "./class-members.js";
@@ -28,7 +27,7 @@ function arrayTargets(project) {
  * The walk over one project's types, against the classes of `held`, the same
  * project's inventory.
  */
-export function valueReach(project, held) {
+export function valueReach(project, held, stored = () => []) {
     const queries = project.queries;
     const names = [...classNames(project, held)];
     const declared = typesAt(project, names.map(([, node]) => node));
@@ -110,6 +109,7 @@ export function valueReach(project, held) {
                 found = must(queries.typeArguments(type));
             }
         }
+        found = [...found, ...stored(type)];
         children.set(type.id, found);
         return found;
     };