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

package/dist/src/resolve.js

@@ -21,9 +21,9 @@ const PLATFORM_MEMBERS = ["os", "arch", "tags"];
 const PROJECT_MEMBER = "project";
 /**
  * One segment of a project path: not empty, not `.` or `..`, and holding no
- * solidus, backslash or line break.
+ * solidus or control character.
  */
-const PROJECT_SEGMENT = String.raw `(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)`;
+const PROJECT_SEGMENT = String.raw `(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.\.[^/\x00-\x1f\x7f]+)`;
 /**
  * A project path: segments joined by a solidus, so the path is relative, below
  * the root it is read against, and spelled one way on every machine.
@@ -151,6 +151,39 @@ function readStrings(parent, name, path, label, minItems, allowed) {
     }
     return value;
 }
+/**
+ * The target kind, a string or an object naming every language. The walk has
+ * already refused an undeclared member, so an object is refused for the first
+ * language it leaves out, then for the first language whose value is refused,
+ * each in the vocabulary's language order.
+ */
+function readTargetKind(target, label) {
+    const value = member(target, "kind");
+    const perLanguage = `an object naming the kind of each of ${spell(LANGUAGES)}`;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        if (!TARGET_KINDS.includes(value)) {
+            throw malformed(label, "target.kind", `${JSON.stringify(value)} is not one of ${spell(TARGET_KINDS)}, nor ${perLanguage}`);
+        }
+        return value;
+    }
+    if (!isRecord(value)) {
+        throw malformed(label, "target.kind", `${JSON.stringify(value)} is neither one of ${spell(TARGET_KINDS)} nor ${perLanguage}`);
+    }
+    const missing = LANGUAGES.find((language) => !Object.hasOwn(value, language));
+    if (missing !== undefined) {
+        throw malformed(label, `target.kind.${missing}`, `is not set, and ${perLanguage} names each`);
+    }
+    for (const language of LANGUAGES) {
+        const kind = value[language];
+        if (typeof kind !== "string" || !TARGET_KINDS.includes(kind)) {
+            throw malformed(label, `target.kind.${language}`, `${JSON.stringify(kind)} is not one of ${spell(TARGET_KINDS)}`);
+        }
+    }
+    return { go: value["go"], ts: value["ts"] };
+}
 /** A component file's extension: a full stop followed by letters and digits. */
 const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
 function readComponentExtensions(ts, label) {
@@ -194,7 +227,7 @@ function readProject(entry, at, label) {
     const project = requireMember(readString(entry, PROJECT_MEMBER, path, label), path, label);
     if (!PROJECT_PATH.test(project)) {
         throw malformed(label, path, `${JSON.stringify(project)} is not a path below the target root: segments joined by /, ` +
-            "none empty, . or .., and no backslash or line break");
+            "none empty, . or .., and no control character");
     }
     return { shape: "project", id, project };
 }
@@ -508,7 +541,7 @@ function readDoc(value, label) {
     }
     return {
         contractVersion,
-        targetKind: readEnum(target, "kind", "target.kind", label, TARGET_KINDS),
+        targetKind: readTargetKind(target, label),
         languages: readStrings(analysis, "languages", "analysis.languages", label, 0, LANGUAGES),
         minConfidence: readEnum(analysis, "min_confidence", "analysis.min_confidence", label, CONFIDENCES),
         generatedFiles: readEnum(analysis, "generated_files", "analysis.generated_files", label, GENERATED_FILES),

package/dist/src/schema.js

@@ -15,7 +15,10 @@ export const SCHEMA_ROOT = {
     kind: "section",
     members: {
         contract_version: leaf,
-        target: { kind: "section", members: { kind: leaf } },
+        target: {
+            kind: "section",
+            members: { kind: { kind: "object", members: { go: leaf, ts: leaf } } },
+        },
         analysis: {
             kind: "section",
             members: {

package/dist/src/suppress-file.js

@@ -205,11 +205,12 @@ export function rowReason(provenance) {
     return `recorded by ${provenance.analyzer} ${provenance.version}`;
 }
 /**
- * The rows of the other language's scheme that the baseline document `text` holds, in
- * document order and as written, which a write keeps. A document that is not a baseline,
- * or a row in a shape no record takes, is refused rather than dropped.
+ * The rows of a scheme other than `own` that the baseline document `text` holds, in
+ * document order and as written, which a write of `own`'s rows keeps. A document that is
+ * not a baseline, or a row in a shape no record takes, of any scheme, is refused rather
+ * than dropped.
  */
-export function otherSchemeRows(text) {
+export function otherSchemeRows(text, own = OWN_SCHEME) {
     const refuse = (detail) => {
         throw new Error(`${BASELINE_FILE} cannot be rewritten keeping the other language's rows: ${detail}`);
     };
@@ -233,7 +234,7 @@ export function otherSchemeRows(text) {
         }
         // readRecord has checked every member is a string and the code and symbol are present.
         const { code, symbol, path, reason } = value;
-        if (code === undefined || symbol === undefined || symbol.startsWith(OWN_SCHEME)) {
+        if (code === undefined || symbol === undefined || symbol.startsWith(own)) {
             return [];
         }
         return [
@@ -246,10 +247,32 @@ export function otherSchemeRows(text) {
         ];
     });
 }
+/** The reference schemes in the order a baseline holds their rows. */
+const SCHEME_ORDER = ["go://", "ts://"];
+function schemeRank(row) {
+    return SCHEME_ORDER.findIndex((scheme) => row.symbol.startsWith(scheme));
+}
+/** A surrogate half no other completes, which Go's encoding/json decodes as U+FFFD. */
+const LONE_SURROGATE = /[\ud800-\udfff]/gu;
+/** One string with every lone surrogate written as U+FFFD. */
+function wellFormed(text) {
+    return text.replace(LONE_SURROGATE, "\ufffd");
+}
 /**
- * A baseline holding one row per finding, in the order given, which is the report's, after
- * the other language's rows `kept`, so two analyzers writing one document in either order
- * write the same bytes. Every recorded row carries the provenance as its reason. A finding
+ * The pieces of a JSON document with U+2028 and U+2029 escaped, as Go's encoding/json
+ * writes them. Neither is JSON syntax, so each stands inside a string.
+ */
+function* separatorsEscaped(pieces) {
+    for (const piece of pieces) {
+        yield piece.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    }
+}
+/**
+ * A baseline holding one row per finding, in the order given, which is the report's, and
+ * the other language's rows `kept`, Go's rows ahead of TypeScript's and each scheme's in
+ * the order given, so two analyzers writing one document in either order write the same
+ * bytes, in the form grammar/suppression.md fixes. Every recorded row carries the
+ * provenance as its reason. A finding
  * missing a value a row needs, and an identity missing its name or version, are refused
  * rather than written, because the grammar requires a reason on every row.
  */
@@ -264,5 +287,16 @@ export function writeBaseline(findings, provenance, kept = []) {
         }
         return { code: found.code, symbol: found.symbol, path: found.path, reason };
     });
-    return jsonChunks({ description: BASELINE_DESCRIPTION, baseline: [...kept, ...baseline] }, 2);
+    const rows = [...kept, ...baseline]
+        .sort((a, b) => schemeRank(a) - schemeRank(b))
+        .map((row) => {
+        const { code, symbol, path, reason } = row;
+        return {
+            code: wellFormed(code),
+            symbol: wellFormed(symbol),
+            ...(path === undefined ? {} : { path: wellFormed(path) }),
+            ...(reason === undefined ? {} : { reason: wellFormed(reason) }),
+        };
+    });
+    return separatorsEscaped(jsonChunks({ description: BASELINE_DESCRIPTION, baseline: rows }, 2));
 }

package/dist/src/suppress-inline.js

@@ -3,11 +3,11 @@
  * one or more codes and a reason, and binding to every declaration that begins on the line
  * below it, or on its own line where it trails a token there.
  */
-import { SyntaxKind } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
+import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isParameterProperty, nodeKey } from "./inventory.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
 import { signatureOf } from "./signatures.js";
-import { SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+import { isPartKind, SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
  * order: a comment in the namespace, a well-formed directive, and a directive that lacks
@@ -132,37 +132,53 @@ function lineComments(file) {
     }
     return found;
 }
+function bindingKey(one) {
+    return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
+}
 /**
  * The declarations of one file by the line each begins on, the line of its first token: a
  * decorator, a modifier or the keyword. A variable's first token is its statement's
  * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters.
+ * function also begins, for a directive, on the line of each of its parameters, and a
+ * class, for a part kind, on the lines of its constructor and its constructor's parameters.
  */
 function declarationLines(file, held, symbols) {
     const below = new Map();
     const add = (offset, one) => {
         const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
         const at = below.get(line) ?? [];
-        if (!at.some((known) => known.id === one.id)) {
+        if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
             at.push(one);
         }
         below.set(line, at);
     };
-    const visit = (node) => {
+    const declaredAt = (node) => {
         const id = held.declarations.get(nodeKey(file, node));
-        const one = id === undefined ? undefined : symbols.get(id);
+        return id === undefined ? undefined : symbols.get(id);
+    };
+    const visit = (node) => {
+        const one = declaredAt(node);
+        const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
+        if (owner !== undefined && isConstructorDeclaration(node)) {
+            for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
+                add(at.pos, { declared: undefined, part: owner });
+            }
+        }
+        const holder = one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
+        if (one !== undefined && holder !== undefined) {
+            add(node.pos, { declared: one, part: holder });
+        }
         if (one !== undefined) {
-            add(node.pos, one);
             // A parameter on a later line of a wrapped signature takes its directive on the
             // line above it, inside the parameter list, and the directive binds the function.
             for (const parameter of signatureOf(node)?.parameters ?? []) {
-                add(parameter.pos, one);
+                add(parameter.pos, { declared: one, part: one });
             }
             const list = node.parent;
             if (node.kind === SyntaxKind.VariableDeclaration &&
                 list.kind === SyntaxKind.VariableDeclarationList &&
                 list.parent.kind === SyntaxKind.VariableStatement) {
-                add(list.parent.pos, one);
+                add(list.parent.pos, { declared: one, part: one });
             }
         }
         node.forEachChild(visit);
@@ -223,7 +239,7 @@ export function inlineSuppressions(perProject) {
             continue;
         }
         for (const one of written.bound) {
-            if (!known.bound.some((other) => other.id === one.id)) {
+            if (!known.bound.some((other) => bindingKey(other) === bindingKey(one))) {
                 known.bound.push(one);
             }
         }
@@ -251,8 +267,15 @@ export function inlineSuppressions(perProject) {
                 }
                 break;
             case "directive": {
-                const declared = [...bound].sort((a, b) => byPosition(a.position, b.position));
                 for (const code of directive.codes) {
+                    const targets = new Map();
+                    for (const one of bound) {
+                        const target = isPartKind(code) ? one.part : one.declared;
+                        if (target !== undefined) {
+                            targets.set(target.id, target);
+                        }
+                    }
+                    const declared = [...targets.values()].sort((a, b) => byPosition(a.position, b.position));
                     const base = {
                         code,
                         path: site.path,

package/dist/src/suppress.js

@@ -34,9 +34,10 @@ export function siteText(site) {
 export const CODE_FORM = /^DS[0-9]{4}$/u;
 /**
  * A path inside the target: relative to the target root, the solidus as separator, no
- * leading `./`, no trailing solidus, no `.` or `..` segment, never absolute.
+ * leading `./`, no trailing solidus, no `.` or `..` segment, never absolute, and no
+ * control character; a backslash is a character of a name.
  */
-export const PATH_EXPRESSION = String.raw `^(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)(?:/(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+))*$`;
+export const PATH_EXPRESSION = String.raw `^(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.\.[^/\x00-\x1f\x7f]+)(?:/(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.\.[^/\x00-\x1f\x7f]+))*$`;
 const PATH_FORM = new RegExp(PATH_EXPRESSION, "u");
 /** Whether one value is a path in the form an entry's `path` takes. */
 export function isEntryPath(value) {

package/dist/src/verbs/analyze.js

@@ -1,11 +1,11 @@
 import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js";
-import { ConfigError } from "../config.js";
+import { ConfigError, kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { partialNotes } from "../partial.js";
-import { buildReport, capFindings, sortFindings, } from "../report.js";
+import { buildReport, LANGUAGE, capFindings, sortFindings, } from "../report.js";
 import { json } from "../reporters/json.js";
 import { RENDERINGS } from "../reporters/reporters.js";
 import { parseTemplate, TemplateError } from "../reporters/template.js";
@@ -188,7 +188,11 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             version,
             conformance: CONFORMANCE,
             declaredGaps: DECLARED_GAPS,
-            target: { kind, root, identity: moduleIdentity(host, scoped.target) },
+            target: {
+                kind: kindOf(kind, LANGUAGE),
+                root,
+                identity: moduleIdentity(host, scoped.target),
+            },
             configurations: configurationsOf(run.projects, targetRoot),
             notBuilt: notBuiltOf(run.notBuilt, targetRoot),
             loaded: run.consumers.map((consumer) => ({

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "7.1.0";
+export const CONTRACT_VERSION = "7.2.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.1.0-dev.2",
+  "version": "7.2.0-dev.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.1.0-dev.2",
+  "version": "7.2.0-dev.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/alias-chain.ts

@@ -14,7 +14,7 @@ import {
   isNamespaceImport,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
-import { declarationsByName, nodeKey, type Inventory } from "./inventory.ts";
+import { declarationsByName, isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -76,7 +76,12 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
       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/src/analysis.ts

@@ -7,7 +7,7 @@
  */
 
 import { lineOf, readComponent } from "./component-files.ts";
-import type { Config, Provenance } from "./config.ts";
+import { kindOf, type Config, type Provenance } from "./config.ts";
 import {
   consumerLoads,
   consumerReferences,
@@ -83,7 +83,7 @@ import {
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
-import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
+import { LANGUAGE, type TypeErrorSkip, type UnansweredCount } from "./report.ts";
 import { SetupError, setupLine, type SetupFailure } from "./setup-failure.ts";
 import {
   pathsOf,
@@ -377,7 +377,7 @@ function readProjects<Answer>(
       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/src/config.ts

@@ -13,6 +13,14 @@ export const REPOSITORY_DOCUMENT = "deadset.json";
  */
 export type TargetKind = "application" | "library";
 
+/** The target kind as a source writes it: one kind for every language, or one per language. */
+export type TargetKindSetting = TargetKind | { readonly go: TargetKind; readonly ts: TargetKind };
+
+/** The kind a target kind setting gives one language's declarations. */
+export function kindOf(setting: TargetKindSetting, language: Language): TargetKind {
+  return typeof setting === "string" ? setting : setting[language];
+}
+
 /** The lowest reachability class a finding must reach to be reported. */
 export type Confidence = "certain" | "probable" | "possible";
 
@@ -183,7 +191,7 @@ export interface TSSection {
  */
 export interface Config {
   readonly contractVersion: string;
-  readonly targetKind: TargetKind | "";
+  readonly targetKind: TargetKindSetting | "";
   readonly analysis: Analysis;
   readonly consumersComplete: boolean;
   readonly rootPatterns: readonly string[];

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

@@ -78,13 +78,13 @@ function codeOf(judged: Judged): string | undefined {
   ) {
     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/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;