@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.4

package/src/manifest.ts

@@ -35,8 +35,8 @@ export interface ManifestEntry {
   readonly path: string;
   readonly role: EntryRole;
   /**
-   * Whether the member declares what a consumer may import, which is `exports` and
-   * the three members that preceded it. A command is published too, and is not this:
+   * Whether the member declares what a consumer may import, which is `exports`, `browser`
+   * and the three members that preceded `exports`. A command is published too, and is not this:
    * `exports` is the surface a library's published API is read from.
    */
   readonly published: boolean;
@@ -136,7 +136,7 @@ function manifestOf(host: Host, targetRoot: string): Record<string, unknown> | u
 export interface Manifest {
   /**
    * Every entry point the manifest names, in the order the members are read: `main`,
-   * `module`, `types`, then each `bin` command, then every target of `exports`, then
+   * `module`, `types`, then `browser` and each file it maps a module to, then each `bin` command, then every target of `exports`, then
    * every token of each script, which names a file only where one is at its path. Each
    * path is absolute.
    */
@@ -171,6 +171,24 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
     }
   }
 
+  // A `browser` string replaces `main` in a browser bundle, and an object replaces each
+  // module it maps with the file it names: https://github.com/defunctzombie/package-browser-field-spec
+  const browser = manifest["browser"];
+  if (typeof browser === "string" && isTarget(browser, false)) {
+    found.push({ member: "browser", path: browser, role: "import", published: true });
+  } else if (isRecord(browser)) {
+    for (const [replaced, value] of Object.entries(browser)) {
+      if (typeof value === "string" && isTarget(value, true)) {
+        found.push({
+          member: below("browser", replaced),
+          path: value,
+          role: "import",
+          published: true,
+        });
+      }
+    }
+  }
+
   const bin = manifest["bin"];
   if (typeof bin === "string" && isTarget(bin, false)) {
     found.push({ member: "bin", path: bin, role: "run", published: false });

package/src/matrix.ts

@@ -223,18 +223,32 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
 
   const union = matrix.union;
   const heldBy: (string | undefined)[] = union.symbols.map(() => undefined);
-  const testReached = reachedWithTheTests(union, [
+  const held = [
     ...input.marked,
     ...(input.exempt ?? []).map((record) => record.id),
     ...(input.unanswered ?? []),
-  ]);
-  const judged = union.symbols.map((symbol, at): readonly Candidate[] | undefined => {
+  ];
+  const testReached = reachedWithTheTests(union, held);
+  // A test uses what it names: a file a test reads through a star re-export or a
+  // namespace keeps the exports nothing names at their own class.
+  const testNamed = reachedWithTheTests(union, held, false);
+  const everywhere = union.symbols.map((symbol, at): readonly Candidate[] | undefined => {
     const held = matrix.heldIn[at] ?? [];
     const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
     return held.length === 0 || found.some((candidate) => candidate === undefined)
       ? undefined
       : found.filter((candidate): candidate is Candidate => candidate !== undefined);
   });
+  const compiled = compiledReferences(
+    matrix,
+    new Set(
+      union.symbols.flatMap((symbol, at) => (everywhere[at] === undefined ? [] : [symbol.id])),
+    ),
+    input.mode,
+  );
+  const judged = everywhere.map((found, at) =>
+    compiled.has(union.symbols[at]?.id ?? "") ? undefined : found,
+  );
   // A configuration that does not hold a test's subject's caller finds the subject dead,
   // so a test is of dead code only where every production subject it names is dead in
   // every configuration that holds it.
@@ -252,7 +266,7 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   const kept = keptByTests(union, testReached, admittedAt);
   const testUsed = testUsedReach(
     union,
-    union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testReached[at] === true),
+    union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testNamed[at] === true),
     judged.map((one) => one !== undefined),
   );
   const candidates: MatrixCandidate[] = [];
@@ -296,6 +310,39 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   };
 }
 
+/**
+ * Every declaration of `dead`, those dead in every configuration that holds them, that a
+ * configuration's graph references from a judged declaration outside `dead` or already
+ * kept, until none joins: deleting one would break that configuration's compile. A
+ * production run counts no reference a test file made.
+ */
+function compiledReferences(
+  matrix: Matrix,
+  dead: ReadonlySet<string>,
+  mode: SweepInput["mode"],
+): ReadonlySet<string> {
+  const kept = new Set<string>();
+  for (let changed = true; changed;) {
+    changed = false;
+    for (const graph of matrix.graphs) {
+      graph.out.forEach((edges, from) => {
+        const id = graph.symbols[from]?.id ?? "";
+        if (graph.subject[from] !== true || (dead.has(id) && !kept.has(id))) {
+          return;
+        }
+        for (const edge of edges) {
+          const to = graph.symbols[edge.to]?.id ?? "";
+          if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+            kept.add(to);
+            changed = true;
+          }
+        }
+      });
+    }
+  }
+  return kept;
+}
+
 /** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
 function testUsedReach(
   union: Graph,

package/src/query.ts

@@ -211,6 +211,8 @@ export interface Queries {
   symbolOfType(type: Type): Answer<TSSymbol | undefined>;
   signaturesOf(type: Type, kind: SignatureKind): Answer<readonly Signature[]>;
   resolvedSignature(node: Node): Answer<Signature | undefined>;
+  /** The signature each call-like node resolves to. */
+  resolvedSignatures(nodes: readonly Node[], cap?: number): Answer<Signature | undefined>[];
   parameterType(signature: Signature, index: number): Answer<Type | undefined>;
   /** The generic signature an instantiated one instantiates; none for another signature. */
   genericOf(signature: Signature): Answer<Signature | undefined>;
@@ -544,6 +546,15 @@ export function queriesOf(
         () => nodeLocation(node),
         () => checker.getResolvedSignature(node),
       ),
+    resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) =>
+      each(
+        "getResolvedSignature",
+        nodes,
+        cap,
+        nodeLocation,
+        (node) => checker.getResolvedSignature.gen(node),
+        (node) => checker.getResolvedSignature(node),
+      ),
     parameterType: (signature, index) =>
       one(
         "getParameterType",

package/src/report.ts

@@ -81,11 +81,6 @@ export interface WireFinding {
     readonly root: boolean;
     readonly symbol_count: number;
     readonly deletable_lines: number;
-    readonly members?: readonly {
-      readonly ref: string;
-      readonly name: string;
-      readonly position: WirePosition;
-    }[];
   };
   readonly retained_by: readonly string[];
   readonly configurations: readonly string[];
@@ -96,6 +91,16 @@ export interface WireFinding {
   readonly details: WireDetails;
 }
 
+/** One dead component a finding names, with its members, as the report lists it once. */
+export interface WireComponent {
+  readonly id: string;
+  readonly members: readonly {
+    readonly ref: string;
+    readonly name: string;
+    readonly position: WirePosition;
+  }[];
+}
+
 interface WireEdgeEvaluation {
   readonly edge: string;
   readonly side: string;
@@ -218,6 +223,8 @@ export interface Report {
     }[];
   };
   readonly findings: readonly WireFinding[];
+  /** Present where the run lists each component in full. */
+  readonly components?: readonly WireComponent[];
   readonly edge_evaluations: readonly WireEdgeEvaluation[];
   readonly stale_suppressions: readonly WireStaleSuppression[];
   readonly declared_gaps: readonly WireDeclaredGap[];
@@ -231,13 +238,20 @@ export interface Report {
 }
 
 /** One hint about the run's setup, as the report schema's `notes` spells it. */
-export interface ReportNote {
-  readonly kind: "unmapped-entry";
-  /** The directory of the manifest the note is about, below the target root. */
-  readonly path: string;
-  readonly key: "ts.entry_files";
-  readonly message: string;
-}
+export type ReportNote =
+  | {
+      readonly kind: "unmapped-entry";
+      /** The directory of the manifest the note is about, below the target root. */
+      readonly path: string;
+      readonly key: "ts.entry_files";
+      readonly message: string;
+    }
+  | {
+      readonly kind: "computed-load";
+      /** The directory of the file that writes the load, below the target root. */
+      readonly path: string;
+      readonly message: string;
+    };
 
 /** What one run answered, from which its report is built. */
 export interface ReportInput {
@@ -258,6 +272,26 @@ export interface ReportInput {
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The notes the run states, in any order. */
   readonly notes?: readonly ReportNote[];
+  /** Whether the run lists each component in full, which `reporters.cascade: full` asks for. */
+  readonly listsComponents?: boolean;
+}
+
+/**
+ * Each component the findings name, once, with the members the first finding naming it
+ * carries, in the order the findings are: `findings` paired with their wire forms and
+ * sorted, then the edge evaluations' findings.
+ */
+function componentsOf(
+  findings: readonly (readonly [WireFinding, CompletedFinding])[],
+): readonly WireComponent[] {
+  const listed = new Map<string, WireComponent>();
+  for (const [wire, finding] of findings) {
+    const { members } = finding.component;
+    if (members !== undefined && !listed.has(wire.component.id)) {
+      listed.set(wire.component.id, { id: wire.component.id, members: members.map(wireSymbol) });
+    }
+  }
+  return [...listed.values()];
 }
 
 /** Two strings ordered bytewise. */
@@ -342,9 +376,6 @@ export function wireFinding(finding: CompletedFinding): WireFinding {
       root: finding.component.root,
       symbol_count: finding.component.symbolCount,
       deletable_lines: finding.component.deletableLines,
-      ...(finding.component.members === undefined
-        ? {}
-        : { members: finding.component.members.map(wireSymbol) }),
     },
     retained_by: finding.retainedBy,
     configurations: finding.configurations,
@@ -470,7 +501,13 @@ function totalsOf(findings: readonly WireFinding[], result: PassResult): WireTot
 
 /** Builds the report of one run, every array in the order the Contract fixes for it. */
 export function buildReport(input: ReportInput): Report {
-  const findings = input.result.findings.map(wireFinding).sort(canonical);
+  const paired = input.result.findings
+    .map((finding) => [wireFinding(finding), finding] as const)
+    .sort(([a], [b]) => canonical(a, b));
+  const findings = paired.map(([wire]) => wire);
+  const evaluated = input.result.edgeEvaluations.flatMap((one) =>
+    one.finding === undefined ? [] : [[wireFinding(one.finding), one.finding] as const],
+  );
   const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
     .sort((a, b) => compare(a.id, b.id))
     .map((one) => ({ id: one.id, role: "consumer" as const, reason: one.reason }));
@@ -500,6 +537,9 @@ export function buildReport(input: ReportInput): Report {
       .map((one) => ({ id: one.id, project: one.project, error: one.error })),
     consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
     findings,
+    ...(input.listsComponents === true
+      ? { components: componentsOf([...paired, ...evaluated]) }
+      : {}),
     edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),
     stale_suppressions: input.result.staleSuppressions.map(wireStale).sort(canonicalStale),
     // Every gap shares the one component of the canonical key a gap supplies, the analyzer's

package/src/reporters/annotations.ts

@@ -1,8 +1,7 @@
-import { fails } from "../config.ts";
+import type { Severity } from "../config.ts";
 import { coalesced } from "../json-chunks.ts";
 import { KINDS } from "../kinds.ts";
 import type { Report } from "../report.ts";
-import type { RenderOptions } from "./reporter.ts";
 
 /** The escapes a workflow command's message needs, so a line break does not end the command. */
 const DATA_ESCAPES: Readonly<Record<string, string>> = { "%": "%25", "\r": "%0D", "\n": "%0A" };
@@ -27,8 +26,18 @@ function kindName(code: string): string {
   return KINDS.get(code)?.name ?? code;
 }
 
+/** The workflow command a record is written as. */
+type Level = "error" | "warning" | "notice";
+
+/** The command each finding severity is annotated with, whatever the failing severity. */
+const LEVELS: Readonly<Record<Severity, Level>> = {
+  deny: "error",
+  warn: "warning",
+  allow: "notice",
+};
+
 function command(
-  level: "error" | "warning",
+  level: Level,
   at: { readonly path: string; readonly line: number; readonly column: number },
   endLine: number,
   title: string,
@@ -43,18 +52,17 @@ const SKIP_MESSAGE =
   "the analysis did not evaluate the function or statement holding this type error: ";
 
 /**
- * One workflow annotation per finding, then one per stale suppression, each naming its
- * file, line, column and last line, titled by its code and kind, then one warning per
- * type-error skip naming its file and line. A finding at or above the failing severity is
- * an error and one below it a warning; a stale suppression is an error, because its kind
- * is fixed on at the failing severity.
+ * The annotations `contract/grammar/annotations.md` states: one per finding, at the
+ * command its severity names, and one error per stale suppression, each naming its file,
+ * line, column and last line and titled by its code and kind; then one warning per
+ * type-error skip naming its file and line, and one per note naming its directory.
  */
-export function annotations(report: Report, options: RenderOptions): Iterable<string> {
+export function annotations(report: Report): Iterable<string> {
   return coalesced(
     (function* lines(): Generator<string, void, undefined> {
       for (const found of report.findings) {
         yield `${command(
-          fails(found.severity, options.failOn) ? "error" : "warning",
+          LEVELS[found.severity],
           found.position,
           found.position.end_line,
           `${found.code} ${found.kind}`,
@@ -73,6 +81,9 @@ export function annotations(report: Report, options: RenderOptions): Iterable<st
       for (const skip of report.type_error_skips) {
         yield `::warning file=${escapeProperty(skip.path)},line=${String(skip.line)},title=${escapeProperty(SKIP_TITLE)}::${escapeData(SKIP_MESSAGE + skip.message)}\n`;
       }
+      for (const note of report.notes) {
+        yield `::warning file=${escapeProperty(note.path)},title=${escapeProperty(note.kind)}::${escapeData(note.message)}\n`;
+      }
     })(),
   );
 }

package/src/reporters/reporter.ts

@@ -1,11 +1,9 @@
-import type { Format, Severity } from "../config.ts";
+import type { Format } from "../config.ts";
 import type { Report } from "../report.ts";
 import type { Template } from "./template.ts";
 
 /** What a rendering reads beside the report. */
 export interface RenderOptions {
-  /** The lowest severity at which a finding fails the run. */
-  readonly failOn: Severity;
   /** The text of the file at one path below the target root, or a throw naming why not. */
   readonly readSource: (path: string) => string;
   /** The template the template rendering renders, where one was named. */

package/src/reporters/sarif.ts

@@ -2,7 +2,7 @@ import type { Confidence, Severity } from "../config.ts";
 import { jsonChunks } from "../json-chunks.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
 import { declarationKey } from "../ref.ts";
-import type { Report, WireFinding, WireStaleSuppression } from "../report.ts";
+import type { Report, WireComponent, WireFinding, WireStaleSuppression } from "../report.ts";
 import { lineHashes, symbolFingerprint } from "./fingerprint.ts";
 import { RenderError, type RenderOptions } from "./reporter.ts";
 import { utf8Bytes } from "./sha256.ts";
@@ -151,8 +151,11 @@ interface Related {
   readonly endLine: number;
 }
 
+/** The members the report lists for one component, none where it lists none. */
+type MembersOf = (id: string) => WireComponent["members"];
+
 /** Every position a finding names beyond its own, in the mapping's order, the first hundred. */
-function relatedOf(found: WireFinding): readonly Related[] {
+function relatedOf(found: WireFinding, members: MembersOf): readonly Related[] {
   const related: Related[] = [];
   for (const one of found.details.implementations ?? []) {
     related.push({ label: "implementation", at: one.position, endLine: one.position.end_line });
@@ -164,7 +167,7 @@ function relatedOf(found: WireFinding): readonly Related[] {
     const at = found.details.name_literal;
     related.push({ label: "name", at, endLine: at.end_line });
   }
-  for (const one of found.component.members ?? []) {
+  for (const one of members(found.component.id)) {
     if (
       declarationKey(one.ref, one.position.path) !==
       declarationKey(found.symbol.ref, found.position.path)
@@ -188,7 +191,9 @@ function messageWithLinks(message: string, related: readonly Related[]): string
 }
 
 /** Every member of the finding the mapping places nowhere else, under its schema name. */
-function propertiesOf(found: WireFinding): Record<string, unknown> {
+/** A result's member bag, its component holding the members the report lists for it once. */
+function propertiesOf(found: WireFinding, members: MembersOf): Record<string, unknown> {
+  const listed = members(found.component.id);
   return {
     language: found.language,
     symbol: found.symbol,
@@ -199,7 +204,7 @@ function propertiesOf(found: WireFinding): Record<string, unknown> {
       : { liveness_relation: found.liveness_relation }),
     test_only: found.test_only,
     generated: found.generated,
-    component: found.component,
+    component: listed.length === 0 ? found.component : { ...found.component, members: listed },
     retained_by: found.retained_by,
     configurations: found.configurations,
     consumers_loaded: found.consumers_loaded,
@@ -220,8 +225,9 @@ function findingResult(
   found: WireFinding,
   index: ReadonlyMap<string, number>,
   hashOf: (at: Located) => string,
+  members: MembersOf,
 ): Record<string, unknown> {
-  const related = relatedOf(found);
+  const related = relatedOf(found, members);
   return {
     ruleId: found.code,
     ruleIndex: ruleIndex(index, found.code),
@@ -241,7 +247,7 @@ function findingResult(
       primaryLocationLineHash: hashOf(found.position),
       "deadsetSymbolRef/v1": symbolFingerprint(found.code, found.symbol.ref),
     },
-    properties: propertiesOf(found),
+    properties: propertiesOf(found, members),
   };
 }
 
@@ -275,8 +281,10 @@ export function sarif(report: Report, options: RenderOptions): Iterable<string>
   const ruleList = rules(kinds);
   const index = new Map(kinds.map((kind, at) => [kind.code, at]));
   const hashOf = lineHashCache(options.readSource);
+  const listed = new Map((report.components ?? []).map((one) => [one.id, one.members]));
+  const members: MembersOf = (id) => listed.get(id) ?? [];
   const results = [
-    ...report.findings.map((found) => findingResult(found, index, hashOf)),
+    ...report.findings.map((found) => findingResult(found, index, hashOf, members)),
     ...report.stale_suppressions.map((stale) => staleResult(stale, index, hashOf)),
   ];
   const languages = [...report.analyzer.languages].sort().join("+");