@cplieger/deadset-ts 4.0.1 → 5.1.0

package/src/verbs/analyze.ts

@@ -1,4 +1,11 @@
-import { runAnalysis, runBaselineWrite, type RunAnalysis, type RunProject } from "../analysis.ts";
+import {
+  runAnalysis,
+  runBaselineWrite,
+  unansweredCounts,
+  type ComponentWarning,
+  type RunAnalysis,
+  type RunProject,
+} from "../analysis.ts";
 import { ConfigError, type Format } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
@@ -220,17 +227,19 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   let recorded: readonly Recorded[];
   let verdict: number;
   let partial: readonly string[];
+  let warnings: readonly ComponentWarning[];
+  let unread: readonly string[];
   try {
     const root = runRelative(invoked, targetRoot);
     const mode = { production: true };
     let analysis: RunAnalysis;
     if (documents.baseline === undefined) {
-      analysis = runAnalysis(openClient(false), host, scoped, config, provenance, mode);
+      analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
       recorded = [];
     } else {
       const reason = rowReason(analyzerProvenance(version));
       const write = runBaselineWrite(
-        openClient(false),
+        openClient(config),
         host,
         scoped,
         config,
@@ -242,7 +251,16 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       recorded = write.rows;
     }
     const { result, run } = analysis;
-    partial = partialNotes({ notBuilt: run.notBuilt, unanswered: run.unanswered });
+    warnings = run.componentWarnings;
+    unread = run.componentsUnread.map(
+      ({ configFile, reason }) =>
+        `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`,
+    );
+    partial = partialNotes({
+      notBuilt: run.notBuilt,
+      unanswered: run.unanswered,
+      targetRoot: resolvePath(invoked, targetRoot),
+    });
     const built = buildReport({
       contractVersion: CONTRACT_VERSION,
       version,
@@ -258,6 +276,9 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       unavailable: [],
       result,
       testFileRules: run.testFileRules,
+      typeErrorSkips: run.typeErrorSkips,
+      unanswered: unansweredCounts(analysis),
+      conventionsApplied: run.conventionsApplied,
     });
     report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
     verdict = verdictOf(result, config);
@@ -293,6 +314,19 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   for (const note of partial) {
     err.write(`deadset-ts: ${note}\n`);
   }
+  for (const line of unread) {
+    err.write(`deadset-ts: ${line}\n`);
+  }
+  for (const warning of warnings) {
+    err.write(
+      `deadset-ts: ${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}\n`,
+    );
+  }
+  for (const skip of report.type_error_skips) {
+    err.write(
+      `deadset-ts: ${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated\n`,
+    );
+  }
   if (report.totals.pending > 0) {
     err.write(
       `deadset-ts: ${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it\n`,

package/src/verbs/explain.ts

@@ -7,6 +7,7 @@ import { OUTSIDE, swept as judged } from "../graph.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { referenceKey, type Configured } from "../matrix.ts";
 import { partialNotes } from "../partial.ts";
+import { resolvePath } from "../paths.ts";
 import { positionKey } from "../position.ts";
 import type { Reference } from "../references.ts";
 import { resolve } from "../resolve.ts";
@@ -365,13 +366,15 @@ function explanation(analysis: RunAnalysis, subject: InventorySymbol, cascade: C
 export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, option }) => {
   const named = namedSymbol(option);
   const { config, provenance } = resolve(inputs());
-  const analysis = runAnalysis(openClient(false), host, scope(), config, provenance, {
+  const scoped = scope();
+  const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, {
     production: true,
   });
   const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
   const notes = partialNotes({
     notBuilt: analysis.run.notBuilt,
     unanswered: analysis.run.unanswered,
+    targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   });
   if (subject === undefined) {
     err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);

package/src/verbs/print-projects.ts

@@ -1,80 +1,28 @@
-import {
-  discoverProjects,
-  DiscoveryError,
-  isGuess,
-  projectErrors,
-  renderDiagnostic,
-  targetRelative,
-  type NotBuilt,
-} from "../discover.ts";
+import { runProjects } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
-import { relativePath, resolvePath } from "../paths.ts";
-import { resolveMatrix } from "../resolve.ts";
-import { diagnosticsOf, runSession } from "../session.ts";
-import { EXIT_CLEAN, EXIT_FAILURE, type Verb } from "./verb.ts";
+import { resolvePath } from "../paths.ts";
+import { resolveUnkinded } from "../resolve.ts";
+import { EXIT_CLEAN, type Verb } from "./verb.ts";
 
 /**
- * Writes the name of every project one run analyzes, one per line, having read each
- * project's diagnostics first: the identifier the build matrix declares for it, or,
- * where discovery derived the project, its configuration file's path below the
- * target root. A derived project that does not load is not one the run analyzes, so it
- * is named on the error stream instead, as the analysis drops it.
+ * Writes the name of every project one run analyzes, one per line: the identifier the
+ * build matrix declares for it, or, where discovery derived the project, its
+ * configuration file's path below the target root. The projects are read as the
+ * analysis reads them, so a project the analysis drops is named on the error stream
+ * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
-  const matrix = resolveMatrix(inputs());
+  const config = resolveUnkinded(inputs());
   const scoped = scope();
-  const engine = openClient(false);
-  const discovered = discoverProjects(engine, host, scoped, matrix);
-  const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
-  const root = resolvePath(host.workingDirectory(), scoped.target.path);
-  const notBuilt: NotBuilt[] = [...discovered.notBuilt];
-  const failures: string[] = [];
-  const session = runSession(
-    engine,
-    discovered.configFiles,
-    (project) => {
-      const id = ids.get(project.configFile) ?? project.configFile;
-      const errors = projectErrors(diagnosticsOf(project));
-      const [unloaded] = errors.load;
-      if (unloaded !== undefined && isGuess(discovered, project.configFile)) {
-        const error = renderDiagnostic(unloaded, (path) => relativePath(root, path) ?? path);
-        notBuilt.push({ id, configFile: project.configFile, error: targetRelative(error, root) });
-        return undefined;
-      }
-      failures.push(...[...errors.load, ...errors.check].map((one) => renderDiagnostic(one)));
-      return id;
-    },
-    discovered.derived ? "record" : "refuse",
-  );
-  for (const configFile of session.unopened) {
-    if (!isGuess(discovered, configFile)) {
-      throw new DiscoveryError(`${configFile} opened no project`, []);
-    }
-    notBuilt.push({
-      id: ids.get(configFile) ?? configFile,
-      configFile,
-      error: "the compiler opened no project for the configuration",
-    });
-  }
-  if (failures.length > 0) {
-    for (const line of failures) {
-      err.write(`${line}\n`);
-    }
-    err.write(`deadset-ts: ${String(failures.length)} error(s), so no answer was produced\n`);
-    return EXIT_FAILURE;
-  }
-  const projects = session.projects.filter((id): id is string => id !== undefined);
-  if (projects.length === 0 && notBuilt.length > 0) {
-    for (const note of partialNotes({ notBuilt, unanswered: [] })) {
-      err.write(`deadset-ts: ${note}\n`);
-    }
-    err.write("deadset-ts: no configuration discovery derived could be built\n");
-    return EXIT_FAILURE;
-  }
-  for (const id of projects) {
+  const answer = runProjects(openClient(config), host, scoped, config);
+  for (const id of answer.configurations) {
     out.write(`${id}\n`);
   }
-  for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+  for (const note of partialNotes({
+    notBuilt: answer.notBuilt,
+    unanswered: answer.unanswered,
+    targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+  })) {
     err.write(`deadset-ts: ${note}\n`);
   }
   return EXIT_CLEAN;

package/src/verbs/print-retained.ts

@@ -1,6 +1,7 @@
 import { runSweep } from "../analysis.ts";
 import { retainedLines } from "../exempt.ts";
 import { partialNotes } from "../partial.ts";
+import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
 import { EXIT_CLEAN, type Verb } from "./verb.ts";
 
@@ -14,14 +15,18 @@ import { EXIT_CLEAN, type Verb } from "./verb.ts";
 export const printRetainedVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
   const { config } = resolve(inputs());
   const scoped = scope();
-  const swept = runSweep(openClient(false), host, scoped, config, {
+  const swept = runSweep(openClient(config), host, scoped, config, {
     marked: [],
     mode: { production: true },
   });
   for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
     out.write(`${line}\n`);
   }
-  for (const note of partialNotes({ notBuilt: swept.notBuilt, unanswered: swept.unanswered })) {
+  for (const note of partialNotes({
+    notBuilt: swept.notBuilt,
+    unanswered: swept.unanswered,
+    targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+  })) {
     err.write(`deadset-ts: ${note}\n`);
   }
   return EXIT_CLEAN;

package/src/verbs/print-roots.ts

@@ -1,5 +1,6 @@
 import { runRoots, type RunRoot } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
+import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
 import { EXIT_CLEAN, EXIT_FINDINGS, type Verb } from "./verb.ts";
 
@@ -27,7 +28,7 @@ function rootLine(root: RunRoot, several: boolean): string {
 export const printRootsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
   const { config, provenance } = resolve(inputs());
   const scoped = scope();
-  const answer = runRoots(openClient(false), host, scoped, config, provenance);
+  const answer = runRoots(openClient(config), host, scoped, config, provenance);
   const several = answer.configurations.length > 1;
   for (const root of answer.roots) {
     out.write(`${rootLine(root, several)}\n`);
@@ -35,7 +36,11 @@ export const printRootsVerb: Verb = ({ out, err, host, inputs, scope, openClient
   for (const finding of answer.findings) {
     err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
   }
-  for (const note of partialNotes({ notBuilt: answer.notBuilt, unanswered: answer.unanswered })) {
+  for (const note of partialNotes({
+    notBuilt: answer.notBuilt,
+    unanswered: answer.unanswered,
+    targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+  })) {
     err.write(`deadset-ts: ${note}\n`);
   }
   return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;

package/src/verbs/verb.ts

@@ -1,4 +1,4 @@
-import type { Inputs } from "../config.ts";
+import type { Config, Inputs } from "../config.ts";
 import type { Emitters } from "../findings/emitter.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
@@ -24,8 +24,11 @@ export interface Invocation {
   readonly inputs: () => Inputs;
   /** The scope the options name: the document `--scope` names, or the target. */
   readonly scope: () => Scope;
-  /** Opens the compiler client. A client the verb opened is closed if the verb throws. */
-  readonly openClient: (collectTiming: boolean) => Engine;
+  /**
+   * 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;
   /** The emitter of every kind family, which a verb that reports findings runs. */
   readonly emitters: Emitters;
   /** The arguments after the verb's name, as written. */

package/src/version-range.ts

@@ -0,0 +1,309 @@
+/**
+ * Whether a version satisfies a dependency range, under the grammar npm, pnpm and yarn
+ * share: `||` alternatives of hyphen ranges or comparator runs, `x` and missing parts
+ * standing for any value, and a prerelease admitted only where a comparator names one
+ * of the same version. A range this grammar does not read is satisfied by nothing.
+ */
+
+/** A version: three numbers and the prerelease identifiers, build metadata dropped. */
+interface Version {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+  readonly prerelease: readonly string[];
+}
+
+/** One comparison a version must pass. */
+interface Comparator {
+  readonly operator: "<" | "<=" | ">" | ">=" | "=";
+  readonly version: Version;
+}
+
+/** A version whose parts may be missing or a wildcard, as a range writes one. */
+interface Partial {
+  readonly major?: number | undefined;
+  readonly minor?: number | undefined;
+  readonly patch?: number | undefined;
+  readonly prerelease: readonly string[];
+}
+
+const NUMBER = /^(?:0|[1-9]\d*)$/u;
+const IDENTIFIER = /^[0-9A-Za-z-]+$/u;
+const WILDCARD = new Set(["x", "X", "*"]);
+
+/** The prerelease identifiers after a hyphen, or `undefined` where one is malformed. */
+function prereleaseOf(text: string | undefined): readonly string[] | undefined {
+  if (text === undefined) {
+    return [];
+  }
+  const parts = text.split(".");
+  return parts.every((part) => IDENTIFIER.test(part)) ? parts : undefined;
+}
+
+/**
+ * One version as a range writes it, a leading `v` or `=` allowed, or `undefined`
+ * where it is not one.
+ */
+function partialOf(text: string): Partial | undefined {
+  const match =
+    /^[v=]?([^.+-]+)(?:\.([^.+-]+)(?:\.([^.+-]+)(?:-([^+]+))?)?)?(?:\+[0-9A-Za-z.-]+)?$/u.exec(
+      text,
+    );
+  if (match === null) {
+    return undefined;
+  }
+  const parts: (number | undefined)[] = [];
+  let wild = false;
+  for (const part of [match[1], match[2], match[3]]) {
+    if (part === undefined || WILDCARD.has(part)) {
+      wild = true;
+      parts.push(undefined);
+      continue;
+    }
+    if (wild || !NUMBER.test(part)) {
+      return undefined;
+    }
+    parts.push(Number(part));
+  }
+  const prerelease = prereleaseOf(match[4]);
+  if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+    return undefined;
+  }
+  return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+}
+
+/** One exact version, or `undefined` where the text is not one. */
+function versionOf(text: string): Version | undefined {
+  const partial = partialOf(text.trim());
+  if (partial?.major === undefined || partial.minor === undefined || partial.patch === undefined) {
+    return undefined;
+  }
+  return {
+    major: partial.major,
+    minor: partial.minor,
+    patch: partial.patch,
+    prerelease: partial.prerelease,
+  };
+}
+
+function exact(
+  major: number,
+  minor: number,
+  patch: number,
+  prerelease: readonly string[] = [],
+): Version {
+  return { major, minor, patch, prerelease };
+}
+
+/** The lowest prerelease of one version, which bounds a range from above. */
+function floorOf(major: number, minor: number, patch: number): Version {
+  return exact(major, minor, patch, ["0"]);
+}
+
+function compareIdentifiers(a: string, b: string): number {
+  const numericA = NUMBER.test(a);
+  const numericB = NUMBER.test(b);
+  if (numericA && numericB) {
+    return Math.sign(Number(a) - Number(b));
+  }
+  if (numericA !== numericB) {
+    return numericA ? -1 : 1;
+  }
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+
+/** Two versions ordered by precedence. */
+function compare(a: Version, b: Version): number {
+  const core =
+    Math.sign(a.major - b.major) || Math.sign(a.minor - b.minor) || Math.sign(a.patch - b.patch);
+  if (core !== 0) {
+    return core;
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    return Math.sign(b.prerelease.length - a.prerelease.length);
+  }
+  for (let at = 0; at < Math.max(a.prerelease.length, b.prerelease.length); at += 1) {
+    const left = a.prerelease[at];
+    const right = b.prerelease[at];
+    if (left === undefined || right === undefined) {
+      return left === undefined ? -1 : 1;
+    }
+    const order = compareIdentifiers(left, right);
+    if (order !== 0) {
+      return order;
+    }
+  }
+  return 0;
+}
+
+function passes(version: Version, comparator: Comparator): boolean {
+  const order = compare(version, comparator.version);
+  switch (comparator.operator) {
+    case "<":
+      return order < 0;
+    case "<=":
+      return order <= 0;
+    case ">":
+      return order > 0;
+    case ">=":
+      return order >= 0;
+    case "=":
+      return order === 0;
+  }
+}
+
+/** The comparators a version with missing parts stands for: any value of each. */
+function anyOf(partial: Partial): Comparator[] {
+  const { major, minor } = partial;
+  if (major === undefined) {
+    return [{ operator: ">=", version: exact(0, 0, 0) }];
+  }
+  if (minor === undefined) {
+    return [
+      { operator: ">=", version: exact(major, 0, 0) },
+      { operator: "<", version: floorOf(major + 1, 0, 0) },
+    ];
+  }
+  if (partial.patch === undefined) {
+    return [
+      { operator: ">=", version: exact(major, minor, 0) },
+      { operator: "<", version: floorOf(major, minor + 1, 0) },
+    ];
+  }
+  return [{ operator: "=", version: exact(major, minor, partial.patch, partial.prerelease) }];
+}
+
+/** The lowest version a partial version stands for. */
+function lowest(partial: Partial): Version {
+  return exact(partial.major ?? 0, partial.minor ?? 0, partial.patch ?? 0, partial.prerelease);
+}
+
+function tilde(partial: Partial): Comparator[] {
+  const { major, minor } = partial;
+  if (major === undefined || minor === undefined) {
+    return anyOf(partial);
+  }
+  return [
+    { operator: ">=", version: lowest(partial) },
+    { operator: "<", version: floorOf(major, minor + 1, 0) },
+  ];
+}
+
+function caret(partial: Partial): Comparator[] {
+  const { major, minor, patch } = partial;
+  if (major === undefined) {
+    return anyOf(partial);
+  }
+  const from = { operator: ">=" as const, version: lowest(partial) };
+  if (major > 0 || minor === undefined) {
+    return [from, { operator: "<", version: floorOf(major + 1, 0, 0) }];
+  }
+  if (minor > 0 || patch === undefined) {
+    return [from, { operator: "<", version: floorOf(0, minor + 1, 0) }];
+  }
+  return [from, { operator: "<", version: floorOf(0, 0, patch + 1) }];
+}
+
+/** The comparators one primitive comparison stands for, a partial version filled in. */
+function primitive(operator: "<" | "<=" | ">" | ">=", partial: Partial): Comparator[] {
+  const { major, minor, patch } = partial;
+  if (major === undefined) {
+    return operator === "<" || operator === ">"
+      ? [{ operator: "<", version: floorOf(0, 0, 0) }]
+      : [{ operator: ">=", version: exact(0, 0, 0) }];
+  }
+  if (minor !== undefined && patch !== undefined) {
+    return [{ operator, version: lowest(partial) }];
+  }
+  const next = minor === undefined ? exact(major + 1, 0, 0) : exact(major, minor + 1, 0);
+  switch (operator) {
+    case ">":
+      return [{ operator: ">=", version: next }];
+    case ">=":
+      return [{ operator: ">=", version: lowest(partial) }];
+    case "<":
+      return [{ operator: "<", version: floorOf(major, minor ?? 0, 0) }];
+    case "<=":
+      return [{ operator: "<", version: floorOf(next.major, next.minor, 0) }];
+  }
+}
+
+/** The comparators one written comparator stands for, or `undefined` where it is none. */
+function comparatorsOf(token: string): Comparator[] | undefined {
+  const match = /^(<=|>=|<|>|=|~>|~|\^)?(.*)$/u.exec(token);
+  const operator = match?.[1] ?? "";
+  const partial = partialOf(match?.[2] ?? "");
+  if (partial === undefined) {
+    return undefined;
+  }
+  switch (operator) {
+    case "~":
+    case "~>":
+      return tilde(partial);
+    case "^":
+      return caret(partial);
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return primitive(operator, partial);
+    default:
+      return anyOf(partial);
+  }
+}
+
+/** The comparators of one alternative, or `undefined` where it does not read. */
+function alternativeOf(text: string): Comparator[] | undefined {
+  const spaced = text.trim().replaceAll(/(<=|>=|<|>|=|~>|~|\^)\s+/gu, "$1");
+  if (spaced === "") {
+    return anyOf({ prerelease: [] });
+  }
+  const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(spaced);
+  if (hyphen !== null) {
+    const from = partialOf(hyphen[1] ?? "");
+    const to = partialOf(hyphen[2] ?? "");
+    if (from === undefined || to === undefined) {
+      return undefined;
+    }
+    return [...primitive(">=", from), ...(to.major === undefined ? [] : primitive("<=", to))];
+  }
+  const found: Comparator[] = [];
+  for (const token of spaced.split(/\s+/u)) {
+    const comparators = comparatorsOf(token);
+    if (comparators === undefined) {
+      return undefined;
+    }
+    found.push(...comparators);
+  }
+  return found;
+}
+
+/** Whether one alternative admits one version, its prerelease rule included. */
+function admits(alternative: readonly Comparator[], version: Version): boolean {
+  if (!alternative.every((comparator) => passes(version, comparator))) {
+    return false;
+  }
+  if (version.prerelease.length === 0) {
+    return true;
+  }
+  return alternative.some(
+    ({ version: bound }) =>
+      bound.prerelease.length > 0 &&
+      bound.major === version.major &&
+      bound.minor === version.minor &&
+      bound.patch === version.patch,
+  );
+}
+
+/** Whether `version` satisfies `range`; `false` where either does not read. */
+export function satisfies(version: string, range: string): boolean {
+  const parsed = versionOf(version);
+  if (parsed === undefined) {
+    return false;
+  }
+  const alternatives = range.split("||").map(alternativeOf);
+  return (
+    alternatives.every((alternative) => alternative !== undefined) &&
+    alternatives.some((alternative) => admits(alternative, parsed))
+  );
+}

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 = "4.0.0";
+export const CONTRACT_VERSION = "5.2.0";