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

package/dist/src/inventory.js

@@ -1,4 +1,4 @@
-import { isClassDeclaration, isComputedPropertyName, isEnumDeclaration, isEnumMember, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isModuleBlock, isModuleDeclaration, isNamespaceExport, isParenthesizedTypeNode, isPrivateIdentifier, isPropertyDeclaration, isPropertySignatureDeclaration, isSetAccessorDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeLiteralNode, isUnionTypeNode, isVariableStatement, ModifierFlags, } from "@typescript/native/unstable/ast";
+import { isClassDeclaration, isComputedPropertyName, isEnumDeclaration, isEnumMember, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isModuleBlock, isModuleDeclaration, isNamespaceExport, isParenthesizedTypeNode, isPrivateIdentifier, isPropertyDeclaration, isPropertySignatureDeclaration, isSetAccessorDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeLiteralNode, isUnionTypeNode, isVariableStatement, ModifierFlags, } from "@typescript/native/ast";
 import { dirnamePath, joinPath, relativePath } from "./paths.js";
 import { byPosition, positionKey, renderPosition, writtenLength, } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
@@ -693,6 +693,30 @@ export function inventory(project, host, targetRoot) {
         }
         return undefined;
     }
+    const dependents = new Map();
+    for (const container of containers.filter((one) => one.memberKind === "enum-member")) {
+        const ids = container.members.map((member) => {
+            const record = byNode.get(nodeKey(member.getSourceFile(), member));
+            return record === undefined ? undefined : positionKey(record.position);
+        });
+        container.members.forEach((_member, index) => {
+            const after = [];
+            for (let next = index + 1; next < container.members.length; next += 1) {
+                const member = container.members[next];
+                if (member === undefined || !isEnumMember(member) || member.initializer !== undefined) {
+                    break;
+                }
+                const id = ids[next];
+                if (id !== undefined) {
+                    after.push(id);
+                }
+            }
+            const id = ids[index];
+            if (id !== undefined && after.length > 0) {
+                dependents.set(id, after);
+            }
+        });
+    }
     const byId = new Map(building.map((record) => [positionKey(record.position), record]));
     const symbols = building
         .map(render)
@@ -706,6 +730,7 @@ export function inventory(project, host, targetRoot) {
             .map((symbol) => symbol.id),
         byName: namesOf(building),
         modules: new Map(modules.map(([record, name]) => [positionKey(record.position), name])),
+        dependents,
     };
 }
 /** Whether one declaration is, or is declared under, a scope or container left unanswered. */

package/dist/src/keyof-comparisons.js

@@ -0,0 +1,170 @@
+/**
+ * The members a comparison with a key reads: where one operand of `===`, `!==`, `==` or
+ * `!=`, or a `switch` expression a `case` label is compared with, is declared with a type
+ * that holds `keyof X`, the literal the other side has names the member of `X` under that
+ * key, because deleting the member makes the comparison a type error.
+ */
+import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isParenthesizedExpression, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+/** The operators that compare their operands for equality. */
+const EQUALITIES = new Set([
+    SyntaxKind.EqualsEqualsEqualsToken,
+    SyntaxKind.ExclamationEqualsEqualsToken,
+    SyntaxKind.EqualsEqualsToken,
+    SyntaxKind.ExclamationEqualsToken,
+]);
+function unwrapped(node) {
+    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+/** The name node an operand's symbol is read at: an identifier, or a property access's name. */
+function nameOf(node) {
+    const at = unwrapped(node);
+    if (isIdentifier(at)) {
+        return at;
+    }
+    return isPropertyAccessExpression(at) ? at.name : undefined;
+}
+/** The operand of each `keyof` one type node holds, through every type node it is built of. */
+function keyofOperands(node) {
+    const found = [];
+    const visit = (at) => {
+        if (isTypeOperatorNode(at) && at.operator === SyntaxKind.KeyOfKeyword) {
+            found.push(at.type);
+            return;
+        }
+        at.forEachChild(visit);
+    };
+    visit(node);
+    return found;
+}
+/** The names a literal type or a union of them spells, or none. */
+function literalNames(parts) {
+    const names = [];
+    for (const part of parts) {
+        if (part.isStringLiteralType()) {
+            names.push(part.value);
+        }
+        else if (part.isNumberLiteralType()) {
+            names.push(String(part.value));
+        }
+        else {
+            return [];
+        }
+    }
+    return names;
+}
+/**
+ * The references the key comparisons of one project's own files make to the members their
+ * literal side names, each made by the declaration holding the comparison.
+ */
+export function keyofComparisonReferences(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const comparisons = [];
+    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 (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+                comparisons.push({ file, from: holder, keyed: node.left, other: node.right });
+                comparisons.push({ file, from: holder, keyed: node.right, other: node.left });
+            }
+            if (isSwitchStatement(node)) {
+                for (const clause of node.caseBlock.clauses) {
+                    if (isCaseClause(clause)) {
+                        comparisons.push({
+                            file,
+                            from: holder,
+                            keyed: node.expression,
+                            other: clause.expression,
+                        });
+                    }
+                }
+            }
+            node.forEachChild((child) => {
+                visit(child, holder);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId);
+        });
+    }
+    const named = comparisons.flatMap((one) => {
+        const name = nameOf(one.keyed);
+        return name === undefined || isElementAccessExpression(unwrapped(one.other))
+            ? []
+            : [{ ...one, name }];
+    });
+    if (named.length === 0) {
+        return [];
+    }
+    // The operand's own declaration states the key type, which the checker resolves to
+    // the literals it admits and so no longer names the type the key indexes.
+    const symbols = queries.symbolsAt(named.map((one) => one.name));
+    const keyed = named.flatMap((one, at) => {
+        const asked = symbols[at];
+        const symbol = asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
+            ? asked
+            : queries.aliased(asked);
+        if (symbol === UNANSWERED || symbol === undefined) {
+            return [];
+        }
+        const operands = symbol.declarations.flatMap((handle) => {
+            const declared = project.declarationAt(handle)?.node?.type;
+            return declared === undefined ? [] : keyofOperands(declared);
+        });
+        return operands.length === 0 ? [] : [{ ...one, operands }];
+    });
+    if (keyed.length === 0) {
+        return [];
+    }
+    const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+    const types = queries.typesAt(nodes);
+    const typeOf = new Map();
+    nodes.forEach((node, at) => {
+        const type = types[at];
+        if (type !== UNANSWERED && type !== undefined) {
+            typeOf.set(node, type);
+        }
+    });
+    const partsOf = (type) => {
+        const parts = queries.constituents(type);
+        return parts === UNANSWERED ? [type] : parts;
+    };
+    const found = [];
+    for (const one of keyed) {
+        const literal = typeOf.get(one.other);
+        const names = literal === undefined ? [] : literalNames(partsOf(literal));
+        if (names.length === 0) {
+            continue;
+        }
+        const position = renderPosition(one.file, root, one.other.getStart());
+        for (const operand of one.operands) {
+            const object = typeOf.get(operand);
+            for (const part of object === undefined ? [] : partsOf(object)) {
+                const properties = queries.propertiesOf(part);
+                for (const property of properties === UNANSWERED ? [] : properties) {
+                    if (!names.includes(property.name)) {
+                        continue;
+                    }
+                    for (const to of chains.declarationsOf(property)) {
+                        found.push({
+                            from: one.from,
+                            to,
+                            position,
+                            use: "read",
+                            resolution: "keyed",
+                            test: testFiles.has(position.path),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return found;
+}

package/dist/src/kinds.js

@@ -13,6 +13,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -23,6 +24,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -34,6 +36,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -44,6 +47,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -54,6 +58,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -64,6 +69,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -71,7 +77,7 @@ const ROWS = [
         name: "unnecessary-export",
         languages: ["go", "ts"],
         rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name.",
+        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis.md gives it.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "narrowable",
@@ -92,10 +98,11 @@ const ROWS = [
         code: "DS1103",
         name: "unreachable-export",
         languages: ["go", "ts"],
-        rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set.",
+        rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set, except where the confidence rule of grammar/analysis.md gives a declaration a string literal spells the class possible.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -117,6 +124,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -135,6 +143,7 @@ const ROWS = [
         name: "unused-satisfaction-assertion",
         languages: ["go"],
         rule: "A compile-time satisfaction assertion whose interface no symbol uses as a type.",
+        precondition: "In a library, an assertion whose interface is published API, an exported interface of a package outside programs can import, has the reachability class possible, whatever consumers the run declares and loads. The assertion checks a promise the published API makes, that the type satisfies the published interface, and that promise is made to every program that imports the package, not only to the consumers the run declares. A loaded consumer that names the interface as a type uses it, and the assertion is not reported.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -144,7 +153,7 @@ const ROWS = [
         code: "DS1301",
         name: "write-only-symbol",
         languages: ["go", "ts"],
-        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
+        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In Go, a conversion the compiler accepts between two struct types, or between two pointer types that are not named types and whose base types are struct types, reads every field of the two struct types where their struct type literals are distinct, recorded at the conversion, because the conversion is legal only while their fields are identical, ignoring tags, and so no field of either can be deleted alone. It reads in the same way every field of each pair of distinct struct type literals the identity of the two types compares in turn: through each field's type, and from there through the element, key, base, parameter and result types of the type literals it reaches, through the method signatures of an interface type literal, and through the type arguments of an instantiated generic type. A field reached there has no reference of its own, as grammar/symbol-ref.md states, so it is never a subject and those reads hold no finding back. It stops at a defined type, whose fields the conversion does not read, because a defined type is identical to itself whatever fields it declares. A pair whose two sides are one struct type literal, the two struct types themselves included, as where one type is declared from the other or the conversion is to the operand's own type, reads nothing, because a field deleted from that literal leaves both sides identical. Where the operand's type or the conversion's type is a type parameter, the struct type its constraint's core type is takes that side's place, and a type parameter operand reads in the same way the fields of each struct type argument an instantiation the program holds gives it, an instantiation made through another generic declaration's own type parameters included. A conversion to any other type, an interface type among them, reads no field under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. An object literal handed to a callee the target does not implement has its members read, as grammar/analysis.md states. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -158,6 +167,7 @@ const ROWS = [
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
+        findingFixabilities: ["manual"],
         fixed: false,
     },
     {
@@ -175,7 +185,7 @@ const ROWS = [
         code: "DS1501",
         name: "file-never-built",
         languages: ["go", "ts"],
-        rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint is the ignore tag is never reported: the toolchain applies no build constraint to a file named on its own command line, so that tag is the toolchain's convention for a file built by hand. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
+        rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint holds only when the ignore tag is set is never reported, because grammar/analysis.md keeps such a file outside the analysis wherever no configuration builds it: the tag is the toolchain's convention for a file kept out of ordinary package builds unless a configuration explicitly satisfies the tag, and built by hand, the toolchain applying no build constraint to a file named on its own command line. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
         precondition: 'Reported only when the configuration declares the build matrix complete, and never for a file the toolchain ignored solely because it imports "C" under a build with cgo disabled. Such a file is recorded as excluded by cgo rather than as never built.',
         defaultSeverity: "deny",
         maxClass: "certain",
@@ -197,7 +207,7 @@ const ROWS = [
         name: "unused-dependency",
         languages: ["go", "ts"],
         rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency.",
-        precondition: "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. Three more dependencies are needed: one whose command a script entry or a workflow step runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis.md states. A command no script entry and no workflow step runs needs nothing, and a peer the installed manifest of a needed dependency requires is needed only as any other dependency is, because the package manager installs a required peer itself. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the target, and a dependency with none is decided by the import closure alone.",
+        precondition: "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. Four more dependencies are needed: one whose command a script entry or a workflow step runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis.md states, and one that a needed dependency names as a peer, as stated below. A command no script entry and no workflow step runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "manual",
@@ -238,7 +248,7 @@ const ROWS = [
         code: "DS1703",
         name: "stale-suppression",
         languages: ["go", "ts"],
-        rule: "A suppression that matches no current finding, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
+        rule: "A suppression record that is stale, as grammar/suppression.md defines it, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "none",
@@ -303,7 +313,7 @@ const ROWS = [
         name: "unused-result",
         languages: ["go", "ts"],
         rule: "A result value that no call site of the function uses, on a function whose signature is free to change.",
-        precondition: "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible.",
+        precondition: "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible. A call that is the operand of an await expression written as a statement of its own uses a result whose type has a member named then, a promise or another thenable, because the caller sequences on it, and discards any other result. A call written as a statement of its own, or as the operand of void, discards its result whatever its type.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "manual",

package/dist/src/manifest.js

@@ -4,7 +4,7 @@
  * shell running its command or one of its scripts. {@link readManifest} reads one
  * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The manifest's own name. */
 const MANIFEST = "package.json";
 /** The three members that name an entry point beside `exports` and `bin`. */
@@ -148,22 +148,12 @@ export function readManifest(host, targetRoot) {
     };
 }
 /**
- * The entry points every package manifest between the target root and each compiler
- * configuration names: each directory holding a `package.json` that a configuration sits
- * in or below, the target root and `known` excluded, whose manifests the run reads
- * otherwise. Each entry is spelled under its manifest's path below the target root, and
- * is published by its own manifest's rule, as the target's own entries are.
+ * The entry points the manifests of the nested packages in `dirs` name. Each entry is
+ * spelled under its manifest's path below the target root, and is published by its own
+ * manifest's rule, as the target's own entries are.
  */
-export function packageEntries(host, targetRoot, configFiles, known) {
-    const dirs = new Set();
-    for (const configFile of configFiles) {
-        for (let dir = dirnamePath(resolvePath(targetRoot, configFile)); dir !== targetRoot && relativePath(targetRoot, dir) !== undefined; dir = dirnamePath(dir)) {
-            if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
-                dirs.add(dir);
-            }
-        }
-    }
-    return [...dirs].sort().flatMap((dir) => {
+export function packageEntries(host, targetRoot, dirs) {
+    return dirs.flatMap((dir) => {
         const manifest = readManifest(host, dir);
         const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
         return manifest.entries.map((entry) => ({

package/dist/src/matrix.js

@@ -43,7 +43,13 @@ export function matrixOf(per) {
     const references = [];
     const firstSeen = new Map();
     const judged = new Set();
+    const dependents = new Map();
     per.forEach((one, index) => {
+        for (const [id, after] of one.dependents ?? []) {
+            if (!dependents.has(id)) {
+                dependents.set(id, after);
+            }
+        }
         const referenceOnly = new Set(one.referenceOnly);
         for (const symbol of one.symbols) {
             const held = holders.get(symbol.id);
@@ -76,6 +82,7 @@ export function matrixOf(per) {
         graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles)),
         union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))]),
         heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+        dependents,
     };
 }
 /**
@@ -155,10 +162,11 @@ export function sweepMatrix(matrix, input) {
             unreferencedTest: unreferenced,
         });
     });
+    const liveUnder = liveAnywhere(union.symbols, per);
     return {
-        liveUnder: liveAnywhere(union.symbols, per),
+        liveUnder,
         candidates,
-        components: componentsOf(union, dead.map((one, at) => one && heldBy[at] === undefined), testOfDeadCode, unreferencedTest),
+        components: componentsOf(union, dead.map((one, at) => one && heldBy[at] === undefined), testOfDeadCode, unreferencedTest, positionsOf(union, matrix.dependents, liveUnder)),
     };
 }
 /**
@@ -170,6 +178,16 @@ export function liveFilesAt(matrix, result, paths) {
         paths.has(symbol.position.path) &&
         (result.liveUnder.get(symbol.id)?.length ?? 0) === RELATIONS.length);
 }
+/**
+ * Each declaration's dependents by its place in the union, and per place whether the
+ * declaration is live under reachability in some configuration.
+ */
+function positionsOf(union, dependents, liveUnder) {
+    return {
+        dependents: union.symbols.map((symbol) => (dependents.get(symbol.id) ?? []).map((id) => union.at(id)).filter((at) => at !== OUTSIDE)),
+        live: union.symbols.map((symbol) => liveUnder.get(symbol.id)?.includes("reachability") === true),
+    };
+}
 /** The relations in the order a declaration's entry lists them. */
 const RELATIONS = ["reference-counting", "reachability"];
 /**

package/dist/src/member-names.js

@@ -4,7 +4,7 @@
  * string key both hold a name and nothing else, so each holds back every member of
  * that name its own mechanism can reach.
  */
-import { isIdentifier, isNumericLiteral, isPrivateIdentifier, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isIdentifier, isNumericLiteral, isPrivateIdentifier, isStringLiteral, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
 /** The kinds of declaration a member name can name. */
 const MEMBER_KINDS = new Set([

package/dist/src/module-declarations.js

@@ -5,7 +5,7 @@
  * to the same module. One that names it by name or pattern also reads the members it
  * imports, whatever file the specifier resolves to, as a compiler reading no such file does.
  */
-import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";

package/dist/src/namespace-objects.js

@@ -5,7 +5,7 @@
  * names and no other: a property access by name or by a literal index, or a destructured
  * property, names one export, and any other use may read every export.
  */
-import { isArrowFunction, isAwaitExpression, isBindingElement, isCallExpression, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isIdentifier, isImportDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrowFunction, isAwaitExpression, isBindingElement, isCallExpression, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isIdentifier, isImportDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 function isLiteralText(node) {
     return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
 }

package/dist/src/outside-tests.js

@@ -6,7 +6,7 @@
  * Such a file is read without a program, so what its body references beyond the modules
  * it names is not known.
  */
-import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
 import { emittedFrom } from "./emit-map.js";
 import { namesImported } from "./module-declarations.js";

package/dist/src/overrides.js

@@ -6,10 +6,10 @@
  * of its `extends` chain, is used by outside code holding the instance or the class
  * through that class, so its own class references it.
  */
-import { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/ast";
 import { memberComponent } from "./class-members.js";
 import { nodeKey } from "./inventory.js";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { SymbolFlags } from "@typescript/native/sync";
 import { UNANSWERED } from "./query.js";
 import { nameComponent } from "./ref.js";
 /** The member kinds a subclass overrides. */

package/dist/src/query.js

@@ -6,7 +6,7 @@
  * Questions of one accessor about many locations go out together, through the array
  * form where it has one and otherwise as one batch, one round trip per capped run.
  */
-import { isIdentifier } from "@typescript/native/unstable/ast";
+import { isIdentifier } from "@typescript/native/ast";
 /**
  * The greatest number of locations one batched request asks about. A batch is
  * answered by an array of its own length, so an uncapped batch over a large file
@@ -214,6 +214,9 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         constraintOf: (type) => type.isTypeParameter()
             ? one("getConstraint", () => typeLocation(type), () => type.getConstraint())
             : undefined,
+        indexedAccessOf: (type) => type.isIndexedAccessType()
+            ? one("getObjectType", () => typeLocation(type), () => ({ object: type.getObjectType(), index: type.getIndexType() }))
+            : undefined,
         symbolOfType: (type) => one("getSymbol", () => typeLocation(type), () => type.getSymbol()),
         signaturesOf: (type, kind) => one("getSignaturesOfType", () => typeLocation(type), () => checker.getSignaturesOfType(type, kind)),
         resolvedSignature: (node) => one("getResolvedSignature", () => nodeLocation(node), () => checker.getResolvedSignature(node)),

package/dist/src/references.js

@@ -1,4 +1,4 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
@@ -7,7 +7,10 @@ import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, nodeKey } from "./inventory.js";
 import { augmentationReferences } from "./augmentations.js";
+import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
+import { keyofComparisonReferences } from "./keyof-comparisons.js";
+import { unimplementedCalleeReads } from "./unimplemented-callees.js";
 import { moduleDeclarationReferences } from "./module-declarations.js";
 import { overrideReferences } from "./overrides.js";
 import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
@@ -1110,12 +1113,19 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
+    let typedLookups = 0;
     if (consumer === undefined) {
         found.push(...overrideReferences(project, held, chains, new Set(tests)));
+        const before = options.requestCount?.() ?? 0;
         found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
+        found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
+        found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
+        found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
+        typedLookups = (options.requestCount?.() ?? 0) - before;
         found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
     }
-    found.push(...augmentationReferences(held, found));
+    const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
+    found.push(...augmentationReferences(held, found, scripts));
     found.sort((a, b) => byPosition(a.position, b.position) ||
         compare(a.to, b.to) ||
         compare(a.from, b.from) ||
@@ -1135,6 +1145,7 @@ export function references(project, held, targetRoot, options) {
             patternLookups: destructured.cost.patternLookups,
             contextualBatches: contextual.batches,
             contextualLookups: contextual.lookups,
+            typedLookups,
         },
     };
 }

package/dist/src/reflective-lookup.js

@@ -12,8 +12,8 @@
  * element access through a receiver whose type declares a string index signature, and is
  * not `any`, reads that signature and holds nothing back.
  */
-import { isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
-import { TypeFlags } from "@typescript/native/unstable/sync";
+import { isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
+import { TypeFlags } from "@typescript/native/sync";
 import { memberNames } from "./member-names.js";
 import { renderPosition } from "./position.js";
 import { isAnswered, UNANSWERED } from "./query.js";

package/dist/src/report.js

@@ -4,7 +4,7 @@
  * 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 = "8.0.0";
+const SCHEMA_VERSION = "8.1.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. */

package/dist/src/reporters/sarif.js

@@ -122,6 +122,10 @@ function relatedOf(found) {
     for (const at of found.details.write_positions ?? []) {
         related.push({ label: "write", at, endLine: at.end_line });
     }
+    if (found.details.name_literal !== undefined) {
+        const at = found.details.name_literal;
+        related.push({ label: "name", at, endLine: at.end_line });
+    }
     for (const one of found.component.members ?? []) {
         if (declarationKey(one.ref, one.position.path) !==
             declarationKey(found.symbol.ref, found.position.path)) {