@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/src/consumers.ts

@@ -1,16 +1,19 @@
 import type { PartialConfig } from "./config.ts";
+import type { ParseFile } from "./entries/configuration-files.ts";
+import { runDirectories } from "./entries/run-directories.ts";
 import type { Host } from "./host.ts";
 import { inventory } from "./inventory/enumerate.ts";
 import { relativePath } from "./paths.ts";
-import { references, type ConsumerSide, type Reference } from "./references.ts";
+import { references, type ConsumerSide, type References } from "./references.ts";
 import { narrowedTo, type ProjectView } from "./session.ts";
+import { patternTestFile } from "./tests/file-class.ts";
 
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's
  * program holds, against the target root, so each carries the identifier the target's
- * own projects give it. A reference from a consumer's test file is a test reference
- * unless the configuration counts it as a production one.
+ * own projects give it. A reference from a consumer's test file is a test reference;
+ * whether the run counts it as a production one is the sweep's mode.
  */
 export function consumerReferences<Brand>(
   project: ProjectView<Brand>,
@@ -18,18 +21,16 @@ export function consumerReferences<Brand>(
   targetRoot: string,
   consumer: ConsumerSide,
   config: PartialConfig,
-): readonly Reference[] {
+  parse: ParseFile,
+): References {
   const held = inventory(
     narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined),
     host,
     targetRoot,
   );
-  const found = references(project, held, targetRoot, {
-    testFiles: config.ts.test_files,
+  return references(project, held, targetRoot, {
+    testFile: patternTestFile(config.ts.test_files, consumer.root),
     consumer,
-  }).references;
-  if (config.analysis.consumer_tests !== "production") {
-    return found;
-  }
-  return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));
+    directories: runDirectories(host, consumer.root, parse),
+  });
 }

package/src/contextual-uses.ts

@@ -56,16 +56,12 @@ interface ContextualUse {
   readonly ids: readonly string[];
 }
 
-/** What the contextual types of one project's literals and values use, and what asking cost. */
+/** What the contextual types of one project's literals and values use. */
 interface ContextualUses {
   /** Each literal property that writes a member, by the property's node. */
   readonly writes: readonly ContextualUse[];
   /** Each value whose members a position typed by another object type reads. */
   readonly reads: readonly ContextualUse[];
-  /** The batched lookups: contextual types and value types, one per capped run. */
-  readonly batches: number;
-  /** The per-type lookups: each distinct type's constituents, properties and declaring symbol. */
-  readonly lookups: number;
 }
 
 /**
@@ -169,9 +165,6 @@ export function contextualUses<Brand>(
       .filter((symbol) => symbol.visibility === "private-name")
       .map((symbol) => symbol.id),
   );
-  let batches = 0;
-  let lookups = 0;
-  const batchesOf = (count: number): number => Math.ceil(count / cap);
 
   const parts = new Map<number, readonly Type[]>();
   /** The object types one type is: itself, or its constituents at any depth. */
@@ -182,7 +175,6 @@ export function contextualUses<Brand>(
     }
     let found: readonly Type[] = [];
     if (type.isUnionType() || type.isIntersectionType()) {
-      lookups += 1;
       const constituents = queries.constituents(type);
       found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
     } else if (type.isObjectType()) {
@@ -201,7 +193,6 @@ export function contextualUses<Brand>(
     }
     const table = new Map<string, Member>();
     const read = properties.of(type);
-    lookups += read.asked ? 1 : 0;
     for (const property of isAnswered(read.properties) ? read.properties : []) {
       table.set(property.name, {
         ids: chains
@@ -222,7 +213,6 @@ export function contextualUses<Brand>(
   };
 
   const writes: ContextualUse[] = [];
-  batches += batchesOf(literals.length);
   const contexts = queries.contextualTypes(
     literals.map((one) => one.literal),
     cap,
@@ -238,7 +228,6 @@ export function contextualUses<Brand>(
           return name !== undefined && name.text === undefined ? [name.node] : [];
         }),
   );
-  batches += batchesOf(computed.length);
   const keys = new Map<Node, string>();
   (computed.length === 0
     ? []
@@ -272,7 +261,6 @@ export function contextualUses<Brand>(
   });
 
   const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
-  batches += batchesOf(carried.length);
   const types = queries.typesAt(
     carried.map((flow) => flow.value),
     cap,
@@ -327,11 +315,9 @@ export function contextualUses<Brand>(
     if (elements.has(type.id)) {
       return elements.get(type.id);
     }
-    lookups += 1;
     const isArray = queries.isArray(type);
     let element: Type | undefined;
     if (isAnswered(isArray) && isArray) {
-      lookups += 1;
       const held = queries.typeArguments(type);
       element = isAnswered(held) ? held[0] : undefined;
     }
@@ -346,7 +332,6 @@ export function contextualUses<Brand>(
     if (known !== undefined) {
       return known;
     }
-    lookups += type.isTypeReference() ? 1 : 0;
     const held = queries.typeArguments(type);
     const found = isAnswered(held) ? held : [];
     argumentsOf.set(type.id, found);
@@ -363,11 +348,9 @@ export function contextualUses<Brand>(
     if (known !== undefined) {
       return known;
     }
-    lookups += 1;
     let kind = SignatureKind.Call;
     let signatures = queries.signaturesOf(type, kind);
     if (isAnswered(signatures) && signatures.length === 0) {
-      lookups += 1;
       kind = SignatureKind.Construct;
       signatures = queries.signaturesOf(type, kind);
     }
@@ -376,7 +359,6 @@ export function contextualUses<Brand>(
         queries.parameterType(signature, index),
       );
       const result = queries.returnTypeOf(signature);
-      lookups += parameters.length + 1;
       return {
         kind,
         parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
@@ -474,7 +456,6 @@ export function contextualUses<Brand>(
     const type = types[index];
     return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
   });
-  batches += batchesOf(sourced.length);
   const positions = queries.contextualTypes(
     sourced.map((one) => one.flow.value),
     cap,
@@ -556,7 +537,6 @@ export function contextualUses<Brand>(
       isSpreadAssignment(property) ? [{ value: property.expression, from }] : [],
     ),
   );
-  batches += batchesOf(spreads.length);
   const spreadTypes = queries.typesAt(
     spreads.map((one) => one.value),
     cap,
@@ -583,5 +563,5 @@ export function contextualUses<Brand>(
       reads.push({ at: value, from, ids });
     }
   });
-  return { writes, reads, batches, lookups };
+  return { writes, reads };
 }

package/src/contract/config.generated.ts

@@ -291,7 +291,7 @@ export const SETTINGS: readonly SettingRow[] = [
     role: "setting",
     read: true,
     default: [
-      "**/*.test.{ts,tsx,mts,cts}",
+      "**/*.test.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
       "**/*.test-d.{ts,tsx,mts,cts}",
       "**/*.spec-d.{ts,tsx,mts,cts}",
       "**/*.spec.*",
@@ -501,7 +501,10 @@ export const SETTINGS: readonly SettingRow[] = [
     key: "provenance",
     role: "ignored",
     read: true,
-    value: { type: "string", pattern: "^(default|(repository|central|flag): [^\\r\\n]+)$" },
+    value: {
+      type: "string",
+      pattern: "^(default|(repository|central|flag): ([^\\r\\n]|[\\r\\n])+)$",
+    },
     keyPattern: "^[a-z][a-z_]*(\\.[A-Za-z0-9_]+)*$",
   },
 ];

package/src/contract/contract.generated.ts

@@ -3,6 +3,7 @@
 export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"] as const;
 export const SCHEMA_VERSION = "9.0.0";
+export const FACTS_VERSION = "1.0.0";
 export const CORPUS_VERSION = "6.0.0";
 export const CODE_PREFIX = "DS";
 export const FAMILY_KEY_LENGTH = 4;
@@ -34,16 +35,19 @@ export const LANGUAGE_ROWS = {
     analyzer: "deadset-go",
     markers: ["go.mod"],
     skippedDirectories: ["node_modules", "testdata", "vendor", ".*", "_*"],
+    skippedFiles: ["_*", ".*"],
   },
   ts: {
     analyzer: "deadset-ts",
     markers: ["tsconfig*.json", "jsconfig*.json"],
     skippedDirectories: ["node_modules", ".git"],
+    skippedFiles: ["*.min.js", "*.min.cjs", "*.min.mjs"],
   },
   proto: {
     analyzer: "deadset-proto",
     markers: ["buf.yaml", "buf.work.yaml"],
     skippedDirectories: ["node_modules", "vendor", ".*"],
+    skippedFiles: [],
   },
 } as const satisfies Readonly<
   Partial<
@@ -53,6 +57,7 @@ export const LANGUAGE_ROWS = {
         readonly analyzer: string;
         readonly markers: readonly string[];
         readonly skippedDirectories: readonly string[];
+        readonly skippedFiles: readonly string[];
       }
     >
   >
@@ -494,9 +499,9 @@ export const KIND_ROWS = [
     languages: ["go", "ts"],
     subject: "dependency",
     holdsLive: false,
-    rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency. On the TypeScript side, a needed dependency whose every use is written inside declarations that are members of the run's dead components, or at the top level of a file reported under DS1602, that no command runs and that no needed dependency used otherwise names as a peer, is reported as well, dead only through that code: at the reachability class possible where one of those declarations belongs to a library's published API, and found under reachability alone where one of those declarations or files is, so at probable unless ts.roots_complete is true. A use the configuration makes, a use an unanswered specifier may make and an import none of whose bindings is used are uses by live code.",
+    rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency. On the TypeScript side, a needed dependency whose every use is written inside declarations that are members of the run's dead components, or at the top level of a file reported under DS1602, that no command runs and that no needed dependency used otherwise names as a peer, is reported as well, dead only through that code: at the reachability class possible where one of those declarations belongs to a library's published API, and found under reachability alone where one of those declarations or files is, so at probable unless ts.roots_complete is true. A use the configuration makes, a use an unanswered specifier or callee may make and an import none of whose bindings is used are uses by live code.",
     precondition:
-      "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. A `@types/<name>` package in a type root of a compiler configuration that lists no `types`, a `node_modules/@types` directory at or above the configuration's directory or a `typeRoots` entry naming one, is needed by a use, in a file of that configuration, of a global name or an ambient module that one of the package's declaration files declares, which resolves to no declaration of the program: a compiler before version 6 includes every package of the type roots where `types` is not listed, and version 6 and later include none, so the program the analysis builds holds none of those declarations. A package's declaration files are the file its `types` or `typings` names, else its `index.d.ts`, and each file a `/// <reference path>` of one of them reaches inside the package. A global is a top-level declaration of such a file that is no module, or a declaration of a `declare global` block of one that is, and an ambient module is a `declare module` with a string name of a file that is no module. A name that names a member, a property or a label is no use of a global. Four more dependencies are needed: one whose command a script entry, a workflow step or a git hook runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis/conventions.md states, and one that a needed dependency names as a peer, as stated below. A command no script entry, workflow step or git hook runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis/program.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it where no manifest between them declares a dependency of the same name, so a use below a nested manifest that declares the same dependency needs that nested manifest's declaration only, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
+      "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a `require()` call as `roots.23` reads one, or a call of `import.meta.resolve`, of `require.resolve`, whatever `require` names, or of `resolve` on another name that is such a `require`, in them, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. A `@types/<name>` package in a type root of a compiler configuration that lists no `types`, a `node_modules/@types` directory at or above the configuration's directory or a `typeRoots` entry naming one, is needed by a use, in a file of that configuration, of a global name or an ambient module that one of the package's declaration files declares, which resolves to no declaration of the program: a compiler before version 6 includes every package of the type roots where `types` is not listed, and version 6 and later include none, so the program the analysis builds holds none of those declarations. A package's declaration files are the file its `types` or `typings` names, else its `index.d.ts`, and each file a `/// <reference path>` of one of them reaches inside the package. A global is a top-level declaration of such a file that is no module, or a declaration of a `declare global` block of one that is, and an ambient module is a `declare module` with a string name of a file that is no module. A name that names a member, a property or a label is no use of a global. Four more dependencies are needed: one whose command a script entry, a workflow step or a git hook runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis/conventions.md states, and one that a needed dependency names as a peer, as stated below. A command no script entry, workflow step or git hook runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis/program.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it where no manifest between them declares a dependency of the same name, so a use below a nested manifest that declares the same dependency needs that nested manifest's declaration only, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
     details: { dependency_class: "required" },
     defaultEnabled: true,
     defaultSeverity: "deny",
@@ -769,6 +774,49 @@ export const SYMBOL_SUBJECTS = {
   edge: "record",
 } as const satisfies Readonly<Record<string, Subject>>;
 
+export const REMEDIES = {
+  declaration: {
+    names: "a declaration",
+    suppressions: ["inline", "ignore", "baseline"],
+    remedy: "delete the symbol, or wire it up so the program uses it",
+  },
+  binding: {
+    names: "an import binding",
+    suppressions: ["inline", "ignore", "baseline"],
+    remedy: "delete the import, or use what it binds",
+  },
+  part: {
+    names: "a part of a declaration",
+    suppressions: ["inline", "ignore", "baseline"],
+    remedy: "remove the part, or use it",
+  },
+  file: {
+    names: "a file",
+    suppressions: [],
+    remedy:
+      "delete the file, name it as a root, or build it in a configuration of the build matrix",
+  },
+  dependency: {
+    names: "a dependency row",
+    suppressions: ["ignore", "baseline"],
+    remedy: "remove the dependency",
+  },
+  record: {
+    names: "a record of deadset's own configuration",
+    suppressions: [],
+    remedy: "correct or remove the record the finding names",
+  },
+} as const satisfies Readonly<
+  Record<
+    Subject,
+    {
+      readonly names: string;
+      readonly suppressions: readonly ("inline" | "ignore" | "baseline")[];
+      readonly remedy: string;
+    }
+  >
+>;
+
 export const EXEMPTION_CLASSES = [
   {
     class: "interface-satisfaction",
@@ -1283,6 +1331,93 @@ export const EVIDENCE = [
   },
 ] as const;
 
+/** The generators whose TypeScript output a generated file is matched against, in the document's order. */
+export const GENERATORS = [
+  {
+    id: "protoc-gen-es-2",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v2\\.",
+    versions: { min: "v2.10.0", max: "v2.16.0" },
+    cell: "exact",
+  },
+  {
+    id: "protoc-gen-es-2-fallback",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v2\\.",
+    cell: "fallback",
+  },
+  {
+    id: "protoc-gen-es-1",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v1\\.",
+    cell: "exact",
+  },
+  {
+    id: "protoc-gen-connect-es-1",
+    plugin: "protoc-gen-connect-es",
+    header: "^// @generated by protoc-gen-connect-es v1\\.",
+    cell: "exact",
+  },
+  {
+    id: "ts-proto-2-output-schema",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    versions: { min: "v2.11.4", max: "v2.15.0" },
+    cell: "exact",
+  },
+  {
+    id: "ts-proto-2",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    versions: { min: "v2.11.4", max: "v2.15.0" },
+    cell: "rpc-types-fallback",
+  },
+  {
+    id: "ts-proto-2-types",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    versions: { min: "v2.11.4", max: "v2.15.0" },
+    cell: "fallback",
+  },
+  {
+    id: "ts-proto-2-fallback",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    cell: "fallback",
+  },
+  {
+    id: "protoc-gen-js",
+    plugin: "protoc-gen-js",
+    header: "^// GENERATED CODE -- DO NOT EDIT!$",
+    cell: "fallback",
+  },
+  {
+    id: "protoc-gen-grpc-web",
+    plugin: "protoc-gen-grpc-web",
+    header: "^// Code generated by protoc-gen-grpc-web\\. DO NOT EDIT\\.$",
+    cell: "fallback",
+  },
+  {
+    id: "protobuf-ts",
+    plugin: "protobuf-ts",
+    header: "^// @generated by protobuf-ts ",
+    cell: "fallback",
+  },
+  { id: "ts-protoc-gen", plugin: "ts-protoc-gen", header: "^// package: ", cell: "fallback" },
+  {
+    id: "protoc-gen-es-unsupported",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v(?:0|[3-9]|[1-9][0-9]+)\\.",
+    cell: "unsupported",
+  },
+] as const satisfies readonly {
+  readonly id: string;
+  readonly plugin: string;
+  readonly header: string;
+  readonly versions?: { readonly min: string; readonly max: string };
+  readonly cell: string;
+}[];
+
 /** Each group of failure classes, and the text opening the line that names one of its failures. */
 export const FAILURE_PREFIXES = { setup: "setup failure: ", run: "run failure: " } as const;
 
@@ -1294,6 +1429,7 @@ export const FAILURE_CLASSES = {
   "workspace-member-without-source": "setup",
   "convention-not-literal": "setup",
   "no-program": "setup",
+  "unreadable-configuration": "setup",
   "unreadable-document": "setup",
   "missing-import-path": "setup",
   "binding-undecodable": "setup",

package/src/contract/report.generated.ts

@@ -408,6 +408,11 @@ export const REPORT_SCHEMAS = {
         },
         else: { properties: { configurations: { minItems: 1 }, target: { required: ["kind"] } } },
       },
+      {
+        if: { required: ["merged_from"], properties: { merged_from: { maxItems: 0 } } },
+        then: { properties: { analyzer: { properties: { languages: { maxItems: 0 } } } } },
+        else: { properties: { analyzer: { properties: { languages: { minItems: 1 } } } } },
+      },
     ],
     properties: {
       schema_version: { type: "string", pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
@@ -424,7 +429,6 @@ export const REPORT_SCHEMAS = {
           },
           languages: {
             type: "array",
-            minItems: 1,
             uniqueItems: true,
             items: { type: "string", enum: ["go", "ts", "proto"] },
           },
@@ -460,7 +464,7 @@ export const REPORT_SCHEMAS = {
               pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",
             },
             digest: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
-            languages: { $ref: "#/properties/analyzer/properties/languages" },
+            languages: { $ref: "#/properties/analyzer/properties/languages", minItems: 1 },
             totals: { $ref: "#/properties/totals" },
           },
         },