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

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/findings/unused-declarations.js

@@ -54,13 +54,13 @@ function codeOf(judged) {
         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";
     }

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.
@@ -275,12 +308,16 @@ export function projectParts(project, held, references, targetRoot) {
     const signatures = [];
     const calls = new Map();
     const specifiers = new Set();
+    const constructions = new Set();
     const sites = [];
     const contextual = [];
     for (const file of files) {
+        // A parameter property's own parts stay with the parameter when its member goes.
         const declarationAt = (node) => {
             const id = held.declarations.get(nodeKey(file, node));
-            return id === undefined || kinds.get(id) === "file" ? undefined : id;
+            return id === undefined || kinds.get(id) === "file" || isParameterProperty(node)
+                ? undefined
+                : id;
         };
         // 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));
@@ -332,6 +369,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 +461,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 +527,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,8 +554,8 @@ 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 = [];
@@ -523,7 +581,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)) {
@@ -787,7 +846,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 +874,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;

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/ref.js

@@ -25,9 +25,10 @@ const TS_COMPUTED = String.raw `\[[^\]\r\n\t ]+\]`;
 const TS_HEAD = `(?:${TS_IDENT}|${TS_QUOTED})`;
 const TS_MEMBER = `(?:${TS_IDENT}|#${TS_IDENT}|${TS_QUOTED}|${TS_COMPUTED})`;
 const TS_PACKAGE = String.raw `(?:@[A-Za-z0-9._-]+/)?[A-Za-z0-9._-]+`;
-const TS_FILE = String.raw `(?:[^/#\r\n]+/)*[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc]?js|\.jsx)`;
+const TS_DIRS = String.raw `(?:[^/#\r\n]+/)*`;
+const TS_FILE = String.raw `${TS_DIRS}[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc]?js|\.jsx)`;
 const SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_FILE}`;
-const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/package\\.json`;
+const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_DIRS}package\\.json`;
 /**
  * One expression per form the grammar defines, each anchored and each the whole of
  * a reference. Several forms share one expression because they differ in what the

package/dist/src/references.js

@@ -5,7 +5,7 @@ import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
-import { declarationsByName, nodeKey } from "./inventory.js";
+import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
 import { augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
@@ -336,6 +336,7 @@ function sitesOf(file, declarations, fileId, unread) {
     const wholes = [];
     const urls = [];
     const decorated = [];
+    const parameterWrites = [];
     const namespaces = namespaceUses(file);
     const literals = [];
     const flows = [];
@@ -419,7 +420,16 @@ function sitesOf(file, declarations, fileId, unread) {
         }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
-        if (held !== undefined) {
+        // A parameter property's annotation, initializer and decorators stay with the
+        // parameter when the member goes, so they are written inside the constructor's class.
+        if (held !== undefined && isParameterProperty(node)) {
+            parameterWrites.push({
+                name: node.name,
+                from: outer,
+                member: held,
+            });
+        }
+        else if (held !== undefined) {
             enclosing = held;
             for (const modifier of node.modifiers ?? []) {
                 if (isDecorator(modifier)) {
@@ -441,6 +451,7 @@ function sitesOf(file, declarations, fileId, unread) {
         wholes,
         urls,
         decorated,
+        parameterWrites,
         keyed,
     };
 }
@@ -523,15 +534,12 @@ function importedNames(file) {
     importedCache.set(file, names);
     return names;
 }
-/**
- * The name node of every import binding one file's top level declares, and whether it
- * binds a whole module.
- */
+/** The name node of every import binding one file's top level declares. */
 function importBindings(file) {
     const found = [];
     for (const statement of file.statements) {
         if (isImportEqualsDeclaration(statement)) {
-            found.push({ node: statement.name, whole: true });
+            found.push({ node: statement.name });
             continue;
         }
         const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
@@ -539,17 +547,17 @@ function importBindings(file) {
             continue;
         }
         if (clause.name !== undefined) {
-            found.push({ node: clause.name, whole: false });
+            found.push({ node: clause.name });
         }
         const bindings = clause.namedBindings;
         if (bindings === undefined) {
             continue;
         }
         if (bindings.kind === SyntaxKind.NamespaceImport) {
-            found.push({ node: bindings.name, whole: true });
+            found.push({ node: bindings.name });
         }
         else {
-            found.push(...bindings.elements.map((element) => ({ node: element.name, whole: false })));
+            found.push(...bindings.elements.map((element) => ({ node: element.name })));
         }
     }
     return found;
@@ -856,7 +864,7 @@ export function references(project, held, targetRoot, options) {
         }
     }
     const keyNames = computedKeyNames(held.symbols);
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, keyed, } of walked) {
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, parameterWrites, keyed, } of walked) {
         const test = testFile.get(file) === true;
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
@@ -874,6 +882,17 @@ export function references(project, held, targetRoot, options) {
                 test,
             });
         }
+        // The constructor stores its argument in the member a parameter property declares.
+        for (const { name, from, member } of parameterWrites) {
+            found.push({
+                from,
+                to: member,
+                position: renderPosition(file, root, name.getStart()),
+                use: "write",
+                resolution: "syntax",
+                test,
+            });
+        }
         // One batch per capped run of the file's name nodes, the re-exports' nodes after
         // the uses and the evaluated modules' specifiers last, each node once: a bare star
         // re-export's specifier is a link and an evaluation both. A shorthand is left out
@@ -1011,15 +1030,14 @@ export function references(project, held, targetRoot, options) {
                 const chained = symbol === UNANSWERED
                     ? named(binding.node).map((id) => ({ id, stepped: false, guessed: true }))
                     : chains.chainOf(symbol);
-                // The markup may name any export of a module a binding holds whole.
-                const targets = binding.whole
-                    ? chained.flatMap((target) => [
-                        target,
-                        ...declaredIn(target.id)
-                            .filter((one) => one.exported)
-                            .map((one) => ({ ...target, id: one.id })),
-                    ])
-                    : chained;
+                // The markup may name any export of a module a binding's chain reaches, whether a
+                // namespace import binds it or a named or default import of a namespace re-export.
+                const targets = chained.flatMap((target) => [
+                    target,
+                    ...declaredIn(target.id)
+                        .filter((one) => one.exported)
+                        .map((one) => ({ ...target, id: one.id })),
+                ]);
                 for (const target of targets) {
                     found.push({
                         from: fileId,

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.1.0";
+const SCHEMA_VERSION = "8.2.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. */