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

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/verbs/analyze.ts

@@ -6,7 +6,7 @@ import {
   type RunAnalysis,
   type RunProject,
 } from "../analysis.ts";
-import { ConfigError, type Format } from "../config.ts";
+import { ConfigError, kindOf, type Format } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
@@ -16,6 +16,7 @@ import type { NotBuilt } from "../discover.ts";
 import { partialNotes } from "../partial.ts";
 import {
   buildReport,
+  LANGUAGE,
   capFindings,
   sortFindings,
   type Report,
@@ -265,7 +266,11 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       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/src/version.ts

@@ -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";