@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/references.js

@@ -1,16 +1,18 @@
-import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExternalModuleReference, isForInStatement, isForOfStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
+import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, nodeKey } from "./inventory.js";
 import { relativePath } from "./paths.js";
-import { byPosition, renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP, UNANSWERED } from "./query.js";
+import { byPosition, isComponentFile, renderPosition } from "./position.js";
+import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
+import { typeQueryAliases } from "./type-query-alias.js";
+import { handedOn, valuesOf } from "./value-flow.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
- * among them: it reads its target only to write the result back, so nothing else
- * receives what it read, and a declaration whose every other reference is one of these
- * carries no information out of itself.
+ * among them: where its value is discarded it reads its target only to write the result
+ * back, so nothing else receives what it read.
  */
 const ASSIGNMENTS = new Set([
     SyntaxKind.EqualsToken,
@@ -30,6 +32,36 @@ const ASSIGNMENTS = new Set([
     SyntaxKind.QuestionQuestionEqualsToken,
     SyntaxKind.CaretEqualsToken,
 ]);
+/**
+ * The assignments that read their target to decide whether to store at all, so the read
+ * carries information out whatever becomes of the result.
+ */
+const LOGICAL_ASSIGNMENTS = new Set([
+    SyntaxKind.BarBarEqualsToken,
+    SyntaxKind.AmpersandAmpersandEqualsToken,
+    SyntaxKind.QuestionQuestionEqualsToken,
+]);
+/**
+ * Whether the value of one store expression is discarded: it is a statement of its own, a
+ * clause of a `for` loop, the operand of `void`, or the left operand of a comma.
+ */
+function valueDiscarded(node) {
+    let child = node;
+    let parent = node.parent;
+    while (isParenthesizedExpression(parent)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+        return true;
+    }
+    if (isForStatement(parent)) {
+        return parent.initializer === child || parent.incrementor === child;
+    }
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.CommaToken &&
+        parent.left === child);
+}
 /** Whether one node is an identifier or a private name, the two forms a name takes. */
 function isName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
@@ -64,7 +96,11 @@ function markWrite(target, writes) {
         return;
     }
     if (isElementAccessExpression(held)) {
-        markWrite(held.expression, writes);
+        // A store through a member's value lands in storage every holder of the value
+        // reads, so it reads the member; a variable only ever stored into stays written.
+        if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
+            markWrite(held.expression, writes);
+        }
         return;
     }
     if (isArrayLiteralExpression(held)) {
@@ -97,12 +133,18 @@ function markWrite(target, writes) {
  * Records every store one node performs: an assignment, a compound assignment, an
  * increment or a decrement, a `delete`, and an iteration that assigns to a name declared
  * elsewhere. An iteration that declares its own name stores into nothing the inventory
- * holds.
+ * holds. A store that reads its target as well records it in `reads`: a logical
+ * assignment, and a compound assignment, an increment or a decrement whose value is used.
  */
-function markStores(node, writes) {
+function markStores(node, writes, reads) {
     if (isBinaryExpression(node)) {
-        if (ASSIGNMENTS.has(node.operatorToken.kind)) {
+        const operator = node.operatorToken.kind;
+        if (ASSIGNMENTS.has(operator)) {
             markWrite(node.left, writes);
+            if (LOGICAL_ASSIGNMENTS.has(operator) ||
+                (operator !== SyntaxKind.EqualsToken && !valueDiscarded(node))) {
+                markWrite(node.left, reads);
+            }
         }
         return;
     }
@@ -110,6 +152,9 @@ function markStores(node, writes) {
         if (node.operator === SyntaxKind.PlusPlusToken ||
             node.operator === SyntaxKind.MinusMinusToken) {
             markWrite(node.operand, writes);
+            if (!valueDiscarded(node)) {
+                markWrite(node.operand, reads);
+            }
         }
         return;
     }
@@ -193,20 +238,45 @@ function linksOf(file, node, declarations, enclosing) {
     }
     return found;
 }
+/**
+ * Whether one object literal is a destructuring target, written on the left of an
+ * assignment or as a `for` loop's initializer, through the literals and spreads it nests in.
+ */
+function isAssignmentPattern(node) {
+    let child = node;
+    let parent = node.parent;
+    while (isParenthesizedExpression(parent) ||
+        isArrayLiteralExpression(parent) ||
+        isObjectLiteralExpression(parent) ||
+        isSpreadElement(parent) ||
+        isSpreadAssignment(parent) ||
+        (isPropertyAssignment(parent) && parent.initializer === child)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (isBinaryExpression(parent)) {
+        return parent.operatorToken.kind === SyntaxKind.EqualsToken && parent.left === child;
+    }
+    return (isForInStatement(parent) || isForOfStatement(parent)) && parent.initializer === child;
+}
 /**
  * Every name node one file holds that is a use rather than a declaration, in source
  * order, each with its enclosing declaration and its use, and every re-export the file
  * writes. One walk answers all of it, because a second would have to agree with this one
  * about which nodes are names. A declaration's own declared name is left out, which is
- * what makes a declaration referenced only from its own site an unreferenced one.
+ * what makes a declaration referenced only from its own site an unreferenced one, and so
+ * is every node of `unread`, a subtree that is no use.
  */
-function sitesOf(file, declarations, fileId) {
+function sitesOf(file, declarations, fileId, unread) {
     const found = [];
     const reads = [];
     const links = [];
     const evaluations = [];
     const decorated = [];
+    const literals = [];
+    const flows = [];
     const writes = new Set();
+    const alsoRead = new Set();
     const declared = new Set();
     const shorthands = new Map();
     let enclosing = fileId;
@@ -228,19 +298,30 @@ function sitesOf(file, declarations, fileId) {
         }
     };
     const visit = (node) => {
+        if (unread.has(node)) {
+            return;
+        }
         if (isName(node)) {
             if (!declared.has(node.pos)) {
-                found.push({
-                    node,
-                    shorthand: shorthands.get(node.pos),
-                    from: enclosing,
-                    use: writes.has(node.pos) ? "write" : "read",
-                });
+                const site = { node, shorthand: shorthands.get(node.pos), from: enclosing };
+                if (writes.has(node.pos)) {
+                    found.push({ ...site, use: "write" });
+                }
+                if (!writes.has(node.pos) || alsoRead.has(node.pos)) {
+                    found.push({ ...site, use: "read" });
+                }
             }
             return;
         }
         markNames(node);
-        markStores(node, writes);
+        markStores(node, writes, alsoRead);
+        if (isObjectLiteralExpression(node) && !isAssignmentPattern(node)) {
+            literals.push({ literal: node, from: enclosing });
+        }
+        // An assertion needs only comparability, so no member of its operand is read by it.
+        for (const written of isAsExpression(node) ? [] : handedOn(node)) {
+            flows.push(...valuesOf(written).map((value) => ({ value, from: enclosing })));
+        }
         for (const read of propertyReadsOf(node)) {
             reads.push({ ...read, from: enclosing });
         }
@@ -263,8 +344,18 @@ function sitesOf(file, declarations, fileId) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, reads, links, evaluations, decorated };
+    return { uses: found, literals, flows, reads, links, evaluations, decorated };
 }
+/** The declaration kinds of a property an object literal declares. */
+const LITERAL_PROPERTY_KINDS = new Set([
+    SyntaxKind.PropertyAssignment,
+    SyntaxKind.ShorthandPropertyAssignment,
+    SyntaxKind.MethodDeclaration,
+    SyntaxKind.GetAccessor,
+    SyntaxKind.SetAccessor,
+]);
+/** The rule a file the analysis classified as test-support code is counted under. */
+const TEST_SUPPORT_RULE = "test-support";
 /**
  * The name one test-file rule takes. A rule's name is a word list the report's own
  * vocabulary spells, which cannot carry a pattern, so a rule is named by the place of
@@ -277,17 +368,19 @@ function patternRule(index) {
  * The rules over the test files of several projects at once, ordered by rule: a file two
  * projects hold is one file, so each rule counts the distinct paths it matches.
  */
-export function testFileRulesOf(testFiles, paths) {
+export function testFileRulesOf(testFiles, paths, supportFiles = []) {
     const distinct = [...new Set(paths)];
-    return testFiles
-        .map((pattern, index) => {
-        const expression = globExpression(pattern);
-        return {
-            rule: patternRule(index),
-            matched: distinct.filter((path) => expression.test(path)).length,
-        };
-    })
-        .sort((a, b) => compare(a.rule, b.rule));
+    const support = new Set(supportFiles).size;
+    return [
+        ...testFiles.map((pattern, index) => {
+            const expression = globExpression(pattern);
+            return {
+                rule: patternRule(index),
+                matched: distinct.filter((path) => expression.test(path)).length,
+            };
+        }),
+        ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
+    ].sort((a, b) => compare(a.rule, b.rule));
 }
 const importedCache = new WeakMap();
 /**
@@ -332,6 +425,90 @@ function importedNames(file) {
     importedCache.set(file, names);
     return names;
 }
+/**
+ * The name node of every import binding one file's top level declares, and whether it
+ * binds a whole module.
+ */
+function importBindings(file) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (isImportEqualsDeclaration(statement)) {
+            found.push({ node: statement.name, whole: true });
+            continue;
+        }
+        const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
+        if (clause === undefined) {
+            continue;
+        }
+        if (clause.name !== undefined) {
+            found.push({ node: clause.name, whole: false });
+        }
+        const bindings = clause.namedBindings;
+        if (bindings === undefined) {
+            continue;
+        }
+        if (bindings.kind === SyntaxKind.NamespaceImport) {
+            found.push({ node: bindings.name, whole: true });
+        }
+        else {
+            found.push(...bindings.elements.map((element) => ({ node: element.name, whole: false })));
+        }
+    }
+    return found;
+}
+/** The value one assignment stores through the name it writes, where it is a plain assignment. */
+function storedValue(name) {
+    let target = name;
+    if (isPropertyAccessExpression(name.parent) && name.parent.name === name) {
+        target = name.parent;
+    }
+    while (isParenthesizedExpression(target.parent)) {
+        target = target.parent;
+    }
+    const parent = target.parent;
+    return isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === target
+        ? parent.right
+        : undefined;
+}
+/**
+ * The import bindings of one file that only the values written into one declaration
+ * use, for each write into it. A binding is named by an identifier that spells its
+ * local name and is not the member a property access names.
+ */
+function aloneIn(file, uses, writes, found) {
+    const bindings = new Set(importBindings(file).map((binding) => binding.node.getText()));
+    if (bindings.size === 0) {
+        return [];
+    }
+    const occurrences = new Map();
+    for (const site of uses) {
+        const text = site.node.getText();
+        const parent = site.node.parent;
+        if (!bindings.has(text) || (isPropertyAccessExpression(parent) && parent.name === site.node)) {
+            continue;
+        }
+        if (!occurrences.get(text)?.includes(site.node)) {
+            occurrences.set(text, [...(occurrences.get(text) ?? []), site.node]);
+        }
+    }
+    const inside = (node, value) => node.pos >= value.pos && node.end <= value.end;
+    const result = [];
+    for (const write of writes) {
+        const to = found[write.index]?.to;
+        const sameTarget = writes.filter((one) => found[one.index]?.to === to);
+        const names = [...occurrences]
+            .filter(([, nodes]) => nodes.some((node) => inside(node, write.value)) &&
+            nodes.every((node) => sameTarget.some((one) => inside(node, one.value))))
+            .map(([name]) => name)
+            .sort(compare);
+        if (names.length > 0) {
+            result.push({ index: write.index, names });
+        }
+    }
+    return result;
+}
 /** Two strings ordered bytewise, which is the order every set of a run is read in. */
 function compare(a, b) {
     if (a === b) {
@@ -362,7 +539,8 @@ export function references(project, held, targetRoot, options) {
     const found = [];
     const tests = [];
     const chains = aliasChains(project, held);
-    const destructured = destructuring(project, cap);
+    const tables = propertyTables(project.queries);
+    const destructured = destructuring(project, cap, tables);
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
@@ -375,7 +553,22 @@ export function references(project, held, targetRoot, options) {
             .ownSourceFiles()
             .filter((file) => relativePath(consumer.root, file.fileName) !== undefined &&
             relativePath(targetRoot, file.fileName) === undefined);
+    const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
+    let topLevel;
+    /** The declarations one file's top level holds. */
+    const declaredIn = (fileId) => {
+        if (topLevel === undefined) {
+            const byParent = new Map();
+            for (const symbol of held.symbols) {
+                if (fileIds.has(symbol.parent)) {
+                    byParent.set(symbol.parent, [...(byParent.get(symbol.parent) ?? []), symbol]);
+                }
+            }
+            topLevel = byParent;
+        }
+        return topLevel.get(fileId) ?? [];
+    };
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
     /**
@@ -405,6 +598,45 @@ export function references(project, held, targetRoot, options) {
             ]),
         ];
     };
+    // A type-query alias's own type names its export without using it; a use of the
+    // global is the use, so it names every link of the export's chain as well.
+    const aliases = project.ownSourceFiles().flatMap(typeQueryAliases);
+    const unread = new Set(aliases.map((alias) => alias.type));
+    const aliased = new Map();
+    if (aliases.length > 0) {
+        const exported = project.symbolsAt(aliases.map((alias) => project.handle(alias.exported)));
+        aliases.forEach((alias, index) => {
+            const id = declaredAt(alias.declaration);
+            const symbol = exported[index];
+            if (id === undefined || symbol === undefined) {
+                return;
+            }
+            aliased.set(id, symbol === UNANSWERED
+                ? (declarationsByName(held).get(alias.name) ?? []).map((one) => ({
+                    id: one,
+                    stepped: true,
+                    guessed: true,
+                }))
+                : chains.chainOf(symbol).map((target) => ({ ...target, stepped: true })));
+        });
+    }
+    /** One use's targets, then every link an alias global among them stands for, each once. */
+    const throughAliases = (targets) => {
+        if (aliased.size === 0) {
+            return targets;
+        }
+        const all = [...targets];
+        const seen = new Set(targets.map((target) => target.id));
+        for (const target of targets) {
+            for (const forwarded of aliased.get(target.id) ?? []) {
+                if (!seen.has(forwarded.id)) {
+                    seen.add(forwarded.id);
+                    all.push(forwarded);
+                }
+            }
+        }
+        return all;
+    };
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
@@ -418,13 +650,92 @@ export function references(project, held, targetRoot, options) {
         residueFallbacks += 1;
         return project.resolvedSymbolAt(project.handle(site.node));
     };
-    for (const file of files) {
+    const walked = files.map((file) => {
+        const fileId = declaredAt(file) ?? "";
+        return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
+    });
+    const contextual = contextualUses(project, held, chains, walked.flatMap((one) => one.literals), walked.flatMap((one) => one.flows), cap, tables);
+    const writtenBy = new Map();
+    for (const write of contextual.writes) {
+        const property = write.at.parent;
+        writtenBy.set(nodeKey(property.getSourceFile(), property), write.ids);
+    }
+    const forwardedCache = new Map();
+    /**
+     * The members a literal property one symbol declares writes: a use of the property
+     * reaches them, because the literal's type carries the data the member describes.
+     */
+    const forwarded = (symbol) => {
+        const known = forwardedCache.get(symbol.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = [];
+        if (writtenBy.size > 0) {
+            for (const handle of symbol.declarations) {
+                if (!LITERAL_PROPERTY_KINDS.has(handle.kind) || !ownPaths.has(handle.path)) {
+                    continue;
+                }
+                const node = project.declarationAt(handle)?.node;
+                const ids = node === undefined ? undefined : writtenBy.get(nodeKey(node.getSourceFile(), node));
+                for (const id of ids ?? []) {
+                    if (!found.some((target) => target.id === id)) {
+                        found.push({ id, stepped: true, guessed: false });
+                    }
+                }
+            }
+        }
+        forwardedCache.set(symbol.id, found);
+        return found;
+    };
+    /** One resolved symbol's declarations along its chain, and the members its literal properties write. */
+    const targetsOf = (symbol) => {
+        const through = forwarded(symbol);
+        return through.length === 0 ? chains.chainOf(symbol) : [...chains.chainOf(symbol), ...through];
+    };
+    const testFile = new Map();
+    for (const { file } of walked) {
         const path = renderPosition(file, root, 0).path;
         const test = patterns.some((pattern) => pattern.test(path));
+        testFile.set(file, test);
         if (test) {
             tests.push(path);
         }
-        const { uses, reads, links, evaluations, decorated } = sitesOf(file, declarations, declaredAt(file) ?? "");
+    }
+    /** Each write reference's index in `found`, by its file, with the value it stores. */
+    const valued = new Map();
+    const holdsValue = (file, value) => {
+        if (value !== undefined) {
+            valued.set(file, [...(valued.get(file) ?? []), { index: found.length - 1, value }]);
+        }
+    };
+    for (const [use, sites] of [
+        ["write", contextual.writes],
+        ["read", contextual.reads],
+    ]) {
+        for (const site of sites) {
+            const file = site.at.getSourceFile();
+            const position = renderPosition(file, root, site.at.getStart());
+            for (const id of site.ids) {
+                found.push({
+                    from: site.from,
+                    to: id,
+                    position,
+                    use,
+                    resolution: "contextual",
+                    test: testFile.get(file) === true,
+                });
+                if (use === "write") {
+                    holdsValue(file, site.at.parent);
+                }
+            }
+        }
+    }
+    for (const { file, fileId, uses, reads, links, evaluations, decorated } of walked) {
+        const test = testFile.get(file) === true;
+        // A component file's markup may use any binding its blocks declare at the top level.
+        const markup = isComponentFile(file);
+        const bindings = markup ? importBindings(file) : [];
         // A decorator is written inside the declaration it is attached to and receives it,
         // so the declaration is used where the decorator is written, whatever the
         // decorator does with it.
@@ -448,6 +759,7 @@ export function references(project, held, targetRoot, options) {
                 ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
                 ...links.map((link) => link.node),
                 ...evaluations.map((evaluation) => evaluation.node),
+                ...bindings.map((binding) => binding.node),
             ]),
         ];
         const answered = new Map();
@@ -504,6 +816,47 @@ export function references(project, held, targetRoot, options) {
                 }
             }
         }
+        if (markup) {
+            for (const symbol of declaredIn(fileId)) {
+                found.push({
+                    from: fileId,
+                    to: symbol.id,
+                    position: symbol.position,
+                    use: "read",
+                    resolution: "syntax",
+                    test,
+                });
+            }
+            for (const binding of bindings) {
+                const symbol = answered.get(binding.node);
+                if (symbol === undefined) {
+                    continue;
+                }
+                const position = renderPosition(file, root, binding.node.getStart());
+                const chained = symbol === UNANSWERED
+                    ? named(binding.node).map((id) => ({ id, stepped: false, guessed: true }))
+                    : chains.chainOf(symbol);
+                // The markup may name any export of a module a binding holds whole.
+                const targets = binding.whole
+                    ? chained.flatMap((target) => [
+                        target,
+                        ...declaredIn(target.id)
+                            .filter((one) => one.exported)
+                            .map((one) => ({ ...target, id: one.id })),
+                    ])
+                    : chained;
+                for (const target of targets) {
+                    found.push({
+                        from: fileId,
+                        to: target.id,
+                        position,
+                        use: "read",
+                        resolution: target.guessed ? "by-name" : target.stepped ? "alias" : "batch",
+                        test,
+                    });
+                }
+            }
+        }
         // A pattern names a property of the value it destructures, which no name node of
         // the pattern resolves to: a shorthand's name is the local it binds.
         destructured.resolve(reads).forEach((symbol, index) => {
@@ -518,7 +871,7 @@ export function references(project, held, targetRoot, options) {
                     stepped: false,
                     guessed: true,
                 }))
-                : chains.chainOf(symbol);
+                : targetsOf(symbol);
             for (const target of targets) {
                 found.push({
                     from: read.from,
@@ -543,9 +896,9 @@ export function references(project, held, targetRoot, options) {
             const position = renderPosition(file, root, site.node.getStart());
             // A re-export something imports is used and so is the declaration behind it, so
             // the use names every link of the chain its name stands at the head of.
-            const targets = symbol === UNANSWERED
+            const targets = throughAliases(symbol === UNANSWERED
                 ? named(site.node).map((id) => ({ id, stepped: false, guessed: true }))
-                : chains.chainOf(symbol);
+                : targetsOf(symbol));
             for (const target of targets) {
                 found.push({
                     from: site.from,
@@ -555,6 +908,19 @@ export function references(project, held, targetRoot, options) {
                     resolution: target.guessed ? "by-name" : target.stepped ? "alias" : direct,
                     test,
                 });
+                if (site.use === "write") {
+                    holdsValue(file, storedValue(site.node));
+                }
+            }
+        }
+    }
+    const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
+    for (const [file, writes] of valued) {
+        const uses = usesOf.get(file) ?? [];
+        for (const { index, names } of aloneIn(file, uses, writes, found)) {
+            const reference = found[index];
+            if (reference !== undefined) {
+                found[index] = { ...reference, alone: names };
             }
         }
     }
@@ -576,6 +942,8 @@ export function references(project, held, targetRoot, options) {
             aliasSteps: chains.steps,
             patternBatches: destructured.cost.patternBatches,
             patternLookups: destructured.cost.patternLookups,
+            contextualBatches: contextual.batches,
+            contextualLookups: contextual.lookups,
         },
     };
 }

package/dist/src/report.js

@@ -4,12 +4,9 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "6.1.0";
-/**
- * Every report schema version this analyzer reads: the schema versions the Contract it
- * implements admits, each an instance of the one it writes.
- */
-export const SCHEMA_VERSIONS_ACCEPTED = ["6.0.0", SCHEMA_VERSION];
+const SCHEMA_VERSION = "7.0.0";
+/** Every report schema version this analyzer reads: the one the Contract it implements admits. */
+export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
 /** The name this analyzer writes every document under and mints every identifier with. */
 export const ANALYZER_NAME = "deadset-ts";
 /** The language this analyzer claims. */
@@ -234,6 +231,29 @@ export function buildReport(input) {
         test_file_rules: [...input.testFileRules]
             .sort((a, b) => compare(a.rule, b.rule) || a.matched - b.matched)
             .map((one) => ({ rule: one.rule, matched: one.matched })),
+        type_error_skips: [
+            ...new Map(input.typeErrorSkips.map((one) => {
+                const skip = { path: one.path, line: one.line, message: one.message };
+                return [JSON.stringify(skip), skip];
+            })),
+        ]
+            .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
+            .map(([, skip]) => skip),
+        notes: [],
+        unanswered_questions: [...input.unanswered]
+            .sort((a, b) => compare(a.configuration, b.configuration) ||
+            compare(JSON.stringify(a), JSON.stringify(b)))
+            .map((one) => ({
+            configuration: one.configuration,
+            questions: one.questions,
+            declarations: one.declarations,
+        })),
+        conventions_applied: input.conventionsApplied.map((one) => ({
+            name: one.name,
+            package: one.package,
+            version: one.version,
+            manifest: one.manifest,
+        })),
         totals: totalsOf(findings, input.result),
     };
 }

package/dist/src/reporters/annotations.js

@@ -22,11 +22,15 @@ function kindName(code) {
 function command(level, at, endLine, title, message) {
     return `::${level} file=${escapeProperty(at.path)},line=${String(at.line)},col=${String(at.column)},endLine=${String(endLine)},title=${escapeProperty(title)}::${escapeData(message)}`;
 }
+/** The title and the message prefix of a type-error skip's annotation. */
+const SKIP_TITLE = "type error skipped";
+const SKIP_MESSAGE = "the analysis did not evaluate the function or statement holding this type error: ";
 /**
  * One workflow annotation per finding, then one per stale suppression, each naming its
- * file, line, column and last line, titled by its code and kind. A finding at or above the
- * failing severity is an error and one below it a warning; a stale suppression is an error,
- * because its kind is fixed on at the failing severity.
+ * file, line, column and last line, titled by its code and kind, then one warning per
+ * type-error skip naming its file and line. A finding at or above the failing severity is
+ * an error and one below it a warning; a stale suppression is an error, because its kind
+ * is fixed on at the failing severity.
  */
 export function annotations(report, options) {
     return coalesced((function* lines() {
@@ -36,5 +40,8 @@ export function annotations(report, options) {
         for (const stale of report.stale_suppressions) {
             yield `${command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message)}\n`;
         }
+        for (const skip of report.type_error_skips) {
+            yield `::warning file=${escapeProperty(skip.path)},line=${String(skip.line)},title=${escapeProperty(SKIP_TITLE)}::${escapeData(SKIP_MESSAGE + skip.message)}\n`;
+        }
     })());
 }