@cplieger/deadset-ts 8.0.0-dev.8 → 8.0.0-dev.9

package/src/configuration-files.ts

@@ -24,7 +24,13 @@ import type { SourceFiles } from "./source-files.ts";
 import { bytewise } from "./text/compare.ts";
 import { isRecord } from "./json-document.ts";
 import { filesIn } from "./fs/tree.ts";
-import { holdsManifest, inInstalledPackages, manifestAt, readJSON } from "./fs/manifest.ts";
+import {
+  DEPENDENCY_SECTIONS,
+  holdsManifest,
+  inInstalledPackages,
+  manifestAt,
+  readJSON,
+} from "./fs/manifest.ts";
 import { shellWords } from "./text/shell.ts";
 
 /** A configuration module's name, each form with the spelling a root reports it by. */
@@ -40,14 +46,6 @@ const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[]
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
 
-/** The manifest members a dependency is declared in. */
-const DEPENDENCY_MEMBERS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 /** The prefixes a string names a file with, relative to the file that writes it. */
 const RELATIVE_PREFIXES = ["./", "../"] as const;
 
@@ -474,7 +472,7 @@ export function declaredIn(host: Host, dir: string): readonly string[] {
     return [];
   }
   const names = new Set<string>();
-  for (const member of DEPENDENCY_MEMBERS) {
+  for (const member of DEPENDENCY_SECTIONS) {
     const section = value[member];
     if (isRecord(section)) {
       Object.keys(section).forEach((name) => names.add(name));

package/src/consumers.ts

@@ -1,60 +1,9 @@
-/**
- * The consumers a scope declares, loaded beside the target: each a directory on the
- * local filesystem whose compiler configurations open as projects of the run's one
- * snapshot, and whose references to the target's declarations count against them.
- */
-
 import type { PartialConfig } from "./config.ts";
-import { consumerProjects } from "./discover.ts";
 import type { Host } from "./host.ts";
-import { inventory, packageScope } from "./inventory.ts";
+import { inventory } from "./inventory.ts";
 import { relativePath } from "./paths.ts";
 import { references, type ConsumerSide, type Reference } from "./references.ts";
-import type { Module, Scope } from "./scope.ts";
-import { narrowedTo, type Engine, type ProjectView } from "./session.ts";
-
-/** One consumer the run loaded. */
-export interface LoadedConsumer {
-  /** The name the consumer publishes itself under, which every finding names it by. */
-  readonly id: string;
-  /** The consumer's directory, absolute. */
-  readonly path: string;
-}
-
-/** One declared consumer and the compiler configurations it opens as. */
-interface ConsumerLoad {
-  readonly consumer: LoadedConsumer;
-  /** The configuration files, absolute, in discovery order, none a target project's. */
-  readonly configFiles: readonly string[];
-}
-
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host: Host, module: Module): string {
-  return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
-
-/**
- * Every consumer the scope declares, in its order, with the projects it opens as. A
- * configuration that is also one of the target's projects, or an earlier consumer's, is
- * that project's alone. A consumer whose directory is absent, is no directory or holds
- * no configuration ends the run naming it, before any project opens.
- */
-export function consumerLoads(
-  engine: Engine,
-  host: Host,
-  scope: Scope,
-  targetConfigFiles: readonly string[],
-): readonly ConsumerLoad[] {
-  const opened = new Set(targetConfigFiles);
-  return scope.consumers.map((module) => {
-    const configFiles = consumerProjects(engine, host, module.path).filter((configFile) => {
-      const fresh = !opened.has(configFile);
-      opened.add(configFile);
-      return fresh;
-    });
-    return { consumer: { id: moduleIdentity(host, module), path: module.path }, configFiles };
-  });
-}
+import { narrowedTo, type ProjectView } from "./session.ts";
 
 /**
  * Every reference one consumer project's own files make to a declaration of the target.

package/src/contract/contract.generated.ts

@@ -1135,14 +1135,24 @@ export const EVIDENCE = [
   },
 ] as const;
 
-export const SETUP_CLASSES = [
-  { class: "missing-module", languages: ["go", "ts"] },
-  { class: "incomplete-module-sum", languages: ["go"] },
-  { class: "missing-consumer", languages: ["go", "ts"] },
-  { class: "workspace-member-without-source", languages: ["ts"] },
-  { class: "convention-not-literal", languages: ["ts"] },
-  { class: "no-program", languages: ["go", "ts"] },
-] as const;
+/** 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;
 
-/** The text opening the line of the error stream that names one setup failure. */
-export const SETUP_FAILURE_PREFIX = "setup failure: ";
+/** Each failure class the Contract names, and its group. */
+export const FAILURE_CLASSES = {
+  "missing-module": "setup",
+  "incomplete-module-sum": "setup",
+  "missing-consumer": "setup",
+  "workspace-member-without-source": "setup",
+  "convention-not-literal": "setup",
+  "no-program": "setup",
+  "unreadable-document": "setup",
+  "unwritten-output": "run",
+  "unreportable-path": "run",
+  "memory-exhausted": "run",
+  "missing-analyzer": "run",
+  "unadmitted-analyzer": "run",
+  "unresolved-edge": "run",
+  "interrupted-run": "run",
+  "product-fault": "run",
+} as const;

package/src/conventions.ts

@@ -61,14 +61,14 @@ import {
   relativePath,
   resolvePath,
 } from "./paths.ts";
-import type { SetupFailure } from "./setup-failure.ts";
+import type { Failure } from "./failure.ts";
 import type { SourceFiles } from "./source-files.ts";
 import { satisfies } from "./version-range.ts";
 import { bytewise } from "./text/compare.ts";
 import { isRecord } from "./json-document.ts";
 import { unwrapped } from "./unwrap.ts";
 import { filesIn } from "./fs/tree.ts";
-import { INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.ts";
+import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.ts";
 import { globExpression } from "./text/glob.ts";
 import { yamlDocument } from "./text/yaml.ts";
 
@@ -115,7 +115,7 @@ interface GeneratedDirectory {
 /** A setup failure a row met, at the directory of the manifest that declared it. */
 interface ConventionFailure {
   readonly dir: string;
-  readonly failure: SetupFailure;
+  readonly failure: Failure;
 }
 
 /** What the rows decided for one run. */
@@ -169,12 +169,6 @@ const JSON_RC = /^\.[\w-]+rc$/u;
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"] as const;
 
-const DEPENDENCY_SECTIONS = [
-  ...REQUIRED_SECTIONS,
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 function declares(
   manifest: unknown,
   name: string,
@@ -1094,7 +1088,7 @@ export function readConventions(
         failures.push({
           dir: manifest.dir,
           failure: {
-            setupClass: "missing-module",
+            failureClass: "missing-module",
             detail:
               `${manifest.path} declares ${row.package}, which no node_modules at or ` +
               `above its directory holds: run the package manager's install`,
@@ -1120,7 +1114,7 @@ export function readConventions(
         failures.push({
           dir: manifest.dir,
           failure: {
-            setupClass: "convention-not-literal",
+            failureClass: "convention-not-literal",
             detail: where === "." ? failed : `${where}/${failed}`,
           },
         });
@@ -1241,7 +1235,7 @@ export function conventionFailuresFor(
   conventions: Conventions,
   configFile: string,
   ownFiles: readonly string[],
-): readonly SetupFailure[] {
+): readonly Failure[] {
   return conventions.failures
     .filter(
       ({ dir }) =>

package/src/failure.ts

@@ -0,0 +1,63 @@
+import { FAILURE_CLASSES, FAILURE_PREFIXES } from "./contract/contract.generated.ts";
+import type { LocatedDiagnostic } from "./load/diagnostics.ts";
+import { PRODUCT } from "./product.ts";
+
+/** A class of failure the Contract's exit-code table names, of either group. */
+type FailureClass = keyof typeof FAILURE_CLASSES;
+
+/** One cause the run ends with the failure code for. */
+export interface Failure {
+  readonly failureClass: FailureClass;
+  /** What fails and the fix, on one line. */
+  readonly detail: string;
+}
+
+/** The failure as a class line of the error stream, opened by its group's prefix. */
+export function failureLine(failure: Failure): string {
+  return `${FAILURE_PREFIXES[FAILURE_CLASSES[failure.failureClass]]}${failure.failureClass}: ${failure.detail}`;
+}
+
+/**
+ * The lines of the error stream that name the failures: the first one's class line, the run's
+ * only one, then each further failure as its class and detail with no group prefix.
+ */
+export function failureLines([first, ...further]: readonly [Failure, ...Failure[]]): string[] {
+  return [failureLine(first), ...further.map((one) => `${one.failureClass}: ${one.detail}`)];
+}
+
+/**
+ * A run the analysis cannot answer. It ends the run with the failure code and no finding
+ * list, printing the compiler's located errors and then the failures' lines.
+ */
+export class FailureExit extends Error {
+  readonly failures: readonly [Failure, ...Failure[]];
+  /** The compiler's errors behind the failures, in the order it reported them. */
+  readonly diagnostics: readonly LocatedDiagnostic[];
+
+  constructor(
+    failures: readonly [Failure, ...Failure[]],
+    diagnostics: readonly LocatedDiagnostic[] = [],
+  ) {
+    super(failureLines(failures).join("\n"));
+    this.name = "FailureExit";
+    this.failures = failures;
+    this.diagnostics = diagnostics;
+  }
+}
+
+/** A failure exit of one failure. */
+export function failureExit(
+  failureClass: FailureClass,
+  detail: string,
+  diagnostics: readonly LocatedDiagnostic[] = [],
+): FailureExit {
+  return new FailureExit([{ failureClass, detail }], diagnostics);
+}
+
+/** A fault of this analyzer itself, `fault` saying what it cannot do. */
+export function productFault(fault: string): FailureExit {
+  return failureExit(
+    "product-fault",
+    `${PRODUCT} ${fault}: reinstall ${PRODUCT}, and report the fault to its maintainers if a reinstalled ${PRODUCT} fails the same way`,
+  );
+}

package/src/fs/document.ts

@@ -7,21 +7,17 @@
 
 import { CONFIG_MAX_BYTES } from "../contract/config.generated.ts";
 import type { Host } from "../host.ts";
+import { failureExit } from "../failure.ts";
 import { joinPath, relativePath } from "../paths.ts";
 import { message } from "../product.ts";
 import { utf8Bytes } from "../reporters/sha256.ts";
 import { UsageError } from "../usage.ts";
 
-/**
- * A document at the target root that is not one to read: its name resolves outside the
- * target root or to anything but a regular file, or the read fails. Nothing is read from
- * it, and the run ends with the failure code.
- */
-export class TargetDocumentError extends Error {
-  constructor(label: string, reason: string) {
-    super(`${label}: ${reason}`);
-    this.name = "TargetDocumentError";
-  }
+function unreadable(label: string, reason: string): Error {
+  return failureExit(
+    "unreadable-document",
+    `${label}: ${reason}: make it a regular file inside the target root that the run can read, or remove it`,
+  );
 }
 
 /** Refuses a document past the Contract's bound with the usage code, naming it `label`. */
@@ -31,44 +27,44 @@ export function refuseOverBound(label: string, text: string): void {
   }
 }
 
-/** What `read` returns, or its throw as the document's {@link TargetDocumentError}. */
-function attempt<T>(label: string, read: () => T): T {
-  try {
-    return read();
-  } catch (error: unknown) {
-    throw new TargetDocumentError(label, message(error));
-  }
-}
-
 /**
  * The text of the document `name` at the absolute `targetRoot`, undefined where nothing is
- * there, each refusal naming it `label`. A document past the bound is read one byte past
- * it and refused as {@link refuseOverBound} refuses it.
+ * there. One whose name resolves outside the target root or to anything but a regular file,
+ * or whose read fails, is refused by `refuse` naming it `label`, nothing read from it. A
+ * document past the bound is read one byte past it and refused as {@link refuseOverBound} does.
  */
 export function readTargetDocument(
   host: Host,
   targetRoot: string,
   name: string,
   label = name,
+  refuse: (label: string, reason: string) => Error = unreadable,
 ): string | undefined {
+  const attempt = <T>(read: () => T): T => {
+    try {
+      return read();
+    } catch (error: unknown) {
+      throw refuse(label, message(error));
+    }
+  };
   const path = joinPath(targetRoot, name);
-  const kind = attempt(label, () => host.kindOf(path));
+  const kind = attempt(() => host.kindOf(path));
   if (kind === "absent") {
     return undefined;
   }
-  const real = attempt(label, () => host.realPath(path));
+  const real = attempt(() => host.realPath(path));
   if (
     relativePath(
-      attempt(label, () => host.realPath(targetRoot)),
+      attempt(() => host.realPath(targetRoot)),
       real,
     ) === undefined
   ) {
-    throw new TargetDocumentError(label, `resolves to ${real}, outside the target root`);
+    throw refuse(label, `resolves to ${real}, outside the target root`);
   }
   if (kind !== "file") {
-    throw new TargetDocumentError(label, "is not a regular file");
+    throw refuse(label, "is not a regular file");
   }
-  const text = attempt(label, () => host.readFile(real, CONFIG_MAX_BYTES + 1));
+  const text = attempt(() => host.readFile(real, CONFIG_MAX_BYTES + 1));
   refuseOverBound(label, text);
   return text;
 }

package/src/fs/manifest.ts

@@ -8,6 +8,14 @@ export const MANIFEST = "package.json";
 /** The directory a package manager installs packages into, whose files are no project's own. */
 export const INSTALLED_PACKAGES = "node_modules";
 
+/** The manifest members a package declares the packages it depends on under. */
+export const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+] as const;
+
 /** Whether one path passes through an installed-packages directory. */
 export function inInstalledPackages(path: string): boolean {
   return path.split("/").includes(INSTALLED_PACKAGES);