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

package/src/verbs/analyze.ts

@@ -1,25 +1,18 @@
-import {
-  CONTRACT_VERSION,
-  EXIT_CLEAN,
-  EXIT_FAILURE,
-  type Format,
-} from "../contract/contract.generated.ts";
+import { CONTRACT_VERSION, EXIT_CLEAN, type Format } from "../contract/contract.generated.ts";
 import {
   runAnalysis,
   runBaselineWrite,
   unansweredCounts,
-  type ComponentWarning,
   type RunAnalysis,
   type RunProject,
 } from "../analysis.ts";
-import { ConfigError, kindOf } from "../config.ts";
+import { kindOf } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
-import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
 import type { Host } from "../host.ts";
 import type { ManifestEntry } from "../manifest.ts";
-import type { NotBuilt } from "../discover.ts";
+import { moduleIdentity, type NotBuilt } from "../load/discover.ts";
 import { partialNotes } from "../partial.ts";
 import {
   buildReport,
@@ -29,7 +22,6 @@ import {
   type ReportNotBuilt,
   type ReportNote,
 } from "../report.ts";
-import type { Report } from "../contract/report.generated.ts";
 import { reportRefusals } from "../report-schema.ts";
 import { json } from "../reporters/json.ts";
 import { RENDERINGS } from "../reporters/reporters.ts";
@@ -38,8 +30,11 @@ import { resolve } from "../resolve.ts";
 import { otherSchemeRows, rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
 import type { UnseenLoad } from "../unseen-loads.ts";
 import { type Verb, type VerbOptions } from "./verb.ts";
+import { UsageError } from "../usage.ts";
 import { bytewise } from "../text/compare.ts";
-import { diagnose, LANGUAGE, message } from "../product.ts";
+import { productFault, failureExit } from "../failure.ts";
+import { diagnose, message } from "../product.ts";
+import { ownVersion } from "./version.ts";
 
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS: VerbOptions = {
@@ -51,14 +46,6 @@ export const ANALYZE_OPTIONS: VerbOptions = {
 const EXIT_CODE_ON = "on";
 const EXIT_CODE_OFF = "off";
 
-/** A path of the run no report can name, which ends the run with the failure code. */
-class ReportPathError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ReportPathError";
-  }
-}
-
 /** The formats this analyzer renders, for a message that names them. */
 function formatNames(): string {
   return [...RENDERINGS.keys()].sort(bytewise).join(", ");
@@ -70,14 +57,12 @@ function formatsOf(named: readonly string[], configured: readonly Format[]): rea
   const seen = new Set<string>();
   for (const format of formats) {
     if (!RENDERINGS.has(format as Format)) {
-      throw new ConfigError(
-        "malformed",
-        "",
+      throw new UsageError(
         `${JSON.stringify(format)} is not a format this analyzer renders: the formats are ${formatNames()}`,
       );
     }
     if (seen.has(format)) {
-      throw new ConfigError("malformed", "", `the format ${JSON.stringify(format)} is named twice`);
+      throw new UsageError(`the format ${JSON.stringify(format)} is named twice`);
     }
     seen.add(format);
   }
@@ -95,7 +80,8 @@ function runRelative(invoked: string, path: string): string {
   }
   const below = relativePath(invoked, path);
   if (below === undefined) {
-    throw new ReportPathError(
+    throw failureExit(
+      "unreportable-path",
       `a report names its target relative to the directory the run was invoked from, and ${invoked} does not contain ${path}: run from a directory that does`,
     );
   }
@@ -147,8 +133,9 @@ function notBuiltOf(dropped: readonly NotBuilt[], targetRoot: string): readonly
   return dropped.map((one) => {
     const project = relativePath(targetRoot, one.configFile);
     if (project === undefined) {
-      throw new ReportPathError(
-        `the project ${one.id} would be opened from ${one.configFile}, which is not below the target ${targetRoot}, so no report can name it`,
+      throw failureExit(
+        "unreportable-path",
+        `the project ${one.id} would be opened from ${one.configFile}, which is not below the target ${targetRoot}, so no report can name it: analyze a target that holds it`,
       );
     }
     return { id: one.id, project, error: one.error };
@@ -163,14 +150,33 @@ function configurationsOf(
   return projects.map((one) => {
     const project = relativePath(targetRoot, one.configFile);
     if (project === undefined) {
-      throw new ReportPathError(
-        `the project ${one.id} is opened from ${one.configFile}, which is not below the target ${targetRoot}, so no report can name it`,
+      throw failureExit(
+        "unreportable-path",
+        `the project ${one.id} is opened from ${one.configFile}, which is not below the target ${targetRoot}, so no report can name it: analyze a target that holds it`,
       );
     }
     return { id: one.id, project };
   });
 }
 
+/**
+ * Writes one document the run was asked for. A document that cannot be produced or written
+ * ends the run with the run failure that names it and `fix`, the documents written before it
+ * kept.
+ */
+function writeDocument(
+  host: Host,
+  path: string,
+  fix: string,
+  produce: () => Iterable<string>,
+): void {
+  try {
+    host.writeDocument(path, produce());
+  } catch (error: unknown) {
+    throw failureExit("unwritten-output", `${path}: ${message(error)}: ${fix}`);
+  }
+}
+
 /** A count with its noun, so a message reads for one record as well as for several. */
 function counted(n: number, noun: string): string {
   return `${String(n)} ${noun}${n === 1 ? "" : "s"}`;
@@ -189,9 +195,7 @@ function templateOf(
 ): Template | undefined {
   if (named === undefined || named === "") {
     if (formats.includes("template")) {
-      throw new ConfigError(
-        "malformed",
-        "",
+      throw new UsageError(
         "the template format renders the template --template names, and none was named",
       );
     }
@@ -201,7 +205,7 @@ function templateOf(
   try {
     source = host.readFile(resolvePath(invoked, named));
   } catch (error: unknown) {
-    throw new ConfigError("malformed", "", `--template=${named}: ${message(error)}`);
+    throw new UsageError(`--template=${named}: ${message(error)}`);
   }
   try {
     return parseTemplate(source);
@@ -209,7 +213,7 @@ function templateOf(
     if (!(error instanceof TemplateError)) {
       throw error;
     }
-    throw new ConfigError("malformed", "", `--template=${named}: ${error.message}`);
+    throw new UsageError(`--template=${named}: ${error.message}`);
   }
 }
 
@@ -231,25 +235,17 @@ interface Documents {
 export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option, repeated }) => {
   const reportPath = option("report");
   if (reportPath === undefined || reportPath === "") {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       "analyze writes its report to the path --report names, and no path was named",
     );
   }
   const exitCode = option("exit-code") ?? EXIT_CODE_ON;
   if (exitCode !== EXIT_CODE_ON && exitCode !== EXIT_CODE_OFF) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       `--exit-code=${JSON.stringify(exitCode)}: the values are ${EXIT_CODE_ON} and ${EXIT_CODE_OFF}`,
     );
   }
   const { config, provenance } = resolve(inputs());
-  const kind = config.targetKind;
-  if (kind === "") {
-    throw new ConfigError("missing-target-kind", "target.kind", "target.kind is not set");
-  }
   const invoked = host.workingDirectory();
   const baseline = option("baseline-write");
   const documents: Documents = {
@@ -261,126 +257,112 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   const scoped = scope();
   const targetRoot = scoped.target.path;
 
-  let version: string;
-  try {
-    version = host.analyzerVersion();
-  } catch (error: unknown) {
-    diagnose(err, message(error));
-    return EXIT_FAILURE;
-  }
+  const version = ownVersion(host);
 
-  let report: Report;
   let recorded: readonly Recorded[];
-  let verdict: number;
-  let partial: readonly string[];
-  let warnings: readonly ComponentWarning[];
-  let unread: readonly string[];
-  let unfound: readonly string[];
-  try {
-    const root = runRelative(invoked, targetRoot);
-    const mode = { production: true };
-    let analysis: RunAnalysis;
-    if (documents.baseline === undefined) {
-      analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
-      recorded = [];
-    } else {
-      const reason = rowReason(analyzerProvenance(version));
-      const write = runBaselineWrite(
-        openClient(config),
-        host,
-        scoped,
-        config,
-        provenance,
-        mode,
-        reason,
-      );
-      analysis = write.first;
-      recorded = write.rows;
-    }
-    const { result, run } = analysis;
-    warnings = run.componentWarnings;
-    unread = run.componentsUnread.map(
-      ({ configFile, reason }) =>
-        `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`,
+  const root = runRelative(invoked, targetRoot);
+  const mode = { production: true };
+  let analysis: RunAnalysis;
+  if (documents.baseline === undefined) {
+    analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
+    recorded = [];
+  } else {
+    const reason = rowReason(analyzerProvenance(version));
+    const write = runBaselineWrite(
+      openClient(config),
+      host,
+      scoped,
+      config,
+      provenance,
+      mode,
+      reason,
     );
-    unfound = run.librariesUnfound.map(
-      ({ configFile, error }) =>
-        `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: ${error}: the configuration is analyzed without that library`,
-    );
-    partial = partialNotes({
-      notBuilt: run.notBuilt,
-      unanswered: run.unanswered,
-      targetRoot: resolvePath(invoked, targetRoot),
-    });
-    const built = buildReport({
-      contractVersion: CONTRACT_VERSION,
-      version,
-      conformance: CONFORMANCE,
-      declaredGaps: DECLARED_GAPS,
-      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) => ({
-        id: consumer.id,
-        path: runRelative(invoked, consumer.path),
-      })),
-      unavailable: [],
-      result,
-      testFileRules: run.testFileRules,
-      typeErrorSkips: run.typeErrorSkips,
-      unanswered: unansweredCounts(analysis),
-      conventionsApplied: run.conventionsApplied,
-      listsComponents: config.reporters.cascade === "full",
-      notes: [
-        ...unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
-        ...unseenLoadNotes(run.unseenLoads),
-      ],
-    });
-    report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
-    verdict = verdictOf(result, config);
-  } catch (error: unknown) {
-    if (!(error instanceof ReportPathError)) {
-      throw error;
-    }
-    diagnose(err, error.message);
-    return EXIT_FAILURE;
+    analysis = write.first;
+    recorded = write.rows;
   }
+  const { result, run } = analysis;
+  const warnings = run.componentWarnings;
+  const unread = run.componentsUnread.map(
+    ({ configFile, reason }) =>
+      `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`,
+  );
+  const unfound = run.librariesUnfound.map(
+    ({ configFile, error }) =>
+      `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: ${error}: the configuration is analyzed without that library`,
+  );
+  const partial = partialNotes({
+    notBuilt: run.notBuilt,
+    unanswered: run.unanswered,
+    targetRoot: resolvePath(invoked, targetRoot),
+  });
+  const built = buildReport({
+    contractVersion: CONTRACT_VERSION,
+    version,
+    conformance: CONFORMANCE,
+    declaredGaps: DECLARED_GAPS,
+    target: {
+      kind: kindOf(config.target.kind),
+      root,
+      identity: moduleIdentity(host, scoped.target),
+    },
+    configurations: configurationsOf(run.projects, targetRoot),
+    notBuilt: notBuiltOf(run.notBuilt, targetRoot),
+    loaded: run.consumers.map((consumer) => ({
+      id: consumer.id,
+      path: runRelative(invoked, consumer.path),
+    })),
+    unavailable: [],
+    result,
+    testFileRules: run.testFileRules,
+    typeErrorSkips: run.typeErrorSkips,
+    unanswered: unansweredCounts(analysis),
+    conventionsApplied: run.conventionsApplied,
+    listsComponents: config.reporters.cascade === "full",
+    notes: [
+      ...unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+      ...unseenLoadNotes(run.unseenLoads),
+    ],
+  });
+  const report = capFindings(
+    sortFindings(built, config.reporters.sort),
+    config.reporters.max_findings,
+  );
+  const verdict = verdictOf(result, config);
 
-  try {
-    const [refused] = reportRefusals(report);
-    if (refused !== undefined) {
-      throw new Error(
-        `the report breaks the report schema at ${refused.pointer || "the document"}: ${refused.keyword}: ${refused.reason}`,
-      );
-    }
-    host.writeDocument(documents.report, json(report));
-    const options = {
-      readSource: (path: string) => host.readFile(joinPath(targetRoot, path)),
-      template,
-    };
-    for (const format of documents.formats) {
-      const rendering = RENDERINGS.get(format);
-      if (rendering !== undefined) {
-        host.writeDocument(documents.report + rendering.suffix, rendering.render(report, options));
-      }
-    }
-    if (documents.baseline !== undefined) {
-      const kept =
-        host.kindOf(documents.baseline) === "file"
-          ? otherSchemeRows(host.readFile(documents.baseline))
-          : [];
-      host.writeDocument(
-        documents.baseline,
-        writeBaseline(recorded, analyzerProvenance(version), kept),
+  const [refused] = reportRefusals(report);
+  if (refused !== undefined) {
+    throw productFault(
+      `built a report that breaks the report schema at ${refused.pointer || "the document"}: ${refused.keyword}: ${refused.reason}`,
+    );
+  }
+  writeDocument(host, documents.report, "name a path the run can write", () => json(report));
+  const options = {
+    readSource: (path: string) => host.readFile(joinPath(targetRoot, path)),
+    template,
+  };
+  for (const format of documents.formats) {
+    const rendering = RENDERINGS.get(format);
+    if (rendering !== undefined) {
+      writeDocument(
+        host,
+        documents.report + rendering.suffix,
+        "name a path the run can write, or correct the template that renders it",
+        () => rendering.render(report, options),
       );
     }
-  } catch (error: unknown) {
-    diagnose(err, message(error));
-    return EXIT_FAILURE;
+  }
+  const baselinePath = documents.baseline;
+  if (baselinePath !== undefined) {
+    writeDocument(
+      host,
+      baselinePath,
+      "name a path the run can write, or repair the rows of the baseline the run would keep",
+      () => {
+        const kept =
+          host.kindOf(baselinePath) === "file" ? otherSchemeRows(host.readFile(baselinePath)) : [];
+        return writeBaseline(recorded, analyzerProvenance(version), kept);
+      },
+    );
   }
 
   for (const note of partial) {

package/src/verbs/describe.ts

@@ -1,13 +1,13 @@
 import {
   CONTRACT_VERSION,
   EXIT_CLEAN,
-  EXIT_FAILURE,
   EXIT_USAGE,
   SCHEMA_VERSIONS,
 } from "../contract/contract.generated.ts";
 import { CONFORMANCE, type Conformance } from "../conformance.ts";
 import { type Verb } from "./verb.ts";
-import { diagnose, LANGUAGE, message, PRODUCT } from "../product.ts";
+import { diagnose, LANGUAGE, PRODUCT } from "../product.ts";
+import { ownVersion } from "./version.ts";
 
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
@@ -34,19 +34,12 @@ export function describeDocument(version: string, recorded: Conformance | undefi
   return `${JSON.stringify(document, null, 2)}\n`;
 }
 
-/** Writes this analyzer's description to the output stream, and nothing to the error stream. */
+/** Writes this analyzer's description to the output stream. */
 export const describeVerb: Verb = ({ out, err, host, args }) => {
   if (args.length > 0) {
     diagnose(err, `describe takes no argument, got ${JSON.stringify(args[0])}`);
     return EXIT_USAGE;
   }
-  let version: string;
-  try {
-    version = host.analyzerVersion();
-  } catch (error: unknown) {
-    diagnose(err, `describe: ${message(error)}`);
-    return EXIT_FAILURE;
-  }
-  out.write(describeDocument(version, CONFORMANCE));
+  out.write(describeDocument(ownVersion(host), CONFORMANCE));
   return EXIT_CLEAN;
 };

package/src/verbs/explain.ts

@@ -2,7 +2,6 @@ import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.ts";
 import { runAnalysis, type RunAnalysis } from "../analysis.ts";
 import { listing } from "../components.ts";
 import type { Cascade } from "../config.ts";
-import { ConfigError } from "../config.ts";
 import type { CompletedFinding } from "../finding.ts";
 import { OUTSIDE, swept as judged } from "../graph.ts";
 import type { InventorySymbol } from "../inventory.ts";
@@ -14,6 +13,7 @@ import type { Reference } from "../references.ts";
 import { resolve } from "../resolve.ts";
 import type { Root } from "../roots.ts";
 import { type Verb, type VerbOptions } from "./verb.ts";
+import { UsageError } from "../usage.ts";
 import { bytewise } from "../text/compare.ts";
 import { diagnose } from "../product.ts";
 
@@ -47,16 +47,12 @@ function namedSymbol(option: (name: string) => string | undefined): string {
   });
   const [only, ...more] = named;
   if (only === undefined) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       "explain explains the symbol --why, --why-live or --why-not names, and none was named",
     );
   }
   if (more.length > 0) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       `explain explains one symbol, and ${named.map((one) => `--${one.name}`).join(", ")} each name one`,
     );
   }

package/src/verbs/print-projects.ts

@@ -2,7 +2,7 @@ import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runProjects } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
-import { resolveUnkinded } from "../resolve.ts";
+import { resolvePartial } from "../resolve.ts";
 import { type Verb } from "./verb.ts";
 import { diagnose } from "../product.ts";
 
@@ -14,7 +14,7 @@ import { diagnose } from "../product.ts";
  * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
-  const config = resolveUnkinded(inputs());
+  const config = resolvePartial(inputs());
   const scoped = scope();
   const answer = runProjects(openClient(config), host, scoped, config);
   for (const id of answer.configurations) {

package/src/verbs/verb.ts

@@ -1,4 +1,4 @@
-import type { Config, Inputs } from "../config.ts";
+import type { Inputs, PartialConfig } from "../config.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
 import type { Scope } from "../scope.ts";
@@ -21,7 +21,7 @@ interface Invocation {
    * Opens the compiler client for a run under `config`. A client the verb opened is
    * closed if the verb throws.
    */
-  readonly openClient: (config: Config) => Engine;
+  readonly openClient: (config: PartialConfig) => Engine;
   /** The arguments after the verb's name, as written. */
   readonly args: readonly string[];
   /** The last value one of the verb's own options was given, undefined where none was. */

package/src/verbs/version.ts

@@ -1,9 +1,20 @@
 import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.ts";
+import { productFault } from "../failure.ts";
+import type { Host } from "../host.ts";
 import { type Verb } from "./verb.ts";
-import { PRODUCT } from "../product.ts";
+import { message, PRODUCT } from "../product.ts";
+
+/** The version the host reports for this analyzer; one it cannot read is a fault of the analyzer. */
+export function ownVersion(host: Host): string {
+  try {
+    return host.analyzerVersion();
+  } catch (error: unknown) {
+    throw productFault(`cannot read its own version: ${message(error)}`);
+  }
+}
 
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb: Verb = ({ out, host }) => {
-  out.write(`${PRODUCT} ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+  out.write(`${PRODUCT} ${ownVersion(host)}\ncontract ${CONTRACT_VERSION}\n`);
   return EXIT_CLEAN;
 };

package/dist/src/base-url.js

@@ -1,18 +0,0 @@
-import { resolvePath } from "./paths.js";
-/**
- * The `paths` one configuration's resolved options map under the compilers before version
- * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
- * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
- * options' own `paths` stand. Version 7 reads no `baseUrl`:
- * https://github.com/microsoft/TypeScript/issues/62207
- */
-export function baseUrlPaths(options) {
-    const baseUrl = Reflect.get(options, "baseUrl");
-    if (typeof baseUrl !== "string") {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
-        key,
-        targets.map((target) => resolvePath(baseUrl, target)),
-    ]));
-}