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

package/src/matrix.ts

@@ -94,14 +94,6 @@ export interface SweepResult {
   readonly components: readonly Component[];
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * What makes one reference one reference, whichever configuration made it. A consumer's
  * position is rendered against its own root, so the consumer is part of what it names.
@@ -163,7 +155,7 @@ export function matrixOf(per: readonly Configured[]): Matrix {
       references.push(reference);
     }
   });
-  symbols.sort((a, b) => byPosition(a.position, b.position) || compare(a.ref, b.ref));
+  symbols.sort((a, b) => byPosition(a.position, b.position));
 
   return {
     configurations: per.map((one) => one.configuration),

package/src/module-declarations.ts

@@ -113,9 +113,6 @@ interface Named {
 function namedBy(
   held: Inventory,
 ): (specifier: string, names: readonly string[]) => readonly Named[] {
-  if (held.modules.size === 0) {
-    return () => [];
-  }
   const refs = new Map<string, string>();
   const children = new Map<string, InventorySymbol[]>();
   for (const symbol of held.symbols) {

package/src/ref.ts

@@ -27,10 +27,11 @@ 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

package/src/references.ts

@@ -32,6 +32,7 @@ import {
   isVoidExpression,
   SyntaxKind,
   type Node,
+  type ParameterDeclaration,
   type SourceFile,
 } from "@typescript/native/ast";
 import type { Symbol as TSSymbol } from "@typescript/native/sync";
@@ -41,7 +42,13 @@ import { destructuring, propertyReadsOf, type PropertyRead } from "./destructuri
 import { specifierCandidates } from "./configuration-files.ts";
 import { namespaceUses } from "./namespace-objects.ts";
 import { globExpression } from "./glob.ts";
-import { declarationsByName, nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
+import {
+  declarationsByName,
+  isParameterProperty,
+  nodeKey,
+  type Inventory,
+  type InventorySymbol,
+} from "./inventory.ts";
 import { augmentationReferences } from "./augmentations.ts";
 import { elementAccessReferences } from "./element-access.ts";
 import { indexedAccessReferences } from "./indexed-access.ts";
@@ -478,6 +485,13 @@ interface Decorated {
   readonly declaration: string;
 }
 
+/** One parameter property, which its constructor writes, and the declaration that writes it. */
+interface ParameterWrite {
+  readonly name: Node;
+  readonly from: string;
+  readonly member: string;
+}
+
 /** One property a pattern reads, and the declaration the pattern is written inside. */
 interface Read extends PropertyRead {
   readonly from: string;
@@ -494,6 +508,7 @@ interface FileSites {
   readonly wholes: readonly WholeRead[];
   readonly urls: readonly ModuleURL[];
   readonly decorated: readonly Decorated[];
+  readonly parameterWrites: readonly ParameterWrite[];
   readonly keyed: readonly KeyedAccess[];
 }
 
@@ -682,6 +697,7 @@ function sitesOf(
   const wholes: WholeRead[] = [];
   const urls: ModuleURL[] = [];
   const decorated: Decorated[] = [];
+  const parameterWrites: ParameterWrite[] = [];
   const namespaces = namespaceUses(file);
   const literals: LiteralAt[] = [];
   const flows: FlowAt[] = [];
@@ -766,7 +782,15 @@ function sitesOf(
     }
     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 as ParameterDeclaration).name,
+        from: outer,
+        member: held,
+      });
+    } else if (held !== undefined) {
       enclosing = held;
       for (const modifier of (node as { readonly modifiers?: readonly Node[] }).modifiers ?? []) {
         if (isDecorator(modifier)) {
@@ -789,6 +813,7 @@ function sitesOf(
     wholes,
     urls,
     decorated,
+    parameterWrites,
     keyed,
   };
 }
@@ -884,15 +909,12 @@ function importedNames(file: SourceFile): ReadonlyMap<string, readonly (string |
   return names;
 }
 
-/**
- * The name node of every import binding one file's top level declares, and whether it
- * binds a whole module.
- */
-function importBindings(file: SourceFile): readonly { node: Node; whole: boolean }[] {
-  const found: { node: Node; whole: boolean }[] = [];
+/** The name node of every import binding one file's top level declares. */
+function importBindings(file: SourceFile): readonly { node: Node }[] {
+  const found: { node: Node }[] = [];
   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;
@@ -900,16 +922,16 @@ function importBindings(file: SourceFile): readonly { node: Node; whole: boolean
       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;
@@ -1286,6 +1308,7 @@ export function references<Brand>(
     wholes,
     urls,
     decorated,
+    parameterWrites,
     keyed,
   } of walked) {
     const test = testFile.get(file) === true;
@@ -1307,6 +1330,18 @@ export function references<Brand>(
       });
     }
 
+    // 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
@@ -1456,15 +1491,14 @@ export function references<Brand>(
           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/src/report.ts

@@ -19,7 +19,7 @@ import type { StaleSuppression } from "./findings/self-check.ts";
 import type { TestFileRule } from "./references.ts";
 
 /** 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: readonly string[] = [SCHEMA_VERSION];

package/src/resolve.ts

@@ -19,6 +19,7 @@ import {
   type Sort,
   type Source,
   type TargetKind,
+  type TargetKindSetting,
   type TemplateDelimiters,
 } from "./config.ts";
 import { CONVENTION_ROWS } from "./convention-rows.ts";
@@ -57,9 +58,9 @@ 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
@@ -85,7 +86,7 @@ const CASCADES: readonly Cascade[] = ["roots", "full"];
  */
 interface Doc {
   readonly contractVersion: string | undefined;
-  readonly targetKind: TargetKind | undefined;
+  readonly targetKind: TargetKindSetting | undefined;
   readonly languages: readonly Language[] | undefined;
   readonly minConfidence: Confidence | undefined;
   readonly generatedFiles: GeneratedFiles | undefined;
@@ -281,6 +282,55 @@ function readStrings<T extends string>(
   return value as readonly T[];
 }
 
+/**
+ * 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: Record<string, unknown> | undefined,
+  label: string,
+): TargetKindSetting | undefined {
+  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 as readonly string[]).includes(value)) {
+      throw malformed(
+        label,
+        "target.kind",
+        `${JSON.stringify(value)} is not one of ${spell(TARGET_KINDS)}, nor ${perLanguage}`,
+      );
+    }
+    return value as TargetKind;
+  }
+  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 as readonly string[]).includes(kind)) {
+      throw malformed(
+        label,
+        `target.kind.${language}`,
+        `${JSON.stringify(kind)} is not one of ${spell(TARGET_KINDS)}`,
+      );
+    }
+  }
+  return { go: value["go"] as TargetKind, ts: value["ts"] as TargetKind };
+}
+
 /** A component file's extension: a full stop followed by letters and digits. */
 const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
 
@@ -355,7 +405,7 @@ function readProject(
       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 };
@@ -795,7 +845,7 @@ function readDoc(value: unknown, label: string): Doc {
 
   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,
@@ -1052,7 +1102,7 @@ function settleAll(inputs: Inputs): { config: Config; provenance: Map<string, Or
 
   const config: Config = {
     contractVersion: at("contract_version", defaults.contractVersion, (doc) => doc.contractVersion),
-    targetKind: at<TargetKind | "">("target.kind", "", (doc) => doc.targetKind),
+    targetKind: at<TargetKindSetting | "">("target.kind", "", (doc) => doc.targetKind),
     analysis: {
       languages: at("analysis.languages", defaults.analysis.languages, (doc) => doc.languages),
       minConfidence: at(

package/src/schema.ts

@@ -1,19 +1,12 @@
 import { ConfigError } from "./config.ts";
 
 /**
- * How one node of the closed key list is written.
- *
- * - `leaf` is a setting: a scalar, or an array of scalars.
- * - `section` is an object whose member names the key list declares and which
- *   holds no value of its own.
- * - `map` is an object whose member names the key list leaves open, its values
- *   scalars: the severity and provenance objects.
- * - `list` is an array whose entries are objects with declared members. Where
- *   the key list admits an entry in more than one shape, the members are every
- *   shape's together, and which of them one entry may hold is the decoder's
- *   refusal, not the walk's.
- * - `object` is one setting written as an object: its member names are declared
- *   and a source supplies the object whole.
+ * How one node of the closed key list is written: `leaf`, a scalar or an array of
+ * scalars; `section`, an object of declared members and no value of its own; `map`, an
+ * object of open member names and scalar values (severity, provenance); `list`, an
+ * array of objects holding every admitted shape's members; `object`, one setting
+ * written as an object of declared members and supplied whole. Which shape an entry or
+ * a value takes, where the key list admits several, is the decoder's refusal.
  */
 type KeyKind = "leaf" | "section" | "map" | "list" | "object";
 
@@ -46,7 +39,10 @@ export const SCHEMA_ROOT: KeyNode = {
   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/src/signatures.ts

@@ -13,6 +13,7 @@ import {
   isPropertyDeclaration,
   isVariableDeclaration,
   type ArrowFunction,
+  type ConstructorDeclaration,
   type FunctionDeclaration,
   type FunctionExpression,
   type MethodDeclaration,
@@ -21,7 +22,11 @@ import {
 
 /** A function-like node that carries a body of its own. */
 export type SignatureNode =
-  FunctionDeclaration | MethodDeclaration | ArrowFunction | FunctionExpression;
+  | FunctionDeclaration
+  | MethodDeclaration
+  | ArrowFunction
+  | FunctionExpression
+  | ConstructorDeclaration;
 
 /** Whether one node is a function value written in place: an arrow or a function expression. */
 function isFunctionValue(node: Node | undefined): node is ArrowFunction | FunctionExpression {

package/src/suppress-file.ts

@@ -303,11 +303,12 @@ interface KeptRow {
 }
 
 /**
- * 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: string): readonly KeptRow[] {
+export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonly KeptRow[] {
   const refuse = (detail: string): never => {
     throw new Error(
       `${BASELINE_FILE} cannot be rewritten keeping the other language's rows: ${detail}`,
@@ -331,7 +332,7 @@ export function otherSchemeRows(text: string): readonly KeptRow[] {
     }
     // readRecord has checked every member is a string and the code and symbol are present.
     const { code, symbol, path, reason } = value as Readonly<Record<string, string>>;
-    if (code === undefined || symbol === undefined || symbol.startsWith(OWN_SCHEME)) {
+    if (code === undefined || symbol === undefined || symbol.startsWith(own)) {
       return [];
     }
     return [
@@ -345,10 +346,37 @@ export function otherSchemeRows(text: string): readonly KeptRow[] {
   });
 }
 
+/** The reference schemes in the order a baseline holds their rows. */
+const SCHEME_ORDER: readonly string[] = ["go://", "ts://"];
+
+function schemeRank(row: { readonly symbol: string }): number {
+  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: string): string {
+  return text.replace(LONE_SURROGATE, "\ufffd");
+}
+
+/**
+ * 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: Iterable<string>): Generator<string, void, undefined> {
+  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, 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
+ * 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.
  */
@@ -371,5 +399,16 @@ export function writeBaseline(
     }
     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: KeptRow): KeptRow => {
+      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/src/suppress-inline.ts

@@ -4,12 +4,18 @@
  * below it, or on its own line where it trails a token there.
  */
 
-import { SyntaxKind, type Node, type SourceFile } from "@typescript/native/ast";
-import { nodeKey, type Inventory } from "./inventory.ts";
+import {
+  isConstructorDeclaration,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf } from "./signatures.ts";
 import {
+  isPartKind,
   SUPPRESSION_WITHOUT_REASON,
   SuppressionError,
   siteText,
@@ -166,35 +172,64 @@ interface Declared {
   readonly position: Position;
 }
 
+/**
+ * What one placement binds: the declaration a record for a code that reports a
+ * declaration binds, and the one a record for a part kind binds, which holds the part.
+ * A parameter property's field is the first and its class the second; a constructor's
+ * plain parameter binds only the second, because a constructor is no declaration.
+ */
+interface Binding {
+  readonly declared: Declared | undefined;
+  readonly part: Declared;
+}
+
+function bindingKey(one: Binding): string {
+  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: SourceFile,
   held: Inventory,
   symbols: ReadonlyMap<string, Declared>,
-): ReadonlyMap<number, readonly Declared[]> {
-  const below = new Map<number, Declared[]>();
-  const add = (offset: number, one: Declared): void => {
+): ReadonlyMap<number, readonly Binding[]> {
+  const below = new Map<number, Binding[]>();
+  const add = (offset: number, one: Binding): void => {
     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: Node): void => {
+  const declaredAt = (node: Node): Declared | undefined => {
     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: Node): void => {
+    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 (
@@ -202,7 +237,7 @@ function declarationLines(
         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);
@@ -225,7 +260,7 @@ export interface InlineDirective {
   readonly site: Position;
   readonly text: string;
   readonly directive: Directive;
-  readonly bound: Declared[];
+  readonly bound: Binding[];
 }
 
 /**
@@ -282,7 +317,7 @@ export function inlineSuppressions(
       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);
       }
     }
@@ -311,8 +346,15 @@ export function inlineSuppressions(
         }
         break;
       case "directive": {
-        const declared = [...bound].sort((a, b) => byPosition(a.position, b.position));
         for (const code of directive.codes) {
+          const targets = new Map<string, Declared>();
+          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/src/suppress.ts

@@ -88,9 +88,10 @@ 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");
 

package/src/type-errors.ts

@@ -151,7 +151,8 @@ function declaringManifest(
         }
       }
     }
-    if (at === targetRoot || relativePath(targetRoot, at) === undefined || dirnamePath(at) === at) {
+    // The target root is not below itself, so the walk stops after reading its manifest.
+    if (relativePath(targetRoot, at) === undefined) {
       return undefined;
     }
   }