@cplieger/deadset-ts 7.1.0 → 7.2.0-dev.2

package/README.md

@@ -1,6 +1,6 @@
 # deadset-ts
 
-[![npm](https://img.shields.io/npm/v/@cplieger/deadset-ts)](https://www.npmjs.com/package/@cplieger/deadset-ts) [![JSR](https://jsr.io/badges/@cplieger/deadset-ts)](https://jsr.io/@cplieger/deadset-ts)
+[![npm](https://img.shields.io/npm/v/@cplieger/deadset-ts)](https://www.npmjs.com/package/@cplieger/deadset-ts) [![JSR](https://jsr.io/badges/@cplieger/deadset-ts)](https://jsr.io/@cplieger/deadset-ts) [![Mutation (TS)](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/cplieger/deadset-ts/badges/mutation-ts.json)](https://github.com/cplieger/deadset-ts/issues?q=label%3Astryker-tracker)
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 

package/dist/src/alias-chain.js

@@ -5,7 +5,7 @@
  */
 import { isExportAssignment, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceExport, isNamespaceImport, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { declarationsByName, nodeKey } from "./inventory.js";
+import { declarationsByName, isParameterProperty, nodeKey } from "./inventory.js";
 import { UNANSWERED } from "./query.js";
 /**
  * The chain walks over one project, against the declarations of `held`, the same
@@ -28,7 +28,11 @@ export function aliasChains(project, held) {
             }
             const node = project.declarationAt(handle)?.node;
             const id = node === undefined ? undefined : held.declarations.get(nodeKey(node.getSourceFile(), node));
-            if (id !== undefined && !ids.includes(id)) {
+            // A parameter property's node declares the parameter too, whose reads are no member's.
+            const parameter = node !== undefined &&
+                isParameterProperty(node) &&
+                (symbol.flags & SymbolFlags.Property) === 0;
+            if (id !== undefined && !parameter && !ids.includes(id)) {
                 ids.push(id);
             }
         }

package/dist/src/analysis.js

@@ -6,6 +6,7 @@
  * another project's checker, which holds only for views the session hands out.
  */
 import { lineOf, readComponent } from "./component-files.js";
+import { kindOf } from "./config.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
@@ -33,6 +34,7 @@ import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
+import { LANGUAGE } from "./report.js";
 import { SetupError, setupLine } from "./setup-failure.js";
 import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
@@ -158,7 +160,7 @@ function readProjects(engine, host, scope, config, stage) {
             conventions,
             testFiles: config.ts.testFiles,
             parse,
-            publishedAPI: config.targetKind === "library",
+            publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
             publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
         };
     };

package/dist/src/config.js

@@ -5,6 +5,10 @@ import { CONTRACT_VERSION } from "./version.js";
  * target supplied the setting it is about.
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
+/** The kind a target kind setting gives one language's declarations. */
+export function kindOf(setting, language) {
+    return typeof setting === "string" ? setting : setting[language];
+}
 /** The severities ranked, the strongest highest. */
 const SEVERITY_RANK = { allow: 0, warn: 1, deny: 2 };
 /** Whether a finding at one severity fails a run under the failing severity. */

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "5.1.0",
+        corpusVersion: "5.2.0",
         result: "pass",
-        digest: "sha256:befd5e68f8d68e859b2a0920464a5470a157d5d40a881d9cca28716a4575751d",
+        digest: "sha256:4050d1b67fb757bc12a60f8ece7317a3e8485d3383ec52919cd24b9dfd5509dc",
     },
     gaps: [],
 };

package/dist/src/decorator.js

@@ -11,7 +11,7 @@
  * the inventory holds for the class, static members included.
  */
 import { decoratorsOf, spelledDecorator } from "./calls.js";
-import { nodeKey } from "./inventory.js";
+import { isParameterProperty, nodeKey, } from "./inventory.js";
 import { renderPosition } from "./position.js";
 /** The kinds of declaration a decorator is attached to and holds back. */
 const DECORATED = new Set(["class", "method", "class-member"]);
@@ -39,7 +39,8 @@ export function decorator(input) {
         const visit = (node) => {
             const id = held.declarations.get(nodeKey(file, node));
             const symbol = id === undefined ? undefined : byId.get(id);
-            if (symbol !== undefined && DECORATED.has(symbol.kind)) {
+            // A parameter property's decorator is attached to its parameter, and to no member.
+            if (symbol !== undefined && DECORATED.has(symbol.kind) && !isParameterProperty(node)) {
                 for (const attached of decoratorsOf(node)) {
                     const detail = `decorated by ${spelledDecorator(attached)}`;
                     const site = renderPosition(file, targetRoot, attached.getStart());

package/dist/src/dependencies.js

@@ -466,15 +466,11 @@ function skipWhitespace(text, at) {
  */
 function membersAt(text, at) {
     const found = new Map();
-    if (text.charAt(at) !== "{") {
-        return found;
-    }
     let cursor = skipWhitespace(text, at + 1);
     while (text.charAt(cursor) === '"') {
         const keyEnd = valueEnd(text, cursor);
         const key = JSON.parse(text.slice(cursor, keyEnd));
         const value = skipWhitespace(text, skipWhitespace(text, keyEnd) + 1);
-        found.delete(key);
         found.set(key, { key: cursor, value });
         cursor = skipWhitespace(text, valueEnd(text, value));
         if (text.charAt(cursor) === ",") {

package/dist/src/deprecation.js

@@ -47,7 +47,7 @@ export function deprecatedDeclarations(project, held) {
                 }
             }
             const id = held.declarations.get(nodeKey(file, node));
-            if (id !== undefined && node !== file) {
+            if (id !== undefined) {
                 named.push({ id, handle: project.handle(nameNode(node)) });
             }
             node.forEachChild(visit);

package/dist/src/findings/completion.js

@@ -145,7 +145,7 @@ function findingComponents(swept, cascade) {
                 },
             ];
     })
-        .sort((a, b) => byPosition(a.position, b.position) || (a.ref === b.ref ? 0 : a.ref < b.ref ? -1 : 1));
+        .sort((a, b) => byPosition(a.position, b.position));
     return (id) => {
         const component = held.get(id);
         return component === undefined

package/dist/src/findings/interfaces.js

@@ -10,13 +10,6 @@ const UNCALLED_MESSAGE = "no call site invokes or selects the method through the
 function positionOf(symbol) {
     return { ...symbol.position, endLine: Math.max(symbol.position.line, symbol.endLine) };
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /** One run's declarations and candidates, indexed for the two kinds. */
 function indexed(input) {
     const union = input.swept.matrix.union;
@@ -31,7 +24,7 @@ function indexed(input) {
             .map(symbolOf)
             .filter((symbol) => symbol !== undefined)
             .map((symbol) => ({ ref: symbol.ref, name: symbol.name, position: positionOf(symbol) }))
-            .sort((a, b) => byPosition(a.position, b.position) || compare(a.ref, b.ref)),
+            .sort((a, b) => byPosition(a.position, b.position)),
     };
 }
 /** The finding one code makes about one declaration. */

package/dist/src/findings/unused-declarations.js

@@ -39,28 +39,26 @@ const WORDS = {
 const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
 /**
  * The code one candidate is reported under, or none, each symbol once under the most
- * specific code: a test of dead code first; no other test-file declaration, member of a
- * dead container or enum member nothing names; a test-support declaration test code
- * references as test-only use; then deprecation, a test reference, and the unreferenced
- * codes, an unimportable unused export being the unreachable kind's.
+ * specific code: a test of dead code first; no other test-file declaration or enum
+ * member nothing names; a test-support declaration test code references as test-only
+ * use; then deprecation, a test reference, and the unreferenced codes, an unimportable
+ * unused export being the unreachable kind's.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
         return "DS1005";
     }
-    if ((judged.test && !candidate.unreferencedTest) ||
-        judged.containerDead ||
-        NOT_THIS_FAMILY.has(symbol.kind)) {
+    if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
         return undefined;
     }
-    if (candidate.unreferencedTest) {
-        return unreferencedCode(symbol);
-    }
     const referenced = candidate.productionRefs + candidate.testRefs > 0;
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
     }
+    if (candidate.unreferencedTest) {
+        return unreferencedCode(symbol);
+    }
     if (candidate.heldByTests === candidate.id) {
         return "DS1004";
     }
@@ -192,7 +190,6 @@ function familyFindings(input, fallen) {
             candidate,
             symbol,
             test: union.test[at] === true,
-            containerDead: containerDead && !fallen,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
         };

package/dist/src/html-entries.js

@@ -102,9 +102,6 @@ function manifestDirectory(host, root, dir) {
         if (host.kindOf(joinPath(at, "package.json")) === "file") {
             return at;
         }
-        if (at === root) {
-            break;
-        }
     }
     return root;
 }

package/dist/src/injection-container.js

@@ -1,23 +1,25 @@
 /**
  * The injection-container class: a container constructs a class passed to a call
  * `ts.injection_registrations` names, or one a parameter of whose constructor carries a
- * decorator, and populates each of its properties and accessors that carries one, a base
- * class's included. A constructor and its parameters are no declarations of the
- * inventory, so the class stands for them and the registration referencing it keeps it.
+ * decorator, passes every argument of its constructor, and populates each of its
+ * properties and accessors that carries a decorator, a base class's included. So each
+ * parameter property is injected, decorated or not. A constructor is no declaration of
+ * the inventory, so the class stands for it and the registration referencing it keeps it.
  */
 import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetAccessorDeclaration, isPropertyDeclaration, isSetAccessorDeclaration, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.js";
 import { classMembers } from "./class-members.js";
 import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
-import { nodeKey } from "./inventory.js";
+import { isParameterProperty, nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
-/** Whether one member declaration is a property or an accessor carrying a decorator. */
+/** Whether one member declaration is a parameter property, or a property or accessor carrying a decorator. */
 function isInjected(node) {
-    return ((isPropertyDeclaration(node) ||
-        isGetAccessorDeclaration(node) ||
-        isSetAccessorDeclaration(node)) &&
-        decoratorsOf(node).length > 0);
+    return (isParameterProperty(node) ||
+        ((isPropertyDeclaration(node) ||
+            isGetAccessorDeclaration(node) ||
+            isSetAccessorDeclaration(node)) &&
+            decoratorsOf(node).length > 0));
 }
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations(input) {
@@ -43,18 +45,20 @@ function registrations(input) {
         return uses.map((use) => ({ id: use.id, site: use.site, detail }));
     });
 }
-/** The classes of the target a parameter of whose constructor carries a decorator. */
+/**
+ * The classes of the target a parameter of whose constructor carries a decorator, each
+ * with the first such decorator.
+ */
 function constructedForParameters(input) {
     const { project, held } = input;
-    const found = new Set();
+    const found = new Map();
     for (const file of project.ownSourceFiles()) {
         const visit = (node) => {
             if (isClassDeclaration(node) || isClassExpression(node)) {
                 const id = held.declarations.get(nodeKey(file, node));
-                const asks = node.members.some((member) => isConstructorDeclaration(member) &&
-                    member.parameters.some((parameter) => decoratorsOf(parameter).length > 0));
-                if (id !== undefined && asks) {
-                    found.add(id);
+                const [asks] = node.members.flatMap((member) => isConstructorDeclaration(member) ? member.parameters.flatMap(decoratorsOf) : []);
+                if (id !== undefined && asks !== undefined) {
+                    found.set(id, asks);
                 }
             }
             node.forEachChild(visit);
@@ -72,7 +76,7 @@ export function injectionContainer(input) {
     const { project, held, targetRoot } = input;
     const registered = registrations(input);
     const constructed = constructedForParameters(input);
-    const classes = new Set([...registered.map((one) => one.id), ...constructed]);
+    const classes = new Set([...registered.map((one) => one.id), ...constructed.keys()]);
     if (classes.size === 0) {
         return [];
     }
@@ -85,16 +89,15 @@ export function injectionContainer(input) {
             found.push({ id: member.id, detail: registration.detail, site: at(registration.site) });
         }
     }
-    for (const id of constructed) {
+    for (const [id, asks] of constructed) {
         for (const member of injected(id)) {
-            const [decorator] = decoratorsOf(member.node);
-            if (decorator !== undefined) {
-                found.push({
-                    id: member.id,
-                    detail: `injected by ${spelledDecorator(decorator)}`,
-                    site: at(decorator),
-                });
-            }
+            // An undecorated parameter property is passed because a sibling parameter asks.
+            const [decorator = asks] = decoratorsOf(member.node);
+            found.push({
+                id: member.id,
+                detail: `injected by ${spelledDecorator(decorator)}`,
+                site: at(decorator),
+            });
         }
     }
     return found;

package/dist/src/intra-function-parts.js

@@ -4,8 +4,8 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
+import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isParameterProperty, nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
@@ -234,6 +234,39 @@ function hierarchyFixes(declared, extended) {
     }
     return owner.name !== undefined && extended.has(owner.name.text);
 }
+/** Whether a decorator on a constructor's class or on one of its parameters fixes its signature. */
+function decoratorFixes(constructor) {
+    const owner = constructor.parent;
+    return ((owner.modifiers ?? []).some(isDecorator) ||
+        constructor.parameters.some((parameter) => (parameter.modifiers ?? []).some(isDecorator)));
+}
+/** The name an expression spells a class by: an identifier, or the member a property access names. */
+function spelledName(expression) {
+    const node = unwrapped(expression);
+    if (isIdentifier(node)) {
+        return node;
+    }
+    return isPropertyAccessExpression(node) && isIdentifier(node.name) ? node.name : undefined;
+}
+/**
+ * The names one node writes that use a class without using its constructor as a value:
+ * the class a `new` expression calls, the class an `extends` or `implements` clause
+ * names, and the name a type reference spells.
+ */
+function constructionNames(node) {
+    if (isNewExpression(node)) {
+        return [spelledName(node.expression) ?? []].flat();
+    }
+    if (isHeritageClause(node) &&
+        (isClassDeclaration(node.parent) || isClassExpression(node.parent))) {
+        return node.types.flatMap((type) => isTypeReferenceNode(type) ? [] : (spelledName(type.expression) ?? []));
+    }
+    if (isTypeReferenceNode(node)) {
+        const named = isQualifiedName(node.typeName) ? node.typeName.right : node.typeName;
+        return isIdentifier(named) ? [named] : [];
+    }
+    return [];
+}
 /**
  * The symbol identifier each of a batch of identifiers resolves to, where the batch
  * resolves it, and {@link UNANSWERED} where the checker did not answer.
@@ -270,18 +303,16 @@ function readsBinding(use, declared, ids) {
 export function projectParts(project, held, references, targetRoot) {
     const files = project.ownSourceFiles();
     const extended = extendedNames(files);
-    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
     const parts = [];
     const signatures = [];
     const calls = new Map();
     const specifiers = new Set();
+    const constructions = new Set();
     const sites = [];
     const contextual = [];
     for (const file of files) {
-        const declarationAt = (node) => {
-            const id = held.declarations.get(nodeKey(file, node));
-            return id === undefined || kinds.get(id) === "file" ? undefined : id;
-        };
+        // A parameter property's own parts stay with the parameter when its member goes.
+        const declarationAt = (node) => isParameterProperty(node) ? undefined : held.declarations.get(nodeKey(file, node));
         // A part no declaration holds belongs to the file, which is judged while the file is live.
         const fileId = held.declarations.get(nodeKey(file, file));
         const holderOf = (node) => {
@@ -332,6 +363,17 @@ export function projectParts(project, held, references, targetRoot) {
                 walk.declared.push({ id, node, signature });
                 covered.add(signature);
             }
+            // A constructor is no declaration, so the class it belongs to holds its parts.
+            const constructs = isConstructorDeclaration(node) && node.body !== undefined
+                ? declarationAt(node.parent)
+                : undefined;
+            if (constructs !== undefined && isConstructorDeclaration(node)) {
+                walk.declared.push({ id: constructs, node, signature: node });
+                covered.add(node);
+            }
+            for (const name of constructionNames(node)) {
+                constructions.add(position(name));
+            }
             const value = covered.has(node) ? undefined : valueSignature(node);
             const valueHolder = id ?? holderOf(node);
             if (value !== undefined && valueHolder !== undefined && !isStub(value)) {
@@ -413,11 +455,15 @@ export function projectParts(project, held, references, targetRoot) {
         }
         const ids = resolvedIds(project, [...new Set(asked)]);
         for (const one of walk.declared) {
-            sites.push({ file, declared: one });
+            const constructor = isConstructorDeclaration(one.node);
+            if (!constructor) {
+                sites.push({ file, declared: one });
+            }
             signatures.push({
                 declaration: one.id,
                 stub: isStub(one.signature),
-                fixed: hierarchyFixes(one.node, extended),
+                fixed: constructor ? decoratorFixes(one.node) : hierarchyFixes(one.node, extended),
+                constructor,
             });
             const reader = readers.get(one.signature);
             if (reader !== undefined) {
@@ -475,7 +521,13 @@ export function projectParts(project, held, references, targetRoot) {
         }
     }
     parts.push(...resultParts(project, targetRoot, sites, references, calls));
-    return { parts: withContextualRead(project, parts, contextual), signatures, calls, specifiers };
+    return {
+        parts: withContextualRead(project, parts, contextual),
+        signatures,
+        calls,
+        specifiers,
+        constructions,
+    };
 }
 /**
  * A function written in place that no declaration declares: an arrow, a function
@@ -496,16 +548,12 @@ function valueSignature(node) {
 }
 /**
  * Every name one function's parameters bind, a binding pattern's names one by one. A
- * `this` parameter receives no argument and a decorated one is read by its decorator, so
- * neither binds a subject.
+ * `this` parameter receives no argument, a decorated one is read by its decorator, and a
+ * parameter property is read by the write to its member, so none binds a subject.
  */
 function parameterNames(signature) {
     const found = [];
     const patternNames = (pattern, at) => {
-        if (isIdentifier(pattern)) {
-            found.push({ name: pattern, at, pattern: true, exempt: false });
-            return;
-        }
         const rest = isObjectBindingPattern(pattern) &&
             pattern.elements.some((element) => element.dotDotDotToken !== undefined);
         for (const element of pattern.elements) {
@@ -523,7 +571,8 @@ function parameterNames(signature) {
     };
     signature.parameters.forEach((parameter, at) => {
         const name = parameter.name;
-        if ((parameter.modifiers ?? []).some(isDecorator)) {
+        if ((parameter.modifiers ?? []).some(isDecorator) ||
+            isParameterProperty(parameter)) {
             return;
         }
         if (isIdentifier(name)) {
@@ -682,9 +731,7 @@ function deadStores(file, root, block, holder, locals, ids) {
         for (const write of writes) {
             // The rest of the write's own statement runs after it: a later declarator may read the local.
             const own = statements[write.at];
-            const sameStatement = own !== undefined && write.target === local.name
-                ? usesIn(own).filter((use) => use !== local.name)
-                : [];
+            const sameStatement = own !== undefined && write.target === local.name ? usesIn(own) : [];
             if (sameStatement.length > 0) {
                 continue;
             }
@@ -787,7 +834,7 @@ export function intraFunctionFacts(projects, references, exempted) {
         for (const [at, value] of one.calls) {
             calls.set(at, value);
         }
-        for (const at of one.specifiers) {
+        for (const at of [...one.specifiers, ...one.constructions]) {
             specifiers.add(at);
         }
     }
@@ -815,9 +862,11 @@ export function intraFunctionFacts(projects, references, exempted) {
     const free = new Set(signatures
         .map((one) => one.declaration)
         .filter((id) => !fixed.has(id) && !exempted.has(id) && !valued.has(id)));
+    // A class used as a value fixes its constructor's whole signature, whatever reads follow.
+    const constructors = new Set(signatures.filter((one) => one.constructor).map((one) => one.declaration));
     const freeButValued = new Set(signatures
         .map((one) => one.declaration)
-        .filter((id) => !fixed.has(id) && !exempted.has(id) && valued.has(id)));
+        .filter((id) => !fixed.has(id) && !exempted.has(id) && valued.has(id) && !constructors.has(id)));
     // Awaiting a thenable result sequences on it, so a call that awaits one uses it.
     const sequenced = new Set([...parts.values()]
         .filter((part) => part.thenable === true && awaited.has(part.declaration))

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/ast";
+import { isClassDeclaration, isComputedPropertyName, isConstructorDeclaration, isEnumDeclaration, isEnumMember, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isModuleBlock, isModuleDeclaration, isNamespaceExport, isParameterDeclaration, 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";
@@ -232,6 +232,20 @@ function unnamedStart(node) {
     const prefix = DEFAULT_EXPORT.exec(node.getText());
     return prefix === null ? start : start + prefix[0].length;
 }
+/**
+ * Whether one node is a parameter property: a constructor parameter carrying an
+ * accessibility, `readonly` or `override` modifier, which also declares an instance
+ * member of the class, with the parameter's node as the member's declaration.
+ */
+export function isParameterProperty(node) {
+    return (isParameterDeclaration(node) &&
+        isConstructorDeclaration(node.parent) &&
+        (modifiersOf(node) & ModifierFlags.ParameterPropertyModifier) !== 0);
+}
+/** The parameter properties every constructor of one class declares. */
+function parameterPropertiesOf(node) {
+    return node.members.flatMap((member) => isConstructorDeclaration(member) ? member.parameters.filter(isParameterProperty) : []);
+}
 /** The kind a class element takes: a method, or a property or accessor. */
 function classMemberKind(node) {
     return isMethodDeclaration(node) ? "method" : "class-member";
@@ -367,7 +381,7 @@ export function inventory(project, host, targetRoot) {
                 owner: record,
                 declaration: node,
                 nameNode: node.name,
-                members: node.members,
+                members: [...node.members, ...parameterPropertiesOf(node)],
                 memberKind: "class-member",
                 isClass: true,
                 membersAreExports: false,
@@ -677,7 +691,8 @@ export function inventory(project, host, targetRoot) {
             if (isPropertyDeclaration(node) ||
                 isMethodDeclaration(node) ||
                 isGetAccessorDeclaration(node) ||
-                isSetAccessorDeclaration(node)) {
+                isSetAccessorDeclaration(node) ||
+                isParameterProperty(node)) {
                 return classMemberKind(node);
             }
             return undefined;
@@ -718,9 +733,7 @@ export function inventory(project, host, targetRoot) {
         });
     }
     const byId = new Map(building.map((record) => [positionKey(record.position), record]));
-    const symbols = building
-        .map(render)
-        .sort((a, b) => byPosition(a.position, b.position) || (a.ref < b.ref ? -1 : 1));
+    const symbols = building.map(render).sort((a, b) => byPosition(a.position, b.position));
     return {
         symbols,
         declarations: new Map([...byNode].map(([key, record]) => [key, positionKey(record.position)])),

package/dist/src/kinds.js

@@ -153,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 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.",
+        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. A TypeScript parameter property, a constructor parameter that carries a modifier, declares a member of its class that the constructor writes with its argument, so the member is judged under this rule, and under every rule that reads a class member, as a member the class body declares is. 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",
@@ -289,7 +289,7 @@ const ROWS = [
         name: "unused-parameter",
         languages: ["go", "ts"],
         rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not 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, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported when its body reads no parameter after it, and an unread parameter before the last read one is not. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type is not reported when it carries a type annotation, because the inference of the call that holds the function may read the annotation, or when it is an object binding pattern, because the pattern reads each property it names from the argument and the code that hands the argument may act on that read. No name such a pattern binds is reported either. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. No name exempts a parameter. A TypeScript parameter whose name starts with an underscore is judged as any other is, and a Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not 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, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported when its body reads no parameter after it, and an unread parameter before the last read one is not. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type is not reported when it carries a type annotation, because the inference of the call that holds the function may read the annotation, or when it is an object binding pattern, because the pattern reads each property it names from the argument and the code that hands the argument may act on that read. No name such a pattern binds is reported either. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. No name exempts a parameter. A TypeScript parameter whose name starts with an underscore is judged as any other is, and a Go parameter named by the blank identifier declares no name a body could read and is never reported.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "manual",

package/dist/src/matrix.js

@@ -7,13 +7,6 @@ import { componentsOf } from "./components.js";
 import { graphOf, OUTSIDE } from "./graph.js";
 import { byPosition } from "./position.js";
 import { reachedWithTheTests, sweep, } from "./sweep.js";
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * What makes one reference one reference, whichever configuration made it. A consumer's
  * position is rendered against its own root, so the consumer is part of what it names.
@@ -76,7 +69,7 @@ export function matrixOf(per) {
             references.push(reference);
         }
     });
-    symbols.sort((a, b) => byPosition(a.position, b.position) || compare(a.ref, b.ref));
+    symbols.sort((a, b) => byPosition(a.position, b.position));
     return {
         configurations: per.map((one) => one.configuration),
         graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles)),