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

package/src/conformance-record.ts

@@ -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: [],
 } as const;

package/src/decorator.ts

@@ -14,7 +14,12 @@
 import type { Node } from "@typescript/native/ast";
 import { decoratorsOf, spelledDecorator } from "./calls.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
-import { nodeKey, type InventorySymbol, type SymbolKind } from "./inventory.ts";
+import {
+  isParameterProperty,
+  nodeKey,
+  type InventorySymbol,
+  type SymbolKind,
+} from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 
 /** The kinds of declaration a decorator is attached to and holds back. */
@@ -44,7 +49,8 @@ export function decorator<Brand>(input: DetectorInput<Brand>): readonly Evidence
     const visit = (node: Node): void => {
       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/src/dependencies.ts

@@ -616,15 +616,11 @@ function skipWhitespace(text: string, at: number): number {
  */
 function membersAt(text: string, at: number): Map<string, { key: number; value: number }> {
   const found = new Map<string, { key: number; value: number }>();
-  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)) as string;
     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/src/deprecation.ts

@@ -73,7 +73,7 @@ export function deprecatedDeclarations<Brand>(
         }
       }
       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/src/findings/completion.ts

@@ -181,10 +181,7 @@ function findingComponents(
               },
             ];
       })
-      .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/src/findings/interfaces.ts

@@ -19,14 +19,6 @@ function positionOf(symbol: InventorySymbol): FindingPosition {
   return { ...symbol.position, endLine: Math.max(symbol.position.line, symbol.endLine) };
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** One run's declarations and candidates, indexed for the two kinds. */
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
@@ -49,7 +41,7 @@ function indexed(input: EmitterInput): {
         .map(symbolOf)
         .filter((symbol): symbol is InventorySymbol => 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)),
   };
 }
 

package/src/findings/unused-declarations.ts

@@ -52,8 +52,6 @@ interface Judged {
   readonly symbol: InventorySymbol;
   /** Whether a test file declares it. */
   readonly test: boolean;
-  /** Whether its container is itself dead, so it falls with the container. */
-  readonly containerDead: boolean;
   readonly deprecated: boolean;
   /** Whether the unreachable-export kind reports it. */
   readonly unreachable: boolean;
@@ -61,30 +59,26 @@ interface Judged {
 
 /**
  * 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: Judged): string | undefined {
   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";
   }
@@ -233,7 +227,6 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
       candidate,
       symbol,
       test: union.test[at] === true,
-      containerDead: containerDead && !fallen,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),
     };

package/src/html-entries.ts

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

package/src/injection-container.ts

@@ -1,9 +1,10 @@
 /**
  * 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 {
@@ -14,6 +15,7 @@ import {
   isPropertyDeclaration,
   isSetAccessorDeclaration,
   type CallExpression,
+  type Decorator,
   type Node,
 } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.ts";
@@ -27,7 +29,7 @@ import {
   type ResolvedEntry,
 } from "./configured-declarations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
-import { nodeKey } from "./inventory.ts";
+import { isParameterProperty, nodeKey } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 
 /** One class a container constructs, by the registration that says so. */
@@ -37,13 +39,14 @@ interface Registration {
   readonly detail: string;
 }
 
-/** 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: Node): boolean {
   return (
-    (isPropertyDeclaration(node) ||
+    isParameterProperty(node) ||
+    ((isPropertyDeclaration(node) ||
       isGetAccessorDeclaration(node) ||
       isSetAccessorDeclaration(node)) &&
-    decoratorsOf(node).length > 0
+      decoratorsOf(node).length > 0)
   );
 }
 
@@ -77,21 +80,24 @@ function registrations<Brand>(input: DetectorInput<Brand>): readonly Registratio
   });
 }
 
-/** The classes of the target a parameter of whose constructor carries a decorator. */
-function constructedForParameters<Brand>(input: DetectorInput<Brand>): ReadonlySet<string> {
+/**
+ * The classes of the target a parameter of whose constructor carries a decorator, each
+ * with the first such decorator.
+ */
+function constructedForParameters<Brand>(
+  input: DetectorInput<Brand>,
+): ReadonlyMap<string, Decorator> {
   const { project, held } = input;
-  const found = new Set<string>();
+  const found = new Map<string, Decorator>();
   for (const file of project.ownSourceFiles()) {
     const visit = (node: Node): void => {
       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),
+        const [asks] = node.members.flatMap((member) =>
+          isConstructorDeclaration(member) ? member.parameters.flatMap(decoratorsOf) : [],
         );
-        if (id !== undefined && asks) {
-          found.add(id);
+        if (id !== undefined && asks !== undefined) {
+          found.set(id, asks);
         }
       }
       node.forEachChild(visit);
@@ -110,7 +116,7 @@ export function injectionContainer<Brand>(input: DetectorInput<Brand>): readonly
   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 [];
   }
@@ -125,16 +131,15 @@ export function injectionContainer<Brand>(input: DetectorInput<Brand>): readonly
       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/src/intra-function-parts.ts

@@ -19,6 +19,7 @@ import {
   isCatchClause,
   isClassDeclaration,
   isClassExpression,
+  isConstructorDeclaration,
   isContinueStatement,
   isDecorator,
   isDefaultClause,
@@ -37,6 +38,7 @@ import {
   isMethodDeclaration,
   isModuleDeclaration,
   isNamespaceImport,
+  isNewExpression,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isObjectBindingPattern,
@@ -61,6 +63,7 @@ import {
   type Block,
   type CallExpression,
   type CatchClause,
+  type ConstructorDeclaration,
   type FunctionExpression,
   type Identifier,
   type Node,
@@ -68,7 +71,7 @@ import {
   type Statement,
 } from "@typescript/native/ast";
 import type { FindingPosition } from "./finding.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
+import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { positionKey, renderPosition } from "./position.ts";
 import { isAnswered, UNANSWERED, type Answer } from "./query.ts";
 import type { Reference } from "./references.ts";
@@ -117,8 +120,10 @@ interface SignatureFact {
   readonly declaration: string;
   /** Whether the body is empty or does nothing but throw. */
   readonly stub: boolean;
-  /** Whether a class hierarchy fixes the signature: the method overrides, or is overridden. */
+  /** Whether a class hierarchy fixes the signature, or a decorator a constructor's. */
   readonly fixed: boolean;
+  /** Whether the signature is a constructor's, which its class's identifier stands for. */
+  readonly constructor: boolean;
 }
 
 /** What one project answers about the parts of its declarations. */
@@ -129,6 +134,8 @@ export interface ProjectParts {
   readonly calls: ReadonlyMap<string, CallUse>;
   /** Each name an import or an export specifier writes, by position, which uses no value. */
   readonly specifiers: ReadonlySet<string>;
+  /** Each name of {@link constructionNames}, by position, which uses no constructor as a value. */
+  readonly constructions: ReadonlySet<string>;
 }
 
 /** The codes of the parts this module reads. */
@@ -391,6 +398,50 @@ function hierarchyFixes(declared: Node, extended: ReadonlySet<string>): boolean
   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: ConstructorDeclaration): boolean {
+  const owner = constructor.parent;
+  return (
+    ((owner as { readonly modifiers?: readonly Node[] }).modifiers ?? []).some(isDecorator) ||
+    constructor.parameters.some((parameter) =>
+      ((parameter as { readonly modifiers?: readonly Node[] }).modifiers ?? []).some(isDecorator),
+    )
+  );
+}
+
+/** The name an expression spells a class by: an identifier, or the member a property access names. */
+function spelledName(expression: Node): Identifier | undefined {
+  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: Node): readonly Identifier[] {
+  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 [];
+}
+
 /** One declaration of the inventory that declares a function, and that function. */
 interface Declared {
   readonly id: string;
@@ -478,19 +529,18 @@ export function projectParts<Brand>(
 ): ProjectParts {
   const files = project.ownSourceFiles();
   const extended = extendedNames(files);
-  const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
   const parts: PartFact[] = [];
   const signatures: SignatureFact[] = [];
   const calls = new Map<string, CallUse>();
   const specifiers = new Set<string>();
+  const constructions = new Set<string>();
   const sites: { readonly file: SourceFile; readonly declared: Declared }[] = [];
   const contextual: ContextualParameter[] = [];
 
   for (const file of files) {
-    const declarationAt = (node: Node): string | undefined => {
-      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: Node): string | undefined =>
+      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: Node): string | undefined => {
@@ -543,6 +593,18 @@ export function projectParts<Brand>(
         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)) {
@@ -628,11 +690,15 @@ export function projectParts<Brand>(
     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) {
@@ -699,7 +765,13 @@ export function projectParts<Brand>(
   }
 
   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,
+  };
 }
 
 /**
@@ -722,16 +794,12 @@ function valueSignature(node: Node): SignatureNode | undefined {
 
 /**
  * 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: SignatureNode): ParameterName[] {
   const found: ParameterName[] = [];
-  const patternNames = (pattern: BindingName, at: number): void => {
-    if (isIdentifier(pattern)) {
-      found.push({ name: pattern, at, pattern: true, exempt: false });
-      return;
-    }
+  const patternNames = (pattern: Exclude<BindingName, Identifier>, at: number): void => {
     const rest =
       isObjectBindingPattern(pattern) &&
       pattern.elements.some((element) => element.dotDotDotToken !== undefined);
@@ -750,7 +818,8 @@ function parameterNames(signature: SignatureNode): ParameterName[] {
   signature.parameters.forEach((parameter, at) => {
     const name = parameter.name;
     if (
-      ((parameter as { readonly modifiers?: readonly Node[] }).modifiers ?? []).some(isDecorator)
+      ((parameter as { readonly modifiers?: readonly Node[] }).modifiers ?? []).some(isDecorator) ||
+      isParameterProperty(parameter)
     ) {
       return;
     }
@@ -961,10 +1030,7 @@ function deadStores(
     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;
       }
@@ -1096,7 +1162,7 @@ export function intraFunctionFacts(
     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);
     }
   }
@@ -1127,10 +1193,16 @@ export function intraFunctionFacts(
       .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(

package/src/inventory.ts

@@ -1,6 +1,7 @@
 import {
   isClassDeclaration,
   isComputedPropertyName,
+  isConstructorDeclaration,
   isEnumDeclaration,
   isEnumMember,
   isExportAssignment,
@@ -15,6 +16,7 @@ import {
   isModuleBlock,
   isModuleDeclaration,
   isNamespaceExport,
+  isParameterDeclaration,
   isParenthesizedTypeNode,
   isPrivateIdentifier,
   isPropertyDeclaration,
@@ -26,6 +28,7 @@ import {
   isUnionTypeNode,
   isVariableStatement,
   ModifierFlags,
+  type ClassDeclaration,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -490,6 +493,26 @@ function unnamedStart(node: Node): number {
   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: Node): boolean {
+  return (
+    isParameterDeclaration(node) &&
+    isConstructorDeclaration(node.parent) &&
+    (modifiersOf(node) & ModifierFlags.ParameterPropertyModifier) !== 0
+  );
+}
+
+/** The parameter properties every constructor of one class declares. */
+function parameterPropertiesOf(node: ClassDeclaration): readonly 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: Node): SymbolKind {
   return isMethodDeclaration(node) ? "method" : "class-member";
@@ -647,7 +670,7 @@ export function inventory<Brand>(
         owner: record,
         declaration: node,
         nameNode: node.name,
-        members: node.members,
+        members: [...node.members, ...parameterPropertiesOf(node)],
         memberKind: "class-member",
         isClass: true,
         membersAreExports: false,
@@ -974,7 +997,8 @@ export function inventory<Brand>(
         isPropertyDeclaration(node) ||
         isMethodDeclaration(node) ||
         isGetAccessorDeclaration(node) ||
-        isSetAccessorDeclaration(node)
+        isSetAccessorDeclaration(node) ||
+        isParameterProperty(node)
       ) {
         return classMemberKind(node);
       }
@@ -1018,9 +1042,7 @@ export function inventory<Brand>(
   }
 
   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,

package/src/kinds.ts

@@ -191,7 +191,7 @@ const ROWS: readonly KindRow[] = [
     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",
@@ -332,7 +332,7 @@ const ROWS: readonly KindRow[] = [
     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.",
+      "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",