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

package/src/mdx-entries.ts

@@ -9,6 +9,7 @@ import { resolveRelativeSpecifier } from "./configuration-files.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { filesBelow } from "./fs/tree.ts";
 
 /** One file a document imports, the specifier that named it, and the export names it reads. */
 interface DocumentEntry {
@@ -18,9 +19,6 @@ interface DocumentEntry {
   readonly names: readonly string[] | undefined;
 }
 
-/** The directories no document is read below. */
-const SKIPPED: ReadonlySet<string> = new Set(["node_modules", ".git"]);
-
 /** The extensions of a document whose imports an MDX compiler reads. */
 const DOCUMENT = /\.mdx?$/u;
 
@@ -129,28 +127,6 @@ function clauseNames(clause: string): readonly string[] | undefined {
   return names;
 }
 
-/** Every document below `dir`, outside every skipped directory, by absolute path. */
-function documents(host: Host, dir: string): readonly string[] {
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  const found: string[] = [];
-  for (const entry of entries) {
-    const path = joinPath(dir, entry.name);
-    if (entry.directory) {
-      if (!SKIPPED.has(entry.name)) {
-        found.push(...documents(host, path));
-      }
-    } else if (DOCUMENT.test(entry.name)) {
-      found.push(path);
-    }
-  }
-  return found.sort();
-}
-
 /** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
 function importedBy(
   text: string,
@@ -205,7 +181,8 @@ function documentImports(host: Host, root: string): readonly DocumentImports[] {
   if (known !== undefined) {
     return known;
   }
-  const found = documents(host, root).flatMap((path) => {
+  const found = filesBelow(host, root, (name) => DOCUMENT.test(name)).flatMap((below) => {
+    const path = joinPath(root, below);
     try {
       return [{ path, imports: importedBy(host.readFile(path)) }];
     } catch {

package/src/partial.ts

@@ -1,6 +1,7 @@
 import type { NotBuilt } from "./discover.ts";
 import { relativePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
+import { bytewise } from "./text/compare.ts";
 
 /** What a run read only in part. */
 interface Partial {
@@ -24,7 +25,7 @@ function counted(n: number, one: string, many: string): string {
  */
 export function partialNotes(partial: Partial): readonly string[] {
   const notes = [...partial.notBuilt]
-    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    .sort((a, b) => bytewise(a.id, b.id))
     .map(
       (one) =>
         `the derived configuration ${one.id} was not built and is not analyzed: ${one.error}`,

package/src/paths.ts

@@ -1,11 +1,7 @@
 /**
- * Filesystem paths, as the supported platform spells them: a solidus separates
- * segments and a leading solidus makes a path absolute.
- *
- * They are written here rather than taken from the platform's own library because
- * every module below the command line stays free of the platform, and because the
- * supported platform set is one, so a second spelling would be a rule nothing
- * exercises.
+ * Filesystem paths as the supported platform spells them: a solidus between segments, a
+ * leading one for an absolute path. They are written here rather than taken from the
+ * platform's library so every module below the command line stays free of the platform.
  */
 
 const SEPARATOR = "/";
@@ -67,6 +63,25 @@ export function dirnamePath(path: string): string {
   return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
 
+/**
+ * `dir` and every directory above it, nearest first, normalized. With `top`, the list ends
+ * at `top` and is empty where `dir` is neither `top` nor below it; without, it ends at the
+ * root of the path.
+ */
+export function ancestors(dir: string, top?: string): readonly string[] {
+  const end = top === undefined ? undefined : normalizePath(top);
+  const found: string[] = [];
+  for (let at = normalizePath(dir); ; at = dirnamePath(at)) {
+    if (end !== undefined && at !== end && relativePath(end, at) === undefined) {
+      return [];
+    }
+    found.push(at);
+    if (at === end || dirnamePath(at) === at) {
+      return found;
+    }
+  }
+}
+
 /**
  * The extension of one path's last segment, from its last full stop, or the empty string
  * where it has none. A segment that only starts with a full stop has none.
@@ -101,14 +116,11 @@ export function queriedModulePath(specifier: string): string | undefined {
 }
 
 /**
- * One path as it reads below a root, or undefined when it is not below the root.
- * Both are normalized first, so a root written with a trailing separator or a `.`
- * segment reaches the same answer, and the comparison is then lexical, so a root
- * and a path spelled through different symbolic links name nothing in common. The
- * root itself is not below itself.
- *
- * The caller resolves both against the same directory before calling: a relative
- * root and an absolute path are two spellings this cannot reconcile.
+ * One path as it reads below a root, or undefined when it is not strictly below the root:
+ * the root itself is not below itself. Both are normalized, then compared lexically, so a
+ * root and a path spelled through different symbolic links name nothing in common. The
+ * caller resolves both against the same directory first: a relative root and an absolute
+ * path cannot be reconciled.
  */
 export function relativePath(root: string, path: string): string | undefined {
   const at = normalizePath(root);

package/src/position.ts

@@ -1,5 +1,6 @@
 import type { SourceFile } from "@typescript/native/ast";
 import { relativePath } from "./paths.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
  * Where one declaration is written, as every report renders it.
@@ -87,7 +88,7 @@ export function positionKey(position: Position): string {
  */
 export function byPosition(a: Position, b: Position): number {
   if (a.path !== b.path) {
-    return a.path < b.path ? -1 : 1;
+    return bytewise(a.path, b.path);
   }
   if (a.line !== b.line) {
     return a.line - b.line;

package/src/print.ts

@@ -1,96 +1,16 @@
-import {
-  renderOrigin,
-  type Config,
-  type DeclarationEntry,
-  type Provenance,
-  type Provider,
-} from "./config.ts";
-
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry: DeclarationEntry): Record<string, string> {
-  switch (entry.shape) {
-    case "symbol":
-      return { symbol: entry.symbol };
-    case "module":
-      return { module: entry.module, name: entry.name };
-    case "global":
-      return { global: entry.global };
-  }
-}
-
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry: Provider): Record<string, unknown> {
-  const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-  if (entry.shape === "installed") {
-    return installed;
-  }
-  return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
+import { renderOrigin, type Provenance, type ResolvedConfig } from "./config.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
-export function printConfig(config: Config, provenance: Provenance): string {
-  const document = {
-    contract_version: config.contractVersion,
-    target: { kind: config.targetKind },
-    analysis: {
-      languages: config.analysis.languages,
-      min_confidence: config.analysis.minConfidence,
-      generated_files: config.analysis.generatedFiles,
-      consumer_tests: config.analysis.consumerTests,
-      configurations: config.analysis.configurations.map((entry) =>
-        entry.shape === "project"
-          ? { id: entry.id, project: entry.project }
-          : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags },
-      ),
-      matrix: { complete: config.analysis.matrixComplete },
-      template_dirs: config.analysis.templateDirs,
-      template_delimiters: {
-        left: config.analysis.templateDelimiters.left,
-        right: config.analysis.templateDelimiters.right,
-      },
-    },
-    consumers: { complete: config.consumersComplete },
-    roots: { patterns: config.rootPatterns },
-    severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
-    exemptions: { disabled: config.exemptionsDisabled },
-    reporters: {
-      formats: config.reporters.formats,
-      sort: config.reporters.sort,
-      cascade: config.reporters.cascade,
-      max_findings: config.reporters.maxFindings,
-      fail_on: config.reporters.failOn,
-    },
-    providers: { analyzers: config.providers.analyzers.map(providerOf) },
-    go: {},
-    ts: {
-      test_files: config.ts.testFiles,
-      entry_files: config.ts.entryFiles,
-      component_extensions: config.ts.componentExtensions,
-      disabled_conventions: config.ts.disabledConventions,
-      injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-      lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-        components: entry.components.map(declarationOf),
-        bases: entry.bases.map(declarationOf),
-        members: entry.members,
-      })),
-      serializers: config.ts.serializers.map(declarationOf),
-      roots_complete: config.ts.rootsComplete,
-    },
-    provenance: Object.fromEntries(
-      [...provenance]
-        .sort(([a], [b]) => (a < b ? -1 : 1))
-        .map(([path, origin]) => [path, renderOrigin(origin)]),
-    ),
-  };
-  return `${JSON.stringify(document, undefined, 2)}\n`;
+export function printConfig(config: ResolvedConfig, provenance: Provenance): string {
+  const origins = [...provenance]
+    .sort(([a], [b]) => bytewise(a, b))
+    .map(([path, origin]): [string, string] => [path, renderOrigin(origin)]);
+  return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }

package/src/product.ts

@@ -0,0 +1,18 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.ts";
+import type { Writer } from "./run.ts";
+
+/** The language this analyzer reads. */
+export const LANGUAGE = "ts";
+
+/** The analyzer's name: the one its language's row names, which every output spells it with. */
+export const PRODUCT = LANGUAGE_ROWS[LANGUAGE].analyzer;
+
+/** Writes one diagnostic line to the error stream, named for the analyzer. */
+export function diagnose(err: Writer, text: string): void {
+  err.write(`${PRODUCT}: ${text}\n`);
+}
+
+/** The text one thrown value carries. */
+export function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/references.ts

@@ -38,13 +38,13 @@ import {
   type ParameterDeclaration,
   type SourceFile,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import type { Symbol as TSSymbol } from "@typescript/native/sync";
 import { aliasChains, type ChainTarget } from "./alias-chain.ts";
 import { contextualUses, type FlowAt, type LiteralAt } from "./contextual-uses.ts";
 import { destructuring, propertyReadsOf, type PropertyRead } from "./destructuring.ts";
 import { specifierCandidates } from "./configuration-files.ts";
 import { namespaceUses } from "./namespace-objects.ts";
-import { globExpression } from "./glob.ts";
 import {
   declarationsByName,
   isParameterProperty,
@@ -73,6 +73,8 @@ import {
   type KeyedAccess,
 } from "./symbol-keys.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
+import { bytewise } from "./text/compare.ts";
+import { globExpression } from "./text/glob.ts";
 
 /**
  * Every use one project's own files make of the project's own declarations.
@@ -315,15 +317,6 @@ function isName(node: Node): boolean {
   return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
 }
 
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node: Node): Node {
-  let held = node;
-  while (isParenthesizedExpression(held)) {
-    held = held.expression;
-  }
-  return held;
-}
-
 /**
  * Records the name one store writes into.
  *
@@ -333,7 +326,7 @@ function unparenthesized(node: Node): Node {
  * target writes each name it binds, through its spreads and nested patterns.
  */
 function markWrite(target: Node, writes: Set<number>, accesses: Set<Node>): void {
-  const held = unparenthesized(target);
+  const held = parenthesesRemoved(target);
   if (isName(held)) {
     writes.add(held.pos);
     return;
@@ -348,7 +341,7 @@ function markWrite(target: Node, writes: Set<number>, accesses: Set<Node>): void
     accesses.add(held);
     // A store through a member's value lands in storage every holder of the value
     // reads, so it reads the member; a variable only ever stored into stays written.
-    if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
+    if (!isPropertyAccessExpression(parenthesesRemoved(held.expression))) {
       markWrite(held.expression, writes, accesses);
     }
     return;
@@ -524,7 +517,7 @@ interface FileSites {
 
 /** Whether one node is `import.meta.url`. */
 function isImportMetaURL(node: Node): boolean {
-  const at = unparenthesized(node);
+  const at = parenthesesRemoved(node);
   return (
     isPropertyAccessExpression(at) &&
     isMetaProperty(at.expression) &&
@@ -536,7 +529,7 @@ function isImportMetaURL(node: Node): boolean {
 /** The module URL one node builds, where it builds one. */
 function moduleURLOf(node: Node): ModuleURL | undefined {
   const relative = (argument: Node | undefined): string | undefined => {
-    const at = argument === undefined ? undefined : unparenthesized(argument);
+    const at = argument === undefined ? undefined : parenthesesRemoved(argument);
     return at !== undefined &&
       (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
       /^\.\.?\//u.test(at.text)
@@ -551,7 +544,7 @@ function moduleURLOf(node: Node): ModuleURL | undefined {
       : undefined;
   }
   if (isCallExpression(node)) {
-    const callee = unparenthesized(node.expression);
+    const callee = parenthesesRemoved(node.expression);
     const specifier = relative(node.arguments[0]);
     if (
       specifier !== undefined &&
@@ -869,7 +862,7 @@ export function testFileRulesOf(
       };
     }),
     ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
-  ].sort((a, b) => compare(a.rule, b.rule));
+  ].sort((a, b) => bytewise(a.rule, b.rule));
 }
 
 const importedCache = new WeakMap<
@@ -1003,7 +996,7 @@ function aloneIn(
           nodes.every((node) => sameTarget.some((one) => inside(node, one.value))),
       )
       .map(([name]) => name)
-      .sort(compare);
+      .sort(bytewise);
     if (names.length > 0) {
       result.push({ index: write.index, names });
     }
@@ -1011,14 +1004,6 @@ function aloneIn(
   return result;
 }
 
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Every reference one project's own files make to the project's own declarations, in
  * position order, and the files the test-file rules classified.
@@ -1677,9 +1662,9 @@ export function references<Brand>(
   found.sort(
     (a, b) =>
       byPosition(a.position, b.position) ||
-      compare(a.to, b.to) ||
-      compare(a.from, b.from) ||
-      compare(a.use, b.use),
+      bytewise(a.to, b.to) ||
+      bytewise(a.from, b.from) ||
+      bytewise(a.use, b.use),
   );
 
   return {
@@ -1687,7 +1672,7 @@ export function references<Brand>(
       consumer === undefined
         ? found
         : found.map((reference) => ({ ...reference, consumer: consumer.id })),
-    testFilePaths: tests.sort(compare),
+    testFilePaths: tests.sort(bytewise),
     cost: {
       batched,
       fileBatches,